Introdução aos microcontroladores  ARM Cortex-M4 Tiva C Series da  Texas Instruments, Notas de estudo de Engenharia Elétrica
stefano-andrade-de-souza-7
stefano-andrade-de-souza-7

Introdução aos microcontroladores ARM Cortex-M4 Tiva C Series da Texas Instruments, Notas de estudo de Engenharia Elétrica

61 páginas
50Números de download
1000+Número de visitas
Descrição
A apostila aborda temas como instalação dos softwares e APIs fornecidos pela Texas (CCS e TivaWare) para a utilização do microcontrolador e um breve estudo dos periféricos básicos como GPIO, Timer, Interrupção e UART.
100 pontos
Pontos de download necessários para baixar
este documento
Baixar o documento
Pré-visualização3 páginas / 61
Esta é apenas uma pré-visualização
3 mostrados em 61 páginas
Esta é apenas uma pré-visualização
3 mostrados em 61 páginas
Esta é apenas uma pré-visualização
3 mostrados em 61 páginas
Esta é apenas uma pré-visualização
3 mostrados em 61 páginas

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:\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 softwarepró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

intmain(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 */ typedefsignedchar int8_t; typedefunsignedchar uint8_t; typedefshort int16_t; typedefunsignedshort uint16_t; typedefint int32_t; typedefunsignedint uint32_t; typedeflonglong int64_t; typedefunsignedlonglong 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:

voidConfigureUART(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); }

intmain(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

externvoidPortFIntHandler(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:

unsignedlong 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

externvoidPortFIntHandler(void); externvoidTimer0IntHandler (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);

}

intmain(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)***/ voidPortFIntHandler(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***/ voidConfigureUART(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

intmain(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***/ voidTimer0IntHandler (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***/ voidPortFIntHandler(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***/ voidConfigureUART(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); } intmain(void) { unsignedlong 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 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. // //*************************************************************************** voidResetISR(void); staticvoidNmiSR(void); staticvoidFaultISR(void); staticvoidIntDefaultHandler(void); //*************************************************************************** // // External declaration for the reset handler that is to be called when the // processor is started // //***************************************************************************

[Digite texto]

52

externvoid_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 externvoidPortFIntHandler(void); externvoidTimer0IntHandler(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, // Reserved IntDefaultHandler, // 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. // //*************************************************************************** voidResetISR(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. // //*************************************************************************** staticvoidNmiSR(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

staticvoidFaultISR(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. // //*************************************************************************** staticvoidIntDefaultHandler(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-

2.1.0.12573\docs\ 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

voidGPIOADCTriggerDisable (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOADCTriggerEnable (uint32_t ui32Port, uint8_t ui8Pins)  uint32_t GPIODirModeGet (uint32_t ui32Port, uint8_t ui8Pin)  voidGPIODirModeSet (uint32_t ui32Port, uint8_t ui8Pins, uint32_t

ui32PinIO)  voidGPIODMATriggerDisable (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIODMATriggerEnable (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOIntClear (uint32_t ui32Port, uint32_t ui32IntFlags)  voidGPIOIntDisable (uint32_t ui32Port, uint32_t ui32IntFlags)

[Digite texto]

57

voidGPIOIntEnable (uint32_t ui32Port, uint32_t ui32IntFlags)  voidGPIOIntRegister (uint32_t ui32Port, void (_pfnIntHandler)(void))  uint32_t GPIOIntStatus (uint32_t ui32Port, bool bMasked)  uint32_t GPIOIntTypeGet (uint32_t ui32Port, uint8_t ui8Pin)  voidGPIOIntTypeSet (uint32_t ui32Port, uint8_t ui8Pins, uint32_t

ui32IntType)  voidGPIOIntUnregister (uint32_t ui32Port)  voidGPIOPadConfigGet (uint32_t ui32Port, uint8_t ui8Pin, uint32_t

_pui32Strength, uint32_t_pui32PinType)  voidGPIOPadConfigSet (uint32_t ui32Port, uint8_t ui8Pins,

uint32_t,ui32Strength, uint32_tui32PinType)  voidGPIOPinConfigure (uint32_t ui32PinConfig)  int32_t GPIOPinRead (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeADC (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeCAN (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeComparator (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeEPI (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeEthernetLED (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeEthernetMII (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeFan (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeGPIOInput (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeGPIOOutput (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeGPIOOutputOD (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeI2C (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeI2CSCL (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeI2S (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeLPC (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypePECIRx (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypePECITx (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypePWM (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeQEI (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeSSI (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeTimer (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeUART (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeUSBAnalog (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinTypeUSBDigital (uint32_t ui32Port, uint8_t ui8Pins)  voidGPIOPinWrite (uint32_t ui32Port, uint8_t ui8Pins, uint8_t ui8Val)

7.5.2 Funções da UART

voidUART9BitAddrSend (uint32_t ui32Base, uint8_t ui8Addr)  voidUART9BitAddrSet (uint32_t ui32Base, uint8_t ui8Addr, uint8_t

ui8Mask)  voidUART9BitDisable (uint32_t ui32Base)  voidUART9BitEnable (uint32_t ui32Base)  voidUARTBreakCtl (uint32_t ui32Base, bool bBreakState)  bool UARTBusy (uint32_t ui32Base)  int32_t UARTCharGet (uint32_t ui32Base)  int32_t UARTCharGetNonBlocking (uint32_t ui32Base)  voidUARTCharPut (uint32_t ui32Base, unsignedchar ucData)  bool UARTCharPutNonBlocking (uint32_t ui32Base, unsignedchar ucData)  bool UARTCharsAvail (uint32_t ui32Base)  uint32_t UARTClockSourceGet (uint32_t ui32Base)  voidUARTClockSourceSet (uint32_t ui32Base, uint32_t ui32Source)

[Digite texto]

58

voidUARTConfigGetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk, uint32_t _pui32Baud,

 uint32_t _pui32Config)  voidUARTConfigSetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk,

uint32_t ui32Baud,  uint32_t ui32Config)  voidUARTDisable (uint32_t ui32Base)  voidUARTDisableSIR (uint32_t ui32Base)  voidUARTDMADisable (uint32_t ui32Base, uint32_t ui32DMAFlags)  voidUARTDMAEnable (uint32_t ui32Base, uint32_t ui32DMAFlags)  voidUARTEnable (uint32_t ui32Base)  voidUARTEnableSIR (uint32_t ui32Base, bool bLowPower)  voidUARTFIFODisable (uint32_t ui32Base)  voidUARTFIFOEnable (uint32_t ui32Base)  voidUARTFIFOLevelGet (uint32_t ui32Base, uint32_t _pui32TxLevel,

uint32_t _pui32RxLevel)  voidUARTFIFOLevelSet (uint32_t ui32Base, uint32_t ui32TxLevel,

uint32_t ui32RxLevel)  uint32_t UARTFlowControlGet (uint32_t ui32Base)  voidUARTFlowControlSet (uint32_t ui32Base, uint32_t ui32Mode)  voidUARTIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)  voidUARTIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)  voidUARTIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)  voidUARTIntRegister (uint32_t ui32Base, void (_pfnHandler)(void))  uint32_t UARTIntStatus (uint32_t ui32Base, bool bMasked)  voidUARTIntUnregister (uint32_t ui32Base)  voidUARTModemControlClear (uint32_t ui32Base, uint32_t ui32Control)  uint32_t UARTModemControlGet (uint32_t ui32Base)  voidUARTModemControlSet (uint32_t ui32Base, uint32_t ui32Control)  uint32_t UARTModemStatusGet (uint32_t ui32Base)  uint32_t UARTParityModeGet (uint32_t ui32Base)  voidUARTParityModeSet (uint32_t ui32Base, uint32_t ui32Parity)  voidUARTRxErrorClear (uint32_t ui32Base)  uint32_t UARTRxErrorGet (uint32_t ui32Base)  voidUARTSmartCardDisable (uint32_t ui32Base)  voidUARTSmartCardEnable (uint32_t ui32Base)  bool UARTSpaceAvail (uint32_t ui32Base)  uint32_t UARTTxIntModeGet (uint32_t ui32Base)

voidUARTTxIntModeSet (uint32_t ui32Base, uint32_t ui32Mode)

7.5.3 Funções de Interrupção

voidIntDisable (uint32_t ui32Interrupt)  voidIntEnable (uint32_t ui32Interrupt)  uint32_t IntIsEnabled (uint32_t ui32Interrupt)  bool IntMasterDisable (void)  bool IntMasterEnable (void)  voidIntPendClear (uint32_t ui32Interrupt)  voidIntPendSet (uint32_t ui32Interrupt)  int32_t IntPriorityGet (uint32_t ui32Interrupt)  uint32_t IntPriorityGroupingGet (void)  voidIntPriorityGroupingSet (uint32_t ui32Bits)  uint32_t IntPriorityMaskGet (void)  voidIntPriorityMaskSet (uint32_t ui32PriorityMask)  voidIntPrioritySet (uint32_t ui32Interrupt, uint8_t ui8Priority)  voidIntRegister (uint32_t ui32Interrupt, void (_pfnHandler)(void))

[Digite texto]

59

voidIntTrigger (uint32_t ui32Interrupt)

voidIntUnregister (uint32_t ui32Interrupt)

7.5.4 Funções de Timer

voidTimerConfigure (uint32_t ui32Base, uint32_t ui32Config)  voidTimerControlEvent (uint32_t ui32Base, uint32_t ui32Timer,

uint32_t ui32Event)  voidTimerControlLevel (uint32_t ui32Base, uint32_t ui32Timer, bool

bInvert)  voidTimerControlStall (uint32_t ui32Base, uint32_t ui32Timer, bool

bStall)  voidTimerControlTrigger (uint32_t ui32Base, uint32_t ui32Timer,

bool bEnable)  voidTimerControlWaitOnTrigger (uint32_t ui32Base, uint32_t

ui32Timer, bool bWait)  voidTimerDisable (uint32_t ui32Base, uint32_t ui32Timer)  voidTimerEnable (uint32_t ui32Base, uint32_t ui32Timer)  voidTimerIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)  voidTimerIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)  voidTimerIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)  voidTimerIntRegister (uint32_t ui32Base, uint32_t ui32Timer, void

(_pfnHandler)(void))  uint32_t TimerIntStatus (uint32_t ui32Base, bool bMasked)  voidTimerIntUnregister (uint32_t ui32Base, uint32_t ui32Timer)  uint32_t TimerLoadGet (uint32_t ui32Base, uint32_t ui32Timer)  uint64_t TimerLoadGet64 (uint32_t ui32Base)  voidTimerLoadSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t

ui32Value)  voidTimerLoadSet64 (uint32_t ui32Base, uint64_t ui64Value)  uint32_t TimerMatchGet (uint32_t ui32Base, uint32_t ui32Timer)  uint64_t TimerMatchGet64 (uint32_t ui32Base)  voidTimerMatchSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t

ui32Value)  voidTimerMatchSet64 (uint32_t ui32Base, uint64_t ui64Value)  uint32_t TimerPrescaleGet (uint32_t ui32Base, uint32_t ui32Timer)  uint32_t TimerPrescaleMatchGet (uint32_t ui32Base, uint32_t

ui32Timer)  voidTimerPrescaleMatchSet (uint32_t ui32Base, uint32_t ui32Timer,

uint32_t ui32Value)  voidTimerPrescaleSet (uint32_t ui32Base, uint32_t ui32Timer,

uint32_t ui32Value)  voidTimerRTCDisable (uint32_t ui32Base)  voidTimerRTCEnable (uint32_t ui32Base)  voidTimerSynchronize (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:\ti\TivaWare_C_Series-2.1.0.12573\docs\SW-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

[Digite texto]

61

Até o momento nenhum comentário
Esta é apenas uma pré-visualização
3 mostrados em 61 páginas