Quando pensamos em automação, sensoriamento e controle, normalmente fazemos uma associação com sistemas altamente complexos e caros. Claro que sistemas que necessitam de muita precisão e controle tornam-se mais caros mas o princípio básico é o mesmo, coletar um dado do ambiente e a partir deste dado fazer alguma ação.

O projeto Arduino foi criado com este propósito, oferecer um hardware e software livre a um custo acessível. Isto abriu possibilidades de muitos adeptos da eletrônica e da programação criarem sistemas de monitoramento e controle que até então só eram comercializados por empresas de tecnologia.

O Arduino foi criado na Itália por um grupo de desenvolvedores e especialistas em engenharia eletrônica que criaram um hardware baseado no chip microcontrolador atmega da empresa Atmel. Estes desenvolvedores criaram uma placa com os componentes para dar ao chip atmega uma estrutura própria para a prototipagem, ou seja, um ambiente de testes para o desenvolvimento de projetos.

CONHECENDO A ESTRUTURA DO ARDUINO

O Arduino dispõe de vários modelos de placas, cada uma com características próprias voltadas para o desenvolvimento de protótipos específicos. Algumas placas são muito pequenas como a “Lily” e a “Nano”. Estas placas são extremamente pequenas, sendo otimizadas para projetos que não têm muito espaço. Outras placas têm muitas portas/pinos como a placa “Mega”. A “Mega” pode conectar um número bem expressivo de sensores e relés, muito útil para projetos que necessitam controlar muitos equipamentos e sensores.

A placa mais comum é a “Uno”. Ela tem um número razoável de portas – 13 portas digitais e 6 analógicas, e podem na maioria das vezes suprir as necessidades dos projetos. Vejamos na imagem como é o Arduino Uno, suas especificações e portas:

Vamos inicialmente observar 4 informações listadas na imagem, os pinos de conexões:

1. Pinos de Eletricidade – estes pinos são os responsáveis por fornecer energia para os sensores, relés e outros dispositivos. Nestes pinos temos voltagens de 3.3 volts, 5 volts e também os pinos do ground/negativo;
2. Pinos Analógicos – estes pinos são os responsáveis por receber as leituras de vários sensores acoplados ao Arduino. Um sensor de temperatura, de luminosidade ou de distância podem ser conectados nestes pinos;
3. Pinos Digitais – estes pinos trabalham com os dois valores digitais: ligado e desligado. Dentre suas utilidades servem para ligar relés, LEDs e receber informações de sensores que trabalham digitalmente. Alguns pinos digitais recebem outros valores além do ligado ou desligado. Estes pinos são chamados pinos PWM e são utilizados como pinos de entrada ou saída para sensores e LEDs que têm variações em suas correntes;
4. Plug USB – responsável pela conexão com o computador. Esta conexão é a responsável pelo upload do código que será rodado no Arduino. Normalmente depois do projeto feito o cabo USB não é mais utilizado. Existem algumas formas de enviar os dados coletados pelos sensores do Arduino com um computador que é o centro do sistema. Veremos isto no decorrer de nossos artigos.

A equipe de desenvolvimento do Arduino criou uma interface para sua programação. A última versão da IDE pode ser baixada para vários sistemas operacionais no site do projeto:

• http://www.arduino.cc

Várias distribuições GNU/Linux já possuem em seus repositórios os pacotes e estão disponíveis para instalação. No Debian, Ubuntu e outras distribuições que são baseadas nestas a instalação pode ser feita através do APT, Synaptic ou dselect.

A instalação utilizando o APT é muito simples.

Primeiro sincronizamos a lista de pacotes do nosso computador com o mirror:

# apt-get update

Procuramos os pacotes que contém a string “arduino”:

# apt-cache search arduino

Instalamos o pacote:

# apt-get install arduino

Vários pacotes serão listados como dependências para a instalação do arduino. É só aceitar e esperar até os pacotes serem baixados e instalados.

Depois da instalação será criado uma entrada no menu de sua interface gráfica. Como eu uso o Debian 7, no GNOME foi criada uma seção chamada “Eletrônica” e dentro dela adicionada um ícone do Arduino. Em outras interfaces como o Xfce, KDE e LXDE provavelmente serão criadas entradas semelhantes.

Existem outras IDEs que podem ser utilizadas para a programação do Arduino como a “Maria Mole”. Ela pode ser baixada em:

• MariaMole | dalpix.com

CONHECENDO A INTERFACE DE PROGRAMAÇÃO

A IDE desenvolvida pela equipe do Arduino é bem simples e está em constante desenvolvimento. Observe a imagem:

A versão disponível no repositório do Debian 7 é a versão 1.0.1, no site oficial do projeto a versão disponível para download é a 1.0.4.

Para começar a programar existem duas coisas que precisam ser feitas. A primeira é escolher qual é o Arduíno que será utilizado. Clicando em TOOLS > BOARD teremos uma série de placas Arduino disponíveis. É importante escolher a opção correta pois existem diferenças entre as placas.

A outra opção importante é escolher a porta que o Arduino está conectada. Para ter acesso a esta opção basta clicar em TOOLS > SERIAL PORT. Normalmente no GNU/Linux não haverá dificuldades no reconhecimento da porta. No Windows é um pouco mais complicado pois é necessário baixar o driver para seu correto reconhecimento. Nunca testei o Arduino no Windows então não posso ajudar na instalação do driver.

Estes são os passos básicos para começar a programar o Arduino. Vejamos agora como é sua estrutura de programação.

Um projeto no Arduino é chamado de “sketch”. Quando o Arduino é instalado é automaticamente criado no $HOME do usuário um diretório chamado sketchbook. Este diretório é o padrão para todos os projetos criados.

Quando abrimos a IDE do Arduino ele abre um sketch vazio. Para que este sketch possa futuramente ser executado ele precisa obrigatoriamente ter duas seções: setup e loop. A seção setup é lida uma única vez no boot do Arduino. Nesta seção ficam as configurações do projeto. A seção loop é executada enquanto o Arduino estiver ligado. As instruções dentro dessa seção são lidas e executadas. Na seção loop está a leitura dos dados coletados pelos sensores e o acionamento de dispositivos caso alguma ação esteja prevista se algum sensor detectar uma variação já previamente definida no código.

Vejamos à estrutura do sketch:

void setup()
{

}

void loop()
{

}

Alguns cuidados são muito importantes na hora de programar: o arduino tem um limite de memória, são apenas 32 kb de memória, então o código tem que ser enxuto. É sempre bom comentar o código para que futuramente você saiba o que ele faz.

Para comentar uma linha usamos o sinal // (dupla barra). Para comentar várias linhas usamos /* no início da linha e */ no final. Todo o conteúdo entre estes caracteres serão entendidos como comentário.

CONSTRUINDO NOSSO PRIMEIRO PROJETO

Nosso primeiro código é muito simples. A ação produzida por ele será ligar 2 LEDs alternadamente com um intervalo de 1 segundo entre eles.

Para ficar mais didático vou comentar diretamente no código o que o código faz:

// início da seção setup
void setup()
{

// definindo as duas variáveis que serão responsáveis pelos dois leds. Um led vermelho na porta
// digital 12 e um led verde na porta digital 8
  byte ledVermelho = 12;
  byte ledVerde = 8;

// definimos através do "pinMode" que o ledVermelho e o ledVerde serão utilizados como saída
// definimos através do "digitalWrite" que o ledVermelho inicia com o valor 1 – ligado
// definimos através do "digitalWrite" que o ledVerde inicia com o valor 0 – desligado
  pinMode(ledVermelho,OUTPUT);
  digitalWrite(ledVermelho,1);

  pinMode(ledVerde,OUTPUT);
  digitalWrite(ledVerde,0);
}

// agora começa a seção que será repetida indefinidademente
void loop()
{

// ele já começa dando um tempo de 1 segundo.
// no arduino o tempo é medido em milisegundos
  delay(1000);

// o ledVermelho fica desligado, o ledVerde fica ligado
  digitalWrite(ledVermelho,0);
  digitalWrite(ledVerde,1);

// espera um segundo
  delay(1000);

// o ledVermelho fica ligado, o ledVerde fica desligado
  digitalWrite(ledVermelho,1);
  digitalWrite(ledVerde,0);

// quando chega no fim do código ele volta para o início da seção "void loop()" e tudo recomeça.
}

Depois do código escrito é preciso compilar e enviá-lo através do cabo USB para o Arduino. Na IDE, abaixo do menu há a barra de botões com os botões responsáveis pela compilação do código e seu upload. O primeiro botão é responsável por sua compilação, o segundo por seu upload.

Devemos tomar muito cuidado com a sintaxe, nomes de variáveis, palavras reservadas e loops de controle. Qualquer erro impedirá a compilação do código.

No desenvolvimento de projetos com o Arduino um dos componentes fundamentais é o protoboard. Ele é um componente que é utilizado para a construção dos protótipos, antes de se tornarem um produto final. Ele dá liberdade para o projetista testar os componentes sem fazer tudo definitivamente.

O protoboard é composto de linhas e colunas divididas em duas partes. Observe a imagem:

Este é um protoboard padrão encontrado nas lojas de eletrônica. Observe que o dividi em dois setores e cada um destes tem suas respectivas funcionalidades.

• Setor responsável pela alimentação elétrica. Os pontos são conectados entre si horizontalmente (veja a linha vermelha conectando-os horizontalmente). Uma linha pode ser destinada para o positivo e a outra linha para o negativo;
• Setor responsável pela conexão dos componentes do sistema. Os pontos são conectados entre si verticalmente (veja a linha vermelha conectando-os verticalmente). Quando um jumper ou componente se conectar a um ponto da coluna todos os demais pontos estarão energizados.

Vejamos as conexões do Arduino com o protoboard e seus componentes eletrônicos que serão a parte de hardware e que serão controlados pelo programa feito no Arduino. Veja a imagem abaixo:

Vamos analisar as conexões do Arduino com o protoboard e seus componentes. Se nós prestarmos atenção aos dois LEDs vemos que ambos têm resistores conectados na mesma coluna que uma de suas pernas. Do Arduino saem dois jumpers, um da porta digital 8 e outra da porta digital 12. Cada uma destas portas conectam-se a um resistor e este, por sua vez, conecta-se ao LED.

Por fim o LED tem um jumper que tem como destino a linha azul do setor 1, responsável pelo negativo. Como as portas digitais trabalham com dois valores: ligado e desligado, a energia que acenderá os LEDs sai diretamente destas portas, quando o código “escrever” for enviado na porta digital com o valor “1”, 5 volts de corrente contínua serão enviadas para o LED. O resistor está presente para que o LED não queime pois ele trabalha com uma voltagem menor que 5 volts.

Observando no setor do Arduino que denominamos de “1. Pinos de eletricidade” vemos que sai um jumper do pino GND ou negativo e se conecta na linha azul no protoboard. Nosso sistema tem dois elementos eletrônicos – os LEDs, que se conectam ao negativo do protoboard e este se conecta ao Arduino. Num protótipo maior pode-se ter muitas conexões positivas e negativas. Neste nosso primeiro projeto conectando os pinos negativos ao protoboard utilizaremos apenas um pino negativo do Arduino.

Depois que um projeto está feito, seu código já foi compilado e enviado para o Arduino, os componentes eletrônicos, relés, já estão montados e funcionando no protoboard, o computador não precisa mais estar conectado ao Arduino através do cabo USB.

Uma fonte de 9 a 12 volts pode ser conectada ao Arduino para alimentá-lo. Depois que um projeto sai da fase de protótipo e transforma-se em um produto o ideal é que a alimentação elétrica seja feita por uma fonte. Dependendo das necessidades e recursos do Arduino (sensores, relés) baterias de 9 volts podem tem uma vida bem curta. Uma solução de célula fotoelétrica alimentando o Arduino é uma alternativa mas seu custo e complexidade podem ser um fator limitante. O mais simples é utilizar uma extensão elétrica e ligar uma fonte.

CONSIDERAÇÕES FINAIS

Muitos projetos podem utilizar o Arduino como plataforma de desenvolvimento, de simples sensores de temperatura até módulos de automação residencial, tudo com um custo muito menor que as soluções comerciais disponíveis no mercado.

Nesta série de artigos vamos aumentando a complexidade dos projetos e observando no dia a dia onde eles podem ser úteis.