Ambiente de Desenvolvimento para Microcontrolador ARM

Relatrio submetido Universidade Federal de Santa Catarina como requisito para a aprovao na disciplina DAS 5501: Estgio em Controle e Automao Industrial

Marcelo Sousa Menegol

Florianpolis, Junho de 2013

Ambiente de Desenvolvimento para Microcontrolador ARM

Marcelo Sousa Menegol

Orientadores:

Jonatan Vieira, Engenheiro de Software ______________________________

Assinatura do Orientador

Prof. Werner Kraus Jr. _______________________

Assinatura do Orientador

Este relatrio foi julgado no contexto da disciplina DAS5501: Estgio e Controle e Automao Industrial e aprovado na sua forma final pelo Curso de Engenharia de Controle e Automao

Resumo
A Arvus Tecnologia a nica empresa nacional fabricante de equipamentos para Agricultura e Silvicultura de Preciso. Um dos principais equipamentos desenvolvidos por esta empresa um computador de bordo que instalado em mquinas agrcolas. Este computador responsvel por controlar vrios atuadores da mquina e tambm por coletar dados sobre as operaes realizadas. Este computador de bordo tem um processador da arquitetura ARM que o corao de todo o sistema. Como essencial que uma empresa de tecnologia acompanhe as novas tendncias do mercado tecnolgico, do interesse da empresa modernizar o hardware que oferecido a seus clientes. Portanto, comou-se a estudar um novo processador mais moderno que atendesse melhor as demandas deste sistema que aprimorado com frequncia. O processador escolhido foi um ARM de dois ncleos da empresa NXP: o LPC4350. O trabalho principal desenvolvido durante o estgio foi o de estudar esse processador e de encontrar uma forma de se desenvolver nesta plataforma. Alm disso, a plataforma de desenvolvimento deveria ser configurada em um computador com um sistema operacional baseado em sistema Unix. No caso, utilizou-se um computador com o sistema operacional Ubuntu (12.04), e testou-se o processador em uma palca de desenvolvimento: LPC-4350-DB1, da empresa Diolan.

Abstract

Arvus Technology is the only brazilian company that manufactures equipment for Precision Agriculture and Forestry. One of the main equipments developed by this company is a on-board computer that goes embedded in agricultural machinery. This computer is responsible for controling several actuators and collecting data about the operations performed. It has an ARM processor that is the heart of all the system. Since it is essential for an engineering enterprise to keep up with the new technological trends, it is of their interest to update the hardware that they offer to their customers. Therefore, the search for newer processor that could better meet the needs of this system that is frequently improved has begun. And the chosen processor was one of the ARM architecture with two cores, developed by NXP: the LPC4350. The main task developed during this internship was studying this new processor and finding a way of developing in this platform. Besides that, the developing environment should be configured on a computer running a Unix-based operational system. In this case, a computer running Ubuntu (12.04) was used, and the processor was tested on a development board: LPC-4350-DB1, by Diolan.

Sumrio
Captulo 1: Introduo...................................................................................................6 Captulo 2: Entendendo o Problema.............................................................................8 2.1 O microcontrolador e a placa............................................................................8 2.2 O sistema........................................................................................................10 Captulo 3: O ambiente de desenvolvimento..............................................................12 3.1 Eclipse CDT: Ambiente de programao........................................................12 3.2 GNU ARM Eclipse: Ferramenta de gerenciamento de projetos.....................12 3.3 Sourcery G++ Lite : Toolchain........................................................................13 3.4 Zylin Embedded CDT: ferramenta de depurao...........................................14 3.5 OpenOCD.......................................................................................................15 Captulo 4: Configurao do ambiente........................................................................16 4.1 OpenOCD.......................................................................................................16 4.2 Criao de um projeto novo............................................................................17 4.3 Configuraes de Depurao.........................................................................20 Captulo 5: Executando o Cdigo................................................................................22 Captulo 6: Concluses e Perspectivas......................................................................25 Anexo 1: Script Vinculador..........................................................................................27 Anexo 2: Arquivos de Inicializao..............................................................................31

Captulo 1:

Introduo

O computador de bordo desenvolvido pela empresa Arvus Tecnologia controla um sistema multi-tarefa: controla vrias vlvulas e motores da mquina agrcola e recebe dados de vrios sensores diferentes. Portanto, ao se escolher um novo microcontrolador para este sistema, optou-se por um que tivesse mais de um ncleo de processamento para se lanar mo das vantagen que isso traz a um sistema deste tipo. O desafio a ser abordado o de se estudar o processador e descobrir como se utilizar suas vrias funcionalidades do novo microcontrolador de forma que ao se alterar o firmware para esta nova plataforma, ela possa ser executada de maneira mais eficiente. Alm disso, deve-se encontrar uma forma de se desenvolver nesta nova plataforma: trocando-se o microcontrolador, necessrio um novo conjunto de softwares (compiladores, vinculadores, etc) para se trabalhar. E todo o ambiente de desenvolvimento deveria ser criado com softwares gratuitos que funcionem no sistema operacional Ubuntu (utilizado na empresa). O problema de grande relevncia para o Curso de Eng. de Controle a Automao atualmente. A grande maioria dos sistemas de controle so executados em sistemas computacionais. E o grande avano tecnologico atual permite que um nico computador controle vrios sistemas diferentes ao mesmo tempo, o que muitas vezes fora o sistema computacional a ser multi-tarefa. Para aumentar a eficincia desses sistemas o mercado j desenvolveu vrias solues, como os microcontroladores de mais de um ncleo de processamento. Porm, desenvolver nestes novos sitemas nem sempre trivial, nem barato. Para permitir que as novas tecnologias sejam utilizadas, importante que algum desenvolva o know-how sobre como utiliz-las. E as ferramentas devem ser, preferencialmente, gratuitas. O desafio abstrato de se encontrar e configurar uma plataforma de desenvolvimento foi resumido e simplificado nos seguintes objetivos:

- Compilar e executar cdigos de exemplos na placa de desenvolvimento LPC-4350-DB1; - O processo deve ser feito inteiramente com software gratuito. A metodologia empregada no desenvolvimento do trabalho consiste em pesquisa e estudo em bibliografia variada, principalmente pela internet. Alm, claro, de testes frequentes e eventuais correo de erros durante o processo. Cada software empregado no processo tambm foi testado sequencialmente, de forma a tentar garantir que qualquer problema a ser encontrado no fosse consequncia de uma operao executada anteriormente (que o problema estivesse de alguma forma no ltimo software instaladoe no no anterior, por exemplo). Dentre as alternativas para soluo deste problema, muitas definidas pela atual situao da empresa: o sistema operacional no qual o ambiente deveria ser executado e o ambiente de programao (Ubuntu e Eclipse) forma escolhidos por serem aqueles que j so utilizados na empresa, os funcionrios que posteriormente utilizaro o ambiente j esto acostumados a estes sistemas. Outras solues foram escolhidas por serem as que aparentam ter mais material disponvel na rede ou por serem j amplamente utilizadas por outras pessoas. Esta foi a justificativa de se utilizar, por exemplo, a "toolchain" CodeSourcery Sourcery G++ Lite. Nos captulos subsequentes, sero apresentados de maneira mais detalhada o microprocessador, o sistema e os programas escolhidos para se configurar o ambiente de desenvolvimento. Tambm sero apresentados como cada um deve ser configurado, quais os procedimentos necessrios apra se instalar cada componente, etc. No final, pretende-se que este relatrio funcione tambm como um guia para qualquer desenvolvedor que esteja em situao semelhante que queira programar no microcontrolador aqui apresentado ou em outros semelhantes.

Captulo 2:

Entendendo o Problema

Inicialmente, necessrio se estudar um pouco o microcontrolador com o qual estamos lidando e, depois, ter em mente quais so os atuais recursos que teremos que usar para program-lo.

2.1

O microcontrolador e a placa

Os processadores da arquitetura ARM so muito conhecidos atualmente no mercado por terem um alto desempenho para sistemas embarcados. Logo, o processador escolhido para integrar o novo computador de bordo foi desta arquitetura. Alm disso, tendo em vista que temos um sistema multi-tarefa em mos, torna-se interessante se utilizar microcontroladores com mais de um ncleo de processamento. Tais necessidades justificam a escolha do LPC4350 [1] como substituto. O processador LPC4350 um microcontrolador de 32 bits para aplicaes embarcadas baseado em ARM Cortex-M4, que incui um coprocessador ARM Cortex-M0. Tem internamente 264 kB de memria SRAM para o uso de dados e cdigo e 64 kB de memria ROM para inicializao e alguns "drivers" em software. O ncleo Cortex-M4 tem uma arquitetura Harvard, com locais separados para intrues e dados, bem como um terceiro barramento para perifricos. O ncleo Cortex-M0 utiliza a arquitetura von-Neumann. A comunicao entre os dois processadores feita em uma rea de memria SRAM compartilhada que atua como caixa de correio e com um ncelo ativando interrupes do outro. Por exemplo, quando um ncleo envia uma mensagem ao outro, ele ativa uma interrupo deste, que por sua vez, dever ativar uma interrupo daquele para avisar que a mensagem foi devidamente recebida. Para se testar este microcontrolador, utilizou-se a placa de desenvolvimento LPC4350-DB1. Esta placa, alm do microcontroaldor, tem uma srie de outros recursos, dentre eles: - Conector mini USB tipo B; 8

- Conector JTAG; - 16 MB de memria FLASH externa; - 5 Leds controlados pelo usurio; - Jumpers seletores de inicializao.

Figura 1: LPC-4350-DB1 B por Diolan

Segue abaixo o mapa de memria da SRAM do microcontrolador, que a rea de memria a ser utilizada posteriormente.

Figura 2: Mapa de Memria LPC 4350

2.2

O sistema

Por ser a linguagem de programao j utilizada na empresa para o desenvolvimento dos atuais produtos, as solues aqui propostas so para C/C++. A soluo foi pensada para um mquina com um sistema operacional baseado em Unix. Mais especificamente, um computador com Ubuntu 12.04, 64bits. O computador precisa ter uma conexo com a internet para facilitar a instalao das ferramentas demonstradas a seguir. Parte-se do presuposto que o usurio tem a ferramenta Aptitude instalada no computador. Para instal-la, basta executar as seguintes linhas de cdigo no terminal: 10

sudo apt-get -y install aptitude sudo aptitude update Parte-se tambm do presuposto de que o computador tem a ferrmenta Java Runtime Environment. Por ser uma ferramenta recorrente, seu processo de instalao no ser explanado aqui. No existe muitos requisitos de hardware para a soluo encontrada, logo as especificaes tcnicas da mquina so sero descritas aqui. Para o comunicao entre o computador e a placa, so utilizados os seguintes conectores: -Conector USB (Macho A / Macho B 5 pinos) para a alimentao da placa; -Adaptador Olimex ARM-USB-TINY para as funes de gravao e debug;

Figura 3: Olimex ARM-USB Tiny

11

Captulo 3:

O ambiente de desenvolvimento

3.1

Eclipse CDT: Ambiente de programao

Talvez a parte mais importante de um ambiente de desenvolvimento seja o ambiente de programao. nesta ferramentas que o programador ir conceber e desenvolver seu cdigo, sua aplicao. onde tudo comea. Para o caso, decidiu-se escolher o ambiente Eclipse CDT. Optou-se por ele pelo simples fato de j ser utilizado dentro da empresa. Alm disso, a ferramenta se integra facilmente com outras ferramentas. Assim, o processo de se escrever o cdigo, compil-lo, grav-lo do chip e depur-lo se torna muito mais simples, podendo todo ser feito por uma mesma interface. 3.1.1. Processo de instalao

Executar o seguinte comando no terminal: sudo aptitude install eclipse-cdt

3.2

GNU ARM Eclipse: Ferramenta de gerenciamento de projetos ferramenta no completamente imprescindvel para o

Esta

desenvolvimento, porm auxilia o desenvolvedor no gerenciamento de projetos para processadores ARM. Seu nome GNU ARM Eclipse, um plugin para o Eclipse. um projeto Open-Source. 3.2.1. Processo de instalao

Abra a ferramenta Eclipse e, no menu superior, v em Help>Install New Software... Em Work With:, escreva: GNU ARM Eclipse - http://gnuarmeclipse.sourceforge.net/updates Instale o pacote. 12

3.3

Sourcery G++ Lite : Toolchain

Depois de escrito qualquer cdigo a ser gravado no processador, necessrio que se tenha um compilador adequado para o compil-lo. Precisamos de um compilador que seja executado em Linux, mas que gere um cdigo para ser executado em um processador ARM. Compiladores comuns no so capazes de fazer isso. Para tal, precisamos de um cross-compiler, um compilador cruzado. O mesmo ocorre para o depurador, o vinculador, e outras ferramentas. Atualmente existem pacotes, conhecidos como toolchain, que agrupam todas essas ferramentas. Para este caso, necessrio uma toolchain que possa interpretar programas em C, executar em GNU e gerar um programa para ser executado no ARM. Optou-se por usar a Sourcery G++ Lite. Uma toolchain desenvolvida pela empresa CodeSourcery (atual Mentor). Ela inclui: - Compiladores GNU C e C++; - Assembler e vinculador GNU; -Bibliotecas C e C++; -Depurador GNU. 3.3.1. Processo de Instalao

Faa download do pacote no site: http://sourcery.mentor.com/public/gnu_toolchain/arm-none-linuxgnueabi-i686-pc-linux-gnu/arm-2012.09-64-arm-none-linux-gnueabii686-pc-linux-gnu.tar.bz2 Crie um diretrio em /opt (ex.: /opt/codesourcery); Descompacte o pacote dentro do diretorio criado; Esta toolchain precisa que o computador tenha bibliotecas 32bits instaladas. No caso de mquinas 64bits, basta rodar o seguinte cdigo no terminal: 13

sudo apt-get install ia32-libs Depois, importante garantir que o sistema operacional identificar as entradas para a toolchain. No terminal: PATH=[Diretrio de onde foi extrado o pacote]:$PATH (Ex.: PATH=/opt/codesourcery/arm-2012.09/bin:$PATH ) export PATH Agora, j deve ser possvel compilar um arquivo .c e gerar um arquivos .elf (que ser utilizado para se gravar o seu programa no microcontrolador).

3.4

Zylin Embedded CDT: ferramenta de depurao

Apesar de j termos um depurador (que foi instalado junto com a toolchain anteriormente), h um plugin Open-Source para a ferramenta Eclipse que facilita o trabalho de configurao do depurador para este e outros projetos. Seu nome Zylin Embedded CDT, da empresa Zylin. 3.4.1. Processo de Instalao

Abra a ferramenta Eclipse e, no menu superior, v em Help>Install New Software... Em Work With:, escreva: http://opensource.zylin.com/zylincdt Instale o pacote.

14

3.5

OpenOCD

OpenOCD (Open On-Chip Debugger) uma ferramenta de depurao que permite se verificar o cdigo enquanto ele executado no microcontrolador. Ela um projeto Open-Source criada por Dominic Rath. 3.5.1. Processo de Instalao

No terminal, execute: sudo aptitude install openocd

15

Captulo 4:

Configurao do ambiente

Agora que todos os programas e ferramentas esto devidamente instaladas no computador, necessrio se realizar algumas configuraes [2] para que todas funcionem em conjunto.

4.1

OpenOCD

Mesmo que a ferramenta esteja instalada no computador, necessrio se configurar o Ecilpse IDE para que ele a reconhea como uma ferramenta. Em Run>External Tool>External Tool Configurations... selecione Program na aba do lado esquerdo e clique em New launch configuration acima. Em Location, insira a localizao do executvel. Em Working Directory, insira o diretrio do local de trabalho sendo utilizado pelo Eclipse no momento. Em argumentos, insira: - Os arquivos de configurao de interface da ferramenta com o chip. No caso, a interface feita por JTAG. - Os arquivos de configurao para o alvo de gravao e depurao. No caso, LPC4350 - Comandos de configurao que se deseja que sejam executado quando a ferramenta for executada. Mais detalhes sobre estes argumentos e sobre como configurar a ferramenta podem ser encontrados na sua documentao [3].

16

Figura 4: Exemplo de Configurao - OpenOCD

Nota: o arquivo de configurao de alvo (target) possivelmente no est presente no computador at o presente momento. O arquivo utilizado pode ser encontrado em: https://github.com/shyul/openocd/blob/master/tcl/target/lpc4350.cfg

4.2

Criao de um projeto novo

Sempre que um projeto novo for criado, o Plugin GNU ARM ECLIPSE mostra-se til. Em File>New>C++ Project, pode-se escolher a opo de um novo projeto para ARM, bem como j se definir qual ser a toolchain (neste caso Sourcery G++ Lite). Desta forma no ser necessrio se definir manualmente qual toolchain dever ser utilizada, e a gerao de um Makefile (arquivo necessrio para que se vincule e compile o cdigo) ser automtica.

17

Figura 5: Tela de Criao de Novo Projeto

Em um projeto para ARM, existem dois arquivos muito importantes alm do programa em si (arquivos em .c) e de outras bibliotecas e cabealhos: os arquivos de inicializao(.s, .S, .c ou .cpp) e o script vinculador (.ld). Em seguida, dar-se-a uma ateno especial a eles, apesar de serem especficos para cada projeto criado.

18

4.2.1.

Script Vinculador (.ld)

O script vinculador [5] liga vrios objetos e arquivos, realoca seus dados e amarra as referncias de smbolos. Outra forma de enxerg-lo como um arquivo que define as reas de memria que sero usada dos sistema microcontrolado, bem como em que partes da memria cada sesso do programa ficar (main, pilha, vetor de interrupes, e entre outros). Estes arquivos normalmente so escritos de acordo com a linguagem Linker Command Language. Segue no Anexo 1 um exemplo de script vinculador, o que foi usado para se executar o exemplo neste caso. O que ele xecuta , basicamente: -Define o ponto de entrada no cdigo como sendo o procedimento de reset; -Define as reas de memria que sero utilizadas; -Mapeia todo o cdigo e os dados na memria RAM. Mais a respeito da sintaxe utilizada e da estrutura do arquivo pode ser encontrado na documentao.

4.2.2.

Arquivos de Inicializao

Esse arquivos so utilizados para se definir a sequncia de inicializao do ARM, bem como alguns smbolos, vetor de interrupes, e entre outros. Comumente, eles so escritos em assembly [6] (.s ou .S), mas eventualmente podem ser escritos em linguagem C ou C++ (.c ou .cpp). O Anexo 2 um arquivo de inicializao escrito em assembly. Dentre suas definies mais notveis esto: -O tamanho da pilha; -O vetor de interrupes; -O procedimento de reinicializao. 19

4.3

Configuraes de Depurao

Em seguida, necessrio se configurar quais sero os procedimentos a serem executados pelo depurador. Esta configurao especfica para cada projeto criado. Ou seja, precisa ser feita novamente para cada novo projeto. No caso, outilizou-se os exemplos de software providenciados pelos prprios fabricantes da placa de desenvolvimento, que pode ser encontrados em: http://www.lpc4350.com/software-examples Para o teste do ambiente, o exemplo utilizado se chama Buttons Leds Simple. Por ser muito especfico do exemplo em questo, as configuraes do projeto (como, por exemplo, referenciamento de bibliotecas necessrias) no sero abordadas aqui. Pode-se criar uma configurao de depurao em se em New launch configuration. Em C/C++ Application, na primeira aba, deve constar o diretrio do arquivo .elf gerado pela compilao. Na aba Debugger, em GDBdebugger, deve-se inserir o executvel do depurador. No caso: armnone-eabi-gdb. Em seguida, na aba Commands, deve-se inserir os comandos que se deseja que sejam executaos para que a depurao seja feita. Mais detalhes sobre estes comandos e o que cada um representa podem ser encontrados da documentao relacionada [4]. Run>Debug

Configurations.... Seleciona-se Zylin Embedded Debug (Native) e clica-

20

Para o caso aqui tratado, optou-se pela seguinte sequncia de comandos:

target remote localhost:3333 monitor reset monitor soft_reset_halt load monitor halt continue

Que basicamente fazem o seguinte:

Inicia a sesso de depurao; Reinicia o sistema por hardware; Reinicia o sistema por software; Carrega o programa na memria do microcontrolador; Faz uma parada logo aps; Continua e executa o programa gravado.

21

Captulo 5:

Executando o Cdigo

Aps todo o ambiente estar devidamente configurado e o cdigo que se deseja executar no microcontrolador escrito, resta apenas grav-lo e valid-lo. Optou-se por um cdigo simples de exemplo da placa de desenvolvimento, que pode ser encontrado no site do fabricante. O Anexo 3 o procedimento principal (main) do cdigo. Ele deve apenas verificar se os botes S1 a S4 esto pressionados e, para cada um respectivamente, acender os LEDs D3 a D6 caso estejam. Para executar o cdigo e depur-lo: -Compil-lo (Build, no Eclipse); -Executar a configurao criada da ferramenta OpenOCD; -Executar a configurao criada do depurador; Segue abaixo uma imagem de uma sesso de depurao, com o proceidmento principal aberto e o cdigo em assembly de cada intruo ao lado, para que o usurio possa, se quiser, ir depurando o cdigo passo-a-passo.

22

Figura 6: Exemplo de Sesso de Depurao

Figura 7: LPC-4350-DB1 executando cdigo recm gravado 23

Apesar deste ser um exemplo muito simples, as outras funcionalidades devem poder ser utilizadas facilmente (agora que todo o ambiente est configurado). Muitas das outras funcionalidades (como, por exemplo, integrao do LPC4350 com displays LCD ou a comunicao entre os ncleos) j esto disponveis em bibliotecas, criadas as vezes pelo prprio fabricante. H um pacote de bibliotecas chamado CMSIS (Cortex Microcontroller Software Interface Standard, algo como: Padro de Intrface de Software de Microcontroladores Cortex), disponvel gratuitamente no site www.arm.com (ou em sites de outrso forncedores). Este pacote oferece uma interface para o programador, como uma camada a mais entre ele e o processador, de forma a simplificar e facilitar o trabalho. Portanto, para que outras aplicaes possam ser criadas utilizando-se este ambiente de desenvolvimento aqui apesentado, basta que o programador: -Identifique as bibliotecas necessrias para o novo projeto (ou, em casos mais extremos, crie a sua prpria); -Redefina os arquivos de inicializao e o script vinculador; -Redefina os comandos a serem executados pelo depurador (se necessrio); -Redefina as configuraes para estabelecer a conexo entre o computador e o processador (se necessrio).

24

Captulo 6:

Concluses e Perspectivas

Para se desenvover aplicaes e projetos em sistemas embarcado, necessrio ter-se um ambiente de desenvolvimento. E, principalmente quando se trata de lidar com novas tecnologias, criar este ambiente se mostra uma tarefa complicada. Para isto, necessrio se compreender bem o hardware que ir executar a aplicao, bem como os meios de comunic-lo com o a plataforma na qual o software ser desenvolvido (na maioria dos casos, um computador comum). No fim das contas, o criador do ambiente de desenvolvimento tem de compreender bem estes aspectos para que o desenvolvedor do aplicativo no precise se preocupar tanto. Trata-se de criar uma espcie de interface entre o usurio (programador) e hardware (microcontrolador). O desafio de criar este ambiente aumenta quando se inclui a necessidade de que ele seja gratuito. Assim que o hardware lanado no mercado, lana-se tambm uma forma de se utiliz-lo. Porm, estes mtodos costumam ser pagos, o que dificulta sua utilizao por parte de empresas mas, principalmente, de programadores amadores. O trabalho desenvolvido aqui dever ser til no apenas para a empresa Arvus Tecnologia, que dever aproveitar estes resultados para o desenvolvimento de produtos futuros, mas tambm para desenvolvedores amadores que queiram trabalhar com novas tecnologias. Contribui, portanto, para o aparecimento de mais e melhores tecnologias no mercado brasileiro.

25

Bibliografia:

[1] NXP Semiconductors, LPC4350/30/20/10 Product Datasheet, Rev. 4, Maro de 2013, Disponvel em: <http://www.nxp.com/documents/data_sheet/LPC4350_30_20_10.pdf>. [2] J. P. Lynch, ARM Cross Development with Eclipse, Disponvel em: <https://www.sparkfun.com/tutorial/ARM/ARM_Cross_Development_with_Eclipse.pdf >. [3] The Open OCD Project, S. Oliver, O. Harboe, D. Ellis e D. Brownell, OpenOCD User's Guide, 16 de Junho de 2013, Disponvel em: <http://openocd.sourceforge.net/doc/html/index.html>. [4] Free Software Foundation, Debugging with gdb: the gnu Source-Level Debugger, 2013, Disponvel em: <http://sourceware.org/gdb/current/onlinedocs/gdb/>. [5] S. Chamberlain e I. L. Taylor, Using LD, the GNU linker, Verso 2.14, 2003, Disponvel em: <http://www.gnuarm.com/pdf/ld.pdf>. [6] Free Software Foundation, Z. Juric, S. Reichelt e K. Kofler, The GNU Assembler, 2003, Disponvel em: <http://tigcc.ticalc.org/doc/gnuasm.html>.

26

Anexo 1 Script Vinculador

/* * * * * * * * * * * * * * * * Linker script for Cortex-M3 Version:CodeSourcery Sourcery G++ Lite 2007q3-53 BugURL:https://support.codesourcery.com/GNUToolchain/ Copyright 2007 CodeSourcery. The authors hereby grant permission to use, copy, modify, distribute, and license this software and its documentation for any purpose,provided that existing copyright notices are retained in all copies and that this notice is included verbatim in any distributions. No written agreement, license, or royalty fee is required for any of the authorized uses. Modifications to this software may be copyrighted by their authors and need not follow the licensing terms described here, provided that the new terms are clearly indicated on the first page of each file where they apply. */

OUTPUT_FORMAT ("elf32-littlearm", "elf32-bigarm", "elf32-littlearm") ENTRY(__cs3_reset_cortex_m) SEARCH_DIR(.) GROUP(-lgcc -lc -lcs3 -lcs3unhosted -lcs3micro) MEMORY { rom (rx) : ORIGIN = 0x1C000000, LENGTH = 0x400000 ram (rwx) : ORIGIN = 0x10000000, LENGTH = 0x20000 } ram1(rwx) : ORIGIN = 0x10080000, LENGTH = 0x10000

/* These force the linker to search for particular symbols from * the start of the link process and thus ensure the user's * overrides are picked up */ EXTERN(__cs3_reset_cortex_m) EXTERN(__cs3_interrupt_vector_cortex_m) EXTERN(__cs3_start_c main __cs3_stack __cs3_stack_size __cs3_heap_end) PROVIDE(__cs3_stack = __cs3_region_start_ram + __cs3_region_size_ram); PROVIDE(__cs3_stack_size = __cs3_region_start_ram + __cs3_region_size_ram _end); PROVIDE(__cs3_heap_start = _end); PROVIDE(__cs3_heap_end = __cs3_region_start_ram + __cs3_region_size_ram); SECTIONS { .text : { CREATE_OBJECT_SYMBOLS __cs3_region_start_ram = .; *(.cs3.region-head.ram) /* __cs3_region_start_rom = .;*/ /* *(.cs3.region-head.rom)*/ __cs3_interrupt_vector = __cs3_interrupt_vector_cortex_m; *(.cs3.interrupt_vector)

27

/*

/* Make sure we pulled in an interrupt vector. */ ASSERT (. != __cs3_interrupt_vector_cortex_m, "No interrupt vector"); *(.rom) *(.rom.b)*/ *(.ram) __cs3_reset = __cs3_reset_cortex_m; *(.cs3.reset) /* Make sure we pulled in some reset code. */ ASSERT (. != __cs3_reset, "No reset code"); *(.text .text.* .gnu.linkonce.t.*) *(.plt) *(.gnu.warning) *(.glue_7t) *(.glue_7) *(.vfp11_veneer) *(.rodata .rodata.* .gnu.linkonce.r.*) *(.ARM.extab* .gnu.linkonce.armextab.*) *(.gcc_except_table) *(.eh_frame_hdr) *(.eh_frame) . = ALIGN(4); KEEP(*(.init)) . = ALIGN(4); __preinit_array_start = .; KEEP (*(.preinit_array)) __preinit_array_end = .; . = ALIGN(4); __init_array_start = .; KEEP (*(SORT(.init_array.*))) KEEP (*(.init_array)) __init_array_end = .; . = ALIGN(0x4); KEEP (*crtbegin.o(.ctors)) KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors)) KEEP (*(SORT(.ctors.*))) KEEP (*crtend.o(.ctors)) . = ALIGN(4); KEEP(*(.fini)) . = ALIGN(4); __fini_array_start = .; KEEP (*(.fini_array)) KEEP (*(SORT(.fini_array.*))) __fini_array_end = .; KEEP KEEP KEEP KEEP (*crtbegin.o(.dtors)) (*(EXCLUDE_FILE (*crtend.o) .dtors)) (*(SORT(.dtors.*))) (*crtend.o(.dtors))

. = ALIGN(4); __cs3_regions = .;

28

LONG LONG LONG LONG LONG }>ram

(0) (__cs3_region_init_ram) (__cs3_region_start_ram) (__cs3_region_init_size_ram) (__cs3_region_zero_size_ram) */

/* .ARM.exidx is sorted, so has to go in its own output section. __exidx_start = .; .ARM.exidx : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) } >ram __exidx_end = .; .text.align : { . = ALIGN(8); _etext = .; } >ram /* __cs3_region_size_rom = LENGTH(rom); __cs3_region_num = 1;*/ .data : { /* __cs3_region_start_ram = .; *(.cs3.region-head.ram)*/ _sdata = .; KEEP(*(.jcr)) *(.got.plt) *(.got) *(.shdata) *(.data .data.* .gnu.linkonce.d.*) *(.ram.d) . = ALIGN (8); _edata = .; } >ram /*AT>rom*/ .bss (NOLOAD): { . = ALIGN (4); __bss_start__ = .; *(.shbss) *(.bss .bss.* .gnu.linkonce.b.*) *(COMMON) __bss_end__ = .; *(.ram.b) . = ALIGN (4); _end = .; __end = .; } >ram1 .heap (NOLOAD): { *(.heap) } >ram .stack (__cs3_stack - __cs3_stack_size) (NOLOAD): { *(.stack) _estack = .; PROVIDE(estack = .); } >ram __cs3_region_init_ram = LOADADDR (.data);

29

/* /*

__cs3_region_init_ram = LOADADDR (.text);*/ __cs3_region_init_size_ram = _edata - __cs3_region_start_ram;*/ __cs3_region_init_size_ram = _edata - _sdata; __cs3_region_zero_size_ram = _end - _edata; __cs3_region_size_ram = LENGTH(ram); __cs3_region_num = 1; .stab 0 (NOLOAD) : { *(.stab) } .stabstr 0 (NOLOAD) : { *(.stabstr) } /* DWARF debug sections. * Symbols in the DWARF debugging sections are relative to the beginning * of the section so we begin them at 0. */ /* DWARF 1 */ .debug 0 : { *(.debug) } .line 0 : { *(.line) } /* GNU DWARF 1 extensions */ .debug_srcinfo 0 : { *(.debug_srcinfo) } .debug_sfnames 0 : { *(.debug_sfnames) } /* DWARF 1.1 and DWARF 2 */ .debug_aranges 0 : { *(.debug_aranges) } .debug_pubnames 0 : { *(.debug_pubnames) } /* DWARF 2 */ .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) } .debug_abbrev 0 : { *(.debug_abbrev) } .debug_line 0 : { *(.debug_line) } .debug_frame 0 : { *(.debug_frame) } .debug_str 0 : { *(.debug_str) } .debug_loc 0 : { *(.debug_loc) } .debug_macinfo 0 : { *(.debug_macinfo) } /* SGI/MIPS DWARF 2 extensions */ .debug_weaknames 0 : { *(.debug_weaknames) } .debug_funcnames 0 : { *(.debug_funcnames) } .debug_typenames 0 : { *(.debug_typenames) } .debug_varnames 0 : { *(.debug_varnames) } .note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) } .ARM.attributes 0 : { KEEP (*(.ARM.attributes)) } /DISCARD/ : { *(.note.GNU-stack) }

30

Anexo 2 Arquivo de Inicializao

Disponvel em: <http://www.lpc4350.com/lpc43xx/Core/Device/NXP/LPC43xx/Source/Templates/GC C/startup_LPC18xx.s?peg=41>.
/*************************************************************************/ /* startup_LPC18xx.s: Startup file for LPC18xx device series */ /*************************************************************************/ /* Version: CodeSourcery Sourcery G++ Lite (with CS3) */ /*************************************************************************/ /* // <h> Stack Configuration // <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8> // </h> */ .equ Stack_Size, 0x00000100 .equ Sign_Value, 0x5A5A5A5A .section ".stack", "w" .align 3 .globl __cs3_stack_mem .globl __cs3_stack_size __cs3_stack_mem: .if Stack_Size .space Stack_Size .endif .size __cs3_stack_mem, . - __cs3_stack_mem .set __cs3_stack_size, . - __cs3_stack_mem /* // <h> Heap Configuration // <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8> // </h> */ .equ Heap_Size, 0x00001000

.section ".heap", "w" .align 3 .globl __cs3_heap_start .globl __cs3_heap_end __cs3_heap_start: .if Heap_Size .space Heap_Size .endif __cs3_heap_end: /* Vector Table */ .section ".cs3.interrupt_vector" .global __cs3_interrupt_vector_cortex_m .type __cs3_interrupt_vector_cortex_m, %object

31

__cs3_interrupt_vector_cortex_m: .long __cs3_stack .long __cs3_reset .long NMI_Handler .long HardFault_Handler .long MemManage_Handler .long BusFault_Handler .long UsageFault_Handler .long Sign_Value .long 0 .long 0 .long 0 .long SVC_Handler .long DebugMon_Handler .long 0 .long PendSV_Handler .long SysTick_Handler /* External Interrupts */ .long DAC_IRQHandler .long 0 .long DMA_IRQHandler .long 0 .long 0 .long ETH_IRQHandler .long SDIO_IRQHandler .long LCD_IRQHandler .long USB0_IRQHandler .long USB1_IRQHandler .long SCT_IRQHandler .long RIT_IRQHandler .long TIMER0_IRQHandler .long TIMER1_IRQHandler .long TIMER2_IRQHandler .long TIMER3_IRQHandler .long MCPWM_IRQHandler .long ADC0_IRQHandler .long I2C0_IRQHandler .long I2C1_IRQHandler .long 0 .long ADC1_IRQHandler .long SSP0_IRQHandler .long SSP1_IRQHandler .long UART0_IRQHandler .long UART1_IRQHandler .long UART2_IRQHandler .long UART3_IRQHandler .long I2S0_IRQHandler .long I2S1_IRQHandler .long SPIFI_IRQHandler .long SGPIO_IRQHandler .long GPIO0_IRQHandler .long GPIO1_IRQHandler .long GPIO2_IRQHandler .long GPIO3_IRQHandler .long GPIO4_IRQHandler .long GPIO5_IRQHandler .long GPIO6_IRQHandler

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

Top of Stack Reset Handler NMI Handler Hard Fault Handler MPU Fault Handler Bus Fault Handler Usage Fault Handler Reserved Reserved Reserved Reserved SVCall Handler Debug Monitor Handler Reserved PendSV Handler SysTick Handler

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

/* 16 D/A Converter */ Router */ General Purpose DMA */ Reserved */ Reserved */ /* 21 Ethernet */ /* 22 SD/MMC */ /* 23 LCD */ /* 24 USB0*/ /* 25 USB1*/ /* 26 State Configurable Timer*/ /* 27 Repetitive Interrupt Timer*/ /* 28 Timer0*/ /* 29 Timer1*/ /* 30 Timer2*/ /* 31 Timer3*/ /* 32 Motor Control PWM*/ /* 33 A/D Converter 0*/ /* 34 I2C0*/ /* 35 I2C1*/ /* 36 Reserved*/ /* 37 A/D Converter 1*/ /* 38 SSP0*/ /* 39 SSP1*/ /* 40 UART0*/ /* 41 UART1*/ /* 42 UART2*/ /* 43 UART3*/ /* 44 I2S*/ /* 45 AES Engine*/ /* 46 SPI Flash Interface*/ /* 47 SGPIO*/ /* 48 GPIO0*/ /* 49 GPIO1*/ /* 50 GPIO2*/ /* 51 GPIO3*/ /* 52 GPIO4*/ /* 53 GPIO5*/ /* 54 GPIO6*/ /* 17 Event /* 18 /* 19 /* 20

32

.long .long .long .long .long .long .long .long .long .long .long .long .long .long

GPIO7_IRQHandler GINT0_IRQHandler GINT1_IRQHandler EVRT_IRQHandler CAN1_IRQHandler 0 VADC_IRQHandler ATIMER_IRQHandler RTC_IRQHandler 0 WDT_IRQHandler 0 CAN0_IRQHandler QEI_IRQHandler

/* 55 GPIO7*/ /* 56 GINT0*/ /* 57 GINT1*/ /* 58 Event Router*/ /* 59 C_CAN1*/ /* 60 Reserved*/ /* 61 VADC*/ /* 62 ATIMER*/ /* 63 RTC*/ /* 64 Reserved*/ /* 65 WDT*/ /* 66 M0s*/ /* 67 C_CAN0*/ /* 68 QEI*/

.size __cs3_interrupt_vector_cortex_m, . __cs3_interrupt_vector_cortex_m .thumb /* Reset Handler */ .section .cs3.reset,"x",%progbits .thumb_func .globl __cs3_reset_cortex_m .type __cs3_reset_cortex_m, %function __cs3_reset_cortex_m: .fnstart .if (RAM_MODE) /* Clear .bss section (Zero init) */ MOV R0, #0 LDR R1, =__bss_start__ LDR R2, =__bss_end__ CMP R1,R2 BEQ BSSIsEmpty LoopZI: CMP R1, R2 BHS BSSIsEmpty STR R0, [R1] ADD R1, #4 BLO LoopZI BSSIsEmpty: LDR R0,=main BX R0 .else LDR R0,=_start BX R0 .endif .pool .cantunwind .fnend .size __cs3_reset_cortex_m,.-__cs3_reset_cortex_m .section ".text" /* Exception Handlers */

33

.weak NMI_Handler .type NMI_Handler, %function NMI_Handler: B . .size NMI_Handler, . - NMI_Handler .weak HardFault_Handler .type HardFault_Handler, %function HardFault_Handler: B . .size HardFault_Handler, . - HardFault_Handler .weak MemManage_Handler .type MemManage_Handler, %function MemManage_Handler: B . .size MemManage_Handler, . - MemManage_Handler .weak BusFault_Handler .type BusFault_Handler, %function BusFault_Handler: B . .size BusFault_Handler, . - BusFault_Handler .weak UsageFault_Handler .type UsageFault_Handler, %function UsageFault_Handler: B . .size UsageFault_Handler, . - UsageFault_Handler .weak SVC_Handler .type SVC_Handler, %function SVC_Handler: B . .size SVC_Handler, . - SVC_Handler .weak DebugMon_Handler .type DebugMon_Handler, %function DebugMon_Handler: B . .size DebugMon_Handler, . - DebugMon_Handler .weak PendSV_Handler .type PendSV_Handler, %function PendSV_Handler: B . .size PendSV_Handler, . - PendSV_Handler .weak SysTick_Handler .type SysTick_Handler, %function SysTick_Handler: B . .size SysTick_Handler, . - SysTick_Handler /* IRQ Handlers */ .globl .type Default_Handler Default_Handler, %function

34

Default_Handler: B . .size Default_Handler, . - Default_Handler .macro .weak .set .endm IRQ handler \handler \handler, Default_Handler

IRQ DAC_IRQHandler IRQ DMA_IRQHandler IRQ ETH_IRQHandler IRQ SDIO_IRQHandler IRQ LCD_IRQHandler IRQ USB0_IRQHandler IRQ USB1_IRQHandler IRQ SCT_IRQHandler IRQ RIT_IRQHandler IRQ TIMER0_IRQHandler IRQ TIMER1_IRQHandler IRQ TIMER2_IRQHandler IRQ TIMER3_IRQHandler IRQ MCPWM_IRQHandler IRQ ADC0_IRQHandler IRQ I2C0_IRQHandler IRQ I2C1_IRQHandler IRQ ADC1_IRQHandler IRQ SSP0_IRQHandler IRQ SSP1_IRQHandler IRQ UART0_IRQHandler IRQ UART1_IRQHandler IRQ UART2_IRQHandler IRQ UART3_IRQHandler IRQ I2S0_IRQHandler IRQ I2S1_IRQHandler IRQ SPIFI_IRQHandler IRQ SGPIO_IRQHandler IRQ GPIO0_IRQHandler IRQ GPIO1_IRQHandler IRQ GPIO2_IRQHandler IRQ GPIO3_IRQHandler IRQ GPIO4_IRQHandler IRQ GPIO5_IRQHandler IRQ GPIO6_IRQHandler IRQ GPIO7_IRQHandler IRQ GINT0_IRQHandler IRQ GINT1_IRQHandler IRQ EVRT_IRQHandler IRQ CAN1_IRQHandler IRQ VADC_IRQHandler IRQ ATIMER_IRQHandler IRQ RTC_IRQHandler IRQ WDT_IRQHandler IRQ CAN0_IRQHandler IRQ QEI_IRQHandler .end

35