ApostilaTivaCM4C_03_2015

Prévia do material em texto

Introdução aos microcontroladores 
ARM Cortex-M4 Tiva C Series da 
Texas Instruments 
 
 
 
 
 
 
 
 
 
 
 
Stéfano Andrade de Souza 
Março de 2015 
 
[Digite texto] 
 
 2 
 
Um certo espadachim nos seus dias derradeiros disse o seguinte: 
 
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. 
 
Yamamoto Tsunetomo – HAGAKURE 
 
 
 
 
 
 
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 
[Digite texto] 
 
 3 
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 
 
 
[Digite texto] 
 
 4 
 
1. Introdução 
 
Com o crescimento cada vez maior da demanda de equipamentos eletrônicos no 
mercado, ao passar dos anos pode ser visto um enorme avanço da eletrônica em termos 
de redução de custo, miniaturização dos componentes, melhoria da eficiência no consumo 
de energia e, principalmente, aumento de desempenho. Este aumento de desempenho 
vem acompanhado de inúmeras inovações tecnológicas desde o projeto do núcleo dos 
processadores até a interação deste com outros periféricos como memórias ou protocolos 
de comunicação. O resultado deste avanço pode-se ver cada vez mais em nossas casas 
com o acréscimo de equipamentos “inteligentes”, que gerenciam suas próprias funções 
possibilitando ao usuário diversas formas de controle, ou até mesmo em nossos bolsos, os 
smartphones vêm ganhando cada vez mais espaço no mercado mundial e ano após ano 
estão sempre sendo lançadas novas versões com maior poder de processamento e 
eficiência energética. 
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. 
O objetivo deste trabalho é introduzir a alunos de graduação voltada para a área de 
sistemas embarcados, conhecimentos mínimos necessários para iniciar seus estudos e 
pesquisas diante da família de microcontroladores ARM Cortex-M4 Tiva C Series cuja 
fabricante é a Texas Instruments.Logo, este trabalho fornecerá meios aos quais o 
interessado na área instale os softwares adequados, utilize os exemplos fornecidos pelo 
fabricante, crie seus próprios projetos e utilize periféricos do microcontrolador como 
GPIO, UART, Interrupção e Timer. 
 
 
 
 
 
[Digite texto] 
 
 5 
 
2. Os microcontroladores da série TM4C123x 
 
Os microcontroladores da série TM4C123x da Texas Instruments são os mais novos 
microcontroladores de baixo custo da Texas a possuírem um núcleo ARM Cortex-M4. Além 
disto, o microcontrolador ainda conta com poderosos recursos como, resumidamente, 
grande capacidade de memória (FLASH, SRAM e EEPROM), FPU (Floating Point United), 
saídas PWM, Quadrature Encoder Inputs, Debug via JTAG, USART, SSI/SPI, I2C, CAN, USB, 
Hibernate com RTC, Timers e entradas AD com comparadores. 
 
 
Figura 1 - Os Microcontroladores TM4C123X 
[Digite texto] 
 
 6 
 
Figura 2 - Diagrama de Blocos do Microcontrolador TM4C123GH6PM 
 
NOTA: Outras informações poderão ser encontradas no datasheet do microcontrolador 
TM4C123GH6PM em [12]. 
 
 
[Digite texto] 
 
 7 
 
 
2.1 O Núcleo ARM Cortex-M4 
 
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] 
[Digite texto] 
 
 8 
 
Figura 3 - Fabricantes que trabalham com o Núcleo ARM. 
Inicialmente voltado para aplicações de grande poder de processamento que exigiam 
um sistema operacional, hoje a empresa ARM também possui outra linha de núcleos onde 
fornece sua arquitetura para aplicações de menor porte no campo de Microcontroladores 
e FPGA. 
 
Figura 4 - Linha de Núcleos A, R e M da ARM. 
 
 
 
 
 
[Digite texto] 
 
 9 
 
2.2 Periféricos Estudados 
 
Como já citado, dentro da série de microcontroladores TM4C123x, inicialmente serão 
estudados os periféricos de GPIO, NVIC e TIMER. 
 
2.2.1 GPIO – General Purpose IN/OUT 
 
O GPIO (General Purpose In Out) ou, em português, periférico de Entradas e Saídas de 
Uso Geral é o periférico mais importante no estudo de microcontroladores. Com o GPIO é 
possível ler o estado de sensores externos, acionar relés, LEDs, sirenes, etc. Muito utilizado 
no campo da automação de qualquer processo, qualquer que seja o equipamento. 
Na família de microcontroladores TM4C123x, o GPIO conta com a possibilidade de saída 
a +3,3V (tensão de operação do microcontrolador) e entrada a +3,3V ou +5V. O que 
possibilita a compatibilidade elétrica de forma direta com uma vasta gama de periféricos 
eletrônicos que operam com +5V. 
Para aplicações de leitura que requerem um rápido tratamento ou prioridade no 
Firmware em aplicação, é possível habilitar interrupção para qualquer pino do GPIO. Além 
disso, todos os pinos também podem contar com: o recurso Schmitt Trigger, Pull Up, Pull 
Down, modo Coletor Aberto e controle de corrente de saída a 2, 8 ou 18mA. 
Tudo isto torna extremamente versátil diversas aplicações envolvendo este 
microcontrolador e outros periféricos e ainda reduzem custos no projeto de Placas de 
Circuito Impressos (PCIs), evitando circuitos de drivers, buffers de tensão e resistores 
externos. 
 
2.2.2 NVIC – Nested Vector Interrupt Controller 
 
Contando com 256 níveis de prioridade, do 1 ao 15 para o núcleo ARM e do 16 ao 255 
conforme a sua aplicação. As interrupções podem ser habilitadas em qualquer um dos 
pinos do GPIO, conforme dito anteriormente, e disparadas de diversas formas como borda 
de subida, descida, ambas ou nível lógico. 
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. 
 
 
[Digite texto] 
 
 10 
 
 
2.2.3 O TIMER 
 
O periférico TIMER é composto por contadores de 32 e 64 bits podendo ser disparados 
através de interrupções externas ou pelo código no modo “One Shot”. Ou podendo 
trabalhar em modos periódicos, habilitados para chamar uma interrupção a cada período 
de tempo pré-selecionado. 
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 
 
As memórias da série de microcontroladores TM4C123x podem variar, conforme o 
microcontrolador escolhido, atingindo o limite de: 
Flash: 256KB 
EEPROM: 2KB 
SRAM: 32 KB 
 
3. A Placa de Desenvolvimento TIVA C Series EK-TM4C123G 
 
A Placa de Desenvolvimento ou “Launchpad Evaluation Board” pode ser adquirida no 
site de venda da Texas [5] por aproximadamente $13,00. Ela foi desenvolvida de forma a 
extrair e disponibilizar todos os recursos do microcontrolador e facilitar o acesso à 
programação via Software/ICDI e Debug. 
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. 
[Digite texto] 
 
 11 
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. 
 
 
Figura 5 - Placa de Desenvolvimento EK-TM4C123G 
[Digite texto] 
 
 12 
 
Figura 6 - Diagrama de blocos da Placa de Desenvolvimento EK-TM4C123G 
 Nos exemplos mostrados nesta apostila serão utilizados os seguintes pinos do 
microcontrolador: 
 
Figura7 - Pinos de entrada/saída da launchpad 
 
Figura 8 - Pinos da porta Serial utilizada. 
[Digite texto] 
 
 13 
NOTA: Outras informações poderão ser acessadas na documentação: Tiva™ C Series 
TM4C123G LaunchPad Evaluation Board User’s Guide [1]. 
 
4. Code Composer Studio v6 (CCS) 
 
Disponível gratuitamente no site da Launchpad da Texas, o software oficial da Texas é o 
Code Composer Studio que está em sua sexta versão durante a elaboração deste trabalho. 
O Code Composer conta com diversos recursos de debug e otimização do código e IDE 
Eclipse. [4] 
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. 
4.1 Instalando o CCS e configurações necessárias 
 
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: 
 É recomendável que seja feito o download do software através do 
instalador Off-line. 
 Durante a instalação, desativar a “proteção em tempo real” do antivírus 
utilizado. 
 Fornecer as permissões de Firewall solicitadas. 
 Após instalar o CCS, não salve seu “workspace” em usuários que 
contenham acento, ou outros caracteres, no nome. 
 É recomendado que todos os programas sejam instalados dentro da pasta 
“C:\ti”. 
 Utilizando o Windows, clique com o botão direito no executável do CCS e 
execute “como administrador”. 
 
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”. 
[Digite texto] 
 
 14 
 
Figura 9 - Selecionando o suporte a família Tiva C Series no CCS. 
 
2º Passo: Na tela de emuladores do CCS, mantenha a condição pré-estabelecida. 
 
Figura 10 - Configuração padrão do CCS. 
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]. 
[Digite texto] 
 
 15 
 
Figura 11 - App Center 
 
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. 
[Digite texto] 
 
 16 
 
Figura 12 - Tela inicial do CCS. 
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. 
[Digite texto] 
 
 17 
 
Figura 13 - Buscando a TivaWare através do App Center. 
Nota: Caso não seja possível encontrar a TivaWare através do App Center, realizar o 
download através da referência [9]. 
 
Figura 14 - Download da TivaWare 
 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. 
[Digite texto] 
 
 18 
 
Figura 15 -Link de download da TivaWare 
 Na mesma página de downloads também poderão ser encontrados pacotes mais 
completos com os softwares utilizados e exemplos de outras launchpads da Texas. 
Também poderão ser encontrados aplicativos muito úteis como o LM Flash Programmer e 
os drivers ICDI/FTDI necessários caso seu computador não reconheça a launchpad. 
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”. 
Com a conexão feita no modo “Debug”, cheque se no gerenciador de dispositivos os 
itens estão apresentados conforme a figura 16. 
 
Figura 16 - Itens acrescidos ao Gerenciador de Dispositivos do Windows. 
Nota 1: Para chegar ao Gerenciador de Dispositivos digite “gerenciador de dispositivos” 
no iniciar, ou busca, do Windows ou vá através do Painel de Controle. Caso tenha dúvida, 
checar a referência [10]. 
Nota 2: Caso os itens destacados não apareçam no Gerenciador de Dispositivos 
automaticamente, realizar o download do driver necessário conforme a referência [11]. 
[Digite texto] 
 
 19 
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 
 
A TivaWare é um conjunto de ferramentas que incluem uma vasta biblioteca de drivers 
(Driver Library) e exemplos prontos para diversas várias aplicações. Fornecida pela Texas 
para todos os microcontroladores da família TIVA ARM Cortex M4, ela fornece diversas 
funções e bibliotecas que dinamizam a configuração de todos os registradores do 
microcontrolador, facilitando assim o gerenciamento e configuração de seus periféricos e 
comunicação com outros dispositivos. Toda a documentação que envolve sua utilização e 
exemplos de aplicações pode ser baixada no site da Texas conforme a referência [2]. 
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. 
Dois documentos muito importantes para o entendimento da TivaWare e dos seus 
recursos utilizados nesta apostila estarão dentro da pasta “docs” 
(C:\ti\TivaWare_C_Series-2.1.0.12573\docs), são eles: TivaWare Peripheral Driver Library e 
TivaWare Utilities Library. 
 
Figura 17 - Documentação da TivaWare 
[Digite texto] 
 
 20 
Após incluirmos a TivaWare ao nosso projeto, será possível configurarmos de maneira 
simples e rápida todos os periféricos estudados nesta apostila como GPIO, NVIC, TIMER e 
UART. 
5.1 Rodando os exemplos da TivaWare 
 
Após a instalação da TivaWare, será criada uma pasta de nome “TivaWare_C_Series-
x.x.x.x”, conforme recomendado, dentro da pasta “C:\TI”. Abrindo a pasta da TivaWare 
serão encontradas várias pastas muito úteis para o desenvolvimento de novas aplicações 
contendo exemplos, documentação, bootloader, bibliotecas, drivers, etc. 
1º Passo: Para rodarmos os exemplos, será necessário clicar em “Project” -> “Import CCS 
Projects”. 
 
Figura 18 - Importando Projetos I 
 
 
 
 
 
 
 
 
 
[Digite texto] 
 
 21 
 
2º Passo: Abra o “Browse...” e selecione a pasta da TivaWare. 
 
Figura 19 - Importando Projetos II 
 
 
 
 
 
 
 
 
 
 
[Digite texto] 
 
 22 
 
3º Passo:Nesta etapa, serão expostos todos os projetos incluídos na TivaWare. 
Selecione todos ou algum em específico para testar. Inicialmente, iremos testar o 
“project0”. 
 
Figura 20 - Selecionando o Project0 da TivaWare 
 
 
 
 
 
 
[Digite texto] 
 
 23 
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”. 
 
Figura 21- Ferramenta de compilação 
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. 
Figura 22- Mensagens referentes à compilação do projeto. 
 
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. 
[Digite texto] 
 
 24 
 
Figura 23 - Atualizando a versão do compilador utilizado 
Após alterar o compilador, clique em “Build” novamente e verifique que o warning 
desapareceu. Analise brevemente o que o código faz no arquivo “project0.c” no “Project 
Explorer”. 
Logo, o projeto estará pronto para ser enviado para nossa launchpad e ser testado! 
6º Passo: Para enviar o código para o microcontrolador e “debugar” suas ações, 
verifique na janela “Target Configurations”-> “User Defined” se o target: Tiva 
TM4C123GH6PM.ccxml está marcado como Default. 
Caso o target esteja correto, clique na ferramenta de “Debug” (inseto verde) e o código 
irá ser gravado na memória flash microcontrolador. 
 
Figura 24 - Ferramentas de Debug 
[Digite texto] 
 
 25 
 Ao mandar o código pela ferramenta de Debug, o código inicialmente estará em 
estado de “pause” na primeira linha do código. Para ir depurando o código passo a passo, 
utilize as ferramentas de “Step” (setas amarelas), para rodar o código normalmente clique 
na ferramenta “Resume” (seta verde) ou aperte F8. Após rodar o código livremente você 
poderá pausá-lo em qualquer momento através da ferramenta “Suspend” (pause 
amarelo). Para interromper o debug e comunicação com a placa clique em “Terminate” 
(quadrado vermelho). 
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”. 
8º Passo: Para estabelecermos uma comunicação serial da launchpad com o 
computador, precisaremos de um software próprio para este tipo de comunicação. Os 
mais comuns, gratuitos, são o Hercules e o Putty. Em nossos exemplos usaremos o Putty 
que poderá ser baixado, conforme a referência [13], em sua versão mais simples. 
Verifique no gerenciador de dispositivos em qual “COM” está sua launchpad e configure 
o software Putty conforme a figura 25 para a sua porta COM identificada. 
[Digite texto] 
 
 26 
 
Figura 25 - Configuração do Putty para Serial 
Note que os itens alterados serão: 
1. Connection type: Serial (Tipo de comunicação estabelecida) 
2. Serial line: COM__ (COM identificada pelo seu computador) 
3. Speed: 115200 (Baud Rate) 
4. Saved Sessions: TM4C123 (Nome opcional) 
 
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. 
[Digite texto] 
 
 27 
 
Figura 26 - Mensagem exibida através do Putty 
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. 
 
5.2 Criando um Projeto do Zero [3] 
 
Um dos projetos disponibilizados pela Texas é o de nome “project” cuja função é 
fornecer um projeto base, já com todas as configurações necessárias, para projetos mais 
complexos. Ainda sim, mostraremos como criar um projeto do zero para entender melhor 
a utilização de alguns dos recursos da TivaWare e do próprio CCS que estarão sendo 
utilizados. 
1º Passo: Para começarmos um projeto do zero, clique em “Project”-> ”New CCS Project”. 
 
Figura 27 - Iniciando um novo projeto 
 
 
 
 
 
 
 
[Digite texto] 
 
 28 
 
Habilite as configurações interessantes ao projeto conforme a figura 28. 
 
Figura 28 - Configurações do novo projeto 
 
2º Passo: Clique com o botão direito em cima do projeto e clique em “Properties”. Na 
janela de propriedades “CCS General” marque o check box apresentado na figura 29. 
[Digite texto] 
 
 29 
 
Figura 29 - Alterando as opções de target 
Nota: Inicialmente, através das configurações de “View”, tente deixar sua área de trabalho 
do CCS conforme a figura 30. 
 
Figura 30 - Área de trabalho do CCS 
[Digite texto] 
 
 30 
 
 3º Passo: Clique com o botão direito em cima do projeto e clique em “Properties”. 
Selecione janela de propriedades “Resource”-> “Linked Resources” -> “Path Variables” e 
clique em “New”. Clicando em “New” selecione um nome e diretório (pasta da TivaWare) 
conforme a figura 31. 
 
Figura 31 - Criando um New Path Variable 
Logo após, verifique se a nova Path foi adicionada a lista. 
[Digite texto] 
 
 31 
 
Figura 32 - Lista de Path Variables 
3º Passo: Clique com o botão direito em cima do projeto e clique em “Properties”. 
Selecione janela de propriedades “CCS Build”-> “Variables” (Note que a lista está vazia!), 
clique em “Add...” e realize as definições conforme a figura 33. 
 
Figura 33 - Adicionando um diretório de variáveis 
[Digite texto] 
 
 32 
Após criar o diretório, cheque se ele aparecerá na lista de “Variables”.Figura 34 - Diretório de variáveis criado 
4º Passo: Após preparar o nosso projeto, está na hora de realmente incluirmos os 
recursos da TivaWare ao nosso projeto. Para isso, vamos vincular nosso projeto a Driver 
Library. 
Clique “Project”-> “Add Files...” e busque o arquivo “driverlib.lib” dentro de: 
C:\ti\TivaWare_C_Series-2.1.0.12573\driverlib\ccs\Debug. 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 35. 
 
Figura 35 - Vinculando o projeto a driverlib 
5º Passo: Para que as bibliotecas utilizadas em nosso programa sejam encontradas, 
agora iremos configurar as opções do “Include”. 
Clique com o botão direito em cima do projeto e clique em “Properties”. Selecione 
janela de propriedades “CCS Build”-> “ARM Compiler” -> “Include Options” e adicione o 
diretório TIVAWARE_INSTALL conforme a figura 36. 
[Digite texto] 
 
 33 
 
Figura 36 - Configurando o Include 
Verifique se o diretório criado foi adicionado lista. 
 
Figura 37 - Diretório TIVAWARE_INSTALL 
6º Passo: Se todas as etapas anteriores foram seguidas corretamente. Será possível ver 
os arquivos no Project Explorer conforme a figura 38. 
 
Figura 38 - Project Explorer pronto iniciar o projeto 
[Digite texto] 
 
 34 
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. 
Copiar o seguinte código dentro do main.c do nosso projeto: 
///////////////////////////////////////////////////////////////////////////////////// 
// project0.c disponibilizado pela TI adaptado. 
#include <stdint.h> 
#include <stdbool.h> 
#include "inc/hw_types.h" // Inclusão das bibliotecas 
#include "inc/hw_memmap.h" 
#include "driverlib/sysctl.h" 
#include "driverlib/gpio.h" 
#define RED_LED GPIO_PIN_1 
#define BLUE_LED GPIO_PIN_2 // Atribuição de nomes aos pinos do GPIO 
#define GREEN_LED GPIO_PIN_3 
#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); 
 } 
} 
///////////////////////////////////////////////////////////////////////////////////// 
[Digite texto] 
 
 35 
 
Se o código rodou normalmente, nosso projeto do zero foi criado com sucesso! 
 
 Agora, vamos entender as funções de configuração da TivaWare periférico por periférico 
até obtermos o conhecimento básico para a criação de novos projetos. 
 
5.3 Clock Geral do Sistema 
 
Dando início ao projeto do firmware utilizando a TivaWare, é encontrado como primeiro 
passo a ser seguido a configuração do clock geral do sistema. A função a ser utilizada para 
este procedimento é a SyzCtlClockSet(uint32_t ui32Config). Onde ui32Config é o 
parâmetro, ou os parâmetros de configuração (quando vários parâmetros, os mesmos são 
separados por “|”). 
Exemplo de Configuração: 
 SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN) 
No exemplo acima, pode ser verificado a utilização de um cristal externo de 16MHz, 
representados pelos parâmetros SYSCTL_XTAL_16MHZ e SYSCTL_OSC_MAIN e 
configuração do clock do sistema através de uma PLL (que possui 200MHz de referencia 
para cálculos) e divisão da mesma por 5, representadas pelos parâmetros SYSCTL_SYSDIV5 
e SYSCTL_USE_PLL. 
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. 
Exemplo de habilitação do periférico GPIO Port F: 
 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: 
 
 
 
 
 
[Digite texto] 
 
 36 
/* 7.18.1.1 Exact-width integer types */ 
 
 typedef signed char int8_t; 
 typedef unsigned char uint8_t; 
 typedef short int16_t; 
 typedef unsigned short uint16_t; 
 typedef int int32_t; 
 typedef unsigned int uint32_t; 
 
 
 typedef long long int64_t; 
 typedef unsigned long long uint64_t; 
 
5.4 Configurando o GPIO 
 
Para a configuração do GPIO são utilizadas basicamente três funções: 
1. GPIOPinTypeGPIOOutput(uint32_t ui32Port, uint8_t ui8Pins). 
Função onde um pino da GPIO do microcontrolador é configurado como saída. 
Onde o parâmetro ui32Port representa o PORT a ser configurado e o ui8Pins o 
pino. 
 
2. GPIOPinTypeGPIOInput(uint32_t ui32Port, uint8_t ui8Pins). 
Função onde um pino da GPIO do microcontrolador é configurado como entrada. 
 
3. GPIOPadConfigSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32Strength, 
uint32_t ui32PinType). 
Função que configura as portas de entrada onde o parâmetro ui32Strength 
representa a corrente máxima a ser permitida pelo pino e o parâmetro 
ui32PinType configura se o pino terá Pull Up, Pull down ou Coletor Aberto. 
 
Exemplo de configuração do GPIO: 
////Configuração da GPIO F //// 
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 
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); 
 
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. 
[Digite texto] 
 
 37 
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. 
1. GPIOPinRead(uint32_t ui32Port, uint8_t ui8Pins). 
Função que retorna se o pino selecionado está em nível lógico alto (1) ou baixo (0). 
Esta função retorna o valor do pino referente a sua posição no byte referente ao 
PORT verificado.Por exemplo: PIN0 ativo = 00000001, PIN1 ativo = 00000010, 
seguindo até PIN7 ativo 10000000. 
Abrindo a biblioteca gpio.h (C:\ti\TivaWare_C_Series-
2.1.0.12573\driverlib\gpio.h), podemos verificar esta declaração no sistema 
hexadecimal. 
//***************************************************************** 
// 
// 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 
2. GPIOPinWrite(uint32_t ui32Port, uint8_t ui8Pins, uint8_t ui8Val). 
Função que manda nível lógico alto (1) ou nível lógico baixo (0) para o pino em 
questão a partir do mesmo sistema de valores já citado na função GPIOPinRead. 
 
Exemplo de utilização das Funções de entrada e saída: 
GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4) //Retorna o endereço, ou 
valor, do PIN_4 do PORTF caso 1. 
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,GPIO_PIN
_2); //Aciona somente o PIN_2 do PORTF 
 
[Digite texto] 
 
 38 
NOTA: Um exemplo de utilização dos pinos de entrada e saída, conforme a configuração 
apresentada, encontra-se no Exemplo 1 em Anexo. 
 
 
5.5 Utilizando uma UART 
 
Para a configuração de uma UART segue abaixo as principais funções da Driverlib: 
1. UARTConfigSetExpClk(uint32_t ui32Base, uint32t ui32UARTClk, uint32_t 
ui32Baud, uint32_t ui32Config) 
Função que configura os parâmetros da serial utilizada. 
 
2. UARTCharPut(uint32_t ui32Base, unsigned char ucData). 
Função que imprime na serial onde o parâmetro ucData é a informação tipo char a 
enviada. 
3. UARTCharGet(uint32_t ui32Base). 
Função que retorna o caractere lido na serial como int32_t. 
As funções acima são fornecidas pela Driverlib da TivaWare. Em nosso Exemplo 1 em 
Anexo vamos usar algumas funções da biblioteca “uartstdio.h” (C:\ti\TivaWare_C_Series-
2.1.0.12573\utils\uartstdio.h) de Utils. Para entendê-las melhor exercite sua busca pelas 
funções verificando a documentação de “Utils” indicada na figura 17. 
 
 
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) 
{ 
[Digite texto] 
 
 39 
(...) 
} 
} 
 
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. 
 
Figura 39 - Adicionando o arquivo uartstdio.c ao projeto. 
Nota 3: Caso a função “Add Files...” em “Project” esteja apagada, dê um clique no nome 
do seu projeto no Project Explorer. 
5.6 Configurando o NVIC 
 
Para a configuração de uma interrupção temos abaixo as principais funções: 
1. IntMasterEnable() 
Função que permite ao processador responder a todas as chamadas de interrupção 
utilizadas. 
2. 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 da seguinte forma: 
GPIO_INT_PIN_0, GPIO_INT_PIN_1, ... ou GPIO_INT_PIN_7. 
3. GPIOIntTypeSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32IntType). 
Função onde um pino da GPIO do microcontrolador 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 (para borda de descida), GPIO_RISING_EDGE (para borda de 
[Digite texto] 
 
 40 
subida), GPIO_BOTH_EDGE (qualquer borda), GPIO_LOW_LEVEL (nível lógico baixo) 
e GPIO_HIGH_LEVEL (nível lógico alto). 
 
 
Exemplo de configuração de uma Interrupção no Port F e Pino 4 (SW1) por borda de 
descida: 
 GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE); 
 GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); 
 IntEnable(INT_GPIOF); 
 
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); 
//********************************************************************** 
 
 2º Passo: Adicione essa função ao vetor de interrupções em sua devida posição 
substituindo a função padrão “IntDefaultHandler” pela sua função utilizada. Para uma 
interrupção no PORTF, sua posição será aproximadamente na linha 116 do código do 
“tm4c123gh6pmi_startup_ccs.c”. 
IntDefaultHandler, // FLASH Control 
PortFIntHandler, // GPIO Port F 
IntDefaultHandler, // GPIO Port G 
IntDefaultHandler, // GPIO Port H 
 
 
[Digite texto] 
 
 41 
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! 
 
 
5.7 Configurando o TIMER 
 
Para a configuração de um TIMER temos abaixo as principais funções: 
1. TimerConfigure(uint32_t ui32Base, uint32t ui32Config) 
Função que configura o tipo de timer utilizado onde o parâmetro ui32Config e 
escolhido conforme a configuração de Timer periódico, Disparo único, PWM, etc. 
 
2. TimerEnable(uint32_t ui32Base, uint32_t ui32Timer). 
Função que habilita o timer escolhido após a sua configuração onde o parâmetro 
ui32Timer é o Timer escolhido: TIMER_A, TIMER_B, ou TIMER_BOTH. 
3. TimerLoadSet(uint32_t ui32Base, uint32_t ui32Timer, uint32_t 
ui32Value). 
Função que seleciona o valor de estouro do Timer (Em caso de Timer periódico) 
onde o parâmetro ui32Value é um número inteiro representado por até 32 bits. 
4. TimerIntClear(uint32_tui32Base, uint32_t ui32IntFlags). 
Função que deve ser chamada após a interrupção do timer periódico para manter 
o Trigger. 
Exemplo de configuração de Timer Periódico: 
 
 unsigned long Period; 
////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); 
 
NOTA: A função SysCtlClockGet() retorna o valor do clock geral do sistema. 
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. 
[Digite texto] 
 
 42 
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); 
//********************************************************************** 
 
 2º Passo: Adicione essa função ao vetor de interrupções em sua devida posição 
substituindo a função padrão “IntDefaultHandler” pela sua função utilizada. Para uma 
interrupção no PORTF, sua posição será aproximadamente na linha 106 do código do 
“tm4c123gh6pmi_sturtup_ccs.c”. 
 IntDefaultHandler, // Watchdog timer 
 Timer0IntHandler, // Timer 0 subtimer A 
 IntDefaultHandler, // Timer 0 subtimer B 
 IntDefaultHandler, // Timer 1 subtimer A 
 
Após estas configurações, sempre que o timer atingir o período de contagem 
selecionado, ele vai gerar uma interrupção e a função declarada será executada! 
 
 
 
 
 
 
 
 
 
[Digite texto] 
 
 43 
6. Conclusão 
 
Visando introduzir os conceitos básicos necessários a aprendizagem dos 
microcontroladores da série ARM Cortex M4 TM4C123, este trabalho apresentou as 
funcionalidades básicas, diante da utilização a TivaWare, de itens como GPIO, Timer, 
USART e Interrupção. Para que o estudante de sistemas embarcados aprenda outros 
periféricos não utilizados nesta apostila e aprofunde seus conhecimentos sobre esta 
arquitetura, recomenda-se como algumas excelentes formas de informação o workshop 
disponível em forma de vídeos pela TI [3] ou o livro “Introduction to ARM Cortex-M 
Microcontrollers” de Jonathan W. Valvano. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
[Digite texto] 
 
 44 
7. ANEXOS 
7.1 Exemplo 1 – Utilizando o GPIO e UART 
 
Neste exemplo serão mostradas configurações para utilização da GPIO e UART. Os 
pinos PF1, PF2 e PF3 serão configurados como saída por estarem conectados ao LED RGB 
da launchpad e os pinos PF0 e PF4 serão configurados como entrada por estarem nos 
botões SW1 e SW2 da launchpad. Além disto, as informações referentes à cor do LED 
serão impressas pela serial e poderão ser verificadas através do terminal Putty. 
 
//////////////EXEMPLO 1 - CONFIGURAÇÕES DA GPIO E UART//////////////////// 
#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" 
 
//"Defines" retirados da biblioteca "inc/tm4c123gh6pm.h" 
//utilizados para declarar as variáveis de desbloqueio 
//do pino PF0. 
#define GPIO_PORTF_LOCK_R (*((volatile uint32_t *)0x40025520)) 
#define GPIO_PORTF_CR_R (*((volatile uint32_t *)0x40025524)) 
 
int LED=4; 
 
/***Configuração da UART0, Utils.c***/ 
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) { 
 
// Habilita clock geral do sistema 
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16
MHZ|SYSCTL_OSC_MAIN); 
 
////Configuração da GPIO F //// 
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 
 
[Digite texto] 
 
 45 
GPIO_PORTF_LOCK_R = 0x4C4F434B; // Desbloqueio do 
GPIO_PORTF_CR_R = 0x1F; // pino PF0. 
 
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///////////////////////////////// 
 
Com este exemplo em funcionamento, será verificado que: 
1) Pressionado o botão SW1 o LED ficará vermelho e esta informação será 
impressa na serial. 
2) Pressionado o botão SW2 o LED ficará verde e esta informação será 
impressa na serial. 
3) Caso nenhum botão seja apertado o LED ficará azul e nada será impresso 
na serial. 
4) Os valores 2, 4 e 8 representam os pinos (em hexadecimal) conforme 
descrito no tópico “5.4 Configurando o GPIO”. 
 
 
[Digite texto] 
 
 46 
7.2 Exemplo 2 – Utilizando uma Interrupção 
 
Neste exemplo será demonstrado o funcionamento de uma Interrupção. Sempre que o 
botão SW2 for pressionado o código executará as linhas dentro do while e do if e o LED ficará 
verde durante o tempo de delay selecionado. Caso o botão SW1 seja pressionado a execução 
do código irá para a função de tratamento de interrupção PortFIntHandler e o LED ficará 
vermelho. Para verificar melhor como ocorre este procedimento, analise o código linha por 
linha através dos botões de Step. 
/////////////EXEMPLO 2 - CONFIGURAÇÕES DE INTERRUPÇÃO//////////////// 
 
#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" 
 
//"Defines" retirados da biblioteca "inc/tm4c123gh6pm.h" 
//utilizados para declarar as variaveis de desbloqueio 
//do pino PF4. 
#define GPIO_PORTF_LOCK_R (*((volatile uint32_t *)0x40025520)) 
#define GPIO_PORTF_CR_R (*((volatile uint32_t *)0x40025524)) 
 
uint8_t LED=4; 
 
/***Interrupção por borda de descida no PortF Pin4 (SW1)***/ 
void PortFIntHandler(void){ 
 GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); 
 LED=2; 
 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED); 
 UARTprintf("Red\n"); 
 SysCtlDelay(20000000); 
 
} 
 
/***Configuração da UART0, Utils.c***/ 
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); 
 
} 
 
[Digite texto] 
 
 47 
int main(void) { 
 
 
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL
_OSC_MAIN); // Habilita clock geral do sistema 
 
 ////Configuração da GPIO F //// 
 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 
 
 GPIO_PORTF_LOCK_R = 0x4C4F434B; // Desbloqueio do 
 GPIO_PORTF_CR_R = 0x1F; //pino PF0. 
 
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); 
 
 ////Configurando uma interrupção no PortD: Pin4 (SW1)//// 
 GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE); 
 GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); 
 IntEnable(INT_GPIOF); 
 
 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/////////////////////////////////////// 
 
 
 
[Digite texto] 
 
 48 
Com este exemplo em funcionamento, será verificado que: 
1) Se o LED estiver verde ou azul, ou seja, o código está dentro do while, e o botão 
SW1 for pressionado, ele ficará vermelho instantaneamente caracterizando a 
entrada na interrupção. 
2) Se a execução estiver dentro da interrupção, LED vermelho, quando se 
pressiona SW2 nada acontece. Ou seja, o código só volta para o seu “trajeto” 
normal depois de tratar a interrupção. 
3) Neste exemplo a Interrupção foi configurada para borda de descida 
(GPIO_FALLING_EDGE), verifique as variáveis da função GPIOIntTypeSet dentro 
da documentação [2] e teste outras possibilidades como borda de subida, nível 
lógico, etc. 
 
7.3 Exemplo 3 – Utilizando o Timer 
 
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. 
 
///////////////EXEMPLO 3 - CONFIGURAÇÕES DE TIMER//////////////// 
#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" 
#include "driverlib/timer.h" 
#include "inc/hw_timer.h" 
 
 
#define GPIO_PORTF_LOCK_R (*((volatile uint32_t *)0x40025520)) 
#define GPIO_PORTF_CR_R (*((volatile uint32_t *)0x40025524)) 
 
#define MULT_TIMER 1 // Ajuste do Timer para teste 
 
uint8_t LED=4, flag=0; 
 
/***Interrupção periodica do timer0***/ 
void Timer0IntHandler (void) 
{ 
 
 TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT); 
 if(flag==1) 
 { 
 LED=4; 
[Digite texto] 
 
 49 
 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; 
 } 
} 
 
/***Interrupção por borda de descida no PortF Pin4***/ 
void PortFIntHandler(void) 
{ 
 GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); 
 LED=2; 
 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED); 
 UARTprintf("Red\n"); 
 SysCtlDelay(20000000); 
 
} 
 
/***Configuração da UART0, Utils.c***/ 
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) { 
 
 unsigned long Period; 
 
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL
_OSC_MAIN); 
 
 ////Configuração da GPIO F //// 
 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 
 
 GPIO_PORTF_LOCK_R = 0x4C4F434B; // desbloqueia o PortF 
 GPIO_PORTF_CR_R = 0x1F; // permite alterações para PF4-0 
 
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, 
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); 
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0); 
[Digite texto] 
 
 50 
GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4, 
GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); 
 
 ////Configurando uma interrupção no PortD: Pin4 (SW1)//// 
 GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE); 
 GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); 
 IntPrioritySet(INT_GPIOF, 0x40); // Setando prioridade 
 IntEnable(INT_GPIOF); 
 
 ////Habilitação do TIMER0//// 
 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); 
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); //Configura o Timer 
como periódico 
Period = (SysCtlClockGet()*MULT_TIMER); // Recebe o valor do clock 
multiplicado por uma variável para o período 
 TimerLoadSet(TIMER0_BASE, TIMER_A, Period -1); 
 TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); 
 TimerEnable(TIMER0_BASE, TIMER_A); 
 IntPrioritySet(INT_TIMER0A, 0x10); // Setando prioridade 
 IntEnable(INT_TIMER0A); 
 
 
 ConfigureUART(); 
 
 while(1) 
 { 
 //Isso mesmo! O while está vazio! 
 } 
 
} 
///////////////////////////EXEMPLO 3 - FIM////////////////////// 
 
Com este exemplo em funcionamento, será verificado que: 
1) Sempre que o Timer atingir seu período, será gerada uma interrupção que 
mudará a cor do LED entre verde e azul. 
2) Com a prioridade escolhida sempre que o botão SW1 for pressionado, a 
interrupção por borda de descida será executada deixando o LED vermelho. 
Logo, como a prioridade do Timer é maior que a do GPIOF, assim que o Timer 
cumprir seu período o LED deixará de ficar vermelho e mudará para azul ou 
verde. 
3) Experimente alternar o valor das prioridades e poderá verificar que 
pressionando o botão SW1 o LED ficará vermelho até concluir o tempo de delay 
selecionado. Independente das interrupções de Timer que agora estão com 
uma prioridade inferior. Note que quanto menor o valor ajustado a prioridade 
maior será a prioridade da interrupção. 
 IntPrioritySet(INT_GPIOF, 0x10); 
 IntPrioritySet(INT_TIMER0A, 0x40); 
4) Experimente também alterar o valor da constante MULT_TIMER para alterar o 
período de ajuste do Timer. 
 #define MULT_TIMER 4 // Ajuste do Timer para teste 
[Digite texto] 
 
 51 
5) Caso queira programar alguma função para o botão SW2 no pinoPF0, este 
exemplo permaneceu com as suas configurações como nos exemplos 
anteriores. 
 
7.4 Arquivo TM4C123GH6PM_STARTUP_CCS.C 
 
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 
// 
//*************************************************************************** 
[Digite texto] 
 
 52 
extern void _c_int00(void); 
 
//*************************************************************************** 
// 
// 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 
[Digite texto] 
 
 53 
 IntDefaultHandler, // Quadrature Encoder 0 
 IntDefaultHandler, // ADC Sequence 0 
 IntDefaultHandler, // ADC Sequence 1 
 IntDefaultHandler, // ADC Sequence 2 
 IntDefaultHandler, // ADC Sequence 3 
 IntDefaultHandler, // Watchdog timer 
 Timer0IntHandler, // Timer 0 subtimer A 
 IntDefaultHandler, // Timer 0 subtimer B 
 IntDefaultHandler, // Timer 1 subtimer A 
 IntDefaultHandler, // Timer 1 subtimer B 
 IntDefaultHandler, // Timer 2 subtimer A 
 IntDefaultHandler, // Timer 2 subtimer B 
 IntDefaultHandler, // Analog Comparator 0 
 IntDefaultHandler, // Analog Comparator 1 
 IntDefaultHandler, // Analog Comparator 2 
 IntDefaultHandler, // System Control (PLL, OSC, BO) 
 IntDefaultHandler, // FLASH Control 
 PortFIntHandler, // GPIO Port F 
 IntDefaultHandler, // GPIO Port G 
 IntDefaultHandler, // GPIO Port H 
 IntDefaultHandler, // UART2 Rx and Tx 
 IntDefaultHandler, // SSI1 Rx and Tx 
 IntDefaultHandler, // Timer 3 subtimer A 
 IntDefaultHandler, // Timer 3 subtimer B 
 IntDefaultHandler, // I2C1 Master and Slave 
 IntDefaultHandler, // Quadrature Encoder 1 
 IntDefaultHandler, // CAN0 
 IntDefaultHandler, // CAN1 
 0, // Reserved 
 0, // Reserved 
 IntDefaultHandler, // Hibernate 
 IntDefaultHandler, // USB0 
 IntDefaultHandler, // PWM Generator 3 
 IntDefaultHandler, // uDMA Software Transfer 
 IntDefaultHandler, // uDMA Error 
 IntDefaultHandler, // ADC1 Sequence 0 
 IntDefaultHandler, // ADC1 Sequence 1 
 IntDefaultHandler, // ADC1 Sequence 2 
 IntDefaultHandler, // ADC1 Sequence 3 
 0, // Reserved 
 0, // ReservedIntDefaultHandler, // GPIO Port J 
 IntDefaultHandler, // GPIO Port K 
 IntDefaultHandler, // GPIO Port L 
 IntDefaultHandler, // SSI2 Rx and Tx 
 IntDefaultHandler, // SSI3 Rx and Tx 
 IntDefaultHandler, // UART3 Rx and Tx 
 IntDefaultHandler, // UART4 Rx and Tx 
 IntDefaultHandler, // UART5 Rx and Tx 
 IntDefaultHandler, // UART6 Rx and Tx 
 IntDefaultHandler, // UART7 Rx and Tx 
 0, // Reserved 
 0, // Reserved 
 0, // Reserved 
 0, // Reserved 
 IntDefaultHandler, // I2C2 Master and Slave 
 IntDefaultHandler, // I2C3 Master and Slave 
 IntDefaultHandler, // Timer 4 subtimer A 
 IntDefaultHandler, // Timer 4 subtimer B 
[Digite texto] 
 
 54 
 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 
[Digite texto] 
 
 55 
 IntDefaultHandler, // GPIO Port Q7 
 IntDefaultHandler, // GPIO Port R 
 IntDefaultHandler, // GPIO Port S 
 IntDefaultHandler, // PWM 1 Generator 0 
 IntDefaultHandler, // PWM 1 Generator 1 
 IntDefaultHandler, // PWM 1 Generator 2 
 IntDefaultHandler, // PWM 1 Generator 3 
 IntDefaultHandler // PWM 1 Fault 
}; 
 
//*************************************************************************** 
// 
// 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. 
// 
//*************************************************************************** 
[Digite texto] 
 
 56 
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////////////////////// 
 
 
7.5 Funções da TivaWare 
 
Através da TivaWare™ Peripheral Driver Library [2], ou C:\ti\TivaWare_C_Series-