1

TUTORIAL

INCORPORANDO A BIBLIOTECA DO ARDUINO AO ECLIPSE

Jefferson Z. Moro jefferson.moro@gmail.com

Vinicius Franchini viniciusnf@gmail.com

Campinas, maio de 2011

2

Motivação

O Arduino veio para simplificar a programação de microcontroladores. Além de não precisar

de gravador devido ao bootloader, seu Ambiente de Desenvolvimento Integrado (IDE)

permite o uso de C++, que amplia as possibilidades de projetos. Tal ambiente traz bibliotecas

que facilitam o uso e encurtam o tempo gasto para iniciar um projeto.

Contudo, esse ambiente é limitado em ferramentas. Quando o projeto toma grandes

dimensões, o IDE do Arduino deixa de exercer seu propósito facilitador, apesar de suas

bibliotecas ainda serem muito úteis. Dessa forma, busca-se o uso de IDEs mais completos,

juntamente com essa poderosa biblioteca.

A primeira opção que vem a cabeça é usar o IDE da Atmel, o AVR Studio. Todavia, esse

ambiente de desenvolvimento não compila C++, pois as bibliotecas do Arduino não são

suportadas. Outra ideia é fazer uso do Eclipse.

O Eclipse é um IDE de código aberto (Open Source), feito em Java, que pode ser usado para

o desenvolvimento de muitas linguagens. Ex.: PHP, Java, Python, HTML, C/C++, etc. Ele

foi inicialmente desenvolvida pela IBM, e depois foi doado para uma comunidade software

livre.

Entre as vantagens ferramentais oferecidas pelo Eclipse está a de rodar em vários sistemas

operacionais e a de facilitar a busca por funções e definições. Ele trata os arquivos

adicionados ao projeto de forma integrada. Assim, basta mandar fazer uma procura e você

encontrará o quer, independente de em qual arquivo o objeto esteja. Outra vantagem do

programa é que seu desenvolvimento é todo baseado em plug-ins. Um deles é o AVR Eclipse

plug-in.

A ideia é essa: usar o IDE Eclipse como ambiente de desenvolvimento e criar uma biblioteca

estática que armazene todas as funções incluídas no IDE do Arduino.

Preparando o Software

Primeiramente, façamos o download da última versão de cada programa necessário. Vide a

Tabela 1.

Programa Onde baixar? Observações

Eclipse IDE C/C++ http://www.eclipse.org/downloads/ Escolha o sistema operacional

Arduino IDE http://arduino.cc/en/Main/Software Escolha o sistema operacional

WinAVR http://sourceforge.net/projects/winavr/files/ Somente para Windows

AVR-GCC Vide sua distribuição Somente para Linux

AVR Eclipse plug-in http://sourceforge.net/projects/avr-eclipse/files/

3

Vamos por partes. Após baixar o Ecipse, você deve descompactá-lo. Não é necessário instalá-lo

afinal ele é feito em Java, simplesmente execute a aplicação “eclipse”. Na caixa de diálogos,

escolha o diretório onde o seu Workspace ficará, marque a opção de usar esse caminho como

padrão e clique em OK. Veja a Figura 1.

Figura 1

Na página de boas vindas que abrirá, escolha a opção Go to the workbench. Observe a Figura 2.

Figura 2

4

Uma vez baixado o IDE do Arduino, apenas descompacte a pasta, pois só utilizaremos suas

bibliotecas.

O próximo passo será instalar o WinAVR (para Windows), ou AVR-GCC (para Linux).

Em seguida, instale o AVR-Plugin. Para isso, como o Eclipse fechado, descompacte a pasta

do AVR-Plugin, copie as pastas plugin e features para dentro da pasta do Eclipse (a mesma

onde está o aplicativo). Aparecerá uma mensagem perguntando se você deseja mesclar as

pastas. Marque que sim para todos os itens. Pronto, basta abrir o Eclipse e o plugin será

carregado junto. Um botão do AVR plugin deve aparecer na barra de ferramentas. Veja a

Figura 3.

Figura 3

Pronto, o IDE Eclipse está pronto para trabalhar com o AVR.

Gerando a Biblioteca

1. Abra o Eclipse e crie um novo projeto C++: New

a. FileNewC++ Project

b. Project Name: Arduino_Lib

c. Project Type: AVR Cross Target Static Library

d. Toolchains: AVR-GCC Toolchain

e. Clique em Next

f. Desmarque a opcão de debug.

g. Clique em Next

h. Selecione o MCU type e a frequência do seu Arduino. Ex.: MCU: Atmega328P,

frequência: 16000000 Hz.

i. Clique em finish.

2. Clique em Project Properties.

3. Selecione C/C++ Build e expanda esta categoria.

4. Selecione Settings.

5

5. No painel da direita, clique em AVR Compiler:

a. Debugging. Selecione No debugging info.

b. Optimization. Selecione Size Optimizations.

Figura 4

6. No painel da direita, clique em AVR C++ Compiler

a. Debugging. Selecione No debugging info.

b. Optimization. Selecione Size Optimizations.

7. Clique em Ok.

8. Clique com o botão direito do mouse no projeto Arduino_Lib ImportGeneralFile

SystemNext.

9. No diálogo File System, clique em Browse e selecione a pasta onde está a biblioteca do

Arduino. No nosso caso estamos usando a versão 22: ..Arduino-

0022hardwarearduinocoresarduino.

10. Selecione todos os arquivos exceto o main.cpp. Clique em Finish.

6

Figura 5

11. Compile o projeto: Project Build Project.

Pronto, você acaba de gerar uma biblioteca do Arduino para uso no Eclipse. Alguns warnings

(cerca de 12) serão exibidos, mas não se preocupe, tratam-se de avisos de conversão de tipo e

alteração de cabeçalho.

O próximo passo é criar um projeto que utilize nossa biblioteca “Arduino_Lib”.

Configurando um projeto

1. Abra o Eclipse e crie um novo projeto C++:

a. FileNewC++ Project

7

b. Project Name: Exemplo

c. Project Type: AVR Cross Target Application

d. Toolchains: AVR-GCC Toolchain

e. Clique em Next

f. Marque as opções release e debug.

g. Clique em Next

h. Selecione o MCU type e a frequência do seu Arduino. Ex.: MCU: Atmega328P,

frequência: 16000000 Hz.

i. Clique em finish.

2. Clique em ProjectProperties.

3. Selecione C/C++ Build e expanda a categoria

4. Selecione Settings.

5. Em Configurations, selecione All configurations.

6. Clique em Additional Tools in Toolchain

a. Marque obrigatoriamente Generate HEX file for flash memory, para gerar o

arquivo “.hex”

b. Marque Print size, parar exibir no final da compilação, o tamanho do arquivo hex

gerado

c. Marque outros arquivos de saída desejados (opcional)

Figura 6

8

7. Clique em AVR Compiler:

a. Em Directories, adicione o caminho para a pasta do projeto Arduino_Lib, que

será montado pelo Eclipse da seguinte forma: "${workspace_loc:/Arduino_Lib}”

8. Clique em AVR C++ Compiler:

a. Em Directories, adicione o caminho para a pasta do projeto Arduino_Lib, que

será montado pelo Eclipse da seguinte forma: "${workspace_loc:/Arduino_Lib}”

9. Clique AVR C/C++ Linker

a. Usando C++, o arquivo “.hex” pode ficar grande. No menu linker, mude o

command para avr-gcc

b. Altere o command line pattern para: ${COMMAND} --cref -s -Os

${OUTPUT_FLAG}${OUTPUT_PREFIX}${OUTPUT} ${INPUTS} -lm

${FLAGS}

10. Ainda em AVR C/C++ Linker, clique em Libraries

a. Selecione no painel da direita Libraries e adicione o nome de nossa biblioteca

para Arduino (Arduino_Lib).

b. Selecione agora Libraries Path e adicione o caminho para libArduino_Lib.a, o

qual está dentro da pasta Arduino_Lib/Release. Será montado pelo Eclipse da

seguinte forma: "${workspace_loc:/Arduino_Lib/Release}"

c. Clique em Apply.

Figura 7

9

11. No mesmo menu do passo 5 (Configurations), selecione Release.

12. Clique em AVR Compiler:

a. Debugging. Selecione No debugging info

b. Optimization. Selecione Size Optimizations (-Os).

13. No painel direito, clique em AVR C++ Compiler

a. Debugging. Selecione No debugging info

b. Optimization. Selecione Size Optimizations (-Os).

14. Clique em Ok. A parte de configurações termina aqui.

Criando um arquivo main.c/cpp

É hora de criar nosso arquivo principal (main.c ou main.cpp). O compilador Avr-gcc compila

tanto arquivos .c, quanto .cpp. Como projetos em C++ podem incorporar arquivos em C,

optamos por utilizar C++.

1. Clique com o botão direito do mouse na pasta do projeto Exemplo New Source

File.

2. Em source file, coloque o nome main.cpp.

3. Clique em Finish.

4. Abra o arquivo main.cpp e copie o código de exemplo abaixo:

#include "WProgram.h"

/* Escolhe pino do LED do Arduino */

const int PINO_LED = 13;

/* Configura PINO_LED como sendo de saída */

void configPinagem ()

{

pinMode(PINO_LED, OUTPUT);

}

int main(void)

{

init(); // inicializa a biblioteca do Arduino

configPinagem(); //

for (;;) {

digitalWrite(PINO_LED, HIGH);

delay(200);

digitalWrite(PINO_LED, LOW);

delay(1000);

}

}

5. Como estamos utilizando C++, é necessário colocar o seguinte trecho de código abaixo:

extern "C" void __cxa_pure_virtual()

10

{

cli();

for (;;);

}

Isto é necessário apenas em C++ pois, quando uma função puramente virtual é criada, é

necessário um manipulador para erros para quando tal função é chamada. Quando existem

funções virtuais em uma aplicação, é necessário que o programador forneça seu próprio

manipulador de erros __cxa_pure_virtual(). É isso que feito !

6. Para compilar o código, basta clicar na setinha ao lado do martelo, na barra de

ferramentas superior no Eclipse, e selecionar Release. O código deve compilar sem erros.

Figura 8

Utilizando o modo de depuração

Uma das diferenças mais significativas entre o modo de depuração (Debug) e o modo de

lançamento (Release) é que, em debug a informação de depuração simbólica é emitida para

ajudar na busca de erros na aplicação, enquanto a otimização do código não é levada em conta.

11

Por outro lado, em uma Release, a informação de depuração simbólica não é emitida, mas há

uma otimização do código. Consequentemente, por esses dois motivos, o tamanho do arquivo

gerado é menor que no modo Debug.

Entretanto, erros curiosos podem aparecer quando se utiliza o modo Release, pois otimizações do

compilador ou diferenças na inicialização de variáveis podem levar a execuções não esperadas

do código. Como exemplo, basta citar que quando uma variável global é criada e seu valor é

alterado somente na rotina de interrupção e a otimização está ativada, a variável pode ser

compilada como constante pelo AVR-GCC. Sendo assim, sua declaração deve ser precedida de

volatile para que ela não sofra otimização e isso não ocorra.

Para configurar o modo de depuração, faça o seguinte:

1. Siga todos os passos da parte 3-Configurando um projeto, até (inclusive) o passo 10.

2. No mesmo menu do passo 5 (Configurations), selecione Debug.

3. Clique em AVR Compiler:

a. Debugging. Selecione Standard debugging info (-g2)

b. Optimization. Selecione No Optimizations (-O0).

4. Clique em AVR C++ Compiler

a. Debugging. Selecione Standard debugging info (-g2)

b. Optimization. Selecione No Optimizations (-O0).

5. Clique em Ok. A parte de configurações para depuração termina aqui.

Agora você poderá escolher entre dois modos de compilação: Debug e Release. Para isso, basta

selecionar o modo na seta ao lado do martelo na barra de ferramentas do Eclipse.

Como demonstração que modo release pode gerar códigos mais otimizados, tomemos como

exemplo o projeto que acabamos de criar nesse tutorial. Se o projeto for compilado no modo

release, as informações exibidas no console serão:

AVR Memory Usage

----------------

Device: atmega328p

Program: 1132 bytes (3.5% Full)

(.text + .data + .bootloader)

Data: 9 bytes (0.4% Full)

(.data + .bss + .noinit)

Por outro lado, no modo debug, ter-se-á:

AVR Memory Usage

----------------

12

Device: atmega328p

Program: 1160 bytes (3.5% Full)

(.text + .data + .bootloader)

Data: 9 bytes (0.4% Full)

(.data + .bss + .noinit)

Veja que até mesmo para um pequeno projeto, existe uma diferença de 28 bytes entre os

arquivos gerados pelos dois modos!

Otimizando o projeto

É possível otimizar ainda mais nosso projeto. Para tanto algumas configurações extras devem ser

adicionadas.

Faça as configurações abaixo para “Arduino_Lib”:

1. Clique em ProjectProprietsC/C++ BuildSettings

2. Em Configuration escolha Release

3. Clique em AVR Compiler:

a. Optimization Other Optimization flags. Escreva a seguinte linha de comando:

-ffunction-sections -fdata-sections

4. Clique em AVR C++ Compiler:

a. Optimization Other Optimization flags. Escreva a seguinte linha de comando:

-ffunction-sections -fdata-sections

5. Clique em Ok.

Compile o projeto “Arduino_Lib”. Repita os 5 passos acima para o projeto “Exemplo”.

Em seguida, faça também as seguintes alterações em “Exemplo”:

1. Clique em ProjectProprietsC/C++ BuildSettings

2. Em Configuration escolha Release

3. Clique em AVR C++ LinkerGeneral:

a. Other Arguments. Escreva a seguinte linha de comando: -Wl,--gc-sections

4. Clique em Ok e compile o projeto no modo Release.

Uuuaaal!! Como pode-se observar abaixo, no modo release otimizado, um ganho de 176 bytes é

conseguido em relação ao modo debug e um ganho de 148 bytes em relação ao modo release.

AVR Memory Usage

----------------

Device: atmega328p

Program: 984 bytes (3.0% Full)

(.text + .data + .bootloader)

13

Data: 9 bytes (0.4% Full)

(.data + .bss + .noinit)

Outra observação relevante é que, usando o IDE do Arduino e compilando o mesmo exemplo

(“Exemplo”), obteve-se o seguinte resultado:

Binary sketch size: 1024 bytes (of a 30720 byte maximum)

Ou seja, o projeto no Eclipse teve um ganho de 40 bytes.

Referências

http://haacked.com/archive/2004/02/14/difference-between-debug-vs-release-build.aspx

http://zanona.com.br/blog/archives/30

http://www.devmedia.com.br/post-11512-Instalando-o-Eclipse-+-Java-Development-Kit-Parte-1.html

http://www.jimschrempp.com/features/computer/arduino_notes_eclipse.htm

http://www.codeproject.com/KB/system/Arduino_Unleashed.aspx

http://itpedia.nyu.edu/wiki/Arduino_in_Eclipse