Neste tutorial mostraremos como instalar e configurar as ferramentas necessárias para começar a programar a Launchpad Tiva C usando a distribuição Linux Ubuntu.
Após configurar o ambiente de programação, mostraremos os passos para a criação de um projeto, onde será usado uma aplicação de exemplo baseado no curso Embedded Systems - Shape the World, dando um incentivo para quem quer começar a usar a plataforma Linux para programar a Launchpad Tiva C.
Instalando os pacotes necessários
Abra o terminal e instale os seguintes pacotes:
1 2 3 4 | $ sudo apt-get install gcc-arm-none-eabi $ sudo apt-get install gdb-arm-none-eabi $ sudo apt-get install openocd $ sudo apt-get install lm4flash |
Para verificar se os pacotes foram devidamente instalados, rode os comandos abaixo e verifique suas saídas.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | $ arm-none-eabi-gcc --version arm-none-eabi-gcc (15:4.9.3+svn227297-1) 4.9.3 20150529 (prerelease) Copyright (C) 2014 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. $ arm-none-eabi-gdb --version GNU gdb (7.8-0ubuntu1+6) 7.8 Copyright (C) 2014 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> dThis is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "--host=x86_64-linux-gnu --target=arm-none-eabi". Type "show configuration" for configuration details. For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>. Find the GDB manual and other documentation resources online at: <http://www.gnu.org/software/gdb/documentation/>. For help, type "help". Type "apropos word" to search for commands related to "word". $ openocd --version Open On-Chip Debugger 0.9.0 (2015-09-02-10:42) Licensed under GNU GPL v2 For bug reports, read http://openocd.org/doc/doxygen/bugs.html |
1 2 3 4 5 6 | $ lm4flash -V LM4Flash version 0.1.3 - Flasher for Stellaris Launchpad ICDI boards Copyright (C) 2012 Fabio Utzig <fabio@utzig.net> Copyright (C) 2012 Peter Stuge <peter@stuge.se> This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
Instalando o Eclipse e seus pacotes
Acesse o site do Eclipse e baixe o pacote Eclipse IDE for C/C++ Developers compatível com a arquitetura de seu computador. Descompacte esse pacote do Eclipse e o mova para o diretório /opt no seu PC:
1 | $ cd /opt/ && sudo tar -zxvf ~/Downloads/eclipse-*.tar.gz |
Se você não tiver instalado o pacote JRE (Java runtime environment) em sua máquina, ao abrir o Eclipse será apresentada uma tela de erro. Para resolver isso de forma fácil, você pode usar central de pacotes do Ubuntu para instalar o pacote JRE ou rodar o comando abaixo:
1 | $ sudo apt-get install openjdk-8-jre |
Abra o Eclipse, acesse Help -> Install new software…, em Work with adicione o repositório GNU ARM Eclipse. Selecione e instale o pacote GNU ARM C/C++ Cross Development Tools. Esse plugin irá gerenciar os projetos ARM.
Entendendo como as ferramentas se relacionam
GCC: O pacote toolchain gcc-arm-none-eabi contém o compilador GCC. Essa ferramenta irá gerar o código binário da nossa aplicação para a arquitetura ARM Cortex-M4.
binutils: Ferramenta que cria, manuseia e gerencia os arquivos binários gerados pelo GCC.
Makefile: É o nome de arquivo de texto onde estão todas as ordens e regras que relacionam os distintos elementos (libraries) que formam parte do projeto. Informando quais arquivos serão compilados para gerar o arquivo binário.
GDB: O pacote gdb-arm-none-eabi contém o depurador GNU para processadores ARM Cortex-A/R/M. Ele conversa com a interface JTAG, e durante o processo de depuração usa outra aplicação: o OpenOCD.
OpenOCD: O pacote openocd contém uma aplicação que utiliza múltiplas interfaces JTAG, o que nos permite depurar distintos dispositivos. Precisaremos configurar e indicar o JTAG usado pela Launchpad Tiva C.
objcopy: ferramenta que copia o conteúdo de um arquivo objeto para outro. Ele será usado para gerar o arquivo .bin (binary) a partir de um .elf (Executable and Linkable Format).
lm4flash: O pacote lm4flash contém uma aplicação que grava na Tiva C o arquivo binário da aplicação gerado pelo objcopy do GCC.
Eclipse + CDT (C/C++): Usaremos a IDE do Eclipse para interagir, configurar e compilar nossas aplicações, lembrado que a compilação do projeto se baseia no arquivo makefile.
Antes de criar um novo projeto
Para a criação do nosso primeiro projeto precisaremos dos arquivos linker.ld, startup.c e tm4c123gh6pm.h. Em outros compiladores como o CCS, Keil e IAR esses arquivos são criados automaticamente. Faça o download desses arquivos aqui.
A Launchapad TIVA C possui uma memória Flash de 256 KB e uma memória SRAM de 32 KB. O arquivo Linker script permite usar distintas regiões de memória para mapear a aplicação dentro dessas memórias. A escrita, leitura e o tamanho de cada região de memória pode ser alterado modificando esse arquivo. Comumente as regiões de memória são divididas em: text, data, bss, stack e heap.
Memória usada | Região de memória | Descrição |
Flash | text | Contém a sequência de instruções do programa incluindo as variáveis declaradas como const. Caso a aplicação use bootloader esta região de memoria é divida em duas partes. |
SRAM | data | Contém as variáveis que tiveram seus valores iniciais especificados em tempo de compilação. |
SRAM | bss | Contém as variáveis globais que não foram inicializadas no código fonte do programa. E uma boa pratica por padrão inicializadas essas variáveis com zero. |
SRAM | heap | É uma área de memória na qual o processo pode guardar variáveis alocadas dinamicamente. |
SRAM | stack | É uma área de memória que guarda as informações necessárias à execução de funções. Quando uma função é chamada, o processo aloca uma região de memória na pilha para armazenar informações como as variáveis locais da função e o endereço de retorno. |
O arquivo startup.c contém a tabela do vetor de interrupção do microcontrolador e o ponto de entrada da aplicação, responsável por inicializar a memória (seções DATA e BSS) e executar a função main().
O arquivo header tm4c123gh6pm.h contém o mapeamento de todos os registradores do microcontrolador TM4C123GH6PM, que é usado pela placa da Launchpad Tiva C.
Criando um novo projeto
Inicialize o Eclipse:
Copie os arquivos main.c, linker.ld, startup.c e tm4c123gh6pm.h, baixados anteriormente, na pasta src do projeto Exemplo1. O arquivo main.c contém uma aplicação simples que configura a placa para funcionar a uma taxa de 80 MHz, configura a UART0 para funcionar com um baudrate de 115200 bps, lê as teclas sw1 e sw2 e usa o led rgb da placa.
Na rotina principal, toda vez que uma tecla é pressionada é ligado um led de cor diferente, que incrementa um contador e envia uma mensagem pela porta serial, informado a tecla e o número de vezes que ela foi pressionada.
Neste ponto configuraremos o compilador GCC que instalamos para a nossa arquitetura alvo. As imagens abaixo mostram o passo a passo para fazer isso.
Entre em: Project->Properties->C/C++ build->Settings
Abaixo configuramos o GCC para usar a arquitetura ARM da TIVA C. Deixe as configurações iguais.
Na imagem abaixo adicionar as macros ARM_MATH_CM4, PART_TM4C123GH6PM e TARGET_IS_TM4C123_RB1 para informar ao compilador GCC o microcontrolador alvo que desejamos usar.
A seguir informamos o caminho do arquivo linker da nossa aplicação.
Agora adicionamos o seguinte comando para gerar o arquivo .bin a partir do arquivo .elf apos a compilação, pois ele será usado pelo lm4flash para gravar nossa aplicação na TIVA C.
1 | arm-none-eabi-objcopy -O binary ${ProjName}.elf ${ProjName}.bin |
Compile o projeto com Project->Build All. A imagem seguinte mostra a saída da compilação, indicando que foram gerados os arquivos .hex, .elf e .bin com sucesso.
Configurando o OpenOCD para debug
Após ter compilado com sucesso o projeto, entre em: Run->Debug Configurations. Crie um novo objeto do tipo GDB OpenOCD Debugging.
Nesta parte precisamos indicar ao OpenOCD o JTAG da nossa placa. No campo “Executable” precisamos indicar o comando ou caminho para executar o OpenOCD.
Adicione o comando: openocd
No campo “config options” adicione o trecho:
1 2 | /usr/share/openocd/scripts/ --file ./board/ek-tm4c123gxl.cfg |
Adicione o recurso de debug de nossa aplicação da IDE do Eclipse.
A imagem abaixo mostra o projeto Exemplo1 durante o processo de depuração:
Configurando o LM4flash
O LM4flash grava o arquivo binário (.bin) de nossa aplicação gerado pelo GCC na TIVA C. Você irá reparar que o próprio GDB acaba gravando a aplicação na placa, por isso o uso de LM4flash é apenas um opcional.
Acesse: Run->External Tools->External Tools Configurations...
Crie um novo program, em Location indique o caminho onde o lm4flah se encontra, em Working Directory indique o local onde o arquivo binário que deseja gravar foi criado, e, por último, em Arguments indique o nome do arquivo binário que deseja gravar.
A figura abaixo mostra a gravação do arquivo .bin realizada com sucesso.
Comunicação Serial
Para estabelecer uma comunicação serial com a TIVA C usaremos o picocom, mas antes precisamos saber em qual porta serial a TIVA C está conectada em nosso sistema. Para isso usaremos o comando abaixo:
1 2 3 4 5 | $ dmesg | grep tty [ 0.000000] console [tty0] enabled [ 4.706173] systemd[1]: Created slice system-getty.slice. [ 43.499262] cdc_acm 3-1.3:1.0: ttyACM0: USB ACM device [ 211.083860] usb 1-1: pl2303 converter now attached to ttyUSB0 |
Podemos ver que foram encontradas 2 portas seriais em nosso sistema, a ttyACM0 e ttyUSB0. A primeira pertence à TIVA C e a segunda a um conversor USB/Serial qualquer que tenha ligado ao computador.
Após descobrirmos a porta serial usada pela TIVA C, iremos instalar, configurar e executar o picocom usando as rotinas abaixo.
1 2 3 4 | $ sudo apt-get install picocom $ alias picocom='picocom /dev/ttyACM0 -l -b 115200 -f n' $ sudo chmod 777 /dev/ttyACM0 $ picocom |
A figura abaixo mostra o picocom comunicando-se com a TIVA C.
Conclusão
Neste artigo usamos ferramentas gratuitas para criar um ambiente de programação para a launchapad TIVA C na plataforma Ubuntu. Implementamos uma aplicação exemplo e vimos como criar uma comunicação serial com o Linux usando o picocom.
Caso você possua outra placa ARM Cortex-M, você poderá usar este mesmo artigo para criar o ambiente de programação para ela, basta configurar o GCC e openocd com as configurações de sua placa.
Referências
http://www.midiacom.uff.br/~diego/disciplinas/2011_1/sisop/NotasAula7.pdf
https://sergioprado.org/padrao-elf-para-arquivos-objeto/
Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.
Obrigado! Sua inscrição foi um sucesso.
Ops, algo deu errado. Por favor tente novamente.
Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.
Deixe um comentário