Apostila tm4c 03_2015

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:
Figura 7 - 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:tiTivaWare_C_Series-2.1.0.12573docs), 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:tiTivaWare_C_Series-2.1.0.12573driverlibccsDebug. 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
//
}
}
/////////////////////////////////////////////////////////////////////////////////////

[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:ticcsv6toolscompilerarm_5.1.8include), 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 ////
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:tiTivaWare_C_Series-
2.1.0.12573driverlibgpio.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
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:tiTivaWare_C_Series-
2.1.0.12573utilsuartstdio.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:tiTivaWare_C_Series-2.1.0.12573utilsuartstdio.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_t ui32Base, 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
//**********************************************************************
//
// External declarations for the interrupt handlers used by the
application.
//
//**********************************************************************
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
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 "inc/hw_types.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
{
}
int main(void) {
// Habilita clock geral do sistema
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16
MHZ|SYSCTL_OSC_MAIN);

[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);
ConfigureUART();
while(1)
{
// Se SW2 for pressionado//
if(!(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0) &
GPIO_PIN_0))
{
LED=8;
UARTprintf("Verden");
}
if(!(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4) &
GPIO_PIN_4))
{
LED=2;
UARTprintf("Vermelhon");
}
GPIOPinWrite(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED);
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 "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.
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("Redn");
}
void
{
}

[Digite texto]
47
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL
_OSC_MAIN); // Habilita clock geral do sistema
GPIO_PORTF_LOCK_R = 0x4C4F434B; // Desbloqueio do
GPIO_PORTF_CR_R = 0x1F; //pino PF0.
////Configurando uma interrupção no PortD: Pin4 (SW1)////
ConfigureUART();
while(1)
{
if(!(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0) & GPIO_PIN_0))
{
LED=8;
UARTprintf("Verden");
GPIOPinWrite(GPIO_PORTF_BASE,
GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED);
}
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,
LED);
SysCtlDelay(200);
LED=4;
}
}
//////////////////////EXEMPLO 2 - FIM///////////////////////////////////////

[Digite texto]
48
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 "driverlib/interrupt.h"
#include "inc/hw_ints.h"
#include "driverlib/timer.h"
#include "inc/hw_timer.h"
#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
LED);
UARTprintf("Bluen");
flag=0;
}
else
{
LED=8;
LED);
UARTprintf("Greenn");
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("Redn");
}
void
{
}
int main(void) {
unsigned long Period;
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL
_OSC_MAIN);
GPIO_PORTF_LOCK_R = 0x4C4F434B; // desbloqueia o PortF
GPIO_PORTF_CR_R = 0x1F; // permite alterações para PF4-0

[Digite texto]
50
////Configurando uma interrupção no PortD: Pin4 (SW1)////
IntPrioritySet(INT_GPIOF, 0x40); // Setando prioridade
////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//////////////////////
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 pino PF0, 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.
//
//***************************************************************************
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, // SSI0 Rx and Tx
IntDefaultHandler, // I2C0 Master and Slave
IntDefaultHandler, // PWM Fault
IntDefaultHandler, // PWM Generator 0

[Digite texto]
53
IntDefaultHandler, // Quadrature Encoder 0
IntDefaultHandler, // ADC Sequence 0
IntDefaultHandler, // Watchdog timer
Timer0IntHandler, // Timer 0 subtimer A
IntDefaultHandler, // Analog Comparator 0
IntDefaultHandler, // System Control (PLL, OSC, BO)
IntDefaultHandler, // FLASH Control
PortFIntHandler, // GPIO Port F
IntDefaultHandler, // GPIO Port G
IntDefaultHandler, // GPIO Port H
IntDefaultHandler, // CAN0
IntDefaultHandler, // CAN1
0, // Reserved
0, // Reserved
IntDefaultHandler, // Hibernate
IntDefaultHandler, // USB0
IntDefaultHandler, // uDMA Software Transfer
IntDefaultHandler, // uDMA Error
IntDefaultHandler, // ADC1 Sequence 0
0, // Reserved
0, // Reserved
IntDefaultHandler, // GPIO Port J
IntDefaultHandler, // GPIO Port K
IntDefaultHandler, // GPIO Port L
0, // Reserved
0, // Reserved
0, // Reserved
0, // Reserved

[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, // Wide Timer 0 subtimer A
IntDefaultHandler, // Wide Timer 0 subtimer B
IntDefaultHandler, // FPU
0, // Reserved
0, // Reserved
IntDefaultHandler, // GPIO Port M
IntDefaultHandler, // GPIO Port N
0, // Reserved
0, // Reserved
IntDefaultHandler, // GPIO Port P (Summary or P0)
IntDefaultHandler, // GPIO Port P1
IntDefaultHandler, // GPIO Port Q (Summary or Q0)
IntDefaultHandler, // GPIO Port Q1

[Digite texto]
55
IntDefaultHandler, // GPIO Port R
IntDefaultHandler, // GPIO Port S
IntDefaultHandler, // PWM 1 Generator 0
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_int00n"
" 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:tiTivaWare_C_Series-
2.1.0.12573docs SW-TM4C-DRL-UG-2.1.0.12573.pdf, poderá ser verificada várias funções
que não foram demonstradas nesta apostila.
7.5.1 Funções da GPIO
 void GPIOADCTriggerDisable (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOADCTriggerEnable (uint32_t ui32Port, uint8_t ui8Pins)
 uint32_t GPIODirModeGet (uint32_t ui32Port, uint8_t ui8Pin)
 void GPIODirModeSet (uint32_t ui32Port, uint8_t ui8Pins, uint32_t
ui32PinIO)
 void GPIODMATriggerDisable (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIODMATriggerEnable (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOIntClear (uint32_t ui32Port, uint32_t ui32IntFlags)
 void GPIOIntDisable (uint32_t ui32Port, uint32_t ui32IntFlags)

[Digite texto]
57
 void GPIOIntEnable (uint32_t ui32Port, uint32_t ui32IntFlags)
 void GPIOIntRegister (uint32_t ui32Port, void (_pfnIntHandler)(void))
 uint32_t GPIOIntStatus (uint32_t ui32Port, bool bMasked)
 uint32_t GPIOIntTypeGet (uint32_t ui32Port, uint8_t ui8Pin)
 void GPIOIntTypeSet (uint32_t ui32Port, uint8_t ui8Pins, uint32_t
ui32IntType)
 void GPIOIntUnregister (uint32_t ui32Port)
 void GPIOPadConfigGet (uint32_t ui32Port, uint8_t ui8Pin, uint32_t
_pui32Strength, uint32_t_pui32PinType)
 void GPIOPadConfigSet (uint32_t ui32Port, uint8_t ui8Pins,
uint32_t,ui32Strength, uint32_tui32PinType)
 void GPIOPinConfigure (uint32_t ui32PinConfig)
 int32_t GPIOPinRead (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeADC (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeCAN (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeComparator (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeEPI (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeEthernetLED (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeEthernetMII (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeFan (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeGPIOInput (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeGPIOOutput (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeGPIOOutputOD (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeI2C (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeI2CSCL (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeI2S (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeLPC (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypePECIRx (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypePECITx (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypePWM (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeQEI (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeSSI (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeTimer (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeUART (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeUSBAnalog (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinTypeUSBDigital (uint32_t ui32Port, uint8_t ui8Pins)
 void GPIOPinWrite (uint32_t ui32Port, uint8_t ui8Pins, uint8_t ui8Val)
7.5.2 Funções da UART
 void UART9BitAddrSend (uint32_t ui32Base, uint8_t ui8Addr)
 void UART9BitAddrSet (uint32_t ui32Base, uint8_t ui8Addr, uint8_t
ui8Mask)
 void UART9BitDisable (uint32_t ui32Base)
 void UART9BitEnable (uint32_t ui32Base)
 void UARTBreakCtl (uint32_t ui32Base, bool bBreakState)
 bool UARTBusy (uint32_t ui32Base)
 int32_t UARTCharGet (uint32_t ui32Base)
 int32_t UARTCharGetNonBlocking (uint32_t ui32Base)
 void UARTCharPut (uint32_t ui32Base, unsigned char ucData)
 bool UARTCharPutNonBlocking (uint32_t ui32Base, unsigned char ucData)
 bool UARTCharsAvail (uint32_t ui32Base)
 uint32_t UARTClockSourceGet (uint32_t ui32Base)
 void UARTClockSourceSet (uint32_t ui32Base, uint32_t ui32Source)

[Digite texto]
58
 void UARTConfigGetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk,
uint32_t _pui32Baud,
 uint32_t _pui32Config)
 void UARTConfigSetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk,
uint32_t ui32Baud,
 uint32_t ui32Config)
 void UARTDisable (uint32_t ui32Base)
 void UARTDisableSIR (uint32_t ui32Base)
 void UARTDMADisable (uint32_t ui32Base, uint32_t ui32DMAFlags)
 void UARTDMAEnable (uint32_t ui32Base, uint32_t ui32DMAFlags)
 void UARTEnable (uint32_t ui32Base)
 void UARTEnableSIR (uint32_t ui32Base, bool bLowPower)
 void UARTFIFODisable (uint32_t ui32Base)
 void UARTFIFOEnable (uint32_t ui32Base)
 void UARTFIFOLevelGet (uint32_t ui32Base, uint32_t _pui32TxLevel,
uint32_t _pui32RxLevel)
 void UARTFIFOLevelSet (uint32_t ui32Base, uint32_t ui32TxLevel,
uint32_t ui32RxLevel)
 uint32_t UARTFlowControlGet (uint32_t ui32Base)
 void UARTFlowControlSet (uint32_t ui32Base, uint32_t ui32Mode)
 void UARTIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)
 void UARTIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)
 void UARTIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)
 void UARTIntRegister (uint32_t ui32Base, void (_pfnHandler)(void))
 uint32_t UARTIntStatus (uint32_t ui32Base, bool bMasked)
 void UARTIntUnregister (uint32_t ui32Base)
 void UARTModemControlClear (uint32_t ui32Base, uint32_t ui32Control)
 uint32_t UARTModemControlGet (uint32_t ui32Base)
 void UARTModemControlSet (uint32_t ui32Base, uint32_t ui32Control)
 uint32_t UARTModemStatusGet (uint32_t ui32Base)
 uint32_t UARTParityModeGet (uint32_t ui32Base)
 void UARTParityModeSet (uint32_t ui32Base, uint32_t ui32Parity)
 void UARTRxErrorClear (uint32_t ui32Base)
 uint32_t UARTRxErrorGet (uint32_t ui32Base)
 void UARTSmartCardDisable (uint32_t ui32Base)
 void UARTSmartCardEnable (uint32_t ui32Base)
 bool UARTSpaceAvail (uint32_t ui32Base)
 uint32_t UARTTxIntModeGet (uint32_t ui32Base)
 void UARTTxIntModeSet (uint32_t ui32Base, uint32_t ui32Mode)
7.5.3 Funções de Interrupção
 void IntDisable (uint32_t ui32Interrupt)
 void IntEnable (uint32_t ui32Interrupt)
 uint32_t IntIsEnabled (uint32_t ui32Interrupt)
 bool IntMasterDisable (void)
 bool IntMasterEnable (void)
 void IntPendClear (uint32_t ui32Interrupt)
 void IntPendSet (uint32_t ui32Interrupt)
 int32_t IntPriorityGet (uint32_t ui32Interrupt)
 uint32_t IntPriorityGroupingGet (void)
 void IntPriorityGroupingSet (uint32_t ui32Bits)
 uint32_t IntPriorityMaskGet (void)
 void IntPriorityMaskSet (uint32_t ui32PriorityMask)
 void IntPrioritySet (uint32_t ui32Interrupt, uint8_t ui8Priority)
 void IntRegister (uint32_t ui32Interrupt, void (_pfnHandler)(void))

[Digite texto]
59
 void IntTrigger (uint32_t ui32Interrupt)
 void IntUnregister (uint32_t ui32Interrupt)
7.5.4 Funções de Timer
 void TimerConfigure (uint32_t ui32Base, uint32_t ui32Config)
 void TimerControlEvent (uint32_t ui32Base, uint32_t ui32Timer,
uint32_t ui32Event)
 void TimerControlLevel (uint32_t ui32Base, uint32_t ui32Timer, bool
bInvert)
 void TimerControlStall (uint32_t ui32Base, uint32_t ui32Timer, bool
bStall)
 void TimerControlTrigger (uint32_t ui32Base, uint32_t ui32Timer,
bool bEnable)
 void TimerControlWaitOnTrigger (uint32_t ui32Base, uint32_t
ui32Timer, bool bWait)
 void TimerDisable (uint32_t ui32Base, uint32_t ui32Timer)
 void TimerEnable (uint32_t ui32Base, uint32_t ui32Timer)
 void TimerIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)
 void TimerIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)
 void TimerIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)
 void TimerIntRegister (uint32_t ui32Base, uint32_t ui32Timer, void
(_pfnHandler)(void))
 uint32_t TimerIntStatus (uint32_t ui32Base, bool bMasked)
 void TimerIntUnregister (uint32_t ui32Base, uint32_t ui32Timer)
 uint32_t TimerLoadGet (uint32_t ui32Base, uint32_t ui32Timer)
 uint64_t TimerLoadGet64 (uint32_t ui32Base)
 void TimerLoadSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t
ui32Value)
 void TimerLoadSet64 (uint32_t ui32Base, uint64_t ui64Value)
 uint32_t TimerMatchGet (uint32_t ui32Base, uint32_t ui32Timer)
 uint64_t TimerMatchGet64 (uint32_t ui32Base)
 void TimerMatchSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t
ui32Value)
 void TimerMatchSet64 (uint32_t ui32Base, uint64_t ui64Value)
 uint32_t TimerPrescaleGet (uint32_t ui32Base, uint32_t ui32Timer)
 uint32_t TimerPrescaleMatchGet (uint32_t ui32Base, uint32_t
ui32Timer)
 void TimerPrescaleMatchSet (uint32_t ui32Base, uint32_t ui32Timer,
uint32_t ui32Value)
 void TimerPrescaleSet (uint32_t ui32Base, uint32_t ui32Timer,
uint32_t ui32Value)
 void TimerRTCDisable (uint32_t ui32Base)
 void TimerRTCEnable (uint32_t ui32Base)
 void TimerSynchronize (uint32_t ui32Base, uint32_t ui32Timers)
 uint32_t TimerValueGet (uint32_t ui32Base, uint32_t ui32Timer)
 uint64_t TimerValueGet64 (uint32_t ui32Base)

[Digite texto]
60
8. Referências
Tiva™ C Series TM4C123G LaunchPad Evaluation Board [1],
http://www.ti.com/lit/ug/spmu296/spmu296.pdf
TivaWare™ Peripheral Driver Library [2],
http://www.ti.com/lit/ug/spmu298a/spmu298a.pdf
C:tiTivaWare_C_Series-2.1.0.12573docsSW-TM4C-DRL-UG-2.1.0.12573.pdf
Getting Started with the TIVA C Series TM4C123G Launchpad[3],
http://processors.wiki.ti.com/index.php/Getting_Started_with_the_TIVA%E2%84%A2_
C-Series_TM4C123G_LaunchPad?DCMP=tivac&HQS=TM4C123G-Launchpad-Workshop
TI Softwares [4],
http://www.ti.com/ww/en/launchpad/software.html
Ti eStore [5],
https://estore.ti.com/Tiva-C-LaunchPad.aspx
ARM [6],
http://www.arm.com/products/processors/index.php
http://www.tecmundo.com.br/qualcomm/7708-por-que-os-processadores-arm-
podem-mudar-o-rumo-dos-dispositivos-eletronicos-.htm
http://www.hardware.com.br/termos/arm
Download CCS v6 [7],
http://processors.wiki.ti.com/index.php/Download_CCS
GUI Composer [8],
http://processors.wiki.ti.com/index.php/Category:GUI_Composer
Download TivaWare [9],
http://www.ti.com/tool/sw-tm4c
Abrir o Gerenciador de Dispositivos [10],
http://technet.microsoft.com/pt-br/library/cc754081.aspx
Download ICDI drivers [11],
http://www.ti.com/tool/stellaris_icdi_drivers
Tiva™ TM4C123GH6PM Microcontroller Datasheet [12],
http://www.ti.com/lit/ds/spms376e/spms376e.pdf
Putty download [13],
http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe
Links Acessados em 30 de Novembro de 2014

Apostila tm4c 03_2015

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Apostila tm4c 03_2015

Semelhante a Apostila tm4c 03_2015 (20)

Mais de Regisnaldo Gurgel

Mais de Regisnaldo Gurgel (9)

Apostila tm4c 03_2015