Arduino - Definição e Programação

Prévia do material em texto

0 
 
 
 
 
 
ARDUINO 
 
 
DUEMILANOVE 
 
 
 
 
 
1 
 
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 
 
 
2 
 
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 
 
 
 
3 
 
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 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4 
 
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. 
5 
 
É 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, processaessas 
6 
 
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 
7 
 
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 5 V 
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. 
 
 
 
8 
 
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; 
5 V 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 
(ground) 
Pino terra 
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 
9 
 
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 
10 
 
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 
11 
 
 
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 
12 
 
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). 
13 
 
 
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. 
 
14 
 
 
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 
 
15 
 
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 
16 
 
 
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 daBarra 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) 
17 
 
 
Os botões da barra de ferramentas e suas funções são listados na Tabela 
Verify/compile (Verifique) 
Usado para verificar se o código está correto e livre 
de erros antes de enviá-lo para sua placa Arduino 
Stop (parar) 
O monitor de série para a partir do funcionamento. 
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. 
New (novo) 
Cria um novo desenho em branco para você digitar o 
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. 
Open (abra) 
Apresenta uma lista de esboços armazenados dentro 
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. 
Save(salvar) 
Salva o código dentro da janela de desenho para seu 
arquivo de seu projeto. Uma vez completo, você vai 
ter uma mensagem "Done Saving" na parte inferior 
da janela do seu código. 
Upload 
O código dentro da janela de seus desenhos atuais 
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. 
 Monitor Serial 
É uma ferramenta muito útil, especialmente para 
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 
18 
 
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. 
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). 
19 
 
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. 
 
 
20 
 
 
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 
21 
 
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. 
22 
 
 
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 
23 
 
 / / 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. 
 
24 
 
À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; 
25 
 
desenvolvimento de celulares customizados; instrumentos musicais; paredes 
interativas; automação comercial e residencial; monitoramento de condições 
ambientais; circuit bending entre outros.