Você está na página 1de 61
Introdução aos microcontroladores ARM Cortex-M4 Tiva C Series da Texas Instruments Stéfano Andrade de Souza
Introdução aos microcontroladores ARM Cortex-M4 Tiva C Series da Texas Instruments Stéfano Andrade de Souza

Introdução aos microcontroladores ARM Cortex-M4 Tiva C Series da

Texas Instruments

aos microcontroladores ARM Cortex-M4 Tiva C Series da Texas Instruments Stéfano Andrade de Souza Março de

Stéfano Andrade de Souza

Março de 2015

[Digite texto]
[Digite texto]
[Digite texto] Um certo espadachim nos seus dias derradeiros disse o seguinte: Na vida de um

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

2
2
[Digite texto]
[Digite texto]

Sumário

[Digite texto] Sumário 1. Introdução 4 2. Os microcontroladores da série TM4C123x 5 2.1 O Núcleo

1. Introdução

4

2. Os microcontroladores da série TM4C123x

5

2.1 O Núcleo ARM Cortex-M4

7

2.2 Periféricos Estudados

9

2.2.1 GPIO General Purpose IN/OUT

9

2.2.2 NVIC Nested Vector Interrupt Controller

9

2.2.3 O TIMER

10

2.2.4 A Memória

10

3. A Placa de Desenvolvimento TIVA C Series EK-TM4C123G

10

4. Code Composer Studio v6 (CCS)

13

4.1

Instalando o CCS e configurações necessárias

13

5. A TivaWare

19

5.1 Rodando os exemplos da TivaWare

20

5.2 Criando um Projeto do Zero [3]

27

5.3 Clock Geral do Sistema

35

5.4 Configurando o GPIO

36

5.5 Utilizando uma UART

38

5.6 Configurando o NVIC

39

5.7 Configurando o TIMER

41

6. Conclusão

43

7. ANEXOS

44

7.1 Exemplo 1 Utilizando o GPIO e UART

44

7.2 Exemplo 2 Utilizando uma Interrupção

46

7.3 Exemplo 3 Utilizando o Timer

48

7.4 Arquivo TM4C123GH6PM_STARTUP_CCS.C

51

7.5 Funções da TivaWare

56

7.5.1 Funções da GPIO

56

7.5.2 Funções da UART

57

7.5.3 Funções de Interrupção

58

7.5.4 Funções de Timer

59

8. Referências

60

3
3
[Digite texto]
[Digite texto]

1. Introdução

[Digite texto] 1. Introdução Com o crescimento cada vez maior da demanda de equipamentos eletrônicos no

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.

4
4
[Digite texto]
[Digite texto]
[Digite texto] 2. Os microcontroladores da série TM4C123x Os microcontroladores da série TM4C123x da Texas Instruments

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.

I2C, CAN, USB, Hibernate com RTC, Timers e entradas AD com comparadores. Figura 1 - Os

Figura 1 - Os Microcontroladores TM4C123X

[Digite texto]
[Digite texto]
[Digite texto] Figura 2 - Diagrama de Blocos do Microcontrolador TM4C123GH6PM NOTA: Outras informações poderão ser
[Digite texto] Figura 2 - Diagrama de Blocos do Microcontrolador TM4C123GH6PM NOTA: Outras informações poderão ser

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]
[Digite texto]

2.1 O Núcleo ARM Cortex-M4

[Digite texto] 2.1 O Núcleo ARM Cortex-M4 Os processadores ARM são conhecidos pela sua versatilidade, pois

Os processadores ARM são conhecidos pela sua versatilidade, pois possuem poucas instruções para programação. São encontrados em telefones celulares, calculadoras, periféricos de computador, equipamentos eletrônicos em geral e aplicações industriais. Atualmente os processadores ARM são 90% dos processadores embarcados RISC de 32 bits.

Desenvolvida pela inglesa Acorn Computer Limited em 1983, foi o primeiro processador RISC criado para uso comercial. Até então, a maioria dos computadores utilizava a arquitetura CISC, com suporte instruções complexas, simultâneas e de execução mais lenta mas que resultavam em códigos menores, pela simplificação da estrutura de programação decorrente e menos entradas e saídas (diminuindo assim a necessidade de memória).

Os RISC, por outro lado, visam a simplificação dessas instruções, com o intuito de atingir a máxima eficiência por ciclo (podendo realizar tarefas menores com processos mais curtos) e uma maior ordenação das operações dentro do núcleo de processamento.

Por terem um número menor de circuitos internos, os RISC também podem trabalhar com clocks mais altos. No entanto, as divisões entre estes dois termos estão se tornando cada vez mais nebulosas, uma vez que os processadores modernos já combinam as duas linhas em suas diferentes camadas de hardware.

Nos dias atuais, a empresa ARM (Advanced RISC Machine LTDA) se especializou em licenciar seus núcleos para parceiros que fabricam e vendem para seus clientes. Como parte da sua estratégia, a ARM investe na assistência àqueles que desenvolvem produtos que utilizam seus chips, através de softwares de depuração, placas de projeto, etc, se tornando assim basicamente uma empresa de Propriedade Intelectual (IP), não possuindo grandes fábricas de semicondutores. [6]

7
7
[Digite texto]
[Digite texto]
[Digite texto] Figura 3 - Fabricantes que trabalham com o Núcleo ARM. Inicialmente voltado para aplicações
[Digite texto] Figura 3 - Fabricantes que trabalham com o Núcleo ARM. Inicialmente voltado para aplicações

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.

para aplicações de menor porte no campo de Microcontroladores e FPGA. Figura 4 - Linha de

Figura 4 - Linha de Núcleos A, R e M da ARM.

[Digite texto]
[Digite texto]

2.2 Periféricos Estudados

[Digite texto] 2.2 Periféricos Estudados Como já citado, dentro da série de microcontroladores TM4C123x, inicialmente

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.

9
9
[Digite texto]
[Digite texto]

2.2.3 O TIMER

[Digite texto] 2.2.3 O TIMER O periférico TIMER é composto por contadores de 32 e 64

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]
[Digite texto]
[Digite texto] Finalmente, a placa ainda disponibiliza um LED RGB e dois botões (SW1 e SW2)

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.

Texas, suas próprias aplicações ou depuração e testes no firmware. Figura 5 - Placa de Desenvolvimento

Figura 5 - Placa de Desenvolvimento EK-TM4C123G

[Digite texto]
[Digite texto]
[Digite texto] Figura 6 - Diagrama de blocos da Placa de Desenvolvimento EK-TM4C123G Nos exemplos mostrados
[Digite texto] Figura 6 - Diagrama de blocos da Placa de Desenvolvimento EK-TM4C123G Nos exemplos mostrados

Figura 6 - Diagrama de blocos da Placa de Desenvolvimento EK-TM4C123G

Nos

exemplos

mostrados

microcontrolador:

nesta

apostila

serão

utilizados

os

seguintes

pinos

do

nesta apostila serão utilizados os seguintes pinos do Figura 7 - Pinos de entrada/saída da launchpad

Figura 7 - Pinos de entrada/saída da launchpad

os seguintes pinos do Figura 7 - Pinos de entrada/saída da launchpad Figura 8 - Pinos

Figura 8 - Pinos da porta Serial utilizada.

[Digite texto]
[Digite texto]
[Digite texto] NOTA: Outras informações poderão ser acessadas na documentação: Tiva™ C Series TM4C123G LaunchPad

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]
[Digite texto]
[Digite texto] Figura 9 - Selecionando o suporte a família Tiva C Series no CCS. 2º
[Digite texto] Figura 9 - Selecionando o suporte a família Tiva C Series no CCS. 2º

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.

emuladores do CCS, mantenha a condição pré-estabelecida. Figura 10 - Configuração padrão do CCS. 3º Passo:

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]
[Digite texto]
[Digite texto] Figura 11 - App Center 4º Passo: Caso os itens anteriores tenham ocorrido de
[Digite texto] Figura 11 - App Center 4º Passo: Caso os itens anteriores tenham ocorrido de

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]
[Digite texto]
[Digite texto] Figura 12 - Tela inicial do CCS. Nota: Caso a caixa “ Updates Available
[Digite texto] Figura 12 - Tela inicial do CCS. Nota: Caso a caixa “ Updates Available

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]
[Digite texto]
[Digite texto] Figura 13 - Buscando a TivaWare através do App Center. Nota: Caso não seja
[Digite texto] Figura 13 - Buscando a TivaWare através do App Center. Nota: Caso não seja

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].

Center, realizar o download através da referência [9] . Figura 14 - Download da TivaWare Chegando

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]
[Digite texto]
[Digite texto] Figura 15 -Link de download da TivaWare Na mesma página de downloads também poderão
[Digite texto] Figura 15 -Link de download da TivaWare Na mesma página de downloads também poderão

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.

os itens estão apresentados conforme a figura 16. Figura 16 - Itens acrescidos ao Gerenciador de

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]
[Digite texto]
[Digite texto] Caso todos os passos apresentados até aqui tenham sido concluídos com êxito, todos os

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.

são eles: TivaWare Peripheral Driver Library e TivaWare Utilities Library. Figura 17 - Documentação da TivaWare

Figura 17 - Documentação da TivaWare

[Digite texto]
[Digite texto]
[Digite texto] Após incluirmos a TivaWare ao nosso projeto, será possível configurarmos de maneira simples e

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”.

será necessário clicar em “Project” - > “Import CCS Projects”. Figura 18 - Importando Projetos I

Figura 18 - Importando Projetos I

[Digite texto]
[Digite texto]

2º Passo: Abra o “Browse

e selecione a pasta da TivaWare.

[Digite texto] 2º Passo: Abra o “Browse ” e selecione a pasta da TivaWare. Figura 19
[Digite texto] 2º Passo: Abra o “Browse ” e selecione a pasta da TivaWare. Figura 19

Figura 19 - Importando Projetos II

[Digite texto]
[Digite texto]
[Digite texto] 3º Passo: Nesta etapa, serão expostos todos os projetos incluídos na TivaWare. iremos testar

3º Passo: Nesta etapa, serão expostos todos os projetos incluídos na TivaWare.

iremos testar o

Selecione

“project0”.

todos ou

algum

em

específico

para

testar.

Inicialmente,

todos ou algum em específico para testar. Inicialmente, Figura 20 - Selecionando o Project0 da TivaWare

Figura 20 - Selecionando o Project0 da TivaWare

[Digite texto]
[Digite texto]
[Digite texto] 4º Passo: Importando o “project0” você irá notar que ele aparece com uma exclamação

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.

projeto e em seguida na opção de “ Build Project ” . Figura 21- Ferramenta de

Figura 21- Ferramenta de compilação

Caso sua área de trabalho não esteja mostrando as janelas de “Console” e “Problemshabilite-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.

referentes aos passos da compilação e erros encontrados. Figura 22- Mensagens referentes à compilação do projeto.

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]
[Digite texto]
[Digite texto] Figura 23 - Atualizando a versão do compilador utilizado Após alterar o compilador, clique
[Digite texto] Figura 23 - Atualizando a versão do compilador utilizado Após alterar o compilador, clique

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.

” (inseto verde) e o código irá ser gravado na memória flash microcontrolador. Figura 24 -

Figura 24 - Ferramentas de Debug

[Digite texto]
[Digite texto]
[Digite texto] Ao mandar o código pela ferramenta de Debug , o código inicialmente estará em

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 pointsnas 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]
[Digite texto]
[Digite texto] Figura 25 - Configuração do Putty para Serial Note que os itens alterados serão:
[Digite texto] Figura 25 - Configuração do Putty para Serial Note que os itens alterados serão:

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]
[Digite texto]
[Digite texto] Figura 26 - Mensagem exibida através do Putty Agora que nós temos nossos exemplos
[Digite texto] Figura 26 - Mensagem exibida através do Putty Agora que nós temos nossos exemplos

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”.

um projeto do zero, clique em “ Project ” - > ” New CCS Project ”.

Figura 27 - Iniciando um novo projeto

[Digite texto]
[Digite texto]
[Digite texto] Habilite as configurações interessantes ao projeto conforme a figura 28. Figura 28 - Configurações

Habilite as configurações interessantes ao projeto conforme a figura 28.

interessantes ao projeto conforme a figura 28. Figura 28 - Configurações do novo projeto 2º Passo:

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]
[Digite texto]
[Digite texto] Figura 29 - Alterando as opções de target Nota: Inicialmente, através das configurações de
[Digite texto] Figura 29 - Alterando as opções de target Nota: Inicialmente, através das configurações de

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.

de “View”, tente deixar sua área de trabalho do CCS conforme a figura 30. Figura 30

Figura 30 - Área de trabalho do CCS

[Digite texto]
[Digite texto]
[Digite texto] 3º Passo: Clique com o botão direito em cima do projeto e clique em

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.

nome e diretório (pasta da T ivaWare) conforme a figura 31. Figura 31 - Criando um

Figura 31 - Criando um New Path Variable

Logo após, verifique se a nova Path foi adicionada a lista.

[Digite texto]
[Digite texto]
[Digite texto] Figura 32 - Lista de Path Variables 3º Passo: Clique com o botão direito
[Digite texto] Figura 32 - Lista de Path Variables 3º Passo: Clique com o botão direito

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.

clique em “ Add e realize as d efinições conforme a figura 33. Figura 33 -

Figura 33 - Adicionando um diretório de variáveis

[Digite texto]
[Digite texto]
[Digite texto] Após criar o diretório, cheque se ele aparecerá na lista de “Variables”. Figura 34

Após criar o diretório, cheque se ele aparecerá na lista de “Variables”.

cheque se ele aparecerá na lista de “Variables”. Figura 34 - Diretório de variáveis criado 4º

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.

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.

Clique

Project->

Add

Files

fi gura 35. Clique “ Project ” - > “ Add Files ” 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]
[Digite texto]
[Digite texto] Figura 36 - Configurando o Include Verifique se o diretório criado foi adicionado lista.
[Digite texto] Figura 36 - Configurando o Include Verifique se o diretório criado foi adicionado lista.

Figura 36 - Configurando o Include

Verifique se o diretório criado foi adicionado lista.

Verifique se o diretório criado foi adicionado lista. Figura 37 - Diretório TIVAWARE_INSTALL 6º Passo: Se

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.

ver os arquivos no Project Explorer conforme a figura 38. Figura 38 - Project Explorer pronto

Figura 38 - Project Explorer pronto iniciar o projeto

[Digite texto]
[Digite texto]
[Digite texto] 7º Passo: Para validar o nosso projeto criado do zero. Vamos copiar as linhas

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" #include "inc/hw_memmap.h" #include "driverlib/sysctl.h" #include "driverlib/gpio.h"

// Inclusão das bibliotecas

#define RED_LED

#define BLUE_LED GPIO_PIN_2 // Atribuição de nomes aos pinos do GPIO

#define GREEN_LED GPIO_PIN_3

GPIO_PIN_1

#ifdef DEBUG

void

error (char

{

}

#endif

*pcFilename, uint32_t ui32Line) // Rotina de erro

int

main(void)

{

// // Configurando o clock do sistema //

SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);

// // Habilitando a GPIO F e configurando os pinos 1, 2 e 3 como saída. (Ver os defines!) // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED);

//

// Loop

//

while(1)

{

// // Liga o LED vermelho que está no pino 1 da GPIO F // GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED);

// // Delay //

SysCtlDelay(2000000);

// // Liga o LED azul que está no pino 2 da GPIO F // GPIOPinWrite(GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, BLUE_LED);

// // Delay //

SysCtlDelay(2000000);

}

}

/////////////////////////////////////////////////////////////////////////////////////

[Digite texto]
[Digite texto]
[Digite texto] Se o código rodou normalmente, nosso projeto do zero foi criado com sucesso! Agora,

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:

35
35
[Digite texto]
[Digite texto]

/* 7.18.1.1 Exact-width integer types */

typedef signed char

typedef unsigned char uint8_t;

typedef

typedef unsigned short uint16_t;

typedef

int32_t;

uint32_t;

short int16_t;

int8_t;

int

typedef unsigned int

typedef

typedef unsigned long long uint64_t;

long long int64_t;

5.4 Configurando o GPIO

uint64_t ; long long int64_t ; 5.4 Configurando o GPIO Para a configuração do GPIO são

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]
[Digite texto]
[Digite texto] Nota 1: Todas as funções apresentadas até agora são procedimentos que não retornam nada

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.

a

2.1.0.12573\driverlib\gpio.h),

Abrindo

biblioteca

hexadecimal.

gpio.h

podemos

verificar

esta

(C:\ti\TivaWare_C_Series-

sistema

declaração

no

//***************************************************************** // // The following values define the bit field for the ui8Pins argument to // several of the APIs. // //*****************************************************************

#define GPIO_PIN_0 #define GPIO_PIN_1 #define GPIO_PIN_2 #define GPIO_PIN_3 #define GPIO_PIN_4 #define GPIO_PIN_5 #define GPIO_PIN_6 #define GPIO_PIN_7

0x00000001 // GPIO pin 0 0x00000002 // GPIO pin 1 0x00000004 // GPIO pin 2 0x00000008 // GPIO pin 3 0x00000010 // GPIO pin 4 0x00000020 // GPIO pin 5 0x00000040 // GPIO pin 6 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]
[Digite texto]
[Digite texto] NOTA: Um exemplo de utilização dos pinos de entrada e saída, conforme a configuração

NOTA: Um exemplo de utilização dos pinos de entrada e saída, conforme a configuração apresentada, encontra-se no Exemplo 1 em Anexo.

5.5 Utilizando uma UART

Para a configuração de uma UART segue abaixo as principais funções da Driverlib:

1. UARTConfigSetExpClk(uint32_t ui32Base, uint32t ui32UARTClk, uint32_t ui32Baud, uint32_t ui32Config)

Função que configura os parâmetros da serial utilizada.

2. UARTCharPut(uint32_t ui32Base, unsigned char ucData).

Função que imprime na serial onde o parâmetro ucData é a informação tipo char a enviada.

3. UARTCharGet(uint32_t ui32Base).

Função que retorna o caractere lido na serial como int32_t.

As funções acima são fornecidas pela Driverlib da TivaWare. Em nosso Exemplo 1 em Anexo vamos usar algumas funções da biblioteca “uartstdio.h” (C:\ti\TivaWare_C_Series- 2.1.0.12573\utils\uartstdio.h) de Utils. Para entendê-las melhor exercite sua busca pelas funções verificando a documentação de “Utils” indicada na figura 17.

Exemplo de serial com baud rate: 115200 e enviando um caractere na UART 0 após a sua configuração:

void ConfigureUART(void) // Função retirada do exemplo hello.c

{

 

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); UARTStdioConfig(0, 115200, 16000000);

}

int main(void) {

(

)

ConfigureUART(); // Função de configuração da UART0 UARTprintf("Hello world after Engeneering!!!\n");

while(1)

{

[Digite texto]
[Digite texto]

}

}

(

)

[Digite texto] } } ( ) Nota 1: Note que como a configuração da UART0 foi

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 ”

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

Project-> “Add Files

files” e mude o local de “POROJECT_LOC” para o nosso local criado “TIVAWARE_INSTALL”, conforme a figura 39.

local criado “TIVAWARE_INSTALL”, conforme a figura 39. Figura 39 - Adicionando o arquivo uartstdio.c ao projeto.

Figura 39 - Adicionando o arquivo uartstdio.c ao projeto.

Nota 3: Caso a função “Add Files do seu projeto no Project Explorer.

5.6 Configurando o NVIC

em “Project” esteja apagada, dê um clique no nome

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]
[Digite texto]
[Digite texto] subida), GPIO_BOTH_EDGE (qualquer borda), GPIO_LOW_LEVEL (nível lógico baixo) e GPIO_HIGH_LEVEL (nível

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

do

externa

ao

código,

aproximadamente

na

linha

58

do

código

“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 “

interrupção no PORTF, sua posição será aproximadamente na linha 116 do código do

“tm4c123gh6pmi_startup_ccs.c”.

pela sua função utilizada. Para uma

IntDefaultHandler

IntDefaultHandler,

// FLASH Control

PortFIntHandler,

// GPIO Port F

IntDefaultHandler,

// GPIO Port G // GPIO Port H

IntDefaultHandler,

[Digite texto]
[Digite texto]
[Digite texto] Após estas configurações, sempre que houver uma borda de descida no pino 4 do

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

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.

ui32Base,

uint32_t

ui32Timer,

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.

41
41
[Digite texto]
[Digite texto]
[Digite texto] Novamente, para que uma função de interrupção seja executada sempre que o nosso timer

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

do

externa

“tm4c123gh6pmi_sturtup_ccs.c”.

ao

código,

aproximadamente

na

linha

59

do

código

//********************************************************************** // // External declarations for the interrupt handlers used by the application. // //********************************************************************** // To be added by user extern void PortFIntHandler(void); extern void Timer0IntHandler (void); //**********************************************************************

2º Passo: Adicione essa função ao vetor de interrupções em sua devida posição substituindo a função padrão “IntDefaultHandler” pela sua função utilizada. Para uma interrupção no PORTF, sua posição será aproximadamente na linha 106 do código do

“tm4c123gh6pmi_sturtup_ccs.c”.

IntDefaultHandler,

Timer0IntHandler

,

IntDefaultHandler,

IntDefaultHandler,

Após

estas

configurações,

sempre

que

// Watchdog timer

// Timer 0 subtimer A

// Timer 0 subtimer B // Timer 1 subtimer A

o

timer

atingir

o

período

de

contagem

selecionado, ele vai gerar uma interrupção e a função declarada será executada!

[Digite texto]
[Digite texto]

6. Conclusão

[Digite texto] 6. Conclusão Visando introduzir os conceitos básicos necessários a aprendizagem dos microcontroladores

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 Microcontrollersde Jonathan W. Valvano.

[Digite texto]
[Digite texto]

7. ANEXOS

7.1 Exemplo 1 Utilizando o GPIO e UART

7. ANEXOS 7.1 Exemplo 1 – Utilizando o GPIO e UART Neste exemplo serão mostradas configurações

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 #define GPIO_PORTF_CR_R

(*((volatile uint32_t *)0x40025520)) (*((volatile uint32_t *)0x40025524))

int LED=4;

/***Configuração da UART0, Utils.c***/ void

ConfigureUART(void) // Função retirada do exemplo hello.c

{

 

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); UARTStdioConfig(0, 115200, 16000000);

}

int main(void) {

// Habilita clock geral do sistema

SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16

MHZ|SYSCTL_OSC_MAIN);

////Configuração da GPIO F //// SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

44
44
[Digite texto]
[Digite texto]

GPIO_PORTF_LOCK_R = 0x4C4F434B; GPIO_PORTF_CR_R = 0x1F;

// Desbloqueio do // pino PF0.

GPIO_PORTF_CR_R = 0x1F; // Desbloqueio do // pino PF0. GPIOPinTypeGPIOOutput (GPIO_PORTF_BASE,

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”.

45
45
[Digite texto]
[Digite texto]

7.2 Exemplo 2 Utilizando uma Interrupção

texto] 7.2 Exemplo 2 – Utilizando uma Interrupção Neste exemplo será demonstrado o funcionamento de uma

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 #define GPIO_PORTF_CR_R

(*((volatile uint32_t *)0x40025520)) (*((volatile uint32_t *)0x40025524))

uint8_t LED=4;

/***Interrupção por borda de descida no PortF Pin4 (SW1)***/ void PortFIntHandler(void)

{

 

GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);

LED=2;

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED); UARTprintf("Red\n");

SysCtlDelay(20000000);

}

/***Configuração da UART0, Utils.c***/ void

ConfigureUART(void) // Função retirada do exemplo hello.c

{

 

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); UARTStdioConfig(0, 115200, 16000000);

}

46
46
[Digite texto]
[Digite texto]

int main(void) {

[Digite texto] int main ( void ) { SysCtlClockSet (SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL _OSC_MAIN);

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; GPIO_PORTF_CR_R = 0x1F;

// Desbloqueio do //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///////////////////////////////////////

47
47
[Digite texto]
[Digite texto]

Com este exemplo em funcionamento, será verificado que:

Com este exemplo em funcionamento, será verificado que: Se o LED estiver verde ou azul, ou

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.

1)

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 #define GPIO_PORTF_CR_R

(*((volatile uint32_t *)0x40025520)) (*((volatile uint32_t *)0x40025524))

#define MULT_TIMER 1

// Ajuste do Timer para teste

uint8_t LED=4, flag=0;

/***Interrupção periodica do timer0***/ void Timer0IntHandler (void)

{

TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);

if(flag==1)

{

LED=4;

[Digite texto]
[Digite texto]
[Digite texto] GPIOPinWrite (GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED);   UARTprintf (

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,

LED);

 

UARTprintf("Blue\n");

flag=0;

 

}

else

{

 

LED=8;

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,

LED);

 

UARTprintf("Green\n");

flag=1;

 

}

}

/***Interrupção por borda de descida no PortF Pin4***/ void PortFIntHandler(void)

{

 

GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);

LED=2;

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED); UARTprintf("Red\n");

SysCtlDelay(20000000);

}

/***Configuração da UART0, Utils.c***/ void

ConfigureUART(void) // Função retirada do exemplo hello.c

{

 

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); UARTStdioConfig(0, 115200, 16000000);

}

int main(void) {

unsigned long Period;

SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL

_OSC_MAIN);

////Configuração da GPIO F //// SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

GPIO_PORTF_LOCK_R = 0x4C4F434B; GPIO_PORTF_CR_R = 0x1F;

// desbloqueia o PortF // 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);

49
49
[Digite texto]
[Digite texto]
[Digite texto] GPIOPadConfigSet (GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);

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); IntEnable(INT_GPIOF);

// 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);

IntEnable(INT_TIMER0A);

// Setando prioridade

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.

4)

IntPrioritySet(INT_GPIOF, 0x10); IntPrioritySet(INT_TIMER0A, 0x40);

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

50
50
[Digite texto]
[Digite texto]
[Digite texto] 5) Caso queira programar alguma função para o botão SW2 no pino PF0, este

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 // //***************************************************************************

51
51
[Digite texto]
[Digite texto]

extern void _c_int00(void);

[Digite texto] extern void _c_int00 ( void );

//*************************************************************************** // // Linker variable that marks the top of the stack. // //***************************************************************************

extern uint32_t

STACK_TOP;

//*************************************************************************** // // External declarations for the interrupt handlers used by the application. // //*************************************************************************** // To be added by user

extern void PortFIntHandler(void);

extern void PortFIntHandler ( void ); extern void Timer0IntHandler ( void );
extern void Timer0IntHandler ( void );

extern void Timer0IntHandler(void);

//*************************************************************************** // // The vector table. Note that the proper constructs must be placed on this to // ensure that it ends up at physical address 0x0000.0000 or at the start of // the program if located at a start address other than 0. // //*************************************************************************** #pragma DATA_SECTION(g_pfnVectors, ".intvecs") void (* const g_pfnVectors[])(void) =

{

(void (*)(void))((uint32_t)& STACK_TOP), // The initial stack pointer

ResetISR, NmiSR, FaultISR, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

// The reset handler // The NMI handler // The hard fault handler // The MPU fault handler // The bus fault handler // The usage fault handler

0,

// Reserved

0,

// Reserved

0,

// Reserved

0,

// Reserved

IntDefaultHandler, IntDefaultHandler,

// SVCall handler // 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]
[Digite texto]

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

// Quadrature Encoder 0 // ADC Sequence 0 // ADC Sequence 1 // ADC Sequence 2 // ADC Sequence 3 // Watchdog timer

1 // ADC Sequence 2 // ADC Sequence 3 // Watchdog timer Timer0IntHandler, // Timer 0

Timer0IntHandler,

// Timer 0 subtimer A

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

// Timer 0 subtimer B // Timer 1 subtimer A // Timer 1 subtimer B // Timer 2 subtimer A // Timer 2 subtimer B // Analog Comparator 0 // Analog Comparator 1 // Analog Comparator 2 // System Control (PLL, OSC, BO) // FLASH Control

PortFIntHandler,

// GPIO Port F

IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

// GPIO Port G // GPIO Port H // UART2 Rx and Tx // SSI1 Rx and Tx // Timer 3 subtimer A // Timer 3 subtimer B // I2C1 Master and Slave // Quadrature Encoder 1 // CAN0 // CAN1

0,

// Reserved

0,

// Reserved

IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

// Hibernate // USB0 // PWM Generator 3 // uDMA Software Transfer // uDMA Error // ADC1 Sequence 0 // ADC1 Sequence 1 // ADC1 Sequence 2 // ADC1 Sequence 3

0,

// Reserved

0,

// Reserved

IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

// GPIO Port J // GPIO Port K // GPIO Port L // SSI2 Rx and Tx // SSI3 Rx and Tx // UART3 Rx and Tx // UART4 Rx and Tx // UART5 Rx and Tx // UART6 Rx and Tx // 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]
[Digite texto]
[Digite texto] 0, // Reserved 0, // Reserved 0, // Reserved 0, // Reserved 0, //

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, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

// Timer 5 subtimer A // Timer 5 subtimer B // Wide Timer 0 subtimer A // Wide Timer 0 subtimer B // Wide Timer 1 subtimer A // Wide Timer 1 subtimer B // Wide Timer 2 subtimer A // Wide Timer 2 subtimer B // Wide Timer 3 subtimer A // Wide Timer 3 subtimer B // Wide Timer 4 subtimer A // Wide Timer 4 subtimer B // Wide Timer 5 subtimer A // Wide Timer 5 subtimer B // FPU

0,

// Reserved

0,

// Reserved

IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

// I2C4 Master and Slave // I2C5 Master and Slave // GPIO Port M // GPIO Port N // Quadrature Encoder 2

0,

// Reserved

0,

// Reserved

IntDefaultHandler,

// GPIO Port P (Summary or P0)

IntDefaultHandler,

// GPIO Port P1

IntDefaultHandler,

// GPIO Port P2

IntDefaultHandler,

// GPIO Port P3

IntDefaultHandler,

// GPIO Port P4

IntDefaultHandler,

// GPIO Port P5

IntDefaultHandler,

// GPIO Port P6

IntDefaultHandler,

// GPIO Port P7

IntDefaultHandler,

// GPIO Port Q (Summary or Q0)

IntDefaultHandler,

// GPIO Port Q1

IntDefaultHandler,

// GPIO Port Q2

IntDefaultHandler,

// GPIO Port Q3

IntDefaultHandler,

// GPIO Port Q4

IntDefaultHandler,

// GPIO Port Q5

IntDefaultHandler,

// GPIO Port Q6

54
54
[Digite texto]
[Digite texto]

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler,

IntDefaultHandler

};

// GPIO Port Q7 // GPIO Port R // GPIO Port S // PWM 1 Generator 0 // PWM 1 Generator 1 // PWM 1 Generator 2 // PWM 1 Generator 3 // PWM 1 Fault

1 // PWM 1 Generator 2 // PWM 1 Generator 3 // PWM 1 Fault

//*************************************************************************** // // This is the code that gets called when the processor first starts execution // following a reset event. Only the absolutely necessary set is performed, // after which the application supplied entry() routine is called. Any fancy // actions (such as making decisions based on the reset cause register, and // resetting the bits in that register) are left solely in the hands of the // application. //

//***************************************************************************

void

ResetISR(void)

{

// // Jump to the CCS C initialization routine. This will enable the // floating-point unit as well, so that does not need to be done here. //

asm("

.global _c_int00\n"

"

b.w

_c_int00");

}

//*************************************************************************** // // This is the code that gets called when the processor receives a NMI. This // simply enters an infinite loop, preserving the system state for examination // by a debugger. // //*************************************************************************** static void NmiSR(void)

{

 

// // Enter an infinite loop. //

while(1)

{

}

}

//*************************************************************************** // // This is the code that gets called when the processor receives a fault // interrupt. This simply enters an infinite loop, preserving the system state // for examination by a debugger. // //***************************************************************************

55
55
[Digite texto]
[Digite texto]

static void

FaultISR(void)

{

// // Enter an infinite loop. //

while(1)

{

}

}

( void ) { // // Enter an infinite loop. // while (1) { } }

//*************************************************************************** // // This is the code that gets called when the processor receives an unexpected // interrupt. This simply enters an infinite loop, preserving the system state // for examination by a debugger.

// //*************************************************************************** static void IntDefaultHandler(void)

{

 

// // Go into an infinite loop. //

while(1)

{

}

}

///////////////////////TM4C123GH6PM_SARTUP_CCS.C - FIM//////////////////////

7.5 Funções da TivaWare

Através da TivaWare™ Peripheral Driver Library [2], ou C:\ti\TivaWare_C_Series- 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

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]
[Digite texto]
[Digite texto]  void GPIOIntEnable ( uint32_t ui32Port, uint32_t ui32IntFlags)  void GPIOIntRegister (

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)

57
57
[Digite texto]
[Digite texto]
[Digite texto]  void UARTConfigGetExpClk ( uint32_t ui32Base, uint32_t ui32UARTClk, uint32_t _pui32Baud, 

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