Escolar Documentos
Profissional Documentos
Cultura Documentos
Na vida de um homem existem níveis na busca dos estudos. No mais baixo, ele estuda, mas não
acontece, e o homem sente que tanto ele quanto os outros são incapazes. Nesse momento, ele
é inútil. No nível intermediário, ele ainda não possui utilidade, mas está consciente de suas
limitações e também pode ver as limitações dos outros. Num nível 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 nível mais alto, um homem aparenta
não conhecer nada.
Esses são os níveis em termos gerais. Mas existe um nível transcendental, e este é o mais
excepcional de todos. Quem atinge este nível está ciente do infindável 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 não é orgulhoso, mas, com humildade conhece o caminho para o fim. Dizem que o mestre
Yagyu uma vez comentou: “Eu não conheço o caminho para derrotar os outros, apenas o
caminho da minha própria derrota”.
Por toda sua vida avance diariamente, tornando-se mais capacitado a cada dia que passa. Isso
não 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]
Sumário
1. Introdução ............................................................................................................................. 4
2. Os microcontroladores da série TM4C123x .......................................................................... 5
2.1 O Núcleo ARM Cortex-M4 ............................................................................................. 7
2.2 Periféricos 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 Memória ........................................................................................................... 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 configurações necessárias ............................................................ 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. Conclusão ............................................................................................................................ 43
7. ANEXOS ............................................................................................................................... 44
7.1 Exemplo 1 – Utilizando o GPIO e UART ....................................................................... 44
7.2 Exemplo 2 – Utilizando uma Interrupção.................................................................... 46
7.3 Exemplo 3 – Utilizando o Timer .................................................................................. 48
7.4 Arquivo TM4C123GH6PM_STARTUP_CCS.C ............................................................... 51
7.5 Funções da TivaWare .................................................................................................. 56
7.5.1 Funções da GPIO ................................................................................................. 56
7.5.2 Funções da UART................................................................................................. 57
7.5.3 Funções de Interrupção ...................................................................................... 58
7.5.4 Funções de Timer ................................................................................................ 59
8. Referências .......................................................................................................................... 60
3
[Digite texto]
1. Introdução
Com este avanço gradual da eletrônica 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 tecnológico dos antigos
microcontroladores de 8 ou até 16 bits que já estavam amplamente difundidos no
mercado até então, porém já tinham encontrado suas limitações diante da necessidade de
utilização de interfaces gráficas, comunicação com diversos periféricos através de diversos
protocolos de comunicação ou até mesmo avançados recursos matemáticos empregados a
processamentos de sinais envolvendo ponto flutuante. Foi nesse ambiente de avanço de
arquiteturas que vários fabricantes de microcontroladores empregaram um núcleo ARM
aos seus produtos.
4
[Digite texto]
5
[Digite texto]
6
[Digite texto]
Os processadores ARM são conhecidos pela sua versatilidade, pois possuem poucas
instruções para programação. São encontrados em telefones celulares, calculadoras,
periféricos de computador, equipamentos eletrônicos em geral e aplicações industriais.
Atualmente os processadores ARM são 90% dos processadores embarcados RISC de 32
bits.
Desenvolvida pela inglesa Acorn Computer Limited em 1983, foi o primeiro processador
RISC criado para uso comercial. Até então, a maioria dos computadores utilizava a
arquitetura CISC, com suporte instruções complexas, simultâneas e de execução mais lenta
— mas que resultavam em códigos menores, pela simplificação da estrutura de
programação decorrente e menos entradas e saídas (diminuindo assim a necessidade de
memória).
Os RISC, por outro lado, visam a simplificação dessas instruções, com o intuito de atingir
a máxima eficiência por ciclo (podendo realizar tarefas menores com processos mais
curtos) e uma maior ordenação das operações dentro do núcleo de processamento.
Por terem um número menor de circuitos internos, os RISC também podem trabalhar
com clocks mais altos. No entanto, as divisões entre estes dois termos estão 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 núcleos para parceiros que fabricam e vendem para seus clientes. Como
parte da sua estratégia, a ARM investe na assistência àqueles que desenvolvem produtos
que utilizam seus chips, através de softwares de depuração, placas de projeto, etc, se
tornando assim basicamente uma empresa de Propriedade Intelectual (IP), não possuindo
grandes fábricas de semicondutores. [6]
7
[Digite texto]
8
[Digite texto]
Contando com as interrupções de nível 16 aos 255, o NVIC permite que a prioridade das
interrupções seja alterada conforme sua aplicação até mesmo em tempo de execução do
microcontrolador.
9
[Digite texto]
2.2.3 O TIMER
Além disto, ainda conta com modos PWM (Pulse Width Modulation), RTC (Hibernate) e
CCP (Capture, Compare, and Pulse Width Modulation).
2.2.4 A Memória
Flash: 256KB
EEPROM: 2KB
SRAM: 32 KB
Inicialmente, a Launchpad conta com duas entradas micro USB, uma somente para
alimentação (Device) e outra para alimentação e programação e depuração do código
(Debug), chaveadas por uma chave seletora. Além disto, pode ser visualizado um LED
verde indicando que a placa foi alimentada e, eventualmente, também poderá ser
utilizado um botão para RESET do microcontrolador (SW0).
Para suas aplicações estão disponíveis dois barramentos de pinos com a GPIO, seus
periféricos de comunicação (I2C, UART, SPI, etc.) e alimentação totalmente compatível
com os BoosterPacks disponíveis pela Texas para os microcontroladores da linha TIVA e
MSP430.
10
[Digite texto]
Finalmente, a placa ainda disponibiliza um LED RGB e dois botões (SW1 e SW2)
conectados a pinos do microcontrolador para utilização nos exemplos fornecidos pela
Texas, suas próprias aplicações ou depuração e testes no firmware.
11
[Digite texto]
12
[Digite texto]
Além do CCS, ainda podem ser utilizados outros softwares como: IAR, que é livre até
30Kb de Flash utilizada, possui uma interface extremamente amigável e excelente suporte
nacional; o KEIL; o Mentor Graphics e GCC, dentre outros.
Por ser gratuito, sem limitações de memória, 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 é necessário
criar uma conta no site da TI. Após criar a conta, faça o download do CCS v6 conforme a
referência [7] de acordo com seu sistema operacional.
NOTAS IMPORTANTES:
1º Passo: Após aceitar os termos de licença, 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 opção GUI
Composer. Este aplicativo não será estudado nesta apostila, mas poderá ser muito útil em
aplicações futuras. Para conhecê-lo melhor verificar a referência [8].
14
[Digite texto]
4º Passo: Caso os itens anteriores tenham ocorrido de maneira esperada, o CCS terá
concluído sua instalação e será verificada a tela demonstrada na figura 12. Logo, marque a
opção “Yes”, para ter uma área de trabalho simplificada, e clique na caixa “Updates
Available” e faça as atualizações sugeridas.
15
[Digite texto]
Nota: Caso a caixa “Updates Available” não apareça de forma automática clique em
“Help” e em seguida em “Check for Updates”.
5º Passo: Clique no ícone “App Center” ou em “View” e, logo após “CCS App Center”.
Digite “tivaware” e clique em “Download”. Você será redirecionado para uma página da TI
onde poderá fazer o download da ultima versão da TivaWare.
16
[Digite texto]
Nota: Caso não seja possível encontrar a TivaWare através do App Center, realizar o
download através da referência [9].
Chegando a página de download, você encontrará diversas opções das quais atendem
as linhas de launchpads DK e EK e dos microcontroladores da série TM4C123 ou TM4C129.
Para a nossa launchpad em estudo será necessário baixar, dentro da opção “Kit Software”,
o arquivo SW-EK-TM4C123GXLx.x.x.x.exe.
17
[Digite texto]
Nota: Como em outros downloads, será necessário realizar o login com a sua conta da TI
e dar uma sucinta justificativa de sua aplicação para concretizar os downloads.
6º Passo: Com o cabo USB, conecte sua launchpad ao computador através do conector
“Debug” da placa. Para que o computador reconheça a placa, a chave seletora deverá
estar na posição “Debug”. Caso contrário, para só alimentar a placa com a tensão 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 concluídos com êxito, todos os
requisitos básicos à programação dos microcontroladores Tiva C Series foram instalados e
estarão operando corretamente.
5. A TivaWare
Inicialmente, será demonstrado como testar seus exemplos. Logo após, seguiremos com
a criação de um projeto a utilizando como base e, concluindo, estudaremos seus recursos
básicos para os periféricos utilizados.
19
[Digite texto]
1º Passo: Para rodarmos os exemplos, será necessário 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 exclamação
de “warning” dentro do Project Explorer. Para verificar os motivos destes warnings, clique
na ferramenta “Build” (ícone do martelinho) ou com o botão direito em cima do projeto e
em seguida na opção de “Build Project”.
Caso sua área de trabalho não esteja mostrando as janelas de “Console” e “Problems”
habilite-as em “View”. Após compilar, construir ou depurar o projeto estas janelas exibirão
as mensagens referentes aos passos da compilação e erros encontrados.
Seguindo o único warning reportado pela janela “Problems” você verificará que o
projeto foi criado para uma versão antiga do compilador (5.0.4) e a sua versão do CCS
requer a versão 5.1.8. Para reparar este problema, clique com o botão direito no seu
projeto -> “Properties”-> “CCS General” e mude a opção “Compiler version” para a TI
v5.1.8.
NOTA: Caso já exista uma versão 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 código
irá ser gravado na memória flash microcontrolador.
24
[Digite texto]
Nota: Caso queira debugar o código com ele em funcionamento, insira “break points”
nas linhas de interesse dando dois cliques antes do número da linha. Assim, ao clicar em
“Resume” o código irá rodar até alcançar a linha marcada.
Finalmente, com o código rodando, você verá o LED RGB da launchpad alternando de
cor periodicamente. Com isso, o project0 estará salvo na memória flash do
microcontrolador. Logo, mesmo que você termine o debug e conecte a placa a outro
comutador ou alimentação externa, o código continuará funcionando normalmente! Faça
o teste, troque o conector USB e a posição da chave seletora da placa das posições
“Debug” para a “Device” e veja que o código continuará funcionando normalmente.
Lembrando que a posição “Device” fornece somente a alimentação da USB para a
launchpad (+5V/GND).
7º Passo: Vários exemplos fornecidos pela Texas tem sua depuração realizada através da
porta serial. Para demonstrar a utilização 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]
Após digitar o nome em “Saved Sessions” clique em “Save” e logo após em “Open”. No
futuro, quando você tiver várias configurações salvas, bastará clicar na configuração salva
e clicar em “Load” e logo após “Open”, ou dar dois cliques em cima da configuração.
Após 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 código, você receberá a seguinte mensagem conforme a figura 26.
26
[Digite texto]
Agora que nós temos nossos exemplos rodando, teste outros exemplos e para ver como
alguns periféricos estão sendo configurados, abra o documento “SW-TM4C-EXAMPLES-UG-
2.1.0.12573.pdf” dentro da pasta “docs” na pasta da TivaWare. Estas funções da TivaWare
que estarão sendo utilizadas em todos exemplos serão explicadas após criarmos um
projeto do zero.
1º Passo: Para começarmos um projeto do zero, clique em “Project”-> ”New CCS Project”.
27
[Digite texto]
28
[Digite texto]
Nota: Inicialmente, através das configurações 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á possível 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 código
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 saída. (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 código rodou normalmente, nosso projeto do zero foi criado com sucesso!
Exemplo de Configuração:
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 divisão da
PLL escolhida.
Nota: Para habilitar qualquer periférico como o GPIO, Interrupção, etc. É necessário
habilitar o seu clock através da função: SysCtlPeripheralEnable(ui32Peripheral). Onde
“ui32Peripheral” é o periférico a ser habilitado.
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
NOTA: Para entender melhor o sistema de variáveis 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 declaração:
35
[Digite texto]
O exemplo acima configura na PORT F, os pinos PF1, PF2 e PF3 como saída (LED RGB da
Launchpad) e os pinos PF0 e PF4 como entrada (dois botões da Launchpad). Além disso,
nos pinos PF0 e PF4, permitem uma corrente de até 2mA de entrada e configurados com
Pull Up.
36
[Digite texto]
Nota 1: Todas as funções apresentadas até agora são procedimentos que não retornam
nada “void”.
Nota 2: Por terem funções específicas, o microcontrolador vem com 6 pinos bloqueados
para evitar acidentais alterações. São eles: PC0, PC1, PC2, PC3, PD7 e PF0. Como iremos
utilizar o PF0 como entrada do botão SW2, teremos de desbloqueá-lo. Para verificar como
ele é desbloqueado verifique o Exemplo 1 em Anexo.
Para operar os pinos da GPIO serão utilizadas duas funções, uma para ler o estado dos
pinos de entrada e outra para mudança de estado do pino de saída.
//*****************************************************************
//
// 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).
Função que retorna o caractere lido na serial como int32_t.
Exemplo de serial com baud rate: 115200 e enviando um caractere na UART 0 após a
sua configuração:
void
ConfigureUART(void) // Função 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(); // Função de configuração da UART0
UARTprintf("Hello world after Engeneering!!!\n");
while(1)
{
38
[Digite texto]
(...)
}
}
Nota 1: Note que como a configuração da UART0 foi realizada dentro de uma função,
dentro do int main do programa esta função deverá ser chamada na forma:
ConfigureUART();
Nota 2: Para que o projeto aceite a biblioteca vinda de “utils” será necessário 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 após, escolha a opção “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 função “Add Files...” em “Project” esteja apagada, dê um clique no nome
do seu projeto no Project Explorer.
1. IntMasterEnable()
Função que permite ao processador responder a todas as chamadas de interrupção
utilizadas.
39
[Digite texto]
Como rotina de interrupção, a função a ser chamada pela interrupção acima é a void
PortDIntHandler(void) (nome arbitrário) que é acionada sempre que uma borda de
descida é sujeita ao pino 4 do Port F. Um exemplo de sua utilização pode ser visto no
Exemplo 2 Anexo.
Para que uma função de interrupção seja executada, será necessário declará-la ao
código “tm4c123gh6pmi_sturtup_ccs.c” que representa o vetor de gerenciamento das
funções.
1º Passo: Declare a função a ser chamada através da interrupção desejada como função
externa ao código, aproximadamente na linha 58 do código 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]
Após estas configurações, sempre que houver uma borda de descida no pino 4 do PortF
(SW1 pressionado), sua função de interrupção será executada!
////Habilitação 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 interrupção do Timer Periódico, a função a ser chamada pelo Timer0 é a
“void Timer0IntHandler(void)” que é acionada sempre que o período do Timer é atingido.
Um exemplo de aplicação conforme nossa configuração apresentada poderá ser visto no
Exemplo 3 em Anexo.
41
[Digite texto]
Novamente, para que uma função de interrupção seja executada sempre que o nosso
timer desejar, será necessário declará-la ao código “tm4c123gh6pmi_sturtup_ccs.c”.
1º Passo: Declare a função a ser chamada através da interrupção desejada como função
externa ao código, aproximadamente na linha 59 do código 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. Conclusão
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 periódico programado para gerar uma
interrupção sempre que alcançar seu período pré-estabelecido. Em paralelo com o
funcionamento do Timer, pressionando SW1 ainda será gerada uma interrupção por borda de
subida, dessa maneira poderá ser verificada a execução de duas interrupções ao mesmo
tempo e a alternância 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);
////Habilitação do TIMER0////
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); //Configura o Timer
como periódico
ConfigureUART();
while(1)
{
//Isso mesmo! O while está vazio!
}
}
///////////////////////////EXEMPLO 3 - FIM//////////////////////
50
[Digite texto]
5) Caso queira programar alguma função para o botão SW2 no pino PF0, este
exemplo permaneceu com as suas configurações como nos exemplos
anteriores.
Logo abaixo poderá ser verificado o código do programa que gerencia as interrupções com
as alterações realizadas nos exemplos anteriores. Este código, salvo as alterações, 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. Referências
60
[Digite texto]
61