Vous êtes sur la page 1sur 26

ARDUINO

DUEMILANOVE

0
SUMARIO

1. DEFINIÇÃO DE ARDUINO................................................................................... 04

2. CARACTERÍSTICAS ARDUINO DUEMILENOVE.................................................... 06

2.1. Características Elétricas......................................................................... 07

2.2. Alimentação.......................................................................................... 07

2.2.1. pinos de alimentação............................................................. 08

2.3 Memória................................................................................................ 08

2.4. Entrada e Saída..................................................................................... 08

2.5. Comunicação......................................................................................... 09

2.6. Reset Automático................................................................................. 09

3. PROGRAMAÇÃO................................................................................................ 10

3.1. Instalação do Windows XP............................................................... 11

3.2. Instalação do Windows 7 e Vista...................................................... 12

3.3. Placa e Seleção de Porta................................................................... 12

3.4. Carregue o Seu Primeiro Esboço...................................................... 14

3.5. O IDE Arduino................................................................................... 16

3.6. Declaração Condicional.................................................................... 22

3.7. Loop.................................................................................................. 23

3.8. Array................................................................................................. 23

3.9. While Loop....................................................................................... 23

3.10. Switch Case....................................................................................... 24

3.11. Switch Case 2................................................................................... 24

4. APLICAÇÕES ARDUINO..................................................................................... 24

1
LISTA FIGURAS

Figura 1: Arduino duemilenove compatível.......................... 04

Figura 2: Exemplo led............................................................ 05

Figura 3: Instalação de arte controlado por Arduino............ 06

Figura 4: Arduino duemilanove............................................. 10

Figura 5: O IDE Arduino......................................................... 12

Figura 6: Menu Tools............................................................ 13

Figura 7: O Arduino menu Boards......................................... 13

Figura 8: A lista de Serial Port............................................... 14

Figura 9: O Menu File............................................................ 14

Figura 10: O Menu de contexto.............................................. 15

Figura 11: Led piscando.......................................................... 15

Figura 12: O IDE arduino......................................................... 16

Figura 13: A Barra de Ferramentas (the toolbar).................... 16

Figura 14: A Janela do monitor serial em uso......................... 18

Figura 15: Os menus do IDE.................................................... 19

Figura 16: O menu File............................................................ 19

Figura 17: Menu Edit............................................................... 20

Figura 18: Menu Sketch.......................................................... 20

Figura 19: Menu Tools............................................................ 21

Figura 20: Chip Atmel Atmega............................................... 21

Figura 21: Menu Help............................................................. 22

2
Lista de Tabelas

Tabela 1: Características elétricas....................................... 07

Tabela 2: Pinos de Alimentação.......................................... 08

Tabela 3: Tabela de pinos................................................... 08

Tabela 4: Funcionalidades dos pinos.................................. 09

Tabela 5: As funções dos botões da barra de ferramentas 18

3
1. DEFINIÇÃO DE ARDUINO

O projeto Arduino iniciou-se na cidade de Ivrea, Itália, em 2005, com o intuito


de interagir em projetos escolares de forma a ter um orçamento menor que outros
sistemas de prototipagem disponíveis naquela época. Seu sucesso foi sinalizado com o
recebimento de uma menção honrosa na categoria Comunidades Digitais em 2006,
pela Prix Ars Eletrônica, além da marca de mais de 50.000 placas vendidas até
outubro de 2008.
O Arduino é um microcontrolador de placa única e um software para
programá-lo. O hardware consiste num projeto simples e aberto para o controlador
com um processador AVR Atmel e on-board I / O support. O software é fundamentado
na linguagem de programação padrão (C).
Para colocar isso em termos leigos, um Arduino é um computador pequeno que
pode ser programado para processar as entradas e saídas entre os componentes dos
dispositivos e externos que se conectam a ele (veja a Figura 1).

Figura 2: Arduino duemilanove compatível

Podemos citar como exemplo, o uso simples do Arduino, depois de um botão


pressionado, acende-se uma luz por um determinado período de tempo, digamos 30
segundos. Neste exemplo, o Arduino teria uma lâmpada e um botão
conectado a ele. O Arduino aguarda pacientemente à espera que o botão seja
pressionado e uma vez acionado, o Arduino acende a lâmpada e inicia a contagem.
Após 30 segundos, a lâmpada apaga e aguarda um novo comando.

4
É possível utilizar esta configuração para controlar uma lâmpada num
armário. Você pode estender este conceito, ligando um sensor, como um PIR, para
ligar a lâmpada quando for acionado.
Estes são alguns exemplos simples de como utilizar um Arduino.
Também é possível desenvolver projetos autônomos interativos: conectá-lo a um
computador, uma rede, ou mesmo a Internet para obter e enviar dados para o mesmo
e depois agir sobre esses dados.
Em outras palavras, ele pode enviar um conjunto de dados recebidos dos
sensores de um site, apresentá-los sob a forma de um gráfico. O Arduino pode ser
conectado aos LEDs, display de matriz de pontos (ver Figura 2), botões, interruptores,
motores, sensores de temperatura, sensores de pressão, sensores de distância,
receptores GPS, módulos Ethernet, ou apenas sobre quaisquer saídas de dados.

Figura 2: Exemplo led

A placa Arduino é composta de um AVR Atmel Microprocessador, ou um cristal


oscilador (envia pulsos de tempo numa determinada frequência para permitir que ele
funcione na velocidade correta), e um regulador linear de 5 volts. Dependendo do tipo
de Arduino utilizado, ele também pode ter uma entrada USB para conectar a um PC ou
Mac para upload ou recuperar dados.
Para programar o Arduino utilize o Arduino IDE (Integrated
Development Environment), uma peça de software livre na qual você escreve o código
na linguagem que ele entende, uma linguagem chamada C.
O IDE permite escrever um programa de computador, um conjunto passo-a-
passo, em seguida, faça a atualização para o Arduino. O Arduino, então, processa essas
5
instruções e interage com o que você tem conectado a ele. No mundo Arduino,
programas são conhecidos como esboços. O hardware e software Arduino são open
source, isto significa que o código, esquemas, design, etc, podem ser tomados
livremente por qualquer pessoa para fazer o que quiserem com eles.
O Arduino, versão Duemilanove é o mais popular e mais utilizado
na grande maioria dos projetos Arduino, através da Internet. A internet disponibiliza
uma vasta pesquisa para "Arduino", apresentando uma diversidade de sites e projetos
criados pelo o mesmo.
O Arduino é uma dispositivo incrível permitindo você criar inumeros objetos
(veja a Figura 3), inclusive robôs.

Figura 1: Instalação de arte controlada por Arduino

Com um pouco de entusiasmo para aprender a programar um Arduino e faze-lo


a interagir com outros componentes, você pode criar qualquer coisa, basta usar a sua
imaginação. Acesse o link http://www.arduino.cc/playground/Projects/ArduinoUsers
para visualizar os inúmeros projetos ja realizados utilizando esta plataforma.

2. CARACTERISTICAS ARDUINO DUEMILANOVE

O Arduino Duemilanove (2009 em italiano) é uma placa baseada no


microcontrolador Atmega168 ou Atmega328. Tem 14 pinos de entrada ou saída da
digital (dos quais 6 podem ser utilizados como saídas PWM), 6 entradas analógicas, um
6
oscilador de cristal 16 MHz, controlador USB, uma tomada de alimentação, um
conector ICSP, e um botão de reset. Para sua utilização basta conectá-lo a um
computador com um cabo USB ou ligá-lo com um adaptador AC para DC ou bateria.

2.1. Características Elétricas

Arduino Duemilanove
Microcontrolador ATmega328
Tensão de operação 5V
Tensão de entrada (recomendada) 7 - 12 V
Tensão de entrada (limite) 6 - 20 V
Pinos de Entrada/Saída digital 14 (dos quais 6 provêm PWM)
Entradas analógicas 6
Corrente CC por pino 40 mA
Corrente CC para o pino de 3,3 V 50 mA
Memória Flash 32 KB (2 KB ocupados pelo bootloader)
SRAM 2 KB
EEPROM 1 KB
Velocidade de clock 16 MHz
Tabela 1: Características elétricas

2.2. Alimentação

O Arduino Duemilanove pode ser alimentado pela conexão USB ou por


qualquer fonte de alimentação externa. A fonte de alimentação é selecionada
automaticamente.
A alimentação externa (não - USB) pode ser tanto de uma fonte ou de uma
bateria. A fonte pode ser conectada com um plug de 2,1 mm (centro positivo) no
conector de alimentação. Cabos vindos de uma bateria podem ser inseridos nos pinos
GND (terra) e Vin (entrada de tensão) do conector de alimentação.
A placa pode operar com uma alimentação externa de 6 a 20 V. Entretanto, se a
alimentação for inferior a 7 V, o pino 5 V pode fornecer menos de 5 V e a placa pode
ficar instável. Se a alimentação for superior a 12 V, o regulador de tensão pode
superaquecer e avariar a placa. A alimentação recomendada é de 7 a 12 V.

7
2.2.1. pinos de alimentação:

Vin Entrada de alimentação para a placa Arduino quando uma fonte externa for
utilizada. Você pode fornecer alimentação por este pino, ou, se usar o
conector de alimentação, acessar a alimentação pelo o mesmo;
5V A fonte de alimentação utilizada para o microcontrolador e para outros
componentes da placa. Pode ser proveniente do pino Vin através de um
regulador on-board ou ser fornecida pelo USB ou outra fonte de 5 V
3 V3 Alimentação de 3,3 V fornecida pelo circuito integrado FTDI (controlador
USB). A corrente máxima é de 50 mA
GND Pino terra
(ground)
Tabela 2. Pinos de alimentação

2.3. Memória

O ATmega328 tem 32 KB de memória fash (onde é armazenado o software),


além de 2 KB de SRAM (onde ficam as variáveis) e 1 KB de EPROM (esta última pode
ser lida e escrita através da biblioteca EPROM que guarda os dados permanentemente,
mesmo que desliguemos a placa). A memória SRAM é apagada toda vez que
desligamos o circuito.

2.4. Entrada e Saída

Cada um dos 14 pinos digitais do Duemilanove pode ser usado como entrada
ou saída usando as funções de pinmode( ), digitalWrite( ), e digitalRead( ). Eles operam
com 5 V. Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor
pull-up interno (desconectado por padrão) de 20-50 k. Além disso, alguns pinos têm
funções especializadas:

Serial 0 (RX) e 1 (TX). Usados para receber (RX) e transmitir (TX) dados seriais TTL.
Estes pinos são conectados aos pinos correspondentes do chip serial FTDI USB-
to-TTL.

PWM 3, 5, 6, 9, 10, e 11. Fornecem uma saída analógica PWM de 8-bit com a função
analogwrite( )
SPI 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estes pinos suportam comunicação
SPI, que embora compatível com o hardware, não está incluída na linguagem
do Arduino
LED 13. Há um LED já montado e conectado ao pino digital 13
Tabela 3: Tabela de pinos

8
O Duemilanove tem 6 entradas analógicas, cada uma delas está ligada a um
conversor analógico-digital de 10 bits, ou seja, transformam a leitura analógica em um
valor dentre 1024 possibilidades (exemplo: de 0 a 1023). Por padrão, elas medem de 0
a 5 V, embora seja possível mudar o limite superior usando o pino AREF e um pouco de
código de baixo nível.
Adicionalmente alguns pinos têm funcionalidades especializadas:

I2C 4 (SDA) e 5 (SCL). Suportam comunicação I2C (TWI) usando a biblioteca Wire
AREF Referência de tensão para entradas analógicas. Usados com analogreference( )
Reset Envie o valor LOW para reiniciar o microcontrolador. Tipicamente utilizados
para adicionar um botão de reset aos shields( placas que podem ser plugadas
ao Arduino para extender suas capacidades) que bloqueiam o que há na placa.
Tabela 4: Funcionalidades dos pinos

2.5. Comunicação

Com o Arduino Duemilanove a comunicação com um computador, com outro


Arduino ou com outros micro controladores é muito simplificada. O Atmega328
permite comunicação serial no padrão UART TTL (5 V), que está disponível nos pinos
digitais 0 (RX) e 1 (TX). Um chip FTDI FT232RL na placa encaminha esta comunicação
serial através da USB e os drivers FTDI (incluído no software do Arduino) fornecem
uma porta virtual para o software no computador.
O software Arduino inclui um monitor serial permitindo que dados simples de
texto sejam enviados e recebidos á placa Arduino. Os LEDs RX e TX da placa piscam
quando os dados estão sendo transferidos ao computador pelo chip FTDI e há
conexão USB (mas não quando há comunicação serial pelos pinos 0 e 1).
A biblioteca Software Serial permite comunicação serial por quaisquer dos
pinos digitais do Duemilanove. O Atmega328 também oferece suporte aos padrões de
comunicação I2C (TWI) e SPI. O software do Arduino inclui uma biblioteca Wire para
simplificar o uso do barramento I2C. Para usar a comunicação SPI veja o datasheet
(folha de informações) do Atmega328.

2.6. Reset Automatico

Algumas versões anteriores do Arduino requerem um reset físico (pressionando


o botão de reset na placa) antes de carregar um sketch (o programa a ser compilado).
O Arduino Duemilanove é projetado de modo a permitir que isto seja feito
através do software que esteja rodando no computador conectado. Uma das linhas de
controle de hardware (DTR) do FT232RL está conectada ao reset do Atmega328 via um
capacitor de 100 microfaraday. Quando esta linha é colocada em nível lógico baixo, o
sinal cai por tempo suficiente para reiniciar o chip.
O software Arduino usa esta característica para permitir carregar o programa
simplesmente pressionando o botão upload no ambiente Arduino. Isto significa que o

9
bootloader pode ter um timeout mais curto, já que a ativação do DTR (sinal baixo)
pode ser bem coordenada com o início do upload.
Estas configurações têm outras implicações. Quando o Duemilanove está
conectado a um computador rodando Mac OS X ou GNU/Linux, ele reinicia toda vez
que a conexão é feita por software (via USB). No próximo meio segundo
aproximadamente, o bootloader estará rodando no Duemilanove. Considerando que é
programado para ignorar qualquer coisa a não ser um upload de um novo código, ele
interceptará os primeiros bytes de dados sendo enviados para a placa depois que a
conexão é aberta. Se um sketch rodando na placa recebe configurações de uma vez ou
outros dados ao iniciar, assegure-se que o software está se comunicando e aguarde
um segundo depois de aberta a conexão antes de enviar estes dados.
O Duemilanove tem uma trilha que pode ser cortada para desabilitar o auto-
reset e pode ser ressoldada para reativá-lo, é chamada de RESET-EN, você pode
também desabilitar o auto-reset conectando um resistor de 110 dos +5 V até o sinal de
reset.

3. PROGRAMAÇÃO

Esta seção explica como configurar o “Arduino” e o IDE pela primeira vez. As
instruções para Windows são dadas. Se você usa Linux, consulte o Guia de Introdução
no site do Arduino no www.arduino.cc.playground / Aprendizagem / Linux.
Para a versão Duemilanove (ver figura 4), consulte a página correspondente no
Guia de Introdução do site do Arduino.

Figura 4: Arduino duemilenove compativel – Fabricação brasileira

10
Faça o download do Arduino IDE. Este software grava os programas (ou
esboços) e os envia para a placa. Para as últimas IDE vá para a página de download no
Arduino http://arduino.cc/en/Main/Software e obtenha a versão apropriada para seu
sistema operacional.

3.1. Instalação do Windows XP

Depois de ter baixado a última IDE, descompacte o arquivo e dê um duplo


clique na pasta descompactada para abri-lo. Você verá os arquivos Arduino e
subpastas dentro. Em seguida, conecte o Arduino usando o cabo USB, o LED verde
(chamado PWR) acenderá. O Windows irá dizer "novo hardware encontrado”: e o
Assistente de novo hardware aparecerá. Clique ao lado e o Windows tentará carregar
os controladores. Se o processo falhar, não se preocupe, é normal. Em seguida, clique
com o botão direito do mouse no ícone “Meu Computador” no seu desktop e
selecione Gerenciar. O Computador abrirá a janela Gestão. Agora desça para
gerenciador de eventos na lista Ferramentas do Sistema e clique nele.
Na janela do lado direito, você verá uma lista dos seus dispositivos. O Arduino
aparece na lista com um ícone de marca de exclamação amarelo sobre ele para
mostrar que o dispositivo não foi instalado corretamente.
Clique com o botão direito do mouse sobre este e escolha Update driver.
Escolha "não, não no momento" a partir da primeira página e clique em “próximo”. Em
seguida, escolha a opção "instalar a partir de uma lista ou local específico (avançado)"
e clique novamente em “próximo”. Agora clique em “incluir este local na pesquisa” e,
em seguida em browse. Navegue até a pasta de Drivers para descompactar o Arduino
IDE e clique em “próximo”. O Windows irá instalar o driver e você pode clicar no botão
“finalizar”.

O Arduino mostrará uma lista de Portas de dispositivos, como também a porta


atribuída a ele (por exemplo, COM6). Para abrir o IDE, dê duplo clique no ícone do
Arduino em sua pasta.

3.2. Instalação do Windows 7 e Vista

Depois de ter baixado a última IDE, descompacte o arquivo e dê um duplo


clique na pasta descompactada para abri-lo. Você verá os arquivos Arduino e
subpastas dentro. Em seguida, conecte o seu Arduino usando o cabo USB, aguarde o
LED verde (chamada PWR) acender. O Windows tentará instalar automaticamente os
drivers. Caso falhe, não se preocupe, é normal.
Clique no botão Iniciar do Windows e clique em Painel de Controle. Agora,
clique em Sistema e Segurança, em seguida, clique em Sistema e, em seguida, clique
Gerenciador de dispositivos na lista do lado esquerdo. O Arduino vai aparecer na lista
como um dispositivo e um ícone amarelo de ponto de exclamação sobre ele para
mostrar que ele não foi instalado corretamente. Clique com o botão direito do mouse
11
sobre o Arduino Duemilanove or Nano w/Atmega 328 e procure “Update Driver
Software”.
Em seguida, escolha a opção "Browse my computador for driver software" e na
próxima janela clique no botão Browse. Navegue até a pasta drivers do Arduino que
você descompactou anteriormente e clique em OK e depois em “próximo”. O Windows
vai tentar instalar o driver. Uma caixa do Windows Security irá abrir e indicar:
"Windows não pode verificar este driver software." Clique em "instale este driver
software de qualquer maneira”. A janela de instalação de driver de software vai agora
fazer o seu negócio. Se tudo correr bem, você terá outra janela dizendo "windows
instalou com sucesso o driver software”. Por fim, clique em “procurar”. Para abrir dê
duplo clique no ícone Arduino em sua pasta.

3.3. Placa e Seleção de Porta

Uma vez que você abrir o IDE, ele terá uma aparência semelhante à Figura 5.

Figura 5: O IDE Arduino

Agora vá ao menu Tools e clique em OK. Em seguida, clique Board (ver Figura
6).

12
Figura 6: menu Tools
Será apresentado uma lista de placas (ver Figura 7). Clique em Arduino
Duemilanove or Nano w/Atmega328.

Figura 7. O Arduino menu Boards

Em seguida, clique no menu Tools novamente, clique em Serial Port, e escolha a


porta apropriada da lista para o seu Arduino (Figura 8). Agora você está pronto para
carregar um exemplo de esboço para testar a instalação.

13
Figura 8: A lista de Serial Port

3.4. Carregue o Seu Primeiro Esboço

Agora que você tem instalado os drivers e o IDE com a placa correta e portas
selecionadas, faça o upload de um esboço exemplo para o Arduino testar se tudo está
funcionando corretamente antes de passar para o primeiro projeto.
Primeiro, clique no menu File (Figura 9) e clique em Exemplos.

Figura 9: O menu File

14
Você terá uma lista enorme de exemplos para experimentar. Vamos tentar um
simples. Clique em Basics, e, em seguida, Blink (Figura 10). O esboço Blink será
carregado para o IDE.

Figura 10: O menu de contexto


Em seguida, clique no botão Upload (sexto botão da esquerda) e olhe para o
Arduino. (Se você tiver um Arduino Mini, NG, ou outra placa, talvez você precisa
pressionar o botão de reset na placa antes de clicar no botão Upload.) O RX e TX fará
com que começem a piscar para mostrar os dados sendo transmitidos do seu
computador para a placa. Uma vez o esboço carregado com sucesso, a expressão
"done uploading" será exibido na barra de status do IDE e os RX e TX fazem os leds
pararem de piscar.

Figura 11: LED piscando


15
Após alguns segundos, você deverá ver o Pino 13 LED (diodo emissor de luz o
pequeno ao lado do RX e TX LEDs) começam a piscar em intervalos de um segundo. Se
isso acontecer, significa que você instalou com êxito o seu Arduino. O Blink é um
esboço muito simples que pisca (veja a Figura 11, o verde pequeno (ou laranja) do LED
soldado à placa (é também ligado ao Digital pino 13 do microcontrolador).
Antes de avançar para um projeto, vamos dar uma olhada no IDE Arduino.
Veremos cada parte da programa.

3.5. O IDE Arduino

Quando você abrir a IDE Arduino, será muito semelhante à imagem da Figura
12. Se você estiver usando Windows ou Linux, haverá algumas diferenças pequenas,
mas o IDE é quase a mesma coisa, não importa qual sistema operacional você usa.

Figura 12: IDE arduino

O IDE é dividido em três partes: a barra de ferramentas na parte superior, o


código ou a janela Esboço na central e a janela de mensagens na parte inferior. A barra
de ferramentas é composto por sete botões.
Abaixo da Barra de ferramentas há um guia, ou um conjunto de abas, com o
nome do sketch no guia. Há também um botão do lado direito. Ao longo do topo é o
menu arquivo com menus rotulados de: File (Arquivo), Edit (Editar), Sketch (esboço),
Tools (Ferramentas) e Help (Ajuda). Os botões da barra de ferramentas (veja a Figura
13) fornecem um acesso conveniente as mais usadas funções dentro deste menu
arquivo.

Figura 13: A Barra de Ferramentas (the toolbar)

16
Os botões da barra de ferramentas e suas funções são listados na Tabela
Usado para verificar se o código está correto e livre
Verify/compile (Verifique) de erros antes de enviá-lo para sua placa Arduino
O monitor de série para a partir do funcionamento.
Stop (parar) Ele também destaca outros não-selecionados.
Enquanto o monitor serial está funcionando, você
pode pressionar o botão Stop para obter dados para
examiná-lo instantaneamente. Isto é
particularmente útil se você estiver enviando dados
para fora do Serial Monitor e mais rápido do que
você lê-lo.
Cria um novo desenho em branco para você digitar o
New (novo) seu código. O IDE pergunta um nome e um local para
o desenho (tente usar o local padrão, se possível) e,
em seguida, dá-lhe um esboço em branco para ser
codificado. O guia na parte superior do desenho
mostra o nome que você atribuiu ao seu novo
desenho.
Apresenta uma lista de esboços armazenados dentro
Open (abra) de uma pasta, bem como uma lista de esboços de
exemplo que você pode experimentar com vários
periféricos.Abra o desenho apropriado para o
dispositivo, quando conectado modifique o código
para suas próprias necessidades.
Salva o código dentro da janela de desenho para seu
Save(salvar) arquivo de seu projeto. Uma vez completo, você vai
ter uma mensagem "Done Saving" na parte inferior
da janela do seu código.
O código dentro da janela de seus desenhos atuais
Upload do Arduino. Certifique-se de que você tem a placa e
a porta correta (no menu Tools) antes do upload. É
essencial que você salve o seu desenho antes de
carregá-lo, no caso do sistema travar ou o IDE falhar.
Também é aconselhável utilizar o botão Verify antes
de você fazer o upload para garantir que não haja
erros que precisem ser eliminados em primeiro
lugar.
É uma ferramenta muito útil, especialmente para
Monitor Serial eliminar erros do seu código. Ele permite enviar para
fora do seu Arduino (USB ou placa de série). Você
também pode enviar dados de volta ao Arduino
usando o Serial Monitor, como na Figura 14. No lado
inferior direito, você pode selecionar a taxa de
transmissão de dados da série a ser enviada para o
Arduino. A taxa de transmissão é a taxa por segundo
17
que as mudanças de estado ou de bits (dados) são
enviadas para a placa. A configuração padrão é 9600,
isto significa que se você enviar um novo texto sobre
a série comunicações de linha (neste caso, o cabo
USB), então 1200 letras ou símbolos serão enviados
por segundo (9600 bits / 8 bits por caractere = 1200
bytes ou caracteres).
Tabela 5: As funções dos botões da barra de ferramentas

Figura 14: A janela do monitor serial em uso

No topo está uma caixa de texto em branco para você digitar e enviar de volta
para o Arduino através botão Send. Note-se que o monitor de série receberá dados
seriais se você tenha configurado o código dentro de seu esboço para fazê-lo. Da
mesma forma, o Arduino não receberá os dados enviados a menos que tenha
codificado para enviá-los.
Finalmente, a área preta é onde os dados de série serão exibidos. Na imagem
acima, o Arduino executa o esboço ASCIITable (a partir do exemplo das
Comunicações). Este programa envia os caracteres do Arduino via porta serial (cabo
USB) ao computador onde o monitor as exibe.
Para iniciar o monitor serial, pressione o botão serial monitor. Para pará-lo,
pressione o botão Stop. No Mac ou Linux, quando você clica no botão serial monitor, a
placa Arduino vai reiniciar-se (execute novamente o código desde o início).
Uma vez que você esteja acostumado a transmitir dados via serial com o
Arduino, é possível utilizar outros programas como o Processing, Flash, MaxMSP, etc
para se comunicar com o Arduino e o computador.

18
Você irá fazer uso do monitor serial mais tarde, quando você lê os dados a
partir de sensores obtidos do Arduino e os envia para o monitor serial, num formato
legível.
A parte inferior da janela do IDE é o lugar onde você verá mensagens de erro
(em vermelho): conectar a sua placa, faça o upload do código, ou verificar o código. No
canto inferior esquerdo do IDE você vai ver um número. Esta é a localização atual do
cursor dentro do programa. Se você tiver o código em sua janela, mova para baixo as
linhas de código (usando a tecla ↓ do seu teclado), isso é ú]l para encontrar bugs
destaque por erro de mensagens. Na parte superior da janela do IDE (ou na parte
superior da tela se estiver usando um Mac), você vai ver os vários menus que você
pode clicar para acessar itens do mesmo (veja Figura 15).

Figura 15: Os menus do IDE

O menu File (ver Figura 16), permite acessar as opções para criar um novo
desenho, dar uma olhada nos esboços armazenados, bem como os exemplos de
esboços, salvar o seu desenho ou usar o Save as como opção para dar um nome
diferente, fazer upload de seu esboço para a placa I / O (Arduino), ou imprimir seu
código.

Figura 16. O menu File

O menu Edit (ver Figura 17) oferece opções para deixá-lo cortar, copiar e colar
seções de código. Você também pode selecionar todo o código ou localizar certas
palavras ou frases dentro do código. O Undo(fazer) e Redo(refazer) são uteis para
quando você cometer um erro.

19
Figura 17: menu Edit

O menu Sketch (ver Figura 18) contém as funções Verifique / Compilação e


outras funções úteis, incluindo a opção “importar biblioteca”, que traz uma lista
disponível armazenada dentro da pasta bibliotecas.
Uma biblioteca é uma coleção de códigos que você pode incluir em seu esboço
para melhorar a funcionalidade do seu projeto. Você pode reutilizar código já escrito
por outra pessoa para várias peças de hardware comum. Por exemplo, o Stepper
biblioteca é um conjunto de funções para controlar um motor de passo. Alguém já
teve a bondade e criou todas as funções necessárias para controlar um motor de
passo, por isso, incluindo a biblioteca de passo em seu esboço, você pode usar essas
funções para controlar o motor.
Ao armazenar o código comumente usado em uma biblioteca, você pode
reutilizar para incrementar o seu projeto. Você também pode ocultar as partes
complicadas do código do usuário.
O Show Sketch Folder é uma opção de pasta que abre onde o desenho está
armazenado. A opção Add File permite que você adicione outro arquivo de origem
para o seu esboço, permitindo dividi-lo em pequenos esboços e depois adicioná-las ao
desenho principal.

Figura 18: Menu Sketch


20
O menu Tools (ferramentas) (veja a Figura 19) oferece várias opções Há o Auto
Format que é uma função para tornar seu código mais agradável. A opção Archive
Sketch permite comprimir o seu desenho em um arquivo ZIP e pergunta onde quer
armazená-lo. Finalmente, a função Burn Bootloader grava o Arduino Bootloader (a
parte do código do chip para torná-lo compatível com o Arduino IDE) para o chip. Esta
opção só pode ser usada se você tiver um programador AVR e se tiver substituído o
chip em seu Arduino ou ter comprado Atmega em branco para usar em seu próprio
projeto incorporado.

Figura 19: Menu Tools

A menos que você esteja pensando em gravar muitos chips, normalmente é


mais barato e mais fácil comprar apenas um chip ATmega (veja a Figura 20) com o
Arduino Bootloader já pré-programados.

Figura 20: Um chip Atmel ATmega, o coração de seu Arduino. (Cortesia da imagem de
Earthshine Eletrônica)

O menu final, Help (figura 21), é onde você pode encontrar mais informações
sobre o IDE ou links para os páginas de referência do site do Arduino e outras páginas
úteis. O IDE Arduino é bastante básico e você vai aprender como usá-lo com rapidez e
facilidade nos projetos. Como você se tornar mais proficientes no uso de um Arduino e
programação em C (a linguagem de programação utilizada para o código no Arduino).
Se você quer algo com melhor funcionalidade, você pode tentar um dos programas
profissionais IDE (alguns dos que são livres), tais como Eclipse, ArduIDE, GNU / Emacs,
AVR-GCC, AVR Studio, e até mesmo da Apple XCode.

21
Figura 21: Menu Help

3.6. Declaração condicional

Declaração condicional “If”: como usar um “if” para mudar as condições de


saída com base na mudança das condições de entrada.

• Declaração Condicional
O “if” (), é a mais básica de todas as estruturas de controle de programação. Ele
permite que você faça algo acontecer ou não dependendo de uma determinada
condição: verdadeira ou não. É parecido com este:

if (algumaCondição) {
/ / executar funçao, se a condição for verdadeira
}
[Código]

Há uma variação comum chamada if-else que se parece com isto:

if (algumaCondição) {
/ / executar função, se a condição for verdadeira
}
else {
/ / executar função, se a condição for falsa
}
[Código]

Há também o outro “if”, onde você pode verificar uma segunda condição se a primeira
é falsa:

if (algumaCondição) {
/ / fazer o material, se a condição for verdadeira
}
Else if (outraCondição) {
/ / executar função apenas se a primeira condição é falsa
22
/ / e a segunda condição é verdadeira
}
[Código]

Você vai usar “if” o tempo todo.

3.7. Para Loop: controle múltiplos de LEDs com um loop

Você pode iterar uma série de pinos e fazer alguma coisa para cada um. Por
exemplo, um pisca de 6 LEDs ligados ao Arduino usando um loop for () para o ciclo e
para trás através de pinos digital 2-7. Os LEDs são ligados e desligados, em seqüência,
usando tanto digitalWrite () e delay () funções.
Um bom exemplo é "Knight Rider" em memória a série de TV dos anos 80, onde
David Hasselhoff tinha uma máquina AI chamado KITT dirigindo seu Pontiac. O carro
tinha sido aumentado com abundância de LEDs em todos os tamanhos e efeitos
possíveis para realizar chamativo.

3.8. Array: uma variação do Loop, demonstra como usar uma matriz.

Esta variação do For Loop mostra como usar uma matriz. Uma matriz é uma
variável com várias partes. Se você pensar em uma variável como um copo que
contém valores, você poderia pensar em uma matriz como uma bandeja de cubos de
gelo. É como uma série de copos de alternância, os quais podem conter o valor
máximo dos mesmos.
O exemplo Loop mostra como acender uma série de LEDs ligados aos pinos de 2
a 7 do Arduino, com certas limitações (os pinos devem ser numeradas de forma
contígua, e os LEDs têm que ser ligado em seqüência).
Este exemplo mostra como você pode ativar uma seqüência de pinos, cujos
números não são contíguas, nem necessariamente seqüencial. Para fazer isso, você
pode colocar os números dos pinos em uma matriz e depois usar loops para iterar
sobre a matriz.
Este exemplo faz uso de 6 LEDs ligados à 2 pinos - 7 na placa com 220 ohms,
assim como no For Loop. No entanto, aqui a ordem dos LEDs é determinada pela sua
ordem da matriz, não por sua forma física.
Esta técnica de colocar os pinos em uma matriz é muito útil. Você não tem que
ter os pinos seqüencial para um outro, ou até na mesma ordem. Você pode
reorganizá-los como quiser.

3.9. While Loop: como usar um loop para calibrar um sensor, enquanto um botão
estiver sendo lido.

23
Às vezes, você quer parar tudo no programa enquanto uma determinada
condição é verdadeira. Você pode fazer isso usando um loop while. Este exemplo
mostra como usar um loop while para calibrar o valor de um sensor analógico.
No circuito principal, o esboço abaixo lê o valor de um fotoresistor no pino
analógico 0 e usa-a desvanecer-se um LED no pino 9. Mas enquanto um botão ligado
ao pino digital 2 é pressionado, o programa é executado num método chamado
calibrar () que olha para os valores mais altos e mais baixos do sensor analógico.
Quando você soltar o botão, o desenho continua com o loop principal.
Esta técnica permite você atualizar os valores máximo e mínimo para o
photoresistor quando a iluminação e as condições mudam.

3.10. Switch Case: Como Escolher Entre Um Número Discreto de Valores.

Equivalente a vários comandos if. Este exemplo mostra como dividir uma faixa
do sensor num conjunto de quatro bandas e tomar quatro ações diferentes
dependendo em qual banda o resultado está dentro.
Uma declaração que permite escolher entre duas opções distintas, verdadeiro
ou falso. Quando há mais de duas opções, você pode usar vários comandos if, ou você
pode usar a instrução switch. Switch permite que você escolha entre diversas opções
discretas. Este tutorial mostra como usá-lo para alternar entre os quatro estados
desejados de um resistor foto: realmente escuro, turvo, médio e brilhante.
Este primeiro programa lê o fotoresistor. Em seguida, ele usa o mapa () para
mapear sua saída para um dos quatro valores: 0, 1, 2 ou 3. Finalmente, ele usa o switch
() para imprimir uma declaração de quatro mensagens para o computador,
dependendo de qual dos quatro valores é retornado.

3.11. Switch Case 2

Um exemplo de switch case 2, mostrando como executar ações diferentes


baseadas em caracteres recebidos na porta serial.
Uma declaração que permite escolher entre duas opções distintas, verdadeiro
ou falso.Quando há mais de duas opções, você pode usar vários comandos if, ou você
pode usar a instrução switch. Switch permite você escolher entre diversas opções
discretas.
Este tutorial mostra como usar o interruptor para acender um dos vários LEDs
diferentes com base em um byte de dados recebidos em série. O esboço escuta para a
entrada serial, e se transforma num diodo emissor de luz diferentes para os caracteres
a, b, c, d, ou e.

4. APLICAÇÕES DO ARDUINO

O arduino permite uma imensa variedade de aplicações tais como: robôs; roupas
eletrônicas; máquinas de corte e modelagem 3D de baixo custo; segway open-source;

24
desenvolvimento de celulares customizados; instrumentos musicais; paredes
interativas; automação comercial e residencial; monitoramento de condições
ambientais; circuit bending entre outros.

25