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

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

Stéfano Andrade de Souza Março de 2015

[Digite texto]

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 po ssui 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. M as 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 co m humildade conhece o caminho para o fim. Dizem que o mestre Yagyu uma vez comentou: “Eu “ Eu não conheço o caminho para derrotar os outros, apenas o caminho da minha própria derrota”. 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: Linkedin: br.linkedin.com/in/stefanoandrade/pt Email: Email: [email protected] [email protected]

2

[Digite texto]

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 po ssui 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. M as 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 co m humildade conhece o caminho para o fim. Dizem que o mestre Yagyu uma vez comentou: “Eu “ Eu não conheço o caminho para derrotar os outros, apenas o caminho da minha própria derrota”. 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: Linkedin: br.linkedin.com/in/stefanoandrade/pt Email: Email: [email protected] [email protected]

2

[Digite texto]

Sumário 1.

Introdução ...................................................................... ............................................................................................................................. ....................................................... 4

2.

Os microcontroladores da série TM4C123x ............................................................... .......................................................................... ........... 5 2.1

O Núcleo ARM Cortex-M4 ............................................................ ............................................................................................. ................................. 7

2.2

Periféricos Estudados ................................................................... .................................................................................................... ................................. 9

2.2.1

GPIO – General Purpose IN/OUT................................................................... ........................................................................... ........ 9

2.2.2

NVIC – Nested Vector Interrupt Controller ........................................................... 9

2.2.3

O TIMER ..................................................................... ............................................................................................................... .......................................... 10

2.2.4

A Memória................................................................. ........................................................................................................... .......................................... 10

3.

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

4.

Code Composer Studio v6 (CCS)........................................................... .......................................................................................... ............................... 13 4.1

5.

Instalando o CCS e configurações necessárias ............................................................ 13

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

8.

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

Referências ..................................................................... .......................................................................................................................... ..................................................... 60

3

[Digite texto]

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.

4

[Digite texto]

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

5

[Digite texto]

Figura 2 - Diagrama de Blocos do Microcontrolador TM4C123GH6PM

NOTA: Outras informações poderão ser encontradas no datasheet do microcontrolador TM4C123GH6PM em [12].

6

[Digite texto]

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]

7

[Digite texto]

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.

8

[Digite texto]

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.

9

[Digite texto]

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.

10

[Digite texto] Finalmente, a placa ainda disponibiliza um LED RGB e dois botões (SW1 e SW2) conectados a pinos do microcontrolador para utilização nos exemplos fornecidos pela Texas, suas próprias aplicações ou depuração e testes no firmware.

Figura 5 - Placa de Desenvolvimento EK-TM4C123G

11

[Digite texto]

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.

12

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

13

[Digite texto]

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

14

[Digite texto]

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.

15

[Digite texto]

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.

16

[Digite texto]

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.

17

[Digite texto]

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

18

[Digite texto] Caso todos os passos apresentados até aqui tenham sido concluídos com êxito, todos os requisitos básicos à programação dos microcontroladores Tiva C Series foram instalados e estarão operando corretamente.

5. A TivaWare 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

19

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

20

[Digite texto]

2º Passo: Abra o “Browse...” e selecione a pasta da TivaWare.

Figura 19 - Importando Projetos II

21

[Digite texto]

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

22

[Digite texto] 4º Passo: Importando o “project0” você irá notar que ele aparece com uma exclamação de “warning” dentro do Project Explorer . Para verificar os motivos destes warnings, clique na ferramenta “Build ” (ícone do martelinho) ou com o botão direito em cima do projeto e em seguida na opção de “Build Project . ”

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.

23

[Digite texto]

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

24

[Digite texto] Ao mandar o código pela ferramenta de Debug, o código inicialmente estará em estado de “ pause” na primeira linha do código. Para ir depurando o código passo a passo,

utilize as ferramentas de “Step” (setas amarelas), para rodar o código normalmente clique na ferramenta “Resume” (seta verde) ou aperte F8. Após rodar o código livremente você poderá pausá-lo em qualquer momento através da ferramenta “Suspend ” (pause amarelo). Para interromper o debug e comunicação com a placa clique em “Terminate” (quadrado vermelho). Nota: Caso queira debugar o código com ele em funcionamento, insira “break points” nas linhas de interesse dando dois cliques antes do número da linha. Assim, ao clicar em “Resume” o código irá rodar até alcançar a linha marcada. Finalmente, com o código rodando, você verá o LED RGB da launchpad alternando de cor periodicamente. Com isso, o project0 estará salvo na memória flash do microcontrolador. Logo, mesmo que você termine o debug e conecte a placa a outro comutador ou alimentação externa, o código continuará funcionando normalmente! Faça o teste, troque o conector USB e a posição da chave seletora da placa das posições “Debug” para a “Device” e veja que o código continuará funcionando normalmente. Lembrando que a posição “Device” fornece somente a alimentação da USB para a

launchpad (+5V/GND). 7º Passo: Vários exemplos fornecidos pela Texas tem sua depuração realizada através da porta serial. Para demonstrar a utilização da UART, importe o projeto “hello” da mesma forma que importou o projeto “project0”. Note que para rodar este novo projeto, o

mesmo deverá estar marcado em negrito como “ Active-Debug” no “Project Explorer ”. 8º Passo: Para estabelecermos uma comunicação serial da launchpad com o computador, precisaremos de um software próprio para este tipo de comunicação. Os mais comuns, gratuitos, são o Hercules e o Putty. Em nossos exemplos usaremos o Putty que poderá ser baixado, conforme a referência [13], em sua versão mais simples. Verifique no gerenciador de dispositivos em qual “COM” está sua launchpad e configure o software Putty conforme a figura 25 para a sua porta COM identificada.

25

[Digite texto]

Figura 25 - Configuração do Putty para Serial

Note que os itens alterados serão:

1. 2. 3. 4.

Connection type: Serial Serial line: COM__ Speed: 115200 Saved Sessions: TM4C123

(Tipo de comunicação estabelecida) (COM identificada pelo seu computador) (Baud Rate) (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.

26

[Digite texto]

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

27

[Digite texto]

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.

28

[Digite texto]

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

29

[Digite texto]

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.

30

[Digite texto]

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

31

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

32

[Digite texto]

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

33

[Digite texto] 7º Passo: Para validar o nosso projeto criado do zero. Vamos copiar as linhas de código referentes ao “project0” disponibilizadas pela Texas, compilar e debugar o projeto. Copiar o seguinte código dentro do main.c do nosso projeto:

///////////////////////////////////////////////////////////////////////////////////// // project0.c disponibilizado pela TI adaptado. #include #include #include #include #include #include

"inc/hw_types.h" // Inclusão das bibliotecas "inc/hw_memmap.h" "driverlib/sysctl.h" "driverlib/gpio.h"

#define RED_LED GPIO_PIN_1 #define BLUE_LED GPIO_PIN_2 // Atribuição de nomes aos pinos do GPIO #define GREEN_LED GPIO_PIN_3 #ifdef DEBUG void __error__( char *pcFilename, uint32_t ui32Line) // Rotina de erro

{ } #endif int main(void )

{ // // Configurando o clock do sistema // SysCtlClockSet (SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); // // Habilitando a GPIO F e configurando os pinos 1, 2 e 3 como saída. (Ver os defines!) // SysCtlPeripheralEnable (SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput (GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED); // // Loop // while (1) { // // Liga o LED vermelho que está no pino 1 da GPIO F // GPIOPinWrite (GPIO_PORTF_BASE, RED_LED|BLUE_LED|GREEN_LED, RED_LED); // // Delay // SysCtlDelay (2000000);

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

} }

///////////////////////////////////////////////////////////////////////////////////// 34

[Digite texto]

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

[Digite texto] /* 7.18.1.1 Exact-width integer types */ typedef signed char int8_t; typedef unsigned char uint8_t; typedef short int16_t; typedef unsigned short uint16_t; typedef int int32_t; typedef unsigned int uint32_t;

typedef long long int64_t; typedef unsigned long long uint64_t;

5.4 Configurando o GPIO Para a configuração do GPIO são utilizadas basicamente três funções: 1. GPIOPinTypeGPIOOutput(uint32_t ui32Port, uint8_t ui8Pins). Função onde um pino da GPIO do microcontrolador é configurado como saída. Onde o parâmetro ui32Port representa o PORT a ser configurado e o ui8Pins o pino. 2. GPIOPinTypeGPIOInput(uint32_t ui32Port, uint8_t ui8Pins). Função onde um pino da GPIO do microcontrolador é configurado como entrada. 3. GPIOPadConfigSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32Strength, uint32_t ui32PinType). Função que configura as portas de entrada onde o parâmetro ui32Strength representa a corrente máxima a ser permitida pelo pino e o parâmetro ui32PinType configura se o pino terá Pull Up, Pull down ou Coletor Aberto.

Exemplo de configuração do GPIO: ////Configuração da GPIO F //// SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);

O exemplo acima configura na PORT F, os pinos PF1, PF2 e PF3 como saída (LED RGB da Launchpad) e os pinos PF0 e PF4 como entrada (dois botões da Launchpad). Além disso, nos pinos PF0 e PF4, permitem uma corrente de até 2mA de entrada e configurados com Pull Up.

36

[Digite texto] Nota 1: Todas as funções apresentadas até agora são procedimentos que não retornam nada “void ”. Nota 2: Por terem funções específicas, o microcontrolador vem com 6 pinos bloqueados para evitar acidentais alterações. São eles: PC0, PC1, PC2, PC3, PD7 e PF0. Como iremos utilizar o PF0 como entrada do botão SW2, teremos de desbloqueá-lo. Para verificar como ele é desbloqueado verifique o Exemplo 1 em Anexo. Para operar os pinos da GPIO serão utilizadas duas funções, uma para ler o estado dos pinos de entrada e outra para mudança de estado do pino de saída. 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_Series2.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

37

[Digite texto] 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_Series2.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) {

38

[Digite texto] (...) } }

Nota 1: Note 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: 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() IntMasterEnable() Função que permite ao processador responder a todas as chamadas de interrupção utilizadas. 2. GPIOIntEnable(uint32_t GPIOIntEnable(uint32_t ui32Port, uint32_t ui32IntFlags). 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 GPIOIntTypeSet(uint32_t ui32Port, uint8_t ui8Pins, uint32_t ui32IntType). 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

39

[Digite texto] 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_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE); GPIOIntEnable(GPIO_PORTF_BASE, (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) 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 58 do código do “tm4c123gh6pmi_sturtup_ccs.c”.

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

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

IntDefaultHandler, PortFIntHandler, IntDefaultHandler, IntDefaultHandler,

// // // //

FLASH Control GPIO Port F GPIO Port G GPIO Port H

40

[Digite texto] Após estas configurações, sempre que houver uma borda de descida no pino 4 do PortF (SW1 pressionado), sua função de interrupção i nterrupçã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 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 Timer periódico, Disparo único, PWM, etc.

2. TimerEnable(uint32_t 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 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 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); TIMER_CFG_PERIODIC); Period = (SysCtlClockGet()); TimerLoadSet(TIMER0_BASE, TIMER_A, Period -1); TimerIntEnable(TIMER0_BASE, TIMER_TIMA_PERIODIC) TIMER_TIMA_PERIODIC); ; TimerEnable(TIMER0_BASE, TIMER_A); IntEnable(INT_TIMER0A);

NOTA: A 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. “void Timer0IntHandler(void) Um exemplo de aplicação conforme nossa configuração apresentada poderá ser visto no Exemplo 3 em Anexo.

41

[Digite texto] Novamente, para que uma função de interrupção seja executada sempre que o nosso timer desejar, será necessário declará- la ao código “tm4c123gh6pmi_sturtup_ccs.c”. 1º Passo: Declare a função a ser chamada através da interrupção desejada como função externa ao código, aproximadamente na linha 59 do código do “tm4c123gh6pmi_sturtup_ccs.c”.

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

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,

// // // //

Watchdog timer Timer 0 subtimer A Timer 0 subtimer B 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!

42

[Digite texto]

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

43

[Digite texto]

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 #include #include "inc/hw_memmap.h" #include "inc/hw_types.h" #include "driverlib/sysctl.h" #include "driverlib/gpio.h" #include "driverlib/uart.h" #include "driverlib/pin_map.h" #include "utils/uartstdio.h" //"Defines" retirados da biblioteca "inc/tm4c123gh6pm.h" //utilizados para declarar as variáveis de desbloqueio //do pino PF0. #define GPIO_PORTF_LOCK_R (*((volatile uint32_t *)0x40025520)) #define GPIO_PORTF_CR_R (*((volatile uint32_t *)0x40025524)) int LED=4;

/***Configuração da UART0, Utils.c***/ void ConfigureUART(void) // Função retirada do exemplo hello.c

{ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); UARTStdioConfig(0, 115200, 16000000); } int main(void) {

// Habilita clock geral do sistema SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16 MHZ|SYSCTL_OSC_MAIN); ////Configuração da GPIO F //// SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

44

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

[Digite texto]

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 #include #include #include #include #include #include #include #include #include #include

"inc/hw_memmap.h" "inc/hw_types.h" "driverlib/sysctl.h" "driverlib/gpio.h" "driverlib/uart.h" "driverlib/pin_map.h" "utils/uartstdio.h" "driverlib/interrupt.h" "inc/hw_ints.h"

//"Defines" retirados da biblioteca "inc/tm4c123gh6pm.h" //utilizados para declarar as variaveis de desbloqueio //do pino PF4. #define GPIO_PORTF_LOCK_R (*((volatile uint32_t *)0x40025520)) #define GPIO_PORTF_CR_R (*((volatile uint32_t *)0x40025524)) uint8_t LED=4; /***Interrupção por borda de descida no PortF Pin4 (SW1)***/ void PortFIntHandler(void) { GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); LED=2; GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, LED); UARTprintf("Red\n"); SysCtlDelay(20000000); } /***Configuração da UART0, Utils.c***/ void ConfigureUART(void) // Função retirada do exemplo hello.c


}

46

[Digite texto] int main(void) {

SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL

_OSC_MAIN); // Habilita clock geral do sistema ////Configuração da GPIO F //// SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIO_PORTF_LOCK_R = 0x4C4F434B; GPIO_PORTF_CR_R = 0x1F;

// Desbloqueio do //pino PF0.


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

[Digite texto] 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 #include #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 #define MULT_TIMER 1

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

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

48

[Digite texto] GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,

LED); UARTprintf("Blue\n");

flag=0; } else

{ LED=8; GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,

LED); UARTprintf("Green\n");

flag=1; } } /***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


} 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


GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0);

49

[Digite texto] GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4,

GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); ////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); como periódico

//Configura o Timer

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

50

[Digite texto] 5) Caso queira programar alguma função para o botão SW2 no pino PF0, este exemplo permaneceu com as suas configurações como nos exemplos anteriores.

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

//*************************************************************************** // // Forward declaration of the default fault handlers. // //*************************************************************************** void ResetISR(void); static void NmiSR(void); static void FaultISR(void); static void IntDefaultHandler(void); //*************************************************************************** // // External declaration for the reset handler that is to be called when the // processor is started // //***************************************************************************

51

[Digite texto] extern void _c_int00(void);

//*************************************************************************** // // Linker variable that marks the top of the stack. // //*************************************************************************** extern uint32_t __STACK_TOP; //*************************************************************************** // // External declarations for the interrupt handlers used by the application. // //*************************************************************************** // To be added by user extern void PortFIntHandler(void); extern void Timer0IntHandler(void); //*************************************************************************** // // The vector table. Note that the proper constructs must be placed on this to // ensure that it ends up at physical address 0x0000.0000 or at the start of // the program if located at a start address other than 0. // //*************************************************************************** #pragma DATA_SECTION(g_pfnVectors, ".intvecs") void (* const g_pfnVectors[])(void) = { (void (*)(void))((uint32_t)&__STACK_TOP), // The initial stack pointer ResetISR, // The reset handler NmiSR, // The NMI handler FaultISR, // The hard fault handler IntDefaultHandler, // The MPU fault handler IntDefaultHandler, // The bus fault handler IntDefaultHandler, // The usage fault handler 0, // Reserved 0, // Reserved 0, // Reserved 0, // Reserved IntDefaultHandler, // SVCall handler IntDefaultHandler, // Debug monitor handler 0, // Reserved IntDefaultHandler, // The PendSV handler IntDefaultHandler, // The SysTick handler IntDefaultHandler, // GPIO Port A IntDefaultHandler, // GPIO Port B IntDefaultHandler, // GPIO Port C IntDefaultHandler, // GPIO Port D IntDefaultHandler, // GPIO Port E IntDefaultHandler, // UART0 Rx and Tx IntDefaultHandler, // UART1 Rx and Tx IntDefaultHandler, // SSI0 Rx and Tx IntDefaultHandler, // I2C0 Master and Slave IntDefaultHandler, // PWM Fault IntDefaultHandler, // PWM Generator 0 IntDefaultHandler, // PWM Generator 1 IntDefaultHandler, // PWM Generator 2

52

[Digite texto] IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, Timer0IntHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, PortFIntHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, 0, 0, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, 0, 0, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, 0, 0, 0, 0, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

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

Quadrature Encoder 0 ADC Sequence 0 ADC Sequence 1 ADC Sequence 2 ADC Sequence 3 Watchdog timer Timer 0 subtimer A 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 GPIO Port F 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 Reserved Reserved Hibernate USB0 PWM Generator 3 uDMA Software Transfer uDMA Error ADC1 Sequence 0 ADC1 Sequence 1 ADC1 Sequence 2 ADC1 Sequence 3 Reserved Reserved 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 Reserved Reserved Reserved Reserved I2C2 Master and Slave I2C3 Master and Slave Timer 4 subtimer A Timer 4 subtimer B

53

[Digite texto] 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, 0, 0, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, 0, 0, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler,

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

Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved Reserved 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 Reserved Reserved I2C4 Master and Slave I2C5 Master and Slave GPIO Port M GPIO Port N Quadrature Encoder 2 Reserved Reserved GPIO Port P (Summary or P0) GPIO Port P1 GPIO Port P2 GPIO Port P3 GPIO Port P4 GPIO Port P5 GPIO Port P6 GPIO Port P7 GPIO Port Q (Summary or Q0) GPIO Port Q1 GPIO Port Q2 GPIO Port Q3 GPIO Port Q4 GPIO Port Q5 GPIO Port Q6

54

[Digite texto] IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler, IntDefaultHandler

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

GPIO Port Q7 GPIO Port R GPIO Port S PWM 1 Generator PWM 1 Generator PWM 1 Generator PWM 1 Generator PWM 1 Fault

0 1 2 3

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

{ // // Jump to the CCS C initialization routine. This will enable the // floating-point unit as well, so that does not need to be done here. // __asm(" .global _c_int00\n" " b.w _c_int00"); } //*************************************************************************** // // This is the code that gets called when the processor receives a NMI. This // simply enters an infinite loop, preserving the system state for examination // by a debugger. // //*************************************************************************** static void NmiSR(void)

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

55

[Digite texto] static void FaultISR(void)

{ // // Enter an infinite loop. // while(1) { } } //*************************************************************************** // // This is the code that gets called when the processor receives an unexpected // interrupt. This simply enters an infinite loop, preserving the system state // for examination by a debugger. // //*************************************************************************** static void IntDefaultHandler(void)

{ // // Go into an infinite loop. // while(1) { } } ///////////////////////TM4C123GH6PM_SARTUP_CCS.C

- FIM//////////////////////

7.5 Funções da TivaWare Através da TivaWare™ Peripheral Driver Library [2], ou C:\ti\TivaWare_C_Series2.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 void void void

GPIODMATriggerDisable (uint32_t ui32Port, uint8_t ui8Pins) GPIODMATriggerEnable (uint32_t ui32Port, uint8_t ui8Pins) GPIOIntClear (uint32_t ui32Port, uint32_t ui32IntFlags) GPIOIntDisable (uint32_t ui32Port, uint32_t ui32IntFlags)

56

[Digite texto]     

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

[Digite texto] 

void UARTConfigGetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk,



uint32_t _pui32Baud, uint32_t _pui32Config)



void UARTConfigSetExpClk (uint32_t ui32Base, uint32_t ui32UARTClk,

uint32_t ui32Baud,  uint32_t ui32Config)  void UARTDisable (uint32_t ui32Base)  void UARTDisableSIR (uint32_t ui32Base)  void UARTDMADisable (uint32_t ui32Base, uint32_t ui32DMAFlags)  void UARTDMAEnable (uint32_t ui32Base, uint32_t ui32DMAFlags)  void UARTEnable (uint32_t ui32Base)  void UARTEnableSIR (uint32_t ui32Base, bool bLowPower)  void UARTFIFODisable (uint32_t ui32Base)  void UARTFIFOEnable (uint32_t ui32Base)  void UARTFIFOLevelGet (uint32_t ui32Base, uint32_t _pui32TxLevel, uint32_t _pui32RxLevel)  void UARTFIFOLevelSet (uint32_t ui32Base, uint32_t ui32TxLevel, uint32_t ui32RxLevel)  uint32_t UARTFlowControlGet (uint32_t ui32Base)  void UARTFlowControlSet (uint32_t ui32Base, uint32_t ui32Mode)  void UARTIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)  void UARTIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)  void UARTIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)  void UARTIntRegister (uint32_t ui32Base, void (_pfnHandler)(void))  uint32_t UARTIntStatus (uint32_t ui32Base, bool bMasked)  void UARTIntUnregister (uint32_t ui32Base)  void UARTModemControlClear (uint32_t ui32Base, uint32_t ui32Control)  uint32_t UARTModemControlGet (uint32_t ui32Base)  void UARTModemControlSet (uint32_t ui32Base, uint32_t ui32Control)  uint32_t UARTModemStatusGet (uint32_t ui32Base)  uint32_t UARTParityModeGet (uint32_t ui32Base)  void UARTParityModeSet (uint32_t ui32Base, uint32_t ui32Parity)  void UARTRxErrorClear (uint32_t ui32Base)  uint32_t UARTRxErrorGet (uint32_t ui32Base)  void UARTSmartCardDisable (uint32_t ui32Base)  void UARTSmartCardEnable (uint32_t ui32Base)  bool UARTSpaceAvail (uint32_t ui32Base)  uint32_t UARTTxIntModeGet (uint32_t ui32Base)  void UARTTxIntModeSet (uint32_t ui32Base, uint32_t ui32Mode)

7.5.3 Funções de Interrupção

             

void IntDisable (uint32_t ui32Interrupt) void IntEnable (uint32_t ui32Interrupt) uint32_t IntIsEnabled (uint32_t ui32Interrupt) bool IntMasterDisable (void) bool IntMasterEnable (void) void IntPendClear (uint32_t ui32Interrupt) void IntPendSet (uint32_t ui32Interrupt) int32_t IntPriorityGet (uint32_t ui32Interrupt) uint32_t IntPriorityGroupingGet (void) void IntPriorityGroupingSet (uint32_t ui32Bits) uint32_t IntPriorityMaskGet (void) void IntPriorityMaskSet (uint32_t ui32PriorityMask) void IntPrioritySet (uint32_t ui32Interrupt, uint8_t ui8Priority) void IntRegister (uint32_t ui32Interrupt, void (_pfnHandler)(void))

58

[Digite texto] 



void IntTrigger (uint32_t ui32Interrupt) void IntUnregister (uint32_t ui32Interrupt)

7.5.4 Funções de Timer

 

void TimerConfigure (uint32_t ui32Base, uint32_t ui32Config) void TimerControlEvent (uint32_t ui32Base, uint32_t ui32Timer,

uint32_t ui32Event) 

void TimerControlLevel (uint32_t ui32Base, uint32_t ui32Timer, bool

bInvert) 

void TimerControlStall (uint32_t ui32Base, uint32_t ui32Timer, bool

bStall) 

void TimerControlTrigger (uint32_t ui32Base, uint32_t ui32Timer,

bool bEnable)                          

void TimerControlWaitOnTrigger (uint32_t ui32Base, uint32_t

ui32Timer, bool bWait) void TimerDisable (uint32_t ui32Base, uint32_t ui32Timer) void TimerEnable (uint32_t ui32Base, uint32_t ui32Timer) void TimerIntClear (uint32_t ui32Base, uint32_t ui32IntFlags) void TimerIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags) void TimerIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags) void TimerIntRegister (uint32_t ui32Base, uint32_t ui32Timer, void (_pfnHandler)(void)) uint32_t TimerIntStatus (uint32_t ui32Base, bool bMasked) void TimerIntUnregister (uint32_t ui32Base, uint32_t ui32Timer) uint32_t TimerLoadGet (uint32_t ui32Base, uint32_t ui32Timer) uint64_t TimerLoadGet64 (uint32_t ui32Base) void TimerLoadSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value) void TimerLoadSet64 (uint32_t ui32Base, uint64_t ui64Value) uint32_t TimerMatchGet (uint32_t ui32Base, uint32_t ui32Timer) uint64_t TimerMatchGet64 (uint32_t ui32Base) void TimerMatchSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value) void TimerMatchSet64 (uint32_t ui32Base, uint64_t ui64Value) uint32_t TimerPrescaleGet (uint32_t ui32Base, uint32_t ui32Timer) uint32_t TimerPrescaleMatchGet (uint32_t ui32Base, uint32_t ui32Timer) void TimerPrescaleMatchSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value) void TimerPrescaleSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value) void TimerRTCDisable (uint32_t ui32Base) void TimerRTCEnable (uint32_t ui32Base) void TimerSynchronize (uint32_t ui32Base, uint32_t ui32Timers) uint32_t TimerValueGet (uint32_t ui32Base, uint32_t ui32Timer) uint64_t TimerValueGet64 (uint32_t ui32Base)

59

[Digite texto]

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

60

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

Recommend Documents