Escolar Documentos
Profissional Documentos
Cultura Documentos
ApostilaTM4C 03 2015 PDF
ApostilaTM4C 03 2015 PDF
Na vida de um homem existem nveis na busca dos estudos. No mais baixo, ele estuda, mas no
acontece, e o homem sente que tanto ele quanto os outros so incapazes. Nesse momento, ele
intil. No nvel intermedirio, ele ainda no possui utilidade, mas est consciente de suas
limitaes e tambm pode ver as limitaes dos outros. Num nvel mais elevado, ele tem
orgulho de suas habilidades, se regozija com os elogios das pessoas e lamenta a falta de
habilidade dos companheiros. Esse homem tem valor. No nvel mais alto, um homem aparenta
no conhecer nada.
Esses so os nveis em termos gerais. Mas existe um nvel transcendental, e este o mais
excepcional de todos. Quem atinge este nvel est ciente do infindvel quando se adentra
profundamente por um certo Caminho e nunca imagina a si mesmo no fim da jornada. Ele
realmente conhece suas falhas e nunca em toda sua vida chega a pensar que bem-sucedido.
Ele no orgulhoso, mas, com humildade conhece o caminho para o fim. Dizem que o mestre
Yagyu uma vez comentou: Eu no conheo o caminho para derrotar os outros, apenas o
caminho da minha prpria derrota.
Por toda sua vida avance diariamente, tornando-se mais capacitado a cada dia que passa. Isso
no tem fim.
Caso tenha algo a contribuir com essa apostila, por favor, entrar em contato:
Linkedin: br.linkedin.com/in/stefanoandrade/pt
Email: stefano.andrade@engenharia.ufjf.br
2
[Digite texto]
Sumrio
1. Introduo ............................................................................................................................. 4
2. Os microcontroladores da srie TM4C123x .......................................................................... 5
2.1 O Ncleo ARM Cortex-M4 ............................................................................................. 7
2.2 Perifricos Estudados .................................................................................................... 9
2.2.1 GPIO General Purpose IN/OUT ........................................................................... 9
2.2.2 NVIC Nested Vector Interrupt Controller ........................................................... 9
2.2.3 O TIMER ............................................................................................................... 10
2.2.4 A Memria ........................................................................................................... 10
3. A Placa de Desenvolvimento TIVA C Series EK-TM4C123G................................................. 10
4. Code Composer Studio v6 (CCS).......................................................................................... 13
4.1 Instalando o CCS e configuraes necessrias ............................................................ 13
5. A TivaWare .......................................................................................................................... 19
5.1 Rodando os exemplos da TivaWare ............................................................................ 20
5.2 Criando um Projeto do Zero [3] .................................................................................. 27
5.3 Clock Geral do Sistema ................................................................................................ 35
5.4 Configurando o GPIO................................................................................................... 36
5.5 Utilizando uma UART .................................................................................................. 38
5.6 Configurando o NVIC ................................................................................................... 39
5.7 Configurando o TIMER ................................................................................................ 41
6. Concluso ............................................................................................................................ 43
7. ANEXOS ............................................................................................................................... 44
7.1 Exemplo 1 Utilizando o GPIO e UART ....................................................................... 44
7.2 Exemplo 2 Utilizando uma Interrupo.................................................................... 46
7.3 Exemplo 3 Utilizando o Timer .................................................................................. 48
7.4 Arquivo TM4C123GH6PM_STARTUP_CCS.C ............................................................... 51
7.5 Funes da TivaWare .................................................................................................. 56
7.5.1 Funes da GPIO ................................................................................................. 56
7.5.2 Funes da UART................................................................................................. 57
7.5.3 Funes de Interrupo ...................................................................................... 58
7.5.4 Funes de Timer ................................................................................................ 59
8. Referncias .......................................................................................................................... 60
3
[Digite texto]
1. Introduo
Com este avano gradual da eletrnica surgiram no mercado diversos fabricantes que
optaram por desenvolver seus microcontroladores com alto poder de processamento e
barramento de 32 bits. Esta arquitetura foi um grande salto tecnolgico dos antigos
microcontroladores de 8 ou at 16 bits que j estavam amplamente difundidos no
mercado at ento, porm j tinham encontrado suas limitaes diante da necessidade de
utilizao de interfaces grficas, comunicao com diversos perifricos atravs de diversos
protocolos de comunicao ou at mesmo avanados recursos matemticos empregados a
processamentos de sinais envolvendo ponto flutuante. Foi nesse ambiente de avano de
arquiteturas que vrios fabricantes de microcontroladores empregaram um ncleo ARM
aos seus produtos.
4
[Digite texto]
5
[Digite texto]
6
[Digite texto]
Desenvolvida pela inglesa Acorn Computer Limited em 1983, foi o primeiro processador
RISC criado para uso comercial. At ento, a maioria dos computadores utilizava a
arquitetura CISC, com suporte instrues complexas, simultneas e de execuo mais lenta
mas que resultavam em cdigos menores, pela simplificao da estrutura de
programao decorrente e menos entradas e sadas (diminuindo assim a necessidade de
memria).
Os RISC, por outro lado, visam a simplificao dessas instrues, com o intuito de atingir
a mxima eficincia por ciclo (podendo realizar tarefas menores com processos mais
curtos) e uma maior ordenao das operaes dentro do ncleo de processamento.
Por terem um nmero menor de circuitos internos, os RISC tambm podem trabalhar
com clocks mais altos. No entanto, as divises entre estes dois termos esto se tornando
cada vez mais nebulosas, uma vez que os processadores modernos j combinam as duas
linhas em suas diferentes camadas de hardware.
Nos dias atuais, a empresa ARM (Advanced RISC Machine LTDA) se especializou em
licenciar seus ncleos para parceiros que fabricam e vendem para seus clientes. Como
parte da sua estratgia, a ARM investe na assistncia queles que desenvolvem produtos
que utilizam seus chips, atravs de softwares de depurao, placas de projeto, etc, se
tornando assim basicamente uma empresa de Propriedade Intelectual (IP), no possuindo
grandes fbricas de semicondutores. [6]
7
[Digite texto]
8
[Digite texto]
Contando com as interrupes de nvel 16 aos 255, o NVIC permite que a prioridade das
interrupes seja alterada conforme sua aplicao at mesmo em tempo de execuo do
microcontrolador.
9
[Digite texto]
2.2.3 O TIMER
Alm disto, ainda conta com modos PWM (Pulse Width Modulation), RTC (Hibernate) e
CCP (Capture, Compare, and Pulse Width Modulation).
2.2.4 A Memria
Flash: 256KB
EEPROM: 2KB
SRAM: 32 KB
Inicialmente, a Launchpad conta com duas entradas micro USB, uma somente para
alimentao (Device) e outra para alimentao e programao e depurao do cdigo
(Debug), chaveadas por uma chave seletora. Alm disto, pode ser visualizado um LED
verde indicando que a placa foi alimentada e, eventualmente, tambm poder ser
utilizado um boto para RESET do microcontrolador (SW0).
Para suas aplicaes esto disponveis dois barramentos de pinos com a GPIO, seus
perifricos de comunicao (I2C, UART, SPI, etc.) e alimentao totalmente compatvel
com os BoosterPacks disponveis pela Texas para os microcontroladores da linha TIVA e
MSP430.
10
[Digite texto]
Finalmente, a placa ainda disponibiliza um LED RGB e dois botes (SW1 e SW2)
conectados a pinos do microcontrolador para utilizao nos exemplos fornecidos pela
Texas, suas prprias aplicaes ou depurao e testes no firmware.
11
[Digite texto]
12
[Digite texto]
Alm do CCS, ainda podem ser utilizados outros softwares como: IAR, que livre at
30Kb de Flash utilizada, possui uma interface extremamente amigvel e excelente suporte
nacional; o KEIL; o Mentor Graphics e GCC, dentre outros.
Por ser gratuito, sem limitaes de memria, rodar todos os exemplos fornecidos pela
Texas para toda a sua linha de microcontroladores, dentre outros motivos, o software a
ser estudado ser o CCS.
Para baixar o CCS, e todos os aplicativos fornecidos pela Texas, inicialmente necessrio
criar uma conta no site da TI. Aps criar a conta, faa o download do CCS v6 conforme a
referncia [7] de acordo com seu sistema operacional.
NOTAS IMPORTANTES:
1 Passo: Aps aceitar os termos de licena, marque o item 32-bit ARM MCUs conforme
a figura 9 e clique em Next.
13
[Digite texto]
3 Passo: Na tela do App Center (Central de aplicativos da TI), marque a opo GUI
Composer. Este aplicativo no ser estudado nesta apostila, mas poder ser muito til em
aplicaes futuras. Para conhec-lo melhor verificar a referncia [8].
14
[Digite texto]
4 Passo: Caso os itens anteriores tenham ocorrido de maneira esperada, o CCS ter
concludo sua instalao e ser verificada a tela demonstrada na figura 12. Logo, marque a
opo Yes, para ter uma rea de trabalho simplificada, e clique na caixa Updates
Available e faa as atualizaes sugeridas.
15
[Digite texto]
5 Passo: Clique no cone App Center ou em View e, logo aps CCS App Center.
Digite tivaware e clique em Download. Voc ser redirecionado para uma pgina da TI
onde poder fazer o download da ultima verso da TivaWare.
16
[Digite texto]
Nota: Caso no seja possvel encontrar a TivaWare atravs do App Center, realizar o
download atravs da referncia [9].
Chegando a pgina de download, voc encontrar diversas opes das quais atendem
as linhas de launchpads DK e EK e dos microcontroladores da srie TM4C123 ou TM4C129.
Para a nossa launchpad em estudo ser necessrio baixar, dentro da opo Kit Software,
o arquivo SW-EK-TM4C123GXLx.x.x.x.exe.
17
[Digite texto]
Nota: Como em outros downloads, ser necessrio realizar o login com a sua conta da TI
e dar uma sucinta justificativa de sua aplicao para concretizar os downloads.
6 Passo: Com o cabo USB, conecte sua launchpad ao computador atravs do conector
Debug da placa. Para que o computador reconhea a placa, a chave seletora dever
estar na posio Debug. Caso contrrio, para s alimentar a placa com a tenso provida
pela porta USB, passe a chave e o cabo USB para o modo Device.
18
[Digite texto]
Caso todos os passos apresentados at aqui tenham sido concludos com xito, todos os
requisitos bsicos programao dos microcontroladores Tiva C Series foram instalados e
estaro operando corretamente.
5. A TivaWare
Inicialmente, ser demonstrado como testar seus exemplos. Logo aps, seguiremos com
a criao de um projeto a utilizando como base e, concluindo, estudaremos seus recursos
bsicos para os perifricos utilizados.
19
[Digite texto]
1 Passo: Para rodarmos os exemplos, ser necessrio clicar em Project -> Import CCS
Projects.
20
[Digite texto]
21
[Digite texto]
22
[Digite texto]
4 Passo: Importando o project0 voc ir notar que ele aparece com uma exclamao
de warning dentro do Project Explorer. Para verificar os motivos destes warnings, clique
na ferramenta Build (cone do martelinho) ou com o boto direito em cima do projeto e
em seguida na opo de Build Project.
Seguindo o nico warning reportado pela janela Problems voc verificar que o
projeto foi criado para uma verso antiga do compilador (5.0.4) e a sua verso do CCS
requer a verso 5.1.8. Para reparar este problema, clique com o boto direito no seu
projeto -> Properties-> CCS General e mude a opo Compiler version para a TI
v5.1.8.
NOTA: Caso j exista uma verso acima da 5.1.8, selecione sempre a mais atual
recomendada.
23
[Digite texto]
Logo, o projeto estar pronto para ser enviado para nossa launchpad e ser testado!
Caso o target esteja correto, clique na ferramenta de Debug (inseto verde) e o cdigo
ir ser gravado na memria flash microcontrolador.
24
[Digite texto]
Nota: Caso queira debugar o cdigo com ele em funcionamento, insira break points
nas linhas de interesse dando dois cliques antes do nmero da linha. Assim, ao clicar em
Resume o cdigo ir rodar at alcanar a linha marcada.
Finalmente, com o cdigo rodando, voc ver o LED RGB da launchpad alternando de
cor periodicamente. Com isso, o project0 estar salvo na memria flash do
microcontrolador. Logo, mesmo que voc termine o debug e conecte a placa a outro
comutador ou alimentao externa, o cdigo continuar funcionando normalmente! Faa
o teste, troque o conector USB e a posio da chave seletora da placa das posies
Debug para a Device e veja que o cdigo continuar funcionando normalmente.
Lembrando que a posio Device fornece somente a alimentao da USB para a
launchpad (+5V/GND).
7 Passo: Vrios exemplos fornecidos pela Texas tem sua depurao realizada atravs da
porta serial. Para demonstrar a utilizao da UART, importe o projeto hello da mesma
forma que importou o projeto project0. Note que para rodar este novo projeto, o
mesmo dever estar marcado em negrito como Active-Debug no Project Explorer.
25
[Digite texto]
Aps digitar o nome em Saved Sessions clique em Save e logo aps em Open. No
futuro, quando voc tiver vrias configuraes salvas, bastar clicar na configurao salva
e clicar em Load e logo aps Open, ou dar dois cliques em cima da configurao.
Aps abrir o terminal Putty, compile o projeto hello no CCS, verifique se ele est sem
warnings e clique em Debug para manda-lo para a launchpad. Com o terminal aberto, ao
rodar o cdigo, voc receber a seguinte mensagem conforme a figura 26.
26
[Digite texto]
Agora que ns temos nossos exemplos rodando, teste outros exemplos e para ver como
alguns perifricos esto sendo configurados, abra o documento SW-TM4C-EXAMPLES-UG-
2.1.0.12573.pdf dentro da pasta docs na pasta da TivaWare. Estas funes da TivaWare
que estaro sendo utilizadas em todos exemplos sero explicadas aps criarmos um
projeto do zero.
1 Passo: Para comearmos um projeto do zero, clique em Project-> New CCS Project.
27
[Digite texto]
28
[Digite texto]
Nota: Inicialmente, atravs das configuraes de View, tente deixar sua rea de trabalho
do CCS conforme a figura 30.
29
[Digite texto]
30
[Digite texto]
31
[Digite texto]
32
[Digite texto]
6 Passo: Se todas as etapas anteriores foram seguidas corretamente. Ser possvel ver
os arquivos no Project Explorer conforme a figura 38.
33
[Digite texto]
7 Passo: Para validar o nosso projeto criado do zero. Vamos copiar as linhas de cdigo
referentes ao project0 disponibilizadas pela Texas, compilar e debugar o projeto.
/////////////////////////////////////////////////////////////////////////////////////
#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line) // Rotina de erro
{
}
#endif
int
main(void)
{
//
// Configurando o clock do sistema
//
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
//
// Habilitando a GPIO F e configurando os pinos 1, 2 e 3 como sada. (Ver os defines!)
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED);
//
// Loop
//
while(1)
{
//
// Liga o LED vermelho que est no pino 1 da GPIO F
//
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED);
//
// Delay
//
SysCtlDelay(2000000);
//
// Liga o LED azul que est no pino 2 da GPIO F
//
GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, BLUE_LED);
//
// Delay
//
SysCtlDelay(2000000);
}
}
/////////////////////////////////////////////////////////////////////////////////////
34
[Digite texto]
Se o cdigo rodou normalmente, nosso projeto do zero foi criado com sucesso!
Exemplo de Configurao:
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN)
Assim, o clock geral do sistema estar configurado para trabalhar com o cristal de 16
MHz da placa de desenvolvimento e estar funcionando a 40 MHz conforme a diviso da
PLL escolhida.
Nota: Para habilitar qualquer perifrico como o GPIO, Interrupo, etc. necessrio
habilitar o seu clock atravs da funo: SysCtlPeripheralEnable(ui32Peripheral). Onde
ui32Peripheral o perifrico a ser habilitado.
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
NOTA: Para entender melhor o sistema de variveis utilizadas pela TivaWare, dentro da
biblioteca stdint.h (C:\ti\ccsv6\tools\compiler\arm_5.1.8\include), dentre outras, poder
ser vista a seguinte declarao:
35
[Digite texto]
O exemplo acima configura na PORT F, os pinos PF1, PF2 e PF3 como sada (LED RGB da
Launchpad) e os pinos PF0 e PF4 como entrada (dois botes da Launchpad). Alm disso,
nos pinos PF0 e PF4, permitem uma corrente de at 2mA de entrada e configurados com
Pull Up.
36
[Digite texto]
Nota 2: Por terem funes especficas, o microcontrolador vem com 6 pinos bloqueados
para evitar acidentais alteraes. So eles: PC0, PC1, PC2, PC3, PD7 e PF0. Como iremos
utilizar o PF0 como entrada do boto SW2, teremos de desbloque-lo. Para verificar como
ele desbloqueado verifique o Exemplo 1 em Anexo.
Para operar os pinos da GPIO sero utilizadas duas funes, uma para ler o estado dos
pinos de entrada e outra para mudana de estado do pino de sada.
//*****************************************************************
//
// The following values define the bit field for the ui8Pins
argument to
// several of the APIs.
//
//*****************************************************************
#define GPIO_PIN_0 0x00000001 // GPIO pin 0
#define GPIO_PIN_1 0x00000002 // GPIO pin 1
#define GPIO_PIN_2 0x00000004 // GPIO pin 2
#define GPIO_PIN_3 0x00000008 // GPIO pin 3
#define GPIO_PIN_4 0x00000010 // GPIO pin 4
#define GPIO_PIN_5 0x00000020 // GPIO pin 5
#define GPIO_PIN_6 0x00000040 // GPIO pin 6
#define GPIO_PIN_7 0x00000080 // GPIO pin 7
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,GPIO_PIN
_2); //Aciona somente o PIN_2 do PORTF
37
[Digite texto]
3. UARTCharGet(uint32_t ui32Base).
Funo que retorna o caractere lido na serial como int32_t.
Exemplo de serial com baud rate: 115200 e enviando um caractere na UART 0 aps a
sua configurao:
void
ConfigureUART(void) // Funo retirada do exemplo hello.c
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
UARTStdioConfig(0, 115200, 16000000);
}
int main(void) {
(...)
ConfigureUART(); // Funo de configurao da UART0
UARTprintf("Hello world after Engeneering!!!\n");
while(1)
{
38
[Digite texto]
(...)
}
}
Nota 1: Note que como a configurao da UART0 foi realizada dentro de uma funo,
dentro do int main do programa esta funo dever ser chamada na forma:
ConfigureUART();
Nota 2: Para que o projeto aceite a biblioteca vinda de utils ser necessrio clicar
Project-> Add Files... e busque o arquivo uartsdtio.c dentro de:
C:\ti\TivaWare_C_Series-2.1.0.12573\utils\uartstdio.c. Logo aps, escolha a opo Link to
files e mude o local de POROJECT_LOC para o nosso local criado TIVAWARE_INSTALL,
conforme a figura 39.
Nota 3: Caso a funo Add Files... em Project esteja apagada, d um clique no nome
do seu projeto no Project Explorer.
1. IntMasterEnable()
Funo que permite ao processador responder a todas as chamadas de interrupo
utilizadas.
39
[Digite texto]
Como rotina de interrupo, a funo a ser chamada pela interrupo acima a void
PortDIntHandler(void) (nome arbitrrio) que acionada sempre que uma borda de
descida sujeita ao pino 4 do Port F. Um exemplo de sua utilizao pode ser visto no
Exemplo 2 Anexo.
Para que uma funo de interrupo seja executada, ser necessrio declar-la ao
cdigo tm4c123gh6pmi_sturtup_ccs.c que representa o vetor de gerenciamento das
funes.
1 Passo: Declare a funo a ser chamada atravs da interrupo desejada como funo
externa ao cdigo, aproximadamente na linha 58 do cdigo do
tm4c123gh6pmi_sturtup_ccs.c.
//**********************************************************************
//
// External declarations for the interrupt handlers used by the
application.
//
//**********************************************************************
// To be added by user
extern void PortFIntHandler(void);
//**********************************************************************
40
[Digite texto]
Aps estas configuraes, sempre que houver uma borda de descida no pino 4 do PortF
(SW1 pressionado), sua funo de interrupo ser executada!
////Habilitao do TIMER0////
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
Period = (SysCtlClockGet());
TimerLoadSet(TIMER0_BASE, TIMER_A, Period -1);
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_PERIODIC);
TimerEnable(TIMER0_BASE, TIMER_A);
IntEnable(INT_TIMER0A);
Como rotina de interrupo do Timer Peridico, a funo a ser chamada pelo Timer0 a
void Timer0IntHandler(void) que acionada sempre que o perodo do Timer atingido.
Um exemplo de aplicao conforme nossa configurao apresentada poder ser visto no
Exemplo 3 em Anexo.
41
[Digite texto]
Novamente, para que uma funo de interrupo seja executada sempre que o nosso
timer desejar, ser necessrio declar-la ao cdigo tm4c123gh6pmi_sturtup_ccs.c.
1 Passo: Declare a funo a ser chamada atravs da interrupo desejada como funo
externa ao cdigo, aproximadamente na linha 59 do cdigo do
tm4c123gh6pmi_sturtup_ccs.c.
//**********************************************************************
//
// External declarations for the interrupt handlers used by the
application.
//
//**********************************************************************
// To be added by user
extern void PortFIntHandler(void);
extern void Timer0IntHandler (void);
//**********************************************************************
42
[Digite texto]
6. Concluso
43
[Digite texto]
7. ANEXOS
int LED=4;
int main(void) {
44
[Digite texto]
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,
GPIO_PIN_4|GPIO_PIN_0);
GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4,
GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
ConfigureUART();
while(1)
{
// Se SW2 for pressionado//
if(!(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0) &
GPIO_PIN_0))
{
LED=8;
UARTprintf("Verde\n");
}
// Se SW1 for pressionado//
if(!(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4) &
GPIO_PIN_4))
{
LED=2;
UARTprintf("Vermelho\n");
GPIOPinWrite(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED);
SysCtlDelay(2000000);
LED=4;
}
}
//////////////////////////EXEMPLO 1 FIM/////////////////////////////////
45
[Digite texto]
#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "driverlib/pin_map.h"
#include "utils/uartstdio.h"
#include "driverlib/interrupt.h"
#include "inc/hw_ints.h"
uint8_t LED=4;
46
[Digite texto]
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL
_OSC_MAIN); // Habilita clock geral do sistema
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0);
GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4,
GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
ConfigureUART();
while(1)
{
// Se SW2 for pressionado//
if(!(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0) & GPIO_PIN_0))
{
LED=8;
UARTprintf("Verde\n");
GPIOPinWrite(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED);
SysCtlDelay(20000000);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,
LED);
SysCtlDelay(200);
LED=4;
}
//////////////////////EXEMPLO 2 - FIM///////////////////////////////////////
47
[Digite texto]
Neste exemplo ser configurado um Timer peridico programado para gerar uma
interrupo sempre que alcanar seu perodo pr-estabelecido. Em paralelo com o
funcionamento do Timer, pressionando SW1 ainda ser gerada uma interrupo por borda de
subida, dessa maneira poder ser verificada a execuo de duas interrupes ao mesmo
tempo e a alternncia de prioridades entre elas.
TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
if(flag==1)
{
LED=4;
48
[Digite texto]
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,
LED);
UARTprintf("Blue\n");
flag=0;
}
else
{
LED=8;
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,
LED);
UARTprintf("Green\n");
flag=1;
}
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL
_OSC_MAIN);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0);
49
[Digite texto]
GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4,
GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
////Habilitao do TIMER0////
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); //Configura o Timer
como peridico
ConfigureUART();
while(1)
{
//Isso mesmo! O while est vazio!
}
}
///////////////////////////EXEMPLO 3 - FIM//////////////////////
50
[Digite texto]
5) Caso queira programar alguma funo para o boto SW2 no pino PF0, este
exemplo permaneceu com as suas configuraes como nos exemplos
anteriores.
Logo abaixo poder ser verificado o cdigo do programa que gerencia as interrupes com
as alteraes realizadas nos exemplos anteriores. Este cdigo, salvo as alteraes, foi gerado
automaticamente pelo CCS e de autoria da Texas Instruments.
///////////////////////TM4C123GH6PM_SARTUP_CCS.C/////////////////////////////
//
//***************************************************************************
//
// Startup code for use with TI's Code Composer Studio.
//
// Copyright (c) 2011-2014 Texas Instruments Incorporated. All rights
reserved.
// Software License Agreement
//
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
//***************************************************************************
#include <stdint.h>
//***************************************************************************
//
// Forward declaration of the default fault handlers.
//
//***************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
//***************************************************************************
//
// External declaration for the reset handler that is to be called when the
// processor is started
//
//***************************************************************************
51
[Digite texto]
//***************************************************************************
//
// Linker variable that marks the top of the stack.
//
//***************************************************************************
extern uint32_t __STACK_TOP;
//***************************************************************************
//
// External declarations for the interrupt handlers used by the application.
//
//***************************************************************************
// To be added by user
extern void PortFIntHandler(void);
extern void Timer0IntHandler(void);
//***************************************************************************
//
// The vector table. Note that the proper constructs must be placed on this
to
// ensure that it ends up at physical address 0x0000.0000 or at the start of
// the program if located at a start address other than 0.
//
//***************************************************************************
#pragma DATA_SECTION(g_pfnVectors, ".intvecs")
void (* const g_pfnVectors[])(void) =
{
(void (*)(void))((uint32_t)&__STACK_TOP),
// The initial stack pointer
ResetISR, // The reset handler
NmiSR, // The NMI handler
FaultISR, // The hard fault handler
IntDefaultHandler, // The MPU fault handler
IntDefaultHandler, // The bus fault handler
IntDefaultHandler, // The usage fault handler
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // SVCall handler
IntDefaultHandler, // Debug monitor handler
0, // Reserved
IntDefaultHandler, // The PendSV handler
IntDefaultHandler, // The SysTick handler
IntDefaultHandler, // GPIO Port A
IntDefaultHandler, // GPIO Port B
IntDefaultHandler, // GPIO Port C
IntDefaultHandler, // GPIO Port D
IntDefaultHandler, // GPIO Port E
IntDefaultHandler, // UART0 Rx and Tx
IntDefaultHandler, // UART1 Rx and Tx
IntDefaultHandler, // SSI0 Rx and Tx
IntDefaultHandler, // I2C0 Master and Slave
IntDefaultHandler, // PWM Fault
IntDefaultHandler, // PWM Generator 0
IntDefaultHandler, // PWM Generator 1
IntDefaultHandler, // PWM Generator 2
52
[Digite texto]
53
[Digite texto]
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved
IntDefaultHandler, // Timer 5 subtimer A
IntDefaultHandler, // Timer 5 subtimer B
IntDefaultHandler, // Wide Timer 0 subtimer A
IntDefaultHandler, // Wide Timer 0 subtimer B
IntDefaultHandler, // Wide Timer 1 subtimer A
IntDefaultHandler, // Wide Timer 1 subtimer B
IntDefaultHandler, // Wide Timer 2 subtimer A
IntDefaultHandler, // Wide Timer 2 subtimer B
IntDefaultHandler, // Wide Timer 3 subtimer A
IntDefaultHandler, // Wide Timer 3 subtimer B
IntDefaultHandler, // Wide Timer 4 subtimer A
IntDefaultHandler, // Wide Timer 4 subtimer B
IntDefaultHandler, // Wide Timer 5 subtimer A
IntDefaultHandler, // Wide Timer 5 subtimer B
IntDefaultHandler, // FPU
0, // Reserved
0, // Reserved
IntDefaultHandler, // I2C4 Master and Slave
IntDefaultHandler, // I2C5 Master and Slave
IntDefaultHandler, // GPIO Port M
IntDefaultHandler, // GPIO Port N
IntDefaultHandler, // Quadrature Encoder 2
0, // Reserved
0, // Reserved
IntDefaultHandler, // GPIO Port P (Summary or P0)
IntDefaultHandler, // GPIO Port P1
IntDefaultHandler, // GPIO Port P2
IntDefaultHandler, // GPIO Port P3
IntDefaultHandler, // GPIO Port P4
IntDefaultHandler, // GPIO Port P5
IntDefaultHandler, // GPIO Port P6
IntDefaultHandler, // GPIO Port P7
IntDefaultHandler, // GPIO Port Q (Summary or Q0)
IntDefaultHandler, // GPIO Port Q1
IntDefaultHandler, // GPIO Port Q2
IntDefaultHandler, // GPIO Port Q3
IntDefaultHandler, // GPIO Port Q4
IntDefaultHandler, // GPIO Port Q5
IntDefaultHandler, // GPIO Port Q6
54
[Digite texto]
//***************************************************************************
//
// This is the code that gets called when the processor first starts
execution
// following a reset event. Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called. Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//***************************************************************************
void
ResetISR(void)
{
//
// Jump to the CCS C initialization routine. This will enable the
// floating-point unit as well, so that does not need to be done here.
//
__asm(" .global _c_int00\n"
" b.w _c_int00");
}
//***************************************************************************
//
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for
examination
// by a debugger.
//
//***************************************************************************
static void
NmiSR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//***************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system
state
// for examination by a debugger.
//
//***************************************************************************
55
[Digite texto]
static void
FaultISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}
//***************************************************************************
//
// This is the code that gets called when the processor receives an
unexpected
// interrupt. This simply enters an infinite loop, preserving the system
state
// for examination by a debugger.
//
//***************************************************************************
static void
IntDefaultHandler(void)
{
//
// Go into an infinite loop.
//
while(1)
{
}
}
///////////////////////TM4C123GH6PM_SARTUP_CCS.C - FIM//////////////////////
56
[Digite texto]
57
[Digite texto]
58
[Digite texto]
59
[Digite texto]
8. Referncias
60
[Digite texto]
61