Introdução Ao Arduino - Get Starter Com Arduino

Introdução ao Arduíno
1 ª Edição
Adaptado por: CIRINEU CARVALHO FERNANDES E GEILTON TELES LOPES

Esta tradução valiosa pouco oferece uma introdução completa para open-source da
plataforma eletrônica de prototipagem que está levando como uma tempestade o projeto de
amadores de todo do mundo. Introdução ao Arduíno dá muitas idéias para projetos com
Arduíno e o ajuda a ir a trabalhar com eles de forma rápida. Se organizando dar para ajustar
os retoques finais em seu esboço de programa, todas as informações que você precisa está
nele, onde você vai aprender sobre:
1. Interação design de computação e física

2. O hardware Arduíno e ambiente de desenvolvimento de software
3. Noções básicas de eletricidade e eletrônica
4. Prototipagem em um breadboard solderless
5. Desenho de um esquema
Com um hardware barato e componente de software open-source que você pode

baixar gratuitamente, começando com Arduíno é um aprender num piscar de olhos. Para
usar os exemplos de introdução deste livro, tudo que você precisa é de um Arduíno USB,
com cabo USB AB, e de um LED. Junte-se a dezenas de milhares de aficcionados que
descobriram esta incrível plataforma. Escrito pelo co-fundador do projeto Arduíno, com
ilustrações de Elisa Canducci, Introdução ao Arduíno você ficará na diversão!
Índice
Capítulo 1. Introdução
Seção 1.1. Público Alvo
Seção 1.2. O que é a computação física?
Capítulo 2. A Via Arduíno
Seção 2.1. Prototipagem
Secção 2.2. Consertar
Seção 2.3. Patching
Seção 2.4. Circuit Bending
Seção 2.5. Teclado Hacks
Seção 2.6. We Love sucata!
Seção 2.7. Hacking Brinquedos
Seção 2.8. Colaboração
Capítulo 3. A plataforma Arduíno
Seção 3.1. O hardware Arduíno
Secção 3.2. O software (IDE)
Seção 3.3. Instalando o Arduíno em seu computador
Secção 3.4. Instalação de drivers: Macintosh
Seção 3.5. Instalando Drivers: Windows
Secção 3.6. Porto: Identificação Macintosh
Seção 3.7. Porto Identificação: Windows
Capítulo 4. Realmente Introdução ao Arduíno
Seção 4.1. Anatomia de um dispositivo interactivo
Seção 4.2. Sensores e atuadores
Secção 4.3. Piscando um LED
Seção 4.4. Passe-me o queijo parmesão
Secção 4.5. Arduíno não é para Quitters
Secção 4.6. Tinkerers Real escrever comentários
Seção 4.7. O Código, Passo a Passo
Seção 4.8. O que estaremos construindo
Seção 4.9. O que é eletricidade?
Secção 4.10. Usando um botão para controlar o LED
Secção 4.11. Como isso funciona?
Secção 4.12. Um circuito, um Mil Comportamentos
Capítulo 5. Avançado de Entrada e Saída
Secção 5.1. Tentando Out Em outros sensores / Off
Secção 5.2. Controlar a luz com PWM
Seção 5.3. Use um sensor de luz em vez do Teclado
Secção 5.4. Entrada analógica
Secção 5.5. Tente sensores analógicos Outros
Secção 5.6. Comunicação Serial
Seção 5.7. Condução cargas maiores (Motors, lâmpadas, etc)
Seção 5.8. Sensores Complex
Capítulo 6. Conversando com o Cloud
Seção 6.1. Saída Digital
Secção 6.2. Planejamento
Secção 6.3. Codificação
Seção 6.4. Montagem do Circuito
Secção 6.5. Veja como montá-lo:
Capítulo 7. Solução de problemas
Seção 7.1. Compreensão
Seção 7.2. Testando a Câmara
Seção 7.3. Testando o Circuito breadboarded
Seção 7.4. Isolamento de problemas
Seção 7.5. Problemas com o IDE
Seção 7.6. Como Obter Ajuda Online
Apêndice A. O Breadboard
Apêndice B. Resistors Leitura e capacitores
Apêndice C. Referência Rápida Arduíno
Secção C.1. ESTRUTURA
Secção C.2. Símbolos especiais
Secção C.3. CONSTANTS
Secção C.4. VARIÁVEIS
Seção C.5. Estruturas de controlo
Seção C.6. ARITHMETIC e fórmulas
Seção C.7. Operadores de Comparação
Seção C.8. Operadores Booleanos
Seção C.9. Operadores de
Seção C.10. Funções de entrada e OUTPUT
Seção C.11. Funções de tempo
Seção C.12. FUNÇÕES MATEMÁTICAS
Seção C.13. NÚMERO funções aleatórias
Seção C.14. COMUNICAÇÃO SERIAL
Apêndice D. Leitura diagramas esquemáticos
Safari Books Open Source Métodos C Microprocessadores Safari Books Engenharia de

Software Programação Hardware Massimo Banzi O'Reilly Media, Inc. Faça Introdução ao
Arduíno, 1 ª Edição
Palavras do Autor
Alguns anos atrás tive um desafio muito interessante: ensinar o mínimo a designers em
eletrônica para que possam construir protótipos interativos dos objetos que estavam
projetando.
Comecei a seguir um instinto subconsciente para ensinar eletrônica da mesma maneira que
foi ensinado na escola. Mais tarde, percebi que ele simplesmente não estava funcionando
tão bem quanto eu gostaria, e comecei a lembrar sentado em uma classe, entediado como o
inferno, ouvindo tudo o que a teoria que está sendo jogada para mim, sem qualquer
aplicação prática para ele.
Na realidade, quando eu estava na escola eu já sabia eletrônica de uma maneira muito

empírica: teoria muito pouco, mas muita experiência hands-on.
Comecei a pensar sobre o processo pelo qual eu realmente aprendi com eletrônicos:
Eu levei para além de qualquer dispositivo eletrônico que eu poderia colocar minhas mãos
sobre. Eu aprendi que lentamente todos os componentes me trouxeram.
Comecei a mexer com eles, mudando algumas das conexões dentro deles e ver o que
aconteceu com o dispositivo: geralmente algo entre uma explosão e uma nuvem de fumo.
Comecei a construção de alguns kits vendidos por revistas de eletrônica.

Nos dispositivos eletrônicos que eu tinha tirado componentes, e kits montáveis e outros
circuitos que eu encontrei em revistas para montar coisas novas. Como uma criança,
sempre fui fascinado por descobrir como as coisas funcionam, por isso, eu costumava levá-
los separados. Essa paixão cresceu como alvo a qualquer objeto não utilizado em casa e
depois o desmontou em pedaços pequenos. Eventualmente, as pessoas trouxeram todos os
tipos de dispositivos para eu estudar. Minha maior experiência na época foi uma máquina de
lavar louça e um dos primeiros computadores que vieram de um escritório de seguros, que
tinha uma impressora grande, cartões eletrônicos, leitores de cartões magnéticos, e muitas
outras peças que se mostrou muito interessante e desafiador para desmontar
completamente.
Depois de fazer essa dissecação do aparelho, eu sabia que eram componentes eletrônicos
e aproximadamente o que eles faziam. Em cima disso, minha casa estava cheia de revistas
de eletrônica antiga que meu pai deve ter comprado no início da década de 1970. Passei
horas lendo os artigos e olhando para os diagramas de circuito sem entender muito.
Este processo de leitura dos artigos mais e mais, com a vantagem do conhecimento
adquirido, tendo para além dos circuitos, criou um círculo virtuoso lento.
Um grande avanço veio no Natal, quando meu pai me deu um kit que permitiu que os
adolescentes a aprender sobre eletrônica. Cada componente foi abrigado em um cubo de
plástico que se encaixam magneticamente com cubos de outro, estabelecendo uma
conexão, o símbolo eletrônico foi escrito em cima. Mal sabia eu que o brinquedo também foi
um marco do design alemão, Dieter Rams, porque o projetou na década de 1960.
Com esta nova ferramenta, eu poderia colocar rapidamente em conjunto de circuitos e testá-
los para ver o que aconteceu. O ciclo de prototipagem foi ficando mais curtos.
Depois disso, eu construí rádios, amplificadores, circuitos que produzem ruídos horríveis e
sons agradáveis, sensores de chuva, e os robôs minúsculos.
Eu passei muito tempo procurando uma palavra em Inglês que resumir essa maneira de
trabalhar sem um plano específico, começando com uma idéia e acabar com um resultado
completamente inesperado. Finalmente, "consertar" veio junto. Eu reconheci como esta
palavra tem sido usada em muitos outros campos para descrever uma forma de operar e de
retratar as pessoas que partiram em um caminho de exploração. Por exemplo, a geração de
diretores franceses que deram origem à "Nouvelle Vague" eram chamados de amadores ».
A melhor definição de ajustes que eu já encontrei vem de uma exposição realizada no
Exploratorium em San Francisco:
Trabalhar é o que acontece quando você tenta algo que não sei bem como fazer, guiado por
capricho, imaginação e curiosidade. Quando você mexer, não existem instruções, mas
também não há falhas, não há certo ou errado maneiras de fazer as coisas. Trata-se de
descobrir como as coisas funcionam e reformulação deles.
Engenhocas, máquinas, objetos incompatíveis descontroladamente trabalhando em

harmonia, este é o material de consertar. Trabalhar é, no seu sentido mais básico, um
processo que combina jogos e investigação www.exploratorium.edu/tinkering
De meus primeiros experimentos sabia quanta experiência você precisa para ser capaz de
criar um circuito que faria o que você quis partir de componentes básicos. Outro avanço foi
no verão de 1982, quando fui para Londres com meus pais e passei muitas horas visitando o
Museu da Ciência. Eles tinham acabado de abrir uma nova ala dedicada aos computadores,
e na sequência de uma série de experiências guiadas, eu aprendi o básico de matemática
binária e programação.
Lá eu percebi que em muitas aplicações, os engenheiros não faziam mais os circuitos de

construção de componentes básicos, mas ao invés disso foi implementado um monte de
inteligência em seus produtos que utilizam microprocessadores. Software foi a substituição
de muitas horas de design eletrônico, e permitiria um ciclo mais curto mexer.
Quando voltei, comecei a poupar dinheiro, porque eu queria comprar um computador e

aprender a programar. Meu primeiro projeto e mais importante depois que estava usando
meu computador novinho em folha ZX81 para controlar uma máquina de solda. Eu sei que
não soa como um projeto muito interessante, mas havia uma necessidade para ela e foi um
grande desafio para mim, porque eu tinha acabado de aprender como programar. Neste
ponto, ficou claro que as linhas de código escrito levariam menos tempo do que modificar
circuitos complexos. Vinte e poucos anos mais tarde, eu gostaria de pensar que essa
experiência me permite ensinar as pessoas que não consegue se lembrar de tomar qualquer
aula de matemática e para infundir-lhes com o mesmo entusiasmo e capacidade de mexer
que eu tinha na minha juventude e que mantido desde então.
Palavras de um dos Adaptadores.
Esta adaptação é dedicada aos nossos pais que lutaram pelo nosso sucesso, também
a todas as crianças pobres e humildes, que não tem condições de estudar e vivem na mais
lastimável pobreza, resultado de um péssimo trabalho político que deixa de construir escolas
técnicas para as nossas crianças e jovens por todo esse Brasil a fora, um país que se
encontra hoje carente de uma mão de obra especializada mergulhado em uma das maiores
desigualdades sociais existentes no mundo.
Andando pelo meu Maranhão a fora pude observar a grande falta que faz uma escola
profissionalizante, lá as crianças que conheço até hoje vivem no trabalho da lavoura,
extraem a castanha presente no babaçu, onde são aproveitados inúmeros produtos
principalmente o óleo vegetal. Infelizmente em pleno ano de 2010, o meu estado ainda vive
a mercê de uma família que o domina e o mantém como um dos estados mais pobres do
Brasil. Assim a força que nos resta é uma esperança de que as coisas mudem por lá e
reverta a atual situação do meu estado.
Ingressei no SENAI no ano de 1995, fazendo o curso de Eletricista de Manutenção

Industrial, experiência que mudou a minha vida, e que me tirou de uma realidade cruel das
ruas, das drogas e da pobreza, obstáculos esses que acompanham a criança e o jovem
carente no Brasil que ainda peca em não fazer investimentos em educação.
Capítulo 1. Introdução
Arduíno é uma plataforma open source de computação física baseada em uma entrada
simples / saída (I / O) a bordo e um ambiente de desenvolvimento que implementa a
linguagem Processing (www.processing.org). Arduíno pode ser usado para desenvolver
objetos interativos autônomo ou pode ser conectado ao software no seu computador (como
o Flash, Processing, VVVV, ou o Max / MSP). As placas podem ser montadas à mão ou
compradas pré-montados, o código-fonte aberto IDE (Integrated Development Environment)
pode ser baixado gratuitamente a partir www.Arduíno.cc
Arduíno é diferente de outras plataformas no mercado devido a estas características:
É um ambiente multiplataforma, que pode ser executado em Windows, Macintosh e Linux.
Baseia-se na programação de Processamento do IDE, um ambiente ao desenvolvimento

fácil de usar utilizada pelos artistas e designers. Programá-lo através de um cabo USB, e
não uma porta serial. Esse recurso é útil, porque muitos computadores modernos não têm
portas seriais.
Trata-se de hardware e software de fonte aberta, se desejar, você pode baixar o esquema
do circuito, comprar todos os componentes, e fazer o seu próprio, sem pagar nada para os
fabricantes de Arduíno. O hardware é barato. As despesas de alimentação USB cerca de €
20 (atualmente, cerca de E.U. $ 35) e substituindo um chip queimada na placa é fácil e não
custa mais de € 5 ou E.U. $ 4. Então você pode dar ao luxo de cometer erros.
Existe uma comunidade ativa de usuários, então há muitas pessoas que podem ajudá-lo.
O projeto Arduíno foi desenvolvido em um ambiente educacional e, portanto, ideal para os

recém-chegados para fazer as coisas de trabalho rapidamente.
Este livro foi concebido para ajudar os iniciantes a entender os benefícios que podem obter a
partir de aprender a usar a plataforma Arduíno e adoptar a sua filosofia.
1.1. Público Alvo
Este livro foi escrito para o "original" usuários Arduíno: designers e artistas. Portanto, ele
tenta explicar as coisas de uma maneira que pode levar alguns engenheiros loucos. Na
verdade, um deles chamado de capítulos introdutórios do meu primeiro projecto fluff ". Isso é
precisamente o ponto. Vamos enfrentá-lo: a maioria dos engenheiros não são capazes de
explicar o que fazer para outro engenheiro, quanto mais um ser humano normal. Vamos
agora mergulhar o cotão.
Nota: Arduíno baseia-se na tese de trabalho Hernando Barragan fez sobre a plataforma de
ligação quando estudava sob Casey Reas e me IDII em Ivrea. O Arduíno começou a se
tornar popular, onde eu percebi como experimentadores amadores e hackers de todos os
tipos começaram a utilizá-lo para criar objetos belos e loucos. Eu percebi que você está
como todos os artistas e designers em sua própria diretiva e ideal, assim este livro é para
você também.
Arduíno nasceu para ensinar Interação e Design, uma disciplina de projeto que coloca no
centro de prototipagem de sua metodologia. Existem muitas definições de Design de
Interação, mas o que eu prefiro é:
1.1.1. Interaction Design é a concepção de uma experiência interativa. No mundo de hoje,

Design de Interação se preocupa com a criação de experiências significativas entre nós
(humanos) e objetos. É uma boa maneira de explorar a criação de belos e talvez até
polêmico, experiências e tecnologia entre nós. Design de Interação design incentiva através
de um processo iterativo baseado em protótipos de fidelidade cada vez maior. Esta parte
também da abordagem de alguns tipos de "convencional" o projeto pode ser estendido para
incluir protótipos com a tecnologia, em especial, com protótipos de eletrônicos.
A área específica do Design de Interação envolvidos com Arduíno é a Computação Física

(ou físico Interaction Design).
1.2. O que é a computação física?
Physical Computing utiliza componentes eletrônicos para protótipo de novos materiais para
designers e artistas.
Ela envolve o design de objetos interativos que podem se comunicar com humanos por meio
de sensores e atuadores controlados por um comportamento implementado como um
software rodando dentro de um microcontrolador (um pequeno computador em um único
chip).
No passado, os eletrônicos usando significava ter que lidar com engenheiros de todo o
tempo, e circuitos de construir um pequeno componente no momento, estas questões
manteve as pessoas criativas de brincar com o meio diretamente. A maioria das ferramentas
foram criadas para os engenheiros e exigiu um vasto conhecimento. Nos últimos anos, os
microcontroladores têm se tornado mais baratos e fáceis de usar, permitindo a criação de
melhores ferramentas.
O progresso que temos feito com Arduíno é trazer estas ferramentas um passo para o
principiante, permitindo que as pessoas comecem a construir dia após apenas dois ou três
de um workshop.
Com Arduíno, um designer ou artista pode facilmente conhecer as noções básicas de

eletrônica e sensores de forma muito rápida e pode começar a construir protótipos com
muito pouco investimento.
Capítulo 2. A Via Arduíno
A filosofia Arduíno baseia-se em fazer desenhos ao invés de falar sobre eles. É uma busca
constante por maneiras mais rápidas e mais potentes para construir protótipos de melhor.
Temos explorou muitas técnicas de prototipagem e desenvolvido maneiras de pensar com
as mãos.
O clássico da engenharia se baseia em um rigoroso processo para a obtenção de A para B,

o caminho Arduíno deleita-se na possibilidade de se perder no caminho e encontrar C em
seu lugar.
Este é o processo de ajustes que nós gostamos tanto de-playing com a mídia de uma forma
aberta e encontrar o inesperado. Nesta busca de maneiras para construir protótipos de
melhor, nós também selecionou uma série de pacotes de software que permitem que o
processo de manipulação constante do software e suporte de hardware.
As próximas seções apresentam algumas filosofias, eventos e pioneiros que têm inspirado a
Via Arduíno.
Prototipagem está no coração da Via Arduíno: fazemos as coisas e construir objetos que
interagem com outros objetos, pessoas e redes. Nós nos esforçamos para encontrar uma
maneira simples e rápida de protótipos de forma mais barata possível.
Um monte de novatos vem se aproximando eletrônica pela primeira vez, acho que eles têm
de aprender a construir tudo do zero. Este é um desperdício de energia: o que você quer é
ser capaz de confirmar que algo trabalhando muito rapidamente para que você possa
motivar-se para dar o próximo passo ou até mesmo motivar alguém a dar-lhe um monte de
dinheiro para fazê-lo. É por isso que nós desenvolvemos "prototipagem oportunista": por que
gastar tempo e energia construindo a partir do zero, um processo que requer tempo e
conhecimento técnico profundo, quando podemos ter dispositivos pré-fabricados e cortar-
lhes a fim de explorar o trabalho duro feito por grandes empresas e engenheiros de bom?
Nosso herói é James Dyson, que fez 5.127 protótipos do seu aspirador antes ele estava
convencido de que ele havia chegado ela (www.international.dyson.com/jd/1947.asp).
2.2. Consertando
Nós acreditamos que é essencial para lidar com a tecnologia, explorando diferentes
possibilidades diretamente no hardware e às vezes software sem um objetivo muito definido.
Reutilizando a tecnologia existente é uma das melhores maneiras de consertar. Primeiros
brinquedos baratos ou antigos equipamentos descartados e adaptando-lhes para que façam
algo de novo é uma das melhores maneiras de chegar a grandes resultados.
2.3. Patching
Eu sempre fui fascinado pela modularidade e a capacidade de construir sistemas

complexos, ligando juntos dispositivos simples. Este processo está muito bem representado
por Robert Moog e sintetizadores analógicos. Músicos construído sons, tentando
combinações infinitas de "remendar" os diferentes módulos com cabos. Esta abordagem
feita a aparência sintetizador como um interruptor do telefone antigo, mas combinadas com
os botões numerosas, que era a plataforma perfeita para mexer com som e inovar a música.
Moog descreveu-o como um processo entre a "testemunhar e descobrir". Eu tenho certeza
que a maioria dos músicos no início não sabia o que todas essas centenas de botões que,
mas tentei e tentei, refinando o seu próprio estilo, sem interrupções no fluxo.
Reduzir o número de interrupções no fluxo é muito importante para a criatividade, a mais

transparente o processo, quanto mais mexer acontece.
Esta técnica tem sido traduzido para o mundo do software por "programação visual"
ambientes como Max, Pure Data, ou VVVV. Essas ferramentas podem ser visualizados
como "caixas" para as diferentes funcionalidades que proporcionam, deixando o usuário
construir "patches", ligando essas caixas juntos. Esses ambientes permitem a experiência do
usuário com a programação, sem a interrupção constante típico do ciclo normal: tipo de
programa ", compilação, caramba, há um erro, erro de correção, compilar, executar". Se
você é visualmente mais ocupado, eu recomendo que você experimentá-los.
2.4. Testando um Circuito
Circuit bending é uma das formas mais interessantes de consertar. É o criativo curto-circuito
de baixa tensão, alimentados por bateria dispositivos eletrônicos de áudio, como pedais de
efeitos de guitarra, brinquedos para crianças, pequenas e sintetizadores para criar novos
instrumentos musicais e geradores de som. O cerne deste processo é a "arte do acaso".
Tudo começou em 1966 quando Reed Ghazala, por acaso, em curto-out do amplificador um
brinquedo contra um objeto de metal na sua gaveta, resultando em um fluxo de sons
incomuns. O que eu gosto benders sobre circuito é a sua capacidade para criar as mais
loucas dispositivos de ajustes de distância com a tecnologia, sem necessariamente
compreender o que eles estão fazendo no lado teórico.
2.5. Teclado Hacks
teclados de computador são ainda a principal forma de interagir com um computador depois
de mais de 60 anos. Alex Pentland, diretor acadêmico do MIT Media Laboratory, comentou
certa vez: "Desculpa a expressão, mas mictórios dos homens são mais inteligentes do que
os computadores. Computadores são isolados do que está ao seu redor." [1]
[1] Citado em Sara Reese Hedberg, "busca MIT Media Lab para computadores perceptivo,"
Intelligent Systems e suas aplicações, IEEE, julho / 1998 agosto
Como tinkerers, podemos implementar novas formas de interagir com o software,

substituindo as chaves com dispositivos que são capazes de sentir o ambiente. Desmontar
um teclado de computador revela uma forma muito simples (e barato) do dispositivo. O
coração dele é uma pequena placa. É normalmente um circuito cheiro verde ou marrom com
dois conjuntos de contatos a duas camadas de plástico que prendem as conexões entre as
chaves diferentes. Se você remover o circuito e usar uma ponte de arame para dois
contatos, você verá uma letra aparecer na tela do computador. Se você sair e comprar um
detector de movimento, sensores e ligar este seu teclado, você verá uma chave a ser
pressionada cada vez que alguém anda na frente do computador. Mapa isso ao seu
programa favorito, e você fez o seu computador tão esperto quanto um urinol. Aprender
sobre hacking teclado é um alicerce fundamental da prototipagem física e computação.
2.6. Nós amamos sucata!
Pessoas jogam fora um monte de tecnologia nos dias de hoje: antigas impressoras,
computadores, máquinas de escritório estranho, equipamentos técnicos, e até mesmo um
monte de material militar. Houve sempre um grande mercado para essa tecnologia em
excesso, especialmente entre os jovens e / ou hackers mais pobres e aqueles que estão
apenas começando. Este mercado se tornam evidentes em Ivrea, onde desenvolvemos
Arduíno. A cidade costumava ser a sede da empresa Olivetti. Eles haviam se tornado os
computadores desde a década de 1960, em meados de 1990, jogaram tudo em ferros-
velhos na região. Estes estão cheios de peças de computador, componentes eletrônicos e
dispositivos estranhos de todos os tipos. Nós passamos inúmeras horas lá, comprando todo
tipo de engenhocas por muito pouco dinheiro e pirataria em nossos protótipos. Quando você
pode comprar um mil alto-falantes para muito pouco dinheiro, você é obrigado a chegar a
alguma idéia no final. Acumular lixo e atravessá-la antes de começar a construir algo a partir
do zero.
2.7. Hacking Brinquedos
Os brinquedos são uma fantástica fonte de tecnologia barata de reutilização, como

evidenciado pela prática de circuit bending mencionado anteriormente. Com a atual afluência
de milhares de muito baratos brinquedos de alta tecnologia da China, você pode criar idéias
rápidas com alguns gatos barulhentos e um par de espadas de luz. Eu tenho feito isso há
alguns anos para chegar aos meus alunos a compreender que a tecnologia não é
assustador ou de difícil abordagem. Um dos meus recursos favoritos é o livreto "Low Tech
Sensores e atuadores" por Usman Haque e Somlai-Adam Fischer
(lowtech.propositions.org.uk). Eu acho que eles têm perfeitamente descritos desta técnica
em que o manual, e eu tenho usado desde então.
Capítulo 3. A plataforma Arduíno
Arduíno é composto de duas partes principais: a placa Arduíno, que é a peça de hardware
que você trabalha, quando você construir seus objetos, bem como a IDE Arduíno, o pedaço
de software que você executa em seu computador. Você usa o IDE para criar um desenho
(um pequeno programa de computador) que você enviar para a placa Arduíno. O desenho
conta a bordo o que fazer.
Não muito tempo atrás, trabalhando em hardware significava construir circuitos a partir do
zero, usando centenas de componentes diferentes, com nomes estranhos como resistor,
capacitor, indutor, transistor, e assim por diante.
Cada circuito foi "wired" para fazer uma aplicação específica, e fazer mudanças necessárias
para você cortar fios, conexões de solda, e muito mais. Com o surgimento das tecnologias
digitais e microprocessadores, estas funções, uma vez que foram realizadas com fios, foram
substituídos por programas de software.
Com o software é fácil modificar a hardware. Com poucas teclas pressionadas, você pode
mudar radicalmente a lógica de um dispositivo e tente duas ou três versões na mesma
quantidade de tempo que você levaria para soldar um par de resistores.
3.1. O hardware Arduíno
A placa Arduíno é uma placa do microcontrolador pequeno, que é um circuito pequeno (o

conselho) que contém um computador inteiro em um pequeno chip (o microcontrolador).
Este computador é, pelo menos, umas mil vezes menos potente que o MacBook que estou
usando para escrever isso, mas é muito mais barato e muito útil para construir dispositivos
interessantes. Olhe para a placa Arduíno: você verá um chip preto com 28 "pernas" do chip
que é o ATmega168, o coração de sua placa.
Nós (a equipe Arduíno) ter colocado no fórum todos os componentes que são necessários
para este microcontrolador para funcionar corretamente e para se comunicar com o
computador. Existem muitas versões desta placa, o que usaremos ao longo deste livro é o
Duemilanove Arduíno, que é o mais simples de usar e melhor para se aprender. No entanto,
estas instruções se aplicam a versões anteriores do conselho, incluindo o mais recente
Arduíno Diecimila eo antigo NG Arduíno. Figura 3-1 mostra o Duemilanove Arduíno; Figura
3-2 mostra o Arduíno NG.
Nestas ilustrações, você verá a placa Arduíno. Na primeira, todos os conectores pode ser
um pouco confuso. Aqui está uma explicação do que cada elemento do conselho de
administração é:
3.1.1. 14 pinos de E / S Digital (pinos 0-13)

Estes podem ser entradas ou saídas, que é especificado pelo desenho que você criar no
IDE.
3.1.2. 6 pinos analógico (pinos 0-5)

Estes pinos de entrada analógica dedicada tomar valores analógicos (ou seja, as leituras de
tensão de um sensor) e convertê-los em um número entre 0 e 1023.
3.1.3. 6 saída analógica pinos (pinos 3, 5, 6, 9, 10 e 11)

Estes são realmente seis dos pinos digitais que podem ser reprogramados para a saída
analógica utilizando o desenho que você criar no IDE.
A placa pode ser alimentada através de porta USB do seu computador, a maioria dos
carregadores USB ou um adaptador AC (9 volts recomendado, ponta barril 2.1mm, centro
positivo). Se não houver nenhuma fonte de alimentação conectado à tomada de poder, o
poder virá da placa USB, mas assim que você conecte uma fonte de alimentação, o
conselho vai usá-la automaticamente.
Observação: Se você estiver usando o antigo Arduíno-NG ou Arduíno Diecimila, você
precisará configurar o jumper de seleção de alimentação (marcado PWR_SEL na placa)
para especificar EXT (externo) ou alimentação USB. Este jumper pode ser encontrada entre
o plugue do adaptador AC e à porta USB.
Figura 3-1. O Duemilanove Arduíno
Figure 3-2. The Arduíno NG

3.2. O software (IDE)
O IDE (Integrated Development Environment) é um programa especial em execução no

computador que permite escrever esboços para a placa Arduíno, em uma linguagem simples
modelado após o processamento (www.processing.org) língua. A mágica acontece quando
você pressiona o botão que envia o desenho para a placa: o código que você escreveu é
traduzido para a linguagem C (que geralmente é bastante difícil para um iniciante de usar), e
é passado para o compilador avr-gcc , uma importante peça de software de fonte aberta que
faz a tradução final para a língua entendida pelo microcontrolador. Esta última etapa é
bastante importante, porque é onde Arduíno torna a sua vida simples, escondendo o máximo
possível das complexidades da programação de microcontroladores.
O ciclo de programação Arduíno é basicamente o seguinte:
1. Ligue sua placa em uma porta USB no seu computador.
2. Escreva um esboço que trará a bordo a vida.
Faça o Upload deste esboço para a instalação por meio da conexão USB e aguarde alguns
segundos para a instalação reiniciar. A placa executa o programa que você escreveu.
Nota: Nota: Instalar Arduíno no Linux é um pouco complicado no momento da redação deste
texto. Veja www.Arduíno.cc/playground/Learning/Linux para obter instruções completas.
3.3. Instalando o Arduíno em seu computador
Para programar a placa Arduíno, primeiro você deve baixar o ambiente de desenvolvimento
(IDE) daqu iwww.Arduíno.cc/en/Main/Software.. Escolha a versão correta para seu sistema
operacional.
Baixe o arquivo e clique duplo nele para descompactá-lo, o que irá criar uma pasta chamada
versão] Arduíno [como Arduíno-0012. Arraste a pasta para onde você gostaria que fosse: o
ambiente de trabalho, sua pasta / Applications (em um Mac), ou o C: \ Program Files (no
Windows). Agora sempre que você quiser executar o IDE Arduíno, você irá abrir a pasta
Arduíno, e dê um duplo clique no ícone do Arduíno. Não faça isso apenas ainda, embora, há
mais um passo para executar.
Observação: Observação: Se você tiver qualquer problema executando o IDE Arduíno,
consulte o Capítulo 7, solução de problemas. Agora você deve instalar os drivers que
permitem que o computador para falar com sua placa através da porta USB.
3.4. Instalação de drivers: Macintosh
Procure a pasta Drivers dentro da pasta do Arduíno-0012 e faça duplo clique no arquivo
chamado FTDIUSBSerialDriver_x_x_x.dmg (x_x_x será substituído com o número da versão
do driver, por exemplo FTDIUSBSerialDriver_v2_2_9_Intel.dmg). Clique duas vezes o dano.
Arquivo para montá-lo.
Nota: Nota: Se você estiver usando um Mac baseado em Intel, como um MacBook,
MacBook Pro, MacBook Air, Mac Pro, ou baseados em Intel Mac Mini ou iMac, não se
esqueça de instalar o driver com o "Intel" em seu nome , como em
FTDIUSBSerialDriver_v2_2_9_Intel.dmg. Se você não estiver usando um Mac baseado em
Intel, instale um sem "Intel" em seu nome.
Em seguida, instalar o software do pacote FTDIUSBSerialDriver clicando duas vezes nele.

Siga as instruções fornecidas pelo instalador e digite a senha de um usuário administrativo,
se solicitado. No final deste processo, reinicie o computador para se certificar de que os
drivers estão corretamente carregados. Agora ligue a placa em seu computador. A luz PWR
no conselho deve aparecer eo LED amarelo chamado "L" deve começar a piscar. Se não,
veja o Capítulo 7, solução de problemas.
3.5. Instalando Drivers: Windows
Ligue a placa Arduíno no computador, quando a janela Novo Hardware aparecer, o Windows
irá primeiro tentar encontrar o driver no site do Windows Update.
Windows XP irá pedir para verificar se o Windows Update, se você não quiser usar o
Windows Update, selecione a opção "Não, não neste momento" e clique em Avançar.
Na próxima tela, escolha a opção "Instalar de uma lista ou local específico" e clique em
Avançar. Marque a caixa "Incluir este local na pesquisa", clique em Procurar, selecione a
pasta onde você instalou o Arduíno, e selecione a Drivers \ USB FTDI pasta Drivers como o
local. Clique em OK e Avançar.
Windows Vista ou Windows Seven vai primeiro tentar encontrar o driver no Windows Update,
se isso falhar, você pode instruí-lo a olhar no FTDI \ Drivers USB pasta Drivers.
Você vai passar por esse procedimento duas vezes, porque o primeiro computador instala o
driver de baixo nível, em seguida, instala um código que faz o olhar como uma placa de
porta serial para o computador.
Uma vez que os drivers são instalados, você pode iniciar o IDE Arduíno Arduíno e começar
a usar. Em seguida, você deve descobrir qual porta serial é atribuído à sua necessidade
Arduíno bordo you'll essa informação para o programa mais tarde. As instruções para obter
esta informação são as seguintes seções.
3.7. Port de Identificação: Windows
No Windows, o processo é um pouco mais complicado, pelo menos no início. Abra o

Gerenciador de Dispositivos clicando no menu Iniciar, botão direito do mouse em
Computador (Vista) ou o meu computador (XP) e escolha Propriedades. No Windows XP,
clique em Hardware e escolha Gerenciador de dispositivos. No Vista, clique em Device
Manager (ele aparece na lista de tarefas no lado esquerdo da janela).
Procure o dispositivo Arduíno na lista do "Portas (COM & LPT)". O Arduíno vai aparecer
como uma porta serial USB e terá um nome como COM3, como mostrado na Figura 3-4.
Figura 3-4. O Gerenciador de Dispositivos do Windows mostrando todas as portas seriais
disponíveis
Nota: Nota: Em algumas máquinas Windows, a porta COM tem um número maior que 9;
essa numeração cria alguns problemas ao Arduíno está tentando se comunicar com ele.
Consulte o Capítulo 7, solução de problemas para obter ajuda sobre este problema.
Uma vez que você descobriu a atribuição de porta COM, você pode selecionar a porta a
partir do menu Ferramentas> Port Serial no IDE Arduíno. Agora, o ambiente de
desenvolvimento do Arduíno pode falar com a placa Arduíno e programá-lo.
Capítulo 4. Introdução ao Arduíno
Agora você vai aprender a construir e programar um dispositivo interativo.
4.1. Anatomia de um dispositivo interactivo
Todos os objetos que irá construir com Arduíno seguem um padrão muito simples, que nós
chamamos de Dispositivo Interativo. O dispositivo interativo é um circuito eletrônico que é
capaz de perceber o ambiente através de sensores (componentes eletrônicos que
convertem as medições do mundo real em sinais elétricos). O dispositivo que processa as
informações que recebe dos sensores com o comportamento que é implementado como
software. O aparelho será então capaz de interagir com o mundo usando atuadores,
componentes eletrônicos que podem converter um sinal elétrico em uma ação física.
Figura 4-1. O dispositivo interactivo
4.2. Sensores e atuadores
Sensores e atuadores são os componentes eletrônicos que permitem que um pedaço de

eletrônica para interagir com o mundo. Como o microcontrolador é um computador muito
simples, só pode processar sinais elétricos (um pouco como os impulsos elétricos que são
enviados entre os neurônios em nossos cérebros). Para a luz sentido, a temperatura, ou
outras quantidades físicas, ele precisa de algo que pode convertê-los em eletricidade. Em
nosso corpo, por exemplo, os olhos converte luz em sinais que são enviados ao cérebro
através dos nervos. Em eletrônica, podemos usar um dispositivo simples, chamado de um
resistor dependente da luz (um LDR ou photoresistor), que pode medir a quantidade de luz
que o atinge e relatá-lo como um sinal de que pode ser entendido pelo microcontrolador.
Uma vez que os sensores foram lidos, o dispositivo tem a informação necessária para
decidir como reagir. O processo de tomada de decisão é feita pelo microcontrolador, ea
reação é realizada por atuadores. Em nossos corpos, por exemplo, os músculos recebem
sinais elétricos do cérebro e convertê-los em um movimento. No mundo eletrônico, essas
funções poderiam ser desempenhadas por uma luz ou um motor elétrico.
Nas seções seguintes, você vai aprender a ler diferentes tipos de sensores e controle de
diferentes tipos de actuadores.
4.3. Piscando um LED
O LED piscando esboço é o primeiro programa que você deve executar para testar se sua
placa Arduíno está funcionando e está configurado corretamente. Também é geralmente o
primeiro exercício de programação que alguém faz quando aprender a programar um
microcontrolador. Um diodo emissor de luz (LED) é um pequeno componente eletrônico que
é um pouco como uma lâmpada, mas é mais eficiente e requer menor voltagem para operar.
Sua placa Arduíno vem com um LED pré-instalado. É marcado como "L". Você também
pode adicionar seu próprio LED de conexão como mostrado na Figura 4-2.
K indica o catodo (negativo) ou mais curtos, indica um anodo (positivo), ou mais de chumbo.
Depois que o LED está ligado, você precisa dizer o que fazer Arduíno. Isto é feito através de
código, ou seja, uma lista de instruções que damos o microcontrolador para ele fazer o que
queremos.
Figura 4-2. Ligar um LED para Arduíno
Em seu computador, vá abrir a pasta onde você copiou o IDE Arduíno. Dê um duplo clique
no ícone do Arduíno para iniciá-lo. Selecione File> New e você será solicitado a escolher um
nome de pasta sketch: este é o lugar onde o seu esboço Arduíno será armazenado. Nome
que Blinking_LED e clique em OK. Em seguida, digite o seguinte texto (Exemplo 4-1) no
editor de desenho Arduíno (a janela principal do IDE Arduíno). Você também pode baixá-lo
www.makezine.com / getstartedArduíno. Ele deve aparecer como mostrado na Figura 4-3.
Exemplo 4-1. Programa LED piscando
#define LED 13 // LED connected to

// digital pin 13
void setup()
{
pinMode(LED, OUTPUT); // sets the digital
// pin as output
}
void loop()
{
digitalWrite(LED, HIGH); // turns the LED on
delay(1000); // waits for a second
digitalWrite(LED, LOW); // turns the LED off
delay(1000); // waits for a second
}
Figura 4-3. O IDE Arduíno com o seu primeiro programa carregado
Agora que o código está na sua IDE, você precisa verificar se ele está correto. Pressione o
botão "Confirmar" (Figura 4-3 mostra a sua localização), se tudo estiver correto, você verá a
mensagem "Compiler done" aparecer na parte inferior do IDE Arduíno. Esta mensagem
significa que o IDE Arduíno traduziu seu desenho em um programa executável que pode ser
executado pelo driver, um pouco como um arquivo. Exe no Windows ou um arquivo app. Em
um Mac.
Neste ponto, você pode carregá-lo na placa: pressione o upload para o I / O botão Câmara
(veja a Figura 4-3). Isso irá redefinir a bordo, obrigando-o a parar o que está fazendo e ouvir
as instruções provenientes da porta USB. O IDE Arduíno envia o desenho atual do conselho,
que irá armazená-lo em sua memória e, eventualmente, executá-lo.
Você verá algumas mensagens aparecerem na área de preto na parte inferior da janela, e
logo acima dessa área, você verá a mensagem "Done uploading" parece que você saiba o
processo foi concluído corretamente. Existem dois LEDs, marcado RX e TX, no conselho,
estes flash toda vez que um byte é enviado ou recebido pela diretoria. Durante o processo
de upload, eles continuam piscando.
Se você não vê a piscar LEDs, ou se você receber uma mensagem de erro, em vez de
"Done uploading", então há um problema de comunicação entre o computador eo Arduíno.
Certifique-se de que você tenha selecionado a porta serial direito (ver Capítulo 3), no menu
Ferramentas> Port Serial. Além disso, verifique o menu Ferramentas> Câmara para
confirmar que o modelo correto de Arduíno é selecionado lá.
Se você ainda estiver tendo problemas, consulte o Capítulo 7, solução de problemas.
Uma vez que o código está em sua placa Arduíno, ele vai ficar lá até você colocar outro
programa sobre ela. O esquema vai sobreviver se a placa é reinicializada ou desligada, um
pouco como os dados no disco do seu computador.
Supondo que o desenho tenha sido carregado corretamente, você verá o LED "L" ligue para
um segundo e, em seguida, desligar por um segundo. Se você instalou um LED separadas,
como mostrado na Figura 4-2, que o LED pisca, também. “O que você acabou de escrever e
correu é um programa de computador“, ou esboço, como são chamados os programas
Arduíno. Arduíno, como eu mencionei antes, é um pequeno computador, e ele pode ser
programado para fazer o que quiser. Isso é feito usando uma linguagem de programação
para escrever uma série de instruções do IDE Arduíno, que o transforma em um arquivo
executável para a sua placa Arduíno.
Vou mostrar próximo como entender o desenho. Primeiro de tudo, o Arduíno executa o
código de cima para baixo, para a primeira linha no topo é a primeira leitura, em seguida, ela
se move para baixo, um pouco como a forma como a reprodução de um player de vídeo
como o QuickTime Player ou Windows Media Player move da esquerda para a direita,
mostrando onde o filme estiver.
4.4. Passe-me o queijo parmesão
Observe a presença de chaves, que são usadas para agrupar linhas de código. Estes são
particularmente úteis quando você quer dar um nome a um grupo de instruções. Se você
estiver no jantar e você perguntar a alguém: "Por favor me passe o queijo parmesão," isto dá
início a uma série de ações que estão resumidos a pequena frase que você acabou de dizer.
Como nós somos seres humanos, tudo vem naturalmente, mas todas as ações individual
minúsculo necessário para fazer isso devem ser especificados para o Arduíno, porque não é
tão poderoso como o nosso cérebro. Assim, para agrupar uma série de instruções, você fura
a (antes de seu código e um) depois.
Você pode ver que existem dois blocos de código que são definidos dessa forma aqui. Antes
de cada uma delas existe um comando estranho:
void setup ()
Esta linha dá um nome a um bloco de código. Se você fosse escrever uma lista de
instruções que ensinam Arduíno como passar o parmesão, você escreveria
passTheParmesan (void) no início de um bloco, e esse bloco se tornaria uma instrução que
você pode ligar de qualquer lugar do código Arduíno. Esses blocos são chamados de
funções. Se depois disto, você escreve passTheParmesan () em qualquer lugar no seu
código, Arduíno irá executar as instruções e continuar de onde parou.
4.5. Arduíno não é para Quitters
Arduíno espera duas funções, existe uma configuração chamada setup() e outra chamada
loop ().
setup () - é onde você coloca todo o código que você deseja executar uma vez no início do
seu programa.
loop () - contém o núcleo do seu programa, que é executado repetidas vezes. Isso é feito
porque Arduíno, não é como regular o seu computador que pode executar vários programas
ao mesmo tempo e os programas não podem parar. Quando você ligar a placa, o código é
executado, quando quiser parar, basta desligá-lo.
4.6. Escrevendo comentários
Qualquer texto que começa com / / é ignorado pelo Arduíno. Essas linhas são comentários,
que são as notas que você deixa no programa por si mesmo, para que você possa se
lembrar do que você fez quando escreveu, ou para outra pessoa, para que eles possam
compreender o seu código.
É muito comum ao escrever um pequeno código, faça o upload para o dispositivo, e diga:
"Ok, estou nunca vai ter que tocar essa droga de novo!" para realizar somente seis meses
depois que você precisa para atualizar o código ou corrigir um erro. Neste ponto, você abrirá
o programa, e se você não incluiu comentários no programa original, você vai pensar: "Uau,
que confusão! Onde eu começo?" À medida que avançamos ao longo, você verá alguns
truques de como fazer seus programas mais legíveis e fáceis de manter.
4.7. O Código, Passo a Passo
Na primeira, você pode considerar este tipo de explicação meia desnecessária, um pouco
como quando eu estava na escola e eu tinha que estudar Dante da Divina Comedia (cada
aluno italiano tem que passar por isso, bem como um outro livro chamado I promessi sposi,
ou Os noivos, oh, os pesadelos). Para cada linha dos poemas, havia uma centena de linhas
de comentário! No entanto, a explicação será muito mais útil aqui como você passar a
escrever seus próprios programas.
// Exemplo 01 : Piscando um LED
Um comentário é uma forma útil para nós a escrever pequenas notas. O comentário do título
anterior apenas nos lembra que este programa, Exemplo 4-1, piscar um LED.
#define LED 13 // conectar o LED

// para o pino digital 13
#define é como uma busca automática que substitui o seu código, neste caso está dizendo
ao Arduíno para escrever o número 13 cada vez que a palavra LED aparece. A substituição
é a primeira coisa que fez quando você clicar em verificar ou Upload de I / O Board (você
nunca vê os resultados da substituição, tal como é feito nos bastidores). Nós estamos
usando esse comando para especificar que o LED piscando e que está ligado ao pino 13 do
Arduíno.
voidsetup ()
Esta linha conta ao Arduíno que o próximo bloco de código será chamado setup(). (Com
essa inauguração suporte curly, um bloco de código começa).
pinMode(LED, OUTPUT); // sets the digital

// pin as output
Finalmente, uma instrução muito interessante. pinMode conta Arduíno como configurar um
pino certo. Pinos Digital pode ser usado como entrada ou saída. Neste caso, precisamos de
um pino de saída para controlar o nosso LED, para que coloque o número do PIN e seu
modo dentro dos parênteses. pinMode é uma função, e as palavras (ou números)
especificada dentro dos parênteses são argumentos. Entrada e saída são constantes na
linguagem Arduíno. (Como variáveis, constantes são atribuídos valores, exceto que os
valores constantes são pré-definidas e nunca mudam.)
{ Esse fechamento das Chaves significa o fim da função setup ().
void loop()
{
loop () é onde você especifica o comportamento principal do seu dispositivo interativo. Vai
ser repetido muitas e muitas vezes até mudar a placa off.
digitalWrite(LED, HIGH); // turns the LED on
Como diz o comentário, digitalWrite () é capaz de ligar (ou desligar) Qualquer pino que foi
configurado como uma saída. O primeiro argumento (neste caso, LED) especifica que o pino
deve ser ligado ou desligado (lembre-se que o LED é um valor constante que se refere ao
pino 13, então este é o pino que está ligado). O segundo argumento pode girar o pino
(HIGH) ou desligado (LOW).
Imagine que cada pino de saída é uma tomada de energia minúsculo, como aqueles que
têm nas paredes de seu apartamento. os europeus são 230 V, as americanas são de 110 V.
O Arduíno trabalha em um mais modesto 5 V. mágica aqui é quando o software torna-se
hardware. Quando você escreve digitalWrite(LED, HIGH), ele manda para o pino de saída
o valor de 5 V, e se você ligar um LED, ele acenderá. Então neste momento no seu código,
uma instrução no software faz algo acontecer no mundo físico, controlando o fluxo de
eletricidade para o pino. Ligar e desligar o pino de agora vamos traduzi-los em algo mais
visível de um ser humano, o LED é o nosso atuador.
delay(1000); // aguardar por um segundo
Arduíno tem uma estrutura muito básica. Portanto, se você quer que as coisas aconteçam
com certa regularidade, dizemos a ele para se sentar calmamente e não fazer nada até a
hora de ir para a próxima etapa. (atraso), basicamente, faz com que o processador se sentar
lá e não fazer nada para a quantidade de milissegundos que você passar como um
argumento. Milisegundos milhares de segundos, portanto, 1000 milissegundos equivalem a
1 segundo. Assim, o LED permanece em um segundo aqui.
digitalWrite(LED, LOW); // turns the LED off
Esta instrução agora desliga o LED que estava anteriormente ligado. Por que nós usamos
HIGH e LOW? Bem, é uma convenção antiga em eletrônica digital. HIGH significa que o
pino está ligado, e no caso do Arduíno, será de 5 V. LOW significa 0 V. Você também pode
substituir esses argumentos mentalmente ON e OFF.
Aqui, demora um segundo. O LED ficará desligado por um segundo.
} Esta Chave marca o encerramento da função de loop.
Em suma, este programa faz isto:
nomeia o pino 13 como uma saída (apenas uma vez no início)
Entra em um loop
Liga o LED conectado ao pino 13
Espera por um segundo
Desliga o LED conectado ao pino 13
Espera por um segundo
Remonta ao início do loop
Espero que isso não era muito doloroso. Você aprenderá mais sobre como o programa para
que você vá através dos exemplos mais tarde. Antes de passarmos para a próxima seção,
eu quero que você jogue com o código. Por exemplo, reduzir o montante de atraso, com
diferentes números de pulsos e fora de forma que você pode ver diferentes padrões de
piscar. Em particular, você deve ver o que acontece quando você faz a prazos muito
pequenos, mas o uso atrasos diferentes para dentro e fora. Há um momento em que algo
estranho acontece, esse "algo" vai ser muito útil quando você aprender sobre modulação por
largura de pulso mais adiante neste livro.
4.8. O que estaremos construindo
Eu sempre fui fascinado pela luz e pela capacidade de controlar diferentes fontes de luz
através da tecnologia. Eu tenho a sorte de trabalhar em alguns projetos interessantes que
envolvem o controle de luz e fazendo-a interagir com as pessoas. Arduíno é realmente bom
nisso. Ao longo deste livro, vamos trabalhar sobre a forma de projeto "Luzes interativo",
Utilizando Arduíno como uma maneira de aprender as noções básicas de como são
construídos os dispositivos interativos.
Na próxima seção, eu vou tentar explicar os conceitos básicos de eletricidade de uma forma
que de um engenheiro, mas não vai se assustar com um programa novo no Arduíno.
4.9 O que é eletricidade
4.10. Usando um botão para controlar o LED
Piscando um LED foi fácil, mas eu não acho que você ficaria se sane sua luminária de mesa
foram a piscar continuamente quando você estava tentando ler um livro. Portanto, você
precisa aprender a controlá-lo. Em nosso exemplo anterior, o LED era nosso atuador, e
nosso Arduíno era controlá-lo. O que está faltando para completar o quadro é um sensor.
Neste caso, vamos usar a forma mais simples de sensor disponível: um botão.
Se você fosse para além de ter um botão, você verá que é um aparelho muito simples: dois
pedaços de metal separados por uma mola e uma tampa de plástico que, quando
pressionadas traz os dois pedaços de metal em contato. Quando os pedaços de metal são
separados, não há circulação de corrente no botão (um pouco como quando uma válvula da
água está fechada); quando pressioná-lo, nós fazemos uma conexão.
Para monitorar o estado de um interruptor, há uma instrução nova para Arduíno que você
vai aprender: a digitalRead () função.
digitalRead() verifica se há qualquer tensão aplicada ao pino que você especificar entre
parênteses, e retorna um valor de alta ou baixa, dependendo das suas conclusões. As
outras instruções que temos utilizado até agora não retornou qualquer informação que
apenas executa o que nós pedimos que eles fizessem. Mas esse tipo de função é um pouco
limitado, porque ele vai nos forçar a ficar com seqüências de instruções muito previsíveis,
sem a entrada do mundo exterior. Com digitalRead (), nós podemos "fazer uma pergunta" ao
Arduíno e receber uma resposta que pode ser armazenado em algum lugar na memória e
usada para tomar decisões imediatamente ou mais tarde.
Construa o circuito mostrado na Figura 4-6. Para construir isso, você precisará obter
algumas peças (estes vêm a calhar quando se trabalha com outros projetos também):
Materiais:
Solderless breadboard: RadioShack www.radioshack.com () Número da peça 276-002,

Maker Shed (www.makershed.com) MKKN3 número da peça. O Apêndice A é uma
introdução à breadboard solda.
kit fio cortado Pré-jumper: RadioShack 276-173, Maker Shed MKKN4
Um resistor de 10K Ohm: RadioShack 271-1335 (5-pack), SparkFun (www.sparkfun.com)

COM-08374
Momentary botão interruptor tátil: SparkFun COM-00097
Figura 4-6. Ligar um botão
Nota: em vez de comprar fio jumper precut, você também pode comprar 22 AWG fio
conexão solid-core em bobinas pequenas e corte e tirá-lo usando cortadores de arame e fio
strippers. Vamos dar uma olhada no código que iremos usar para controlar o LED com o
nosso botão:
Exemplo 4-2. Ligue o LED quando o botão for pressionado
#define LED 13 // the pin for the LED (a variável LED = a saída 13)
#define BUTTON 7 // the input pin where the (a variável BUTTON = a saída 7)
// pushbutton is connected
int val = 0; // val will be used to store the state
// of the input pin
void setup() {
pinMode(LED, OUTPUT); // tell Arduíno LED is an output
pinMode(BUTTON, INPUT); // and BUTTON is an input
}
void loop(){
val = digitalRead(BUTTON); // read input value and store it
// check whether the input is HIGH (button pressed)

if (val == HIGH) {
digitalWrite(LED, HIGH); // turn LED ON
} else {
digitalWrite(LED, LOW);
}
}
No Arduíno, selecione Arquivo> Novo (se você tiver outro sketch aberto, você pode querer
salvar primeiro). Quando Arduíno pede-lhe para o nome da sua pasta de novo desenho,
PushButtonControl tipo. Digite o código do Exemplo 4-2 em Arduíno (ou baixá-lo
www.makezine.com/getstartedArduíno e colá-lo na IDE Arduíno). Se tudo estiver correto, o
LED acende quando você pressiona o botão.
4.11. Como isso funciona?
Tenho introduziu dois novos conceitos com este programa exemplo: funções que retornam o
resultado de seu trabalho e se a declaração.
A instrução if é possivelmente a mais importante instrução em linguagem de programação,

porque permite que o computador (e lembre-se, o Arduíno é um pequeno computador) para
tomar decisões. “Após a palavra-chave se, você tem que escrever uma “pergunta” entre
parênteses, e se a resposta“, ou resultado, é verdade, o primeiro bloco de código será
executado, caso contrário, o bloco de código depois o resto vai ser executado. Repare que
eu usei o símbolo == ao invés de =. O primeiro é usado quando duas entidades que são
comparados e retorna TRUE ou FALSE, o último atribui um valor a uma variável. Certifique-
se que você use o correto, porque é muito fácil cometer esse erro e utilizar apenas =, em
que o programa caso você nunca vai funcionar. Eu sei, porque após 25 anos de
programação, eu ainda cometia esse erro.
Segurando o dedo no botão enquanto você precisa de luz não é prático. Embora o faria
pensar em quanta energia você está desperdiçando quando você anda afastado de uma
lâmpada que você deixou em diante, precisamos descobrir como fazer a vara em botão ".
4.12. Um circuito, um Mil Comportamentos
A grande vantagem de eletrônica digital programável sobre a eletrônica clássica se torna

agora evidente: Eu vou te mostrar como implementar diversos "comportamentos", utilizando
o mesmo circuito eletrônico como na seção anterior, apenas mudando o software.
Como eu mencionei antes, não é muito prático ter que segurar o dedo no botão para ter a
luz acesa. Por isso, deve programar algum tipo de "memória", sob a forma de um
mecanismo de software que vai se lembrar quando temos apertou o botão e mantiver a luz
acesa mesmo depois de ter liberado.
Para fazer isso, vamos usar o que é chamado de variável. (Nós usamos um já, mas eu não
expliquei.) Uma variável é um lugar na memória do Arduíno onde você pode armazenar
dados. Pense nisso como uma daquelas notas pegajosas que você usa para lembrar algo,
como um número de telefone: você pega um, você escrever "Luisa 02 555 1212" nele, e
colá-la no seu monitor de computador ou sua geladeira. Na linguagem Arduíno, é igualmente
simples: você acabou de decidir que tipo de dados que você deseja armazenar (um número
ou um texto, por exemplo), dar-lhe um nome, e quando você quiser, você pode armazenar
os dados ou recuperá-la . Por exemplo:
int val = 0;
int significa que a variável vai armazenar um número inteiro, val é o nome da variável, e = 0
atribui um valor inicial de zero.
Uma variável, como o nome sugere, pode ser modificado em qualquer lugar no seu código,
de modo que, mais tarde, em seu programa, você pode escrever:
val = 112;
reatribui um novo valor, 112, para a variável.
Nota: Já repararam que em Arduíno, todas as instruções, com uma exceção (# define),
termina com um ponto e vírgula? Isso é feito para que o compilador (a parte do Arduíno que
transforma seu desenho em um programa que o microcontrolador pode ser executado) sabe
que sua declaração está terminado e um novo está começando. Lembre-se de usá-lo o
tempo todo, com exclusão de qualquer linha que começa com # define. O # define são
substituídos pelo compilador antes do código é traduzido em um arquivo executável Arduíno.
No programa seguinte, Val é usado para armazenar o resultado de digitalRead (); qualquer
Arduíno começa a partir da entrada termina na variável e vai ficar lá até que uma outra linha
de código alterá-lo. Observe que as variáveis que uso é de um tipo de memória chamada
RAM. É muito rápido, mas quando você desliga o seu conselho, todos os dados
armazenados na RAM são perdidas (o que significa que cada variável é redefinido para seu
valor inicial quando a placa é ligada novamente). Seus próprios programas são
armazenados na memória flash, este é o mesmo tipo usado por seu telefone móvel para
armazenar números de telefone, que mantém seu conteúdo mesmo quando a placa for
desligada.
Vamos agora usar outra variável a se lembrar se o LED tem que ficar ligado ou desligado
depois de soltar o botão. Exemplo 4-3 é uma primeira tentativa de conseguir:
Exemplo 4-3. Ligue o LED quando o botão for pressionado e mantê-lo depois ele é liberado:
#define LED 13 // the pin for the LED

#define BUTTON 7 // the input pin where the
// of the input pin
int state = 0; // 0 = LED off while 1 = LED on
void setup()
{
}
void loop()
{
// check if the input is HIGH (button pressed)

// and change the state
if (val == HIGH)
{
state = 1 - state;
}
if (state == 1)
{
}
else
{
}
}
Agora vamos testar este código. Você vai notar que ele funciona um pouco. Você verá que
a luz muda tão rapidamente que você não pode defini-lo como ligado ou desligado com um
botão.
Vejamos as partes interessantes do código: estado é uma variável que armazena 0 ou 1
para lembrar se o LED está ligado ou desligado. Depois que o botão é liberado, temos que
inicializar a 0 (LED desligado).
Mais tarde, lemos o estado atual do botão, e se for pressionado (val == HIGH), mudamos
estado 0-1, ou vice-versa. Fazemos isso usando um pequeno truque, como o estado só
pode ser 1 ou 0. O truque que eu uso envolve uma pequena expressão matemática baseada
na idéia de que 1-0 é 1 e 1-1 é 0: state = 1 - state;
A linha pode não fazer muito sentido em matemática, mas na programação. O símbolo =
significa "atribuir o resultado do que está atrás de mim para o nome da variável antes de
mim", neste caso, o novo valor de estado é atribuído o valor de 1 menos o valor antigo do
estado.
Mais tarde no programa, você pode ver que nós usamos estado para descobrir se o LED
deve ser ligado ou desligado. Como eu mencionei isso leva a resultados um pouco
esquisitos.
Os resultados são esquisitos por causa da maneira como lemos no botão. Arduíno é muito
rápido, que executa suas próprias instruções internas a uma taxa de 16 milhões de
execuções por segundo que poderia muito bem ser a execução de alguns milhões de linhas
de código por segundo. Então isso significa que enquanto o seu dedo está pressionando o
botão, Arduíno pode estar lendo a posição do botão de alguns milhares de vezes e alterar o
estado em conformidade. Assim, os resultados acabam por ser imprevisível, mas pode ser
desligado quando você queria-o, ou vice-versa. Como até mesmo um relógio quebrado está
certo duas vezes por dia, o programa pode mostrar o comportamento correto de vez em
quando, mas a maior parte do tempo ele vai estar errado.
Como podemos corrigir isso? Bem, é preciso detectar o momento exato em que o botão é
pressionado, que é o único momento que temos de mudar de estado. Do jeito que eu gosto
de fazer é armazenar o valor de val antes de eu ler um novo, o que me permite comparar a
posição atual do botão com o anterior e mudança de estado apenas quando o botão se torna
HIGH após ser LOW.
Exemplo 4-4 contém o código para fazer isso:

Exemplo 4-4. Ligue o LED quando o botão for pressionado e mantê-lo depois de ele é
lançado agora com uma fórmula nova e melhorada!

#define BUTTON 7 // the input pin where the
// of the input pin
int old_val = 0; // this variable stores the previous
// value of "val"
int state = 0; // 0 = LED off and 1 = LED on
void setup() {
}
void loop(){
// yum, fresh
// check if there was a transition
if ((val == HIGH) && (old_val == LOW)){
state = 1 - state;
}
old_val = val; // val is now old, let's store it
if (state == 1) {
} else {
}
}
Capítulo 5.
Entrada e Saída Avançado
O que você aprendeu apenas no capítulo 4 são as operações mais elementares que
podemos fazer em Arduíno: Saída digital de controle e leitura de entrada digital. Se o
Arduíno fosse algum tipo de linguagem humana, estas seriam duas letras do seu alfabeto.
Considerando que existem apenas cinco letras deste alfabeto, você pode ver quanto mais o
trabalho que temos que fazer antes de podermos escrever poesia Arduíno.
fórmula melhorada!
5.1. Tentando Out Em outros sensores / Off

Agora que você aprendeu a usar um botão, você deve saber que existem muitos outros
sensores muito básicos que funcionam segundo o mesmo princípio:
5.1.1. Chaves
Assim como um botão, mas não muda automaticamente o estado quando liberado
5.1.2. Termostatos
Uma opção que se abre quando a temperatura atinge um valor definido
5.1.3. Sensores magnéticos (também conhecido como " reed switch")

Tem dois contatos que se reúnem quando estão perto de um ímã, usado por alarmes para
detectar quando uma janela é aberta
5.1.4. Tapete switches (chaves tipo tapete)

tapetes pequenos, que você pode colocar em um tapete ou um capacho para detectar a
presença de um ser humano (ou gato pesado)
5.1.5. Tilt switches

Um componente eletrônico simples que contém dois contatos e uma bola de metal pouco
(ou uma gota de mercúrio, mas eu não recomendo o uso deles) Um exemplo de um
interruptor de inclinação é chamado de sensor de inclinação. Figura 5-1 mostra o interior de
um modelo típico. Quando o sensor é na posição vertical, as pontes de bola os dois
contatos, e isso funciona como se você tivesse pressionado um botão. Quando este sensor
de inclinação, a bola se move, o contato é aberto, que é como se você tivesse lançado um
botão. Usando este componente simples, você pode aplicar, por exemplo, interfaces
gestuais que reagem quando um objeto é movido ou agitado.
Figura 5-1. O interior de um sensor de inclinação
Outro sensor que você pode querer experimentar é o sensor de infravermelho como
encontrado em alarmes (também conhecido como um sensor infravermelho passivo ou PIR,
ver Figura 5-2). Este pequeno dispositivo dispara quando um ser humano vivo (ou outro ser)
move-se dentro de sua proximidade. É uma maneira simples de detectar o movimento.
Figura 5-2. sensor PIR típica
Você deve experimentar agora, olhando para todos os possíveis dispositivos que têm dois
contatos que fechar, como o termostato que ajusta a temperatura da sala (use um velho que
não é mais ligado), ou apenas colocar dois contatos ao lado do outro e soltando água sobre
elas.
Por exemplo, usando o exemplo final do capítulo 4 e um sensor PIR, você poderia fazer a
sua lâmpada responder à presença de seres humanos, ou você poderia usar um switch
inclinação para construir aquele que se desliga quando está inclinado de um lado.
5.2. Controlar a luz com PWM
Com o conhecimento que você ganhou até agora, você pode criar um lâmpada interativa
que pode ser controlada e não apenas com uma perfuração para ligar / desligar, mas talvez
de uma forma que é um pouco mais elegante. Uma das limitações dos exemplos LED
piscando que temos utilizado até agora é que você pode acender a luz apenas on e off. Uma
lâmpada de fantasia interativa deve ser regulável. Para resolver este problema, podemos
utilizar um pequeno truque que faz um monte de coisas, como a televisão ou cinema
possível: a persistência da visão.
Como sugeri, após o primeiro exemplo no capítulo 4, se você mudar os números na função
de atraso até que você não vê o LED piscando mais, você vai notar que o LED parece ser
regulado em 50% do seu brilho normal. Agora mude os números para que o LED está em
cima é um quarto do tempo que ele está fora. Execute o desenho e você verá que o brilho é
de aproximadamente 25%. Essa técnica é chamada de modulação de largura de pulso
(PWM), uma maneira elegante de dizer que se você piscar o LED rápido o suficiente, você
não vê-lo piscar mais, mas você pode mudar o seu brilho, alterando a relação entre o tempo
e em o tempo fora. Figura 5-3 mostra como isso funciona.
Essa técnica também funciona com outros dispositivos além de um LED. Por exemplo, você
pode mudar a velocidade de um motor da mesma maneira.
Ao experimentar, verá que ao piscar o LED colocando atrasos em seu código um pouco
inconveniente, porque assim você quiser ler um sensor ou enviar dados pela porta serial, o
LED irá piscar enquanto ele está esperando por você para terminar a leitura do sensor.
Felizmente, o processador usado pela placa Arduíno tem um pedaço de hardware que
podem controlar muito eficientemente três LEDs piscando quando seu desenho é outra
coisa. Este hardware é implementado em pinos 9, 10 e 11, que pode ser controlado pela
instrução analogWrite ().
Figura 5-3. PWM em ação
Por exemplo, escrevendo analogWrite (9128) irá definir o brilho de um LED conectado ao
pino 9 para 50%. Por que 128? analogWrite () espera um número entre 0 e 255 como um
argumento, onde 255 significa cheio de brilho e 0 significa desligado.
Nota: Tendo em três canais é muito bom, porque se você comprar LEDs, vermelho, verde,
azul e você pode misturar suas luzes e fazer a luz de qualquer cor que você quiser!
Vamos testá-lo. Construa o circuito que você vê na figura 5-4. Note que os LEDs são
polarizados: o pino de longa duração (positivo) deve ir para a direita, eo pino curto (negativo)
para a esquerda. Além disso, a maioria dos LEDs tem um lado negativo achatado.
Figura 5-4. LED ligado ao pino PWM
Em seguida, crie um novo programa no Arduíno e utilização Exemplo 5-1 (você também
pode fazer download de exemplos de código www.makezine.com/getstartedArduíno:
Exemplo 5-1. Fade um LED dentro e para fora como em um computador Apple dormir

int i = 0; // We'll use this to count up and down
void setup() {
}
void loop(){
for (i = 0; i < 255; i++) { // loop from 0 to 254 (fade in)

analogWrite(LED, i); // set the LED brightness
delay(10); // Wait 10ms because analogWrite
// is instantaneous and we would
// not see any change
}
for (i = 255; i > 0; i--) { // loop from 255 to 1 (fade out)
analogWrite(LED, i); // set the LED brightness

delay(10); // Wait 10ms
}
}
Agora você tem uma característica replicada uma fantasia de um computador portátil (talvez
um pouco de um desperdício usar o Arduíno para algo tão simples). Vamos usar os
conhecimentos para melhorar a nossa luz.
Adicione ao circuito que foi utilizado para ler um botão (voltar no Capítulo 4) para este
breadboard. Veja se você pode fazer isso sem olhar para a próxima página, porque eu quero
que você começar a pensar no fato de que cada circuito elementar que eu mostro aqui é um
bloco de construção para fazer projetos cada vez maiores. Se você precisa de espreitar o
futuro, não se preocupe, a coisa mais importante é que você gasta algum tempo pensando
sobre como poderia parecer.
Para criar esse circuito, você terá que combinar o circuito que você acabou de construir
(mostrado na Figura 5-4) com o circuito de botão mostrado na Figura 4-6. Se você quiser,
você pode simplesmente construir ambos os circuitos em diferentes partes da breadboard,
você tem espaço de sobra. No entanto, uma das vantagens da breadboard (ver Anexo A) é
que há um par de carris horizontalmente na parte inferior e superior. Um deles é de cor
vermelha (para o positivo) e outra azul ou preta (por terra).
Esses trilhos são usados para distribuir energia e terra de onde ela é necessária. No caso do
circuito que você precisa para construir esse exemplo, você tem dois componentes (ambos
resistores) que precisa ser conectado ao GND (terra) pino do Arduíno. Porque o Arduíno tem
dois pinos GND, você pode simplesmente ligar estes dois circuitos exatamente como
mostrado em cada uma das duas figuras, basta ligar os dois até o Arduíno, ao mesmo
tempo. Ou, você pode ligar um fio de ferro da breadboard do terreno para um dos pinos
GND no Arduíno, e então tomar os fios que estão ligados ao GND nos valores e conectá-los
ao invés do ferroviário chão breadboard.
Se você não está pronto para tentar isso, não se preocupe: basta fio até ambos os circuitos
para o Arduíno, como mostrado nas figuras Figura 4-6 e Figura 5-4. Você verá um exemplo
que usa o solo e os trilhos breadboard positivo no capítulo 6.
Voltando para o próximo exemplo, se temos apenas um botão, como é que vamos controlar
o brilho de uma lâmpada? Estamos indo para aprender ainda uma outra técnica de design
de interação: detectando quanto tempo um botão foi pressionado. Para fazer isso, eu preciso
atualizar Exemplo 4-5 do capítulo 4 para adicionar escurecimento. A idéia é construir uma
"interface" no qual um release de imprenssão e ação acende a luz e desligar, e pressione e
segure o brilho mudanças ação.
Vamos dar uma olhada no esboço:
Exemplo 5-2. Ligue o LED quando o botão for pressionado e mantê-lo depois de seu
lançamento, incluindo simples de salto. Se o botão for mantido mudar o brilho.

#define BUTTON 7 // input pin of the pushbutton
int val = 0; // stores the state of the input pin
int old_val = 0; // stores the previous value of "val"

int state = 0; // 0 = LED off while 1 = LED on
int brightness = 128; // Stores the brightness value

unsigned long startTime = 0; // when did we begin pressing?
void setup() {
}
void loop() {

// yum, fresh
// check if there was a transition
if ((val == HIGH) && (old_val == LOW)) {
state = 1 - state; // change the state from off to on

// or vice-versa
startTime = millis(); // millis() is the Arduíno clock

// it returns how many milliseconds
// have passed since the board has
// been reset.
// (this line remembers when the button

// was last pressed)
delay(10);
}
// check whether the button is being held down
if ((val == HIGH) && (old_val == HIGH)) {
// If the button is held for more than 500ms.

if (state == 1 && (millis() - startTime) > 500) {
brightness++; // increment brightness by 1

delay(10); // delay to avoid brightness going
// up too fast
if (brightness > 255) { // 255 is the max brightness
brightness = 0; // if we go over 255

// let's go back to 0
}
}
}
old_val = val; // val is now old, let's store it

if (state == 1) {
analogWrite(LED, brightness); // turn LED ON at the
// current brightness level
} else {
analogWrite(LED, 0); // turn LED OFF
}
}
Agora, experimentá-lo. Como você pode ver, o nosso modelo de interação está tomando
forma. Se você pressionar o botão e soltá-lo imediatamente, você deixa a lâmpada ligada ou
desligada. Se você mantenha o botão pressionado, as mudanças de brilho, basta deixar ir
quando tiver atingido o brilho desejado.
5.3. Use um sensor de luz em vez do Teclado

Agora vamos tentar um experimento interessante. Tome um sensor de luz, como o retratado
na Figura 5-5. Você pode obter um pacote com cinco destes da RadioShack (Número da
peça 276-1657).
Figura 5-5. resistor dependente da luz (LDR)
Na escuridão, a resistência de um resistor dependente da luz (LDR) é bastante elevada.

Quando você brilhar alguma luz para ele, a resistência cai rapidamente e torna-se um
condutor de eletricidade razoavelmente bom. É assim uma espécie de interruptor de luz-
ativado.
Construa o circuito que acompanha Exemplo 4-2 (consulte "Usando um botão para controlar
o LED" no Capítulo 4), em seguida, enviar o código do Exemplo 4-2 para o Arduíno.
Agora ligue o LDR para a breadboard em vez do botão. Você vai notar que se você cobrir o
LDR com as mãos, o LED apaga-se. Descubra a LDR, ea luz passa. Você apenas construiu
o seu primeiro verdadeiro sensor LED-driven. Isto é importante porque pela primeira vez
neste livro, nós estamos usando um componente eletrônico que não é um dispositivo
mecânico simples: é um sensor rico real.
5.4. Entrada analógica
Como você aprendeu na seção anterior, Arduíno é capaz de detectar a existência de uma
tensão aplicada a um dos seus pinos e relatá-lo através do digitalRead () função. Este tipo
de ou / ou resposta é muito bem em muitas aplicações, mas o sensor de luz que usamos só
é capaz de dizer-nos não apenas se há luz, mas também a quantidade de luz que existe.
Esta é a diferença entre uma on / off sensor (que nos diz que se algo está lá) e um sensor
analógico, cujo valor muda continuamente. Para ler este tipo de sensor, precisamos de um
tipo diferente de pinos.
Na parte inferior direita da placa Arduíno, você verá seis pinos marcados "Analog In", que
são os pinos especiais que podem dizer-nos não só a existência de uma voltagem aplicada
a eles, mas se assim for, também o seu valor. Ao utilizar o analogRead () função, podemos
ler a tensão aplicada a um dos pinos. Essa função retorna um número entre 0 e 1023, o que
representa tensões entre 0 e 5 volts. Por exemplo, se há uma tensão de 2,5 V aplicada ao
pino número 0, analogRead (0) retorna 512.
Se você agora construir o circuito que você vê na figura 5-6, com um resistor de 10k, e
executar o código listado no Exemplo 5-3, você verá a bordo LED (você pode também inserir
o seu próprio LED nos pinos 13 e GND, conforme mostrado em "Piscando um LED" no
Capítulo 4) a piscar a uma taxa que é dependente da quantidade de luz que atinge o sensor.
Figura 5-6. Um circuito sensor analógico
Exemplo 5-3. Blink LED a uma taxa especificada pelo valor da entrada analógica
int val = 0; // variable used to store the value

// coming from the sensor
void setup() {
pinMode(LED, OUTPUT); // LED is as an OUTPUT
// Note: Analogue pins are

// automatically set as inputs
}
void loop() {
val = analogRead(0); // read the value from

// the sensor
digitalWrite(13, HIGH); // turn the LED on
delay(val); // stop the program for

// some time
digitalWrite(13, LOW); // turn the LED off
delay(val); // stop the program for

// some time
}
Agora, tente Exemplo 5-4, mas antes que você faça, você precisa modificar seu circuito. Dê
uma olhada na Figura 5-4 e gancho novamente até que o LED de 9 pinos, como mostrado.
Como você já tem algum material sobre a breadboard, você precisa encontrar um lugar na
breadboard onde o LED, fios e resistores não coincidir com o circuito de LDR.
Exemplo 5-4. Ajuste o brilho do LED com um brilho determinado pelo valor da entrada
analógica
int val = 0; // variable used to store the value

// coming from the sensor
void setup() {
pinMode(LED, OUTPUT); // LED is as an OUTPUT
// Note: Analogue pins are

// automatically set as inputs
}
void loop() {
val = analogRead(0); // read the value from

// the sensor
analogWrite(LED, val/4); // turn the LED on at
// the brightness set
// by the sensor
delay(10); // stop the program for

// some time
}
Nota: especificar o brilho que dividindo por 4 val, porque analogRead () retorna um número
até 1023, e analogWrite () aceita um máximo de 255.
5.5. Outros sensores analógicos
Utilizando o mesmo circuito que você viu na seção anterior, você pode ligar um monte de
outros sensores resistivos que trabalham em mais ou menos da mesma maneira. Por
exemplo, você poderia conectar um termistor, que é um simples dispositivo cuja resistência
varia com a temperatura. No circuito, eu mostrei-lhe como mudanças na resistência tornar-
se mudanças na tensão que pode ser medido pelo Arduíno.
Se você trabalha com um termistor, estar ciente de que não há uma conexão direta entre o
valor que você ler e medir a temperatura real. Se você precisar de uma leitura exata, você
deve ler os números que saem do pino análogo ao medir com um termômetro real. Você
pode colocar estes números lado a lado em uma mesa e encontrar uma forma de calibrar os
resultados análogos para as temperaturas do mundo real.
Até agora, temos apenas um LED usado como um dispositivo de saída, mas como podemos
ler os valores reais que Arduíno é a leitura do sensor? Nós não podemos fazer a placa de
piscar os valores em código Morse (bem, nós poderíamos, mas há uma maneira mais fácil
para os seres humanos para ler os valores). Para isso, podemos ter Arduíno falar para um
computador através de uma porta serial, que é descrito na próxima seção.
5.6. Comunicação Serial
Você aprendeu no início deste livro que Arduíno tem uma conexão USB que é utilizado pelo
IDE para carregar código para o processador. A boa notícia é que essa conexão também
pode ser usado pelos esboços que para escrever ao Arduíno para enviar dados de volta
para o computador ou para receber comandos a partir dele. Para este efeito, vamos usar um
objeto de série (um objeto é uma coleção de recursos que são agrupadas para a
conveniência de pessoas a escrever esboços).
Este objeto contém todos os códigos que nós precisamos para enviar e receber dados.
Agora vamos usar o último circuito que construímos com o photoresistor e enviar os valores
que são lidos para o computador. Digite este código em um novo desenho (você pode
também baixar o código de www.makezine.com / getstartedArduíno):
Exemplo 5-5. Enviar para o computador os valores lidos da entrada analógica 0 Certifique-se
de clicar em "Serial Monitor" depois que você enviar
#define SENSOR 0 // select the input pin for the

// sensor resistor
int val = 0; // variable to store the value coming

// from the sensor
void setup() {
Serial.begin(9600); // open the serial port to send

// data back to the computer at
// 9600 bits per second
}
void loop() {
val = analogRead(SENSOR); // read the value from

// the sensor
Serial.println(val); // print the value to

// the serial port
delay(100); // wait 100ms between

// each send
}
Depois que você enviou o código para o seu Arduíno, pressione o “Monitor Serial" botão no
IDE Arduíno (o botão mais à direita na barra de ferramentas), você vai ver os números de
rolamento passado na parte inferior da janela. Agora, qualquer software que possa ler a
partir da porta serial pode falar com Arduíno. Existem muitas linguagens de programação
que permitem escrever programas em seu computador que pode conversar com a porta
serial. Processing (www.processing.org) é um ótimo complemento para Arduíno, porque as
linguagens e IDEs são tão semelhantes.
5.7. Condução cargas maiores (Motors, lâmpadas, etc)
Cada um dos pinos em uma placa Arduíno pode ser usado para dispositivos de energia que
utilizam até 20 miliamperes: esta é uma pequena quantidade de corrente, apenas o
suficiente para conduzir um LED. Se você tentar algo como uma unidade de motor, o pino irá
imediatamente parar de trabalhar, e poderia queimar o processador todo. Para acionar
cargas maiores, como motores ou lâmpadas incandescentes, precisamos usar um
componente externo que pode mudar essas coisas dentro e fora e isso é impulsionado por
um pino do Arduíno. Um tal dispositivo é chamado de transistor MOSFET-ignore o
engraçado nome é um interruptor eletrônico que pode ser acionado pela aplicação de uma
tensão a um dos seus três pinos, cada um dos quais é chamado de portão. É algo como o
interruptor de luz que usamos em casa, onde a ação de um dedo acender a luz e desligar é
substituído por um pino na placa Arduíno enviando tensão para a porta do MOSFET.
Nota: MOSFET significa "metal-oxide semiconductor-transistores de efeito de campo". É um

tipo especial de transistor que opera com base no princípio de efeito de campo. Tal significa
que a energia fluir através de uma peça de material semicondutor (entre o dreno ea fonte de
pinos), quando uma voltagem é aplicada ao pino Gate. Como a porta é isolada do resto
através de uma camada de óxido de metal, não há fluxo de corrente do Arduíno no
MOSFET, o que torna muito simples a interface. Eles são ideais para ligar e desligar cargas
grandes em altas freqüências.
Na Figura 5-7, você pode ver como você deve usar um MOSFET como o IRF520 para ligar e
desligar um pequeno motor acoplado a um ventilador. Você também vai notar que o motor
tem sua fonte de alimentação do conector de 9 V na placa Arduíno. Este é outro benefício do
MOSFET: permite-nos dirigir dispositivos cuja alimentação difere da utilizada pelo Arduíno.
Como o MOSFET está conectada ao pino 9, também podemos usar analogWrite () para
controlar a velocidade do motor através de PWM.
5.8. Sensores Complexos
Nós definimos sensores complexos como aqueles que produzem um tipo de informação que
requer um pouco mais de um digitalRead () ou um analogRead () para ser usado. Estes
circuitos são geralmente de pequeno porte com um microcontrolador pequeno dentro que
pré-processando as informações.
Alguns dos sensores complexos disponíveis incluem ultra-rangers, rangers infravermelho, e
acelerômetro. Você pode encontrar exemplos de como usá-los em nosso site na seção
"Tutoriais" seção (www.Arduíno.cc / pt / Tutorial / homepage).
Fazendo Tom Igoe falar de coisas (O'Reilly) tem uma extensa cobertura destes sensores e
muitos outros sensores complexos.
Figura 5-7. Um circuito de motor para Arduíno
Safari Books Open Source Métodos C Microprocessadores Safari Books Engenharia de Software
Programação Hardware Massimo Banzi O'Reilly Media, Inc. Faça Introdução ao Arduíno, 1 ª Edição
Capítulo 6. Conversando com o Cloud
Nos capítulos anteriores, você aprendeu os fundamentos do Arduíno e os blocos de

construção fundamentais à sua disposição. Deixe-me lembrá-lo que compõe o "Arduíno
Alphabet":
6.1. Saída Digital

6.1.1. Saída Digital
Foi utilizado para controlar um LED, mas, com o circuito adequado, ele pode ser usado para
controle de motores, fazer sons, e muito mais.
6.1.2. Saída Analógica

Isso nos dá a capacidade de controlar a luminosidade do LED, não apenas por sua vez é
ligado ou desligado. Podemos até mesmo controlar a velocidade de um motor com ele.
6.1.3. Entrada Digital

Isto permite-nos ler o estado de sensores simples, como botões ou interruptores de
inclinação.
6.1.4. Entrada Analógica

Podemos ler os sinais dos sensores que emitem um sinal contínuo, que não é apenas ligado
ou desligado, como um potenciômetro ou um sensor de luz.
6.1.5. Comunicação Serial

Isso nos permite comunicar com um computador e trocar dados ou simplesmente
acompanhar o que está acontecendo com o desenho que está sendo executado no Arduíno.
Neste capítulo, vamos ver como montar uma aplicação de trabalho com o que você
aprendeu nos capítulos anteriores. Este capítulo deve mostrar como cada único exemplo
pode ser usado como um bloco de construção de um projeto complexo.
Aqui é onde o designer wannabe em mim sai. Estamos indo para fazer a versão vigésimo
primeiro século de uma lâmpada clássico pelo meu designer italiano favorito, Joe Colombo.
O objeto que vamos construir é inspirado por uma lâmpada chamada "Aton" a partir de 1964.
Fig. 6.1 A lâmpada acabado
A luz, que você pode ver na Figura 6-1, é uma esfera simples, sentadas em uma base com
um grande buraco para manter a esfera de rolar para fora de sua mesa. Este design permite
orientar a luz em diferentes direções.
Em termos de funcionalidade, nós queremos construir um dispositivo que se conectar à

Internet, buscar a atual lista de artigos sobre a Marca blog (blog.makezine.com) e contar
quantas vezes as palavras "paz", "amor", e "Arduíno" são mencionados. Com esses valores,
vamos gerar uma cor e exibi-lo na lâmpada. A lâmpada em si tem um botão que podemos
usar para ligar e desligar, e um sensor de luz para ativação automática.
6.2. Planejamento
Vejamos o que queremos atingir e que pedaços de que precisamos. Primeiro de tudo,
precisamos Arduíno para ser capaz de se conectar à Internet. Como a placa Arduíno tem
apenas uma porta USB, não pode conectá-lo diretamente em uma conexão com a Internet,
então precisamos descobrir como a ponte entre as duas. Normalmente o que as pessoas
fazem é executar um aplicativo em um computador que irá se conectar à Internet, processar
os dados e enviar Arduíno alguns bits de informações simples destilada.
Arduíno é um computador simples com uma pequena memória, não pode processar
arquivos grandes com facilidade, e quando ligamos para um feed RSS chegaremos muito
detalhado arquivo XML que exigiria muito mais RAM. Nós vamos implementar um proxy para
simplificar o XML usando a linguagem Processing.
Processamento
O processamento é Arduíno onde veio. Nós amamos essa linguagem e usá-lo para ensinar
programação para iniciantes, bem como a construção de código bonito. Processing e
Arduíno são a combinação perfeita. Outra vantagem é que o processamento é de código
aberto e funciona em todas as principais plataformas (Mac, Linux e Windows). Ele também
pode gerar aplicações standalone, que funcionam nessas plataformas. Além do mais, a
comunidade de processamento é animada e prestativa, e você pode encontrar milhares de
programas de exemplo do premade.
O proxy funciona o seguinte para nós: ele faz o download do feed RSS do makezine.com e
extratos de todas as palavras do arquivo XML resultante. Em seguida, passando por todas
elas, ele conta o número de vezes que a "paz", "amor" e "Arduíno" aparecem no texto. Com
esses três números, vamos calcular um valor de cor e enviá-lo a Arduíno. O conselho vai
devolver a quantidade de luz medida pelo sensor e mostrá-la na tela do computador.
Do lado do hardware, vamos combinar o exemplo de botão, a exemplo do sensor de

luminosidade, o PWM controle de LED (multiplicado por 3!) E comunicação serial.
Como Arduíno é um dispositivo simples, vamos necessidade de codificar a cor de uma forma
simples. Vamos usar a forma padrão que as cores são representadas em HTML: # seguido
de seis dígitos hexadecimais.
Números hexadecimais são úteis, porque cada número de 8 bits é armazenada em

exatamente dois caracteres, com números decimais, isso varia de um a três caracteres. A
previsibilidade também torna o código mais simples: vamos esperar até vermos um #, então
lemos os seis caracteres que seguem em um buffer (uma variável usada como uma área de
armazenagem temporária de dados). Finalmente, voltemo-nos cada grupo de dois
caracteres em um byte que representa o brilho de um dos três LEDs.
6.3. Codificação
Existem dois desenhos que você vai ser executado: um esboço de processamento, e um
esboço Arduíno. Aqui está o código para o esboço de processamento. Você pode baixá-lo
www.makezine.com / getstartedArduíno.
Exemplo 6-1. peças da lâmpada Arduíno rede do código é inspirada por um post de blog por
Tod E. Kurt (todbot.com)
Import processing.serial.*;
String feed = "http://blog.makezine.com/index.xml";
int interval = 10; // retrieve feed every 60 seconds;

int lastTime; // the last time we fetched the content
int love = 0;
int peace = 0;
int Arduíno = 0;
int light = 0; // light level measured by the lamp
Serial port;
color c;
String cs;
String buffer = ""; // Accumulates characters coming from Arduíno
PFont font;
void setup() {
size(640,480);
frameRate(10); // we don't need fast updates
font = loadFont("HelveticaNeue-Bold-32.vlw");
fill(255);
textFont(font, 32);
// IMPORTANT NOTE:
// The first serial port retrieved by Serial.list()
// should be your Arduíno. If not, uncomment the next
// line by deleting the // before it, and re-run the
// sketch to see a list of serial ports. Then, change
// the 0 in between [ and ] to the number of the port
// that your Arduíno is connected to.
//println(Serial.list());
String ArduínoPort = Serial.list()[0];
port = new Serial(this, ArduínoPort, 9600); // connect to Arduíno
lastTime = 0;
fetchData();
}
void draw() {
background( c );
int n = (interval - ((millis()-lastTime)/1000));
// Build a colour based on the 3 values

c = color(peace, love, Arduíno);
cs = "#" + hex(c,6); // Prepare a string to be sent to Arduíno
text("Arduíno Networked Lamp", 10,40);

text("Reading feed:", 10, 100);
text(feed, 10, 140);
text("Next update in "+ n + " seconds",10,450);

text("peace" ,10,200);
text(" " + peace, 130, 200);
rect(200,172, peace, 28);
text("love ",10,240);
text(" " + love, 130, 240);
rect(200,212, love, 28);
text("Arduíno ",10,280);
text(" " + Arduíno, 130, 280);
rect(200,252, Arduíno, 28);
// write the colour string to the screen

text("sending", 10, 340);
text(cs, 200,340);
text("light level", 10, 380);
rect(200, 352,light/10.23,28); // this turns 1023 into 100
if (n <= 0) {
fetchData();
lastTime = millis();
}
port.write(cs); // send data to Arduíno
if (port.available() > 0) { // check if there is data waiting

int inByte = port.read(); // read one byte
if (inByte != 10) { // if byte is not newline
buffer = buffer + char(inByte); // just add it to the buffer
}
else {
// newline reached, let's process the data

if (buffer.length() > 1) { // make sure there is enough data
// chop off the last character, it's a carriage return

// (a carriage return is the character at the end of a
// line of text)
buffer = buffer.substring(0,buffer.length() -1);
// turn the buffer from string into an integer number

light = int(buffer);
// clean the buffer for the next read cycle

buffer = "";
// We're likely falling behind in taking readings

// from Arduíno. So let's clear the backlog of
// incoming sensor readings so the next reading is
// up-to-date.
port.clear();
}
}
}
}
void fetchData() {
// we use these strings to parse the feed
String data;
String chunk;
// zero the counters

love = 0;
peace = 0;
Arduíno = 0;
try {
URL url = new URL(feed); // An object to represent the URL
// prepare a connection
URLConnection conn = url.openConnection();
conn.connect(); // now connect to the Website
// this is a bit of virtual plumbing as we connect

// the data coming from the connection to a buffered
// reader that reads the data one line at a time.
BufferedReader in = new
BufferedReader(new InputStreamReader(conn.getInputStream()));
// read each line from the feed

while ((data = in.readLine()) != null) {
StringTokenizer st =
new StringTokenizer(data,"\"<>,.()[] ");// break it down
while (st.hasMoreTokens()) {
// each chunk of data is made lowercase
chunk= st.nextToken().toLowerCase() ;
if (chunk.indexOf("love") >= 0 ) // found "love"?

love++; // increment love by 1
if (chunk.indexOf("peace") >= 0) // found "peace"?
peace++; // increment peace by 1
if (chunk.indexOf("Arduíno") >= 0) // found "Arduíno"?
Arduíno++; // increment Arduíno by 1
}
}
// Set 64 to be the maximum number of references we care about.

if (peace > 64) peace = 64;
if (love > 64) love = 64;
if (Arduíno > 64) Arduíno = 64;
peace = peace * 4; // multiply by 4 so that the max is 255,
love = love * 4; // which comes in handy when building a
Arduíno = Arduíno * 4; // colour that is made of 4 bytes (ARGB)
}
catch (Exception ex) { // If there was an error, stop the sketch
ex.printStackTrace();
System.out.println("ERROR: "+ex.getMessage());
}
}
Há duas coisas que você precisa fazer antes que o esboço de processamento será
executado corretamente. Primeiro, você precisa dizer ao processamento para gerar o tipo de
letra que estamos usando para o esboço. Para fazer isso, criar e salvar o desenho. Então,
com o desenho ainda em aberto, clique no menu Ferramentas de Processamento, selecione
Criar fonte. Selecione o tipo de letra chamado HelveticaNeue-Bold, escolher 32 para o
tamanho da fonte e, em seguida, clique em OK.
Segundo, você terá de confirmar que o desenho está usando a porta serial correta para falar
com Arduíno. Você precisa esperar até que você tenha montado o circuito Arduíno e enviou
o esboço Arduíno antes que você possa confirmar isto. Na maioria dos sistemas, este
esboço de processamento irá correr bem. No entanto, se você não vê nada acontecendo no
Arduíno e você não vê qualquer informação do sensor de luz que aparece na tela, localize o
comentário rotulado "NOTA IMPORTANTE" no esquema de processamento e siga as
instruções.
Aqui está o esboço Arduíno (também disponível em www.makezine.com /

getstartedArduíno):
Exemplo 6-2. Arduíno Lâmpada Networked
#define SENSOR 0
#define R_LED 9
#define G_LED 10
#define B_LED 11
#define BUTTON 12
int val = 0; // variable to store the value coming from the sensor
int btn = LOW;

int old_btn = LOW;
int state = 0;
char buffer[7] ;
int pointer = 0;
byte inByte = 0;
byte r = 0;
byte g = 0;
byte b = 0;
void setup() {
Serial.begin(9600); // open the serial port
pinMode(BUTTON, INPUT);
}
void loop() {
val = analogRead(SENSOR); // read the value from the sensor
Serial.println(val); // print the value to
// the serial port
if (Serial.available() >0) {
// read the incoming byte:

inByte = Serial.read();
// If the marker's found, next 6 characters are the colour

if (inByte == '#') {
while (pointer < 6) { // accumulate 6 chars

buffer[pointer] = Serial.read(); // store in the buffer
pointer++; // move the pointer forward by 1
}
// now we have the 3 numbers stored as hex numbers
// we need to decode them into 3 bytes r, g and b
r = hex2dec(buffer[1]) + hex2dec(buffer[0]) * 16;
g = hex2dec(buffer[3]) + hex2dec(buffer[2]) * 16;
b = hex2dec(buffer[5]) + hex2dec(buffer[4]) * 16;
pointer = 0; // reset the pointer so we can reuse the buffer
}
}
btn = digitalRead(BUTTON); // read input value and store it
// Check if there was a transition

if ((btn == HIGH) && (old_btn == LOW)){
state = 1 - state;
}
old_btn = btn; // val is now old, let's store it
if (state == 1) { // if the lamp is on
analogWrite(R_LED, r); // turn the leds on

analogWrite(G_LED, g); // at the colour
analogWrite(B_LED, b); // sent by the computer
} else {
analogWrite(R_LED, 0); // otherwise turn off

analogWrite(G_LED, 0);
analogWrite(B_LED, 0);
}
delay(100); // wait 100ms between each send

}
int hex2dec(byte c) { // converts one HEX character into a number

if (c >= '0' && c <= '9') {
return c - '0';
} else if (c >= 'A' && c <= 'F') {
return c - 'A' + 10;
}
}
6.4. Montagem do Circuito

Figura 6-2 mostra como montar o circuito. Você precisa usar resistores de 10K para todos os
resistores mostrada no diagrama, embora você poderia começar afastado com menores
valores para os resistores conectados à LEDs.
Lembre-se do exemplo PWM no capítulo 5 que os LEDs são polarizados: neste circuito, o
pino longo (positivo) deve ir para a direita, eo pino curto (negativo) para a esquerda. (A
maioria dos LEDs têm um lado negativo achatada, como mostrado na figura.)
Figura 6-2. O "Arduíno Networked Lamp" circuito

Construa o circuito, conforme mostrado, usando um vermelho, um verde e um LED azul. Em
seguida, carregar os esboços em Arduíno e Processing, em seguida, executar os esboços e
experimentá-lo. Se você tiver problemas, consulte o Capítulo 7, "Solução de problemas".
Agora, vamos concluir a construção, colocando a tábua de pão em uma esfera de vidro. O
mais simples e mais barata forma de fazer isso é comprar um IKEA "FADO candeeiro de
mesa". Agora, é vendido por cerca de E.U. $ 14,99 / € 14,99 / £ 8,99 (ahh, o luxo de ser
europeu).
Em vez de usar três LEDs separado, você pode usar um único LED RGB, que tem quatro
leva saindo dela. Você vai ligar-lo em muito da mesma forma que os LEDs mostrado na
Figura 6-2, com uma mudança: em vez de três ligações separadas para o pino terra em
Arduíno, você vai ter uma ligação única (chamado de "catodo comum"), indo ao chão.
SparkFun vende RGB 4-LED para levar alguns dólares (www.sparkfun.com; Número da
peça 00105-COM). Além disso, ao contrário de LEDs discreta cor única, a maior liderança
nesta LED RGB é aquele que vai ao chão. Os três menores leva precisará se conectar a
Arduíno pinos 9, 10 e 11 (com um resistor entre os terminais e os pinos, assim como com o
vermelho em separado, verde, azul e LEDs).
6.5. Veja como montá-lo:

Descompacte a lâmpada e remova o cabo que vai para a luz do fundo. Você não será mais
conectando-a à parede.
Strap o Arduíno em uma breadboard e cola quente a breadboard para a volta da lâmpada.
Solde os fios mais longos para o LED RGB e cola-lo onde a lâmpada costumava ser. Ligar
os fios provenientes do LED à breadboard (onde foi conectado antes de sua remoção).
Lembre-se que você só precisa de uma ligação à terra, se você estiver usando uma ligação
RGB de 4 LED.
Quer encontrar um bom pedaço de madeira com um buraco que pode ser usado como um
substituto para a área ou apenas cortar a parte superior da caixa de papelão que veio com a
luz em cerca de 5cm (ou 2 ") e fazer um buraco com diâmetro berços da lâmpada. Reforçar
o interior da caixa de papelão usando cola quente todos ao longo das bordas para dentro, o
que tornará a base mais estável.
Coloque a esfera na posição e colocar o cabo USB fora do top e conectá-lo ao computador.
Incêndio fora de seu código de processamento, pressione o botão liga / desliga, e vê a luz vir
à vida. Como um exercício, tente adicionar o código que vai acender a lâmpada quando a
sala escurece. Outros aperfeiçoamentos possíveis são:
1. Adicionar sensores de inclinação para ativar a luz ligada ou desligada, girando em

direções diferentes.
2. Adicionar um PIR pequeno sensor para detectar quando alguém está ao redor e desligá-lo
quando ninguém está lá para assistir.
3. Crie diferentes modos para que você possa obter o controle manual da cor ou fazê-lo
desaparecer por muitas cores.
4. Pense em coisas diferentes, experimentar e se divertir!
Capítulo 7. Solução de problemas
Chegará um momento em sua experimentação, quando nada vai estar a funcionar e você
terá que descobrir como corrigi-lo. Solução de problemas e depuração são artes antigas que
existem algumas regras simples, mas a maioria dos resultados são obtidos por meio de um
monte de trabalho.
Quanto mais você trabalha com eletrônica e Arduíno, mais você vai aprender e ganhar
experiência, o que acabará por tornar o processo menos doloroso. Não desanime com os
problemas que você vai encontrar, é tudo mais fácil do que parece no início.
Como todo projeto Arduíno é feita com base tanto de hardware e software, haverá mais de
um lugar para olhar, se algo der errado. Embora a procura de um bug, você deve operar em
três linhas:
7.1. Compreensão
7.1.1. Compreensão
Tente entender o máximo possível como as peças que você está utilizando o trabalho e
como eles estão supostamente contribuir para o projeto acabado. Esta abordagem permitirá
definir uma maneira de testar cada componente separadamente.
7.1.2. Simplificação e segmentação

Os antigos romanos costumavam dizer divide et impera: dividir para reinar. Tente quebrar
(mentalmente) o projeto em seus componentes, usando o conhecimento que você tem e
descobrir onde a responsabilidade de cada componente começa e termina.
7.1.3. Exclusão e da segurança
Ao investigar, testar cada componente separadamente, de modo que você pode estar
absolutamente certos de que cada um trabalha por si só. Você irá gradualmente aumentar a
confiança sobre quais partes do projeto estão fazendo seu trabalho e que são duvidosas.
A depuração é o termo usado para descrever este processo aplicado ao software. A lenda
diz que foi usado pela primeira vez por Grace Hopper na década de 1940, quando os
computadores onde a maioria eletromecânica, e um deles parou de funcionar porque os
insetos reais pego nos mecanismos.
Muitos dos erros de hoje não são mais físicos: eles estão virtual e invisível, ao menos em
parte. Por isso, eles exigem um processo por vezes moroso e chato de ser identificado.
7.2. Testando a Câmara

E se o primeiro exemplo, "piscar um LED," não funcionou? Não que fosse um pouco
deprimente? Vamos descobrir o que fazer.
Antes de começar a culpar o seu projeto, você deve se certificar de que algumas coisas
estão em ordem, como pilotos de avião fazem quando passam por uma lista de verificação
para se certificar de que o avião estará voando adequadamente antes da decolagem:
Conecte seu Arduíno em um plug USB no seu computador.
Verifique se o computador está ligado (sim, isso soa bobo, mas isso já aconteceu). Se a luz
verde acende marcado PWR, isso significa que o computador está alimentando a placa. Se
o LED parece muito fraco, algo está errado com o poder: experimente um cabo USB
diferente e inspecione a porta USB do computador e conecte o Arduíno USB para ver se há
algum dano. Se tudo isso falhar, tente outra porta USB no seu computador ou um
computador completamente diferente.
L Se o Arduíno é novo, o LED amarelo marcado irá piscar com um pouco de um padrão de
nervoso, este é o programa de teste que foi carregado na fábrica para testar a placa.
Se você estiver usando uma fonte de alimentação externa e está usando um Arduíno idade
(Extreme, NG, ou Diecimila), certifique-se que a alimentação está conectado e que o jumper
marcado SV1 está conectando os dois pinos que estão mais próximas ao exterior conector
de alimentação.
Nota: Quando você está tendo problemas com outros desenhos e precisa confirmar que a
placa está funcionando, abra o primeiro "piscar um exemplo" LED no IDE Arduíno e enviá-lo
ao conselho. A bordo LED deve piscar em um padrão regular.
Se você passou por todas essas etapas com sucesso, então você pode ter certeza que seu
Arduíno está funcionando corretamente.
7.3. Testando o Circuito breadboarded
Agora ligue a bordo de seu breadboard pela execução de uma ponte a partir do V 5 e GND
para os trilhos positivos e negativos da breadboard. Se o verde PWR LED, retire os fios de
imediato. Isto significa que há um grande erro no seu circuito e você tem um curto circuito
em algum lugar. Quando isso acontece, o conselho chama muita corrente eo poder é
cortada para proteger o computador.
Nota: Se você é uma questão que pode danificar seu computador, lembre-se que em muitos
computadores, a corrente de proteção é geralmente muito bom, e responde rapidamente.
Além disso, a placa Arduíno é equipado com um PolyFuse ", um dispositivo de protecção de
corrente que redefine a si mesmo quando a culpa é removed.If você é realmente paranóico,
você pode conectar a placa Arduíno através de um hub USB auto-alimentado. Neste caso,
se tudo corre terrivelmente mal, o hub USB é a única que estará empurrando para cima as
margaridas, não o seu computador.
Se você está recebendo um curto-circuito, você tem que começar a "simplificação e
segmentação" do processo. O que você precisa fazer é passar por cada sensor no projeto e
conectar apenas um de cada vez.
A primeira coisa a partir é sempre a fonte de alimentação (as conexões a partir de 5 V e

GND). Olhe ao redor e se certificar de que cada parte do circuito é alimentado corretamente.
Trabalho passo a passo e fazer uma única modificação em um momento é a regra número
um para a fixação material. Esta regra foi martelado na minha cabeça jovem, meu professor
da escola e primeira entidade patronal, Maurizio Pirola. Toda vez que estou a depuração
algo e as coisas não olham boas (e acredite, isso acontece muito), seu rosto aparece na
minha cabeça dizendo "uma modificação de uma vez ... uma modificação em um momento"
e que geralmente é quando eu consertar tudo. Isto é muito importante, porque você vai
saber o que resolveu o problema (é muito fácil perder de vista que essas modificações
realmente resolveu o problema, razão pela qual é tão importante fazer um de cada vez).
Cada experiência de depuração vai construir em sua cabeça uma base de conhecimento
"dos defeitos e possíveis correções. E antes que você perceba, você vai se tornar um
especialista. Isso fará com que você olha muito legal, porque assim como um newbie diz:
"Isso não funciona!" você vai dar-lhe um olhar rápido e ter a resposta em uma fração de
segundo.
7.4. Isolamento de problemas

Outra regra importante é encontrar uma maneira confiável para reproduzir um problema. Se
o seu circuito se comporta de uma maneira engraçada, às vezes aleatório, tente realmente
difícil descobrir o momento exato o problema ocorre e que está causando isso. Este
processo permitirá que você pensa sobre uma possível causa. Também é muito útil quando
você precisa explicar para alguém o que está acontecendo.
Descrevendo o problema de forma tão precisa quanto possível, é também uma boa maneira
de encontrar uma solução. Tente encontrar alguém para explicar o problema, em muitos
casos, uma solução irá aparecer em sua cabeça como se articulam o problema. Brian W.
Kernighan e Rob Pike, em The Practice of Programming (Addison-Wesley, 1999), contam a
história de um universitário que "manteve um ursinho de pelúcia junto ao help desk. Alunos
com bugs misteriosos foram obrigados a explicar-lhes o urso antes que eles pudessem falar
com um conselheiro do Homem. "
7.5. Problemas com o IDE

Em alguns casos, você pode ter um problema usando a IDE Arduíno, particularmente no
Windows.
Se você receber uma mensagem de erro quando você clique duplo no ícone do Arduíno, ou
se nada acontecer, tente um clique duplo no arquivo run.bat como um método alternativo de
lançar Arduíno.
Os usuários do Windows também pode executar em um problema se o sistema operativo

atribui um número de porta COM de COM10 ou superior a Arduíno. Se isso acontecer, você
geralmente pode convencer Windows para atribuir um menor número de porta a Arduíno.
Primeiro, abra o Gerenciador de Dispositivos clicando no menu Iniciar, botão direito do
mouse em Computador (Vista) ou o meu computador (XP) e escolha Propriedades. No
Windows XP, clique em Hardware e escolha Gerenciador de dispositivos. No Vista, clique
em Device Manager (ele aparece na lista de tarefas no lado esquerdo da janela).
Procure os dispositivos de série na lista do "Portas (COM & LPT)". Procurar um dispositivo
de série que você não está usando que é numerado COM9 ou inferior. Botão direito do
mouse e escolha Propriedades no menu. Em seguida, escolha a porta na guia
Configurações e clique em Avançado. Definir o número da porta COM COM10 ou superior,
clique em OK e clique em OK novamente para fechar a caixa de diálogo Propriedades.
Agora, faça o mesmo com o dispositivo da porta USB de série que representa Arduíno, com
uma mudança: atribuir o número da porta COM (COM9 ou inferior) que você acabou
liberado.
Se essas sugestões não ajudarem, ou se você está tendo um problema que não descritas
aqui, confira a página na solução de problemas Arduíno www.Arduíno.cc / pt / / Guia de
problemas.
7.6. Como Obter Ajuda Online

Se você está preso, não passar os dias correndo sozinho, pedir ajuda. Uma das melhores
coisas sobre o Arduíno é a sua comunidade. Você sempre pode ajudar a descobrir se você
pode descrever o seu problema também.
Obtenha o hábito de cortar e colar as coisas em um motor de busca e ver se alguém está
falando sobre isso. Por exemplo, quando o IDE Arduíno cospe para fora uma mensagem de
erro desagradável, copiar e colá-lo em uma pesquisa no Google e ver o que sai. Faça o
mesmo com pedaços de código que você está trabalhando ou apenas um nome de função
específica. Olhe ao seu redor: tudo já foi inventado e é armazenado em algum lugar em uma
página web.
Para iniciar uma investigação mais aprofundada, a partir do site principal www.Arduíno.cc e
olhar para o FAQ (www.Arduíno.cc / pt / Main / FAQ), depois passar para o playground
(www.Arduíno.cc / playground), um livremente wiki editável que qualquer usuário pode
modificar a contribuir documentação. É uma das melhores partes da filosofia fonte todo
aberto. Pessoas contribuir documentação e exemplos de qualquer coisa que você pode
fazer com o Arduíno. Antes de iniciar um projeto, pesquisar o playground e você encontrará
um pouco de código ou um diagrama de circuito para você começar.
Se você ainda não consegue encontrar uma resposta dessa maneira, procure o fórum
(www.Arduíno.cc/cgi-bin/yabb2/YaBB.pl). Se isso não ajudar, envie uma pergunta lá. Pick
placa correta para o problema: existem diversas áreas de software ou problemas de
hardware e até mesmo fóruns em cinco línguas diferentes. Por favor, postar informações,
tanto quanto você pode:
Qual placa Arduíno você está usando?
Que sistema operacional você está usando para executar o IDE Arduíno?
Dê uma descrição geral do que você está tentando fazer. Post links para fichas de peças
estranhas que você está usando.
O número de respostas que você começa depende de quão bem você formular sua
pergunta.
Suas chances aumentam se você evitar essas coisas a todo o custo (estas regras são boas
para qualquer fóruns online, não apenas Arduíno's):
Escrever a sua mensagem toda em maiúsculas. Isso irrita muito as pessoas e é como andar
com um "novato" tatuada em sua testa (em comunidades on-line, digitando em todas as
capitais é considerado "gritar").
Postando a mesma mensagem em várias partes do fórum.
"Batendo" sua mensagem, colocando follow-up comentários perguntando: "Ei, como é que
ninguém respondeu? ou pior ainda, simplesmente postar o texto "colisão". Se você não
obtiver uma resposta, dê uma olhada no seu anúncio. Era clara a respeito? Você forneceu
uma descrição bem redigida do problema que você tem? Você foi bom? Ser sempre
agradável.
Escrever mensagens como "eu quero construir uma nave espacial usando Arduíno como
posso fazer isso". Isso significa que você quer que as pessoas fazem o seu trabalho para
você, e esta abordagem não é apenas diversão para um tinkerer real. É melhor para explicar
o que deseja construir e, em seguida, perguntar uma questão específica sobre uma parte do
projeto e levá-la de lá.
A variação do ponto anterior, quando a questão é claramente alguma coisa, o cartaz da
mensagem é pago para fazer. Se você perguntar a pessoas específicas, as perguntas são
felizes em ajudar, mas se você pedir que eles façam todo o seu trabalho (e não dividir o
dinheiro), a resposta é susceptível de ser menos agradável.
Enviar mensagens que parecem suspeitas, como trabalhos escolares e pedindo o fórum
para fazer sua lição de casa. Os professores gostam de me roam os fóruns e tapa esses
alunos com uma truta grande.
Apêndice A.
O Breadboard
O processo de obtenção de um circuito para o trabalho envolve fazer muitas mudanças até
que ela se comporta de forma adequada, é um processo muito rápido, iterativo, que é algo
como um equivalente electrónico para desenhar. O projeto se desenvolve em suas mãos
como você tentar combinações diferentes. Para obter os melhores resultados, use um
sistema que permite que você altere as conexões entre os componentes mais rápido, mais
prático, e de forma menos destrutiva. Estes requisitos claramente exclui de solda, que é um
processo demorado que coloca os componentes sob tensão cada vez que você aquecê-las
e resfriá-los para baixo.
A resposta para esse problema é um dispositivo muito prático chamado solderless

breadboard. Como você pode ver na Figura A-1, é uma pequena placa de plástico cheio de
buracos, cada um dos quais contém um contato de mola. Você pode empurrar a perna de
um componente em um dos buracos, e vai estabelecer uma conexão elétrica com todos os
outros buracos na mesma coluna vertical de buracos. Cada buraco é uma distância de 2,54
milímetros dos outros.
Porque a maioria dos componentes tem suas pernas (conhecido como techies "pins"),
espaçados em que a distância padrão, chips com várias pernas se encaixam perfeitamente.
Nem todos os contatos em um breadboard são criados iguais, existem algumas diferenças.
As linhas superior e inferior (em vermelho e azul e marcado com + e -) são conectados na
horizontal e são usados para transportar a energia através da placa de modo que quando
você precisar de energia ou terra, você pode fornecê-lo muito rapidamente com um jumper (
um pequeno pedaço de fio utilizado para ligar dois pontos no circuito). A última coisa que
você precisa saber sobre Breadboards é que no meio, há uma lacuna grande que é tão
grande como o tamanho de um pequeno chip. Cada linha vertical dos furos é interrompido
no meio, de modo que quando você conecta em um chip, você não faz um curto-circuito os
pinos que estão nos dois lados do chip. Clever, hein?
Figura A-1. A breadboard solderless
Apêndice B. Resistors Leitura e capacitores

Em ordem para usar as peças eletrônicas, você precisa ser capaz de identificá-los, o que
pode ser uma tarefa difícil para um novato. A maioria dos resistores que você encontrará em
uma loja tem um corpo cilíndrico com dois pés que furam para fora e ter estranhas marcas
coloridas ao seu redor. Quando os resistores primeiro comercial foram feitas, não havia
maneira de imprimir os números suficientemente pequena para caber em seu corpo, os
engenheiros decidiram tão inteligente que poderia apenas representar os valores com tiras
de tinta colorida.
Hoje os novatos têm que descobrir uma maneira de interpretar estes sinais. A "chave" é
bastante simples: geralmente, existem quatro faixas, sendo que cada cor representa um
número. Um dos anéis é geralmente de cor dourada, esta representa a precisão desse
resistor. Para ler as tiras em ordem, segure o resistor de modo que o ouro (ou prata, em
alguns casos) é faixa à direita. Então, leia as cores e mapeá-los para os números
correspondentes. Na tabela a seguir, você encontrará uma tradução entre as cores e seus
valores numéricos.
Por exemplo, laranja, marrom preto, e as marcações de ouro média 103 ± 5%. Fácil, né?
Não é bem assim, porque há uma peculiaridade: o terceiro anel realmente representa o
número de zeros no valor. Portanto 1 0 3 1 0 é realmente seguido por três zeros, então o
resultado final é de 10.000 ohms ± 5%. geeks Electronics tendem a diminuir os valores
exprimindo-se em ohm quilo (de milhares de ohms) e mega ohms (em milhões de ohms),
então um resistor ohms 10.000 é geralmente reduzido para 10k, enquanto 10 milhões se
10M. Por favor note que, porque os engenheiros gostam de otimizar tudo, sobre alguns
diagramas esquemáticos você pode encontrar valores expressos em 4k7, o que significa 4,7
quilo ohms, ou 4700.
Capacitores são um pouco mais fácil: os capacitores em forma de barril (capacitores

eletrolíticos) geralmente têm seus valores impressos sobre eles. O valor de um capacitor é
medida em farads (F), mas a maioria dos capacitores que o encontro vai ser medido em
farads micro (µF). Então, se você ver um capacitor marcado 100 µF, é de 100 micro farad
capacitor.
Muitos dos capacitores em forma de disco (de cerâmica) não têm as suas unidades listadas,
e à utilização de um código numérico de três dígitos que indica o número de pico farads
(pF). Há um milhão PF em um µF. Similar aos códigos de resistor, você pode usar o terceiro
número para determinar o número de zeros para colocar após os dois primeiros, com uma
diferença: se você vê 0-5, que indica o número de zeros. 6 e 7 não são usados, e 8 e 9 são
tratadas de maneira diferente. Se você vir 8, multiplicar o número que o constituem dois
primeiros dígitos por 0,01, e se você ver 9, multiplique por 0,1. Assim, um capacitor
marcado 104 seria 100000 pF ou 0,1 µF. Um capacitor marcado 229 seria 2,2 pF.
Apêndice C.
Referência Rápida Arduíno
Aqui está uma explicação rápida de todas as instruções padrão suportado pela linguagem
Arduíno.
Para uma referência mais detalhada, consulte: Arduíno.cc / pt / Referência / HomePage
C.1. ESTRUTURA
Um sketch Arduíno é executado em duas partes:
void setup ()
Este é o lugar onde você colocar o código de inicialização as instruções que criou o
conselho antes que o loop principal do desenho é iniciado.
loop (void)
Este contém o código principal do seu desenho. Ela contém um conjunto de instruções que
se repetem várias vezes até a placa é desligada.
C.2. Símbolos especiais

Arduíno inclui uma série de símbolos para delinear linhas de código, comentários e blocos
de código.
C.2.1. ; Ponto e vírgula ()

Cada instrução (linha de código) é denunciado por um ponto e vírgula. Esta sintaxe permite-
lhe formatar o código livremente. Você pode até mesmo colocar duas instruções na mesma
linha, contanto que você separe-os com um ponto e vírgula. (No entanto, isso tornaria o
código mais difícil de ler.)
Exemplo:
delay (100);
C.2.2. () (Chaves)
Isto é usado para marcar blocos de código. Por exemplo, quando você escrever um código
para o loop (), você tem que usar colchetes antes e depois do código.
Exemplo:
void loop () {
Serial.println ("ciao");
}
C.2.3. comentários
Estes são trechos de texto ignorado pelo processador Arduíno, mas são extremamente úteis
para se lembrar (ou outros) do que um pedaço de código faz.
Há dois estilos de comentários em Arduíno:
/ / Linha única: esse texto é ignorado até o fim da linha

/ * Linha múltipla:
você pode escrever
um poema inteiro aqui
*/
C.3. CONSTANTES
Arduíno inclui um conjunto de palavras-chave predefinidas com valores especiais. Alto e

baixo são usadas, por exemplo, quando você quiser ligar ou desligar um pino Arduíno.
Entrada e saída são usados para definir um pino específico para ser e de entrada ou de
saída , o verdadeiro e o falso indicar exatamente o que seus nomes sugerem: a verdade ou
falsidade de uma condição ou expressão.
C.4. VARIÁVEIS
Variáveis são denominadas áreas de memória que o Arduíno onde você pode armazenar
dados que você pode usar e manipular o seu esboço. Como o nome sugere, pode ser
alterado quantas vezes quiser.
Porque Arduíno é um processador muito simples, quando você declara uma variável que
você precisa especificar o tipo. Isso significa dizer ao processador o tamanho do valor que
você deseja armazenar.
Aqui estão os tipos de dados que estão disponíveis:
C.4.1. boolean
Pode ter um dos dois valores: verdadeiro ou falso.
C.4.2. char
Possui um caráter único, como A. Como qualquer computador, armazena Arduíno lo como
um número, mesmo que você veja o texto. Quando chars são usadas para armazenar
números, elas podem conter valores de -128 a 127.
Nota: Existem dois grandes conjuntos de caracteres disponíveis em sistemas de

computador: ASCII e UNICODE. ASCII é um conjunto de 127 caracteres que foi usada para,
entre outras coisas, a transmissão de texto entre os terminais de série e sistemas
informáticos de tempo partilhado, como mainframes e minicomputadores. Unicode é um
conjunto muito maior de valores usados por computadores modernos sistemas operacionais
para representar caracteres em uma ampla variedade de línguas. ASCII é ainda útil para a
troca de bits curto da informação em línguas como o italiano ou Inglês que usam caracteres
latinos, números arábicos, símbolos e máquina de escrever comum para a pontuação, etc.
C.4.3. byte
Detém um número entre 0 e 255. Tal como acontece com caracteres, bytes usar apenas um
byte de memória.
C.4.4. int
Utiliza 2 bytes de memória para representar um número entre -32.768 e 32.767, é o mais
comum tipo de dados usado no Arduíno.
C.4.5. unsigned int

Como int, usa 2 bytes, mas o prefixo unsigned significa que ele não pode armazenar
números negativos, pelo que a sua escala vai de 0 a 65.535.
C.4.6. longo
Este é o dobro do tamanho de um int e tem números de -2.147.483.648 a 2.147.483.647.
C.4.7. unsigned long

Unsigned versão do longa, que vai de 0 a 4.294.967.295.
C.4.8. flutuar
Esta muito grande e pode armazenar valores de ponto flutuante, uma maneira elegante de
dizer que você pode usá-lo para armazenar números com um ponto decimal na mesma. Ele
vai comer até 4 bytes de memória RAM preciosos e as funções que podem lidar com eles
consomem muita memória código também. Portanto, use com moderação flutua.
C.4.9. duplo
Precisão dupla número de ponto flutuante, com um valor máximo de 1,7976931348623157 x
10.308. Uau, isso é enorme!
C.4.10. corda
Um conjunto de caracteres ASCII que são usados para armazenar informações textuais
(você pode usar uma seqüência de caracteres para enviar uma mensagem através de uma
porta serial, ou para exibir em um monitor LCD). Para o armazenamento, eles usam um byte
para cada caractere na seqüência, mais um caractere nulo Arduíno para dizer que é o fim da
string. A seguir são equivalentes:
char string1 [] = "Arduíno"; / 7 chars + 1 nulo char

char string2 [8] = "Arduíno" / / Idem
C.4.11. array
A lista de variáveis que podem ser acessados através de um índice. Eles são utilizados para
construir tabelas de valores que podem ser facilmente acessados. Por exemplo, se você
deseja armazenar os diferentes níveis de luminosidade para ser usado quando um LED
sumindo, você pode criar seis variáveis chamado light01, light02, e assim por diante. Melhor
ainda, você poderia usar um array simples como:
luz int [6] = (0, 20, 50, 75, 100);
A palavra "matriz" não é realmente usado na declaração da variável: os símbolos [] e () fazer

o trabalho.
C.5. Estruturas de controle

Arduíno inclui palavras-chave para controlar o fluxo lógico de seu esboço.
C.5.1. se ... mais

Essa estrutura faz com que as decisões em seu programa. se deve ser seguido por uma
questão especificado como uma expressão entre parênteses. Se a expressão for verdadeira,
o que segue será executado. Se for falsa, o bloco de código a seguir o resto vai ser
executado. É possível usar apenas se sem fornecer uma cláusula else.
Exemplo:
if (val == 1) {
digitalWrite (LED, HIGH);
}
C.5.2. FOR
Permite repetir um bloco de código um número especificado de vezes.
Exemplo:
for (int i = 0; i <10; i + +) {

Serial.print ("ciao");
}
C.5.3. caso switch

A instrução if é como uma bifurcação na estrada para o seu programa. caso switch é como
uma rotunda enorme. Ele permite que seu programa de assumir uma variedade de sentidos,
dependendo do valor de uma variável. É muito útil para manter seu código limpo, uma vez
que substitui as longas listas de declarações.
Exemplo:
sensorValue switch () {
caso 23:
digitalWrite (13, HIGH); interrupção;
caso 46:
digitalWrite (12, HIGH);
break;
default: / / se nada partidas este é executado
digitalWrite (12, baixo);
digitalWrite (13, baixo);
}
C.5.4. While
Semelhante ao caso, este executa um bloco de código enquanto uma determinada condição
é verdadeira.
Exemplo:
/ / LED pisca quando o sensor for inferior a 512

sensorValue = analogRead (1);
while (sensorValue <512) {
delay (100);
delay (100);
}
C.5.5. fazer ... enquanto

Assim como, enquanto, exceto que o código é executado antes que a condição é avaliada.
Essa estrutura é usada quando você deseja que o código dentro do seu bloco para executar
pelo menos uma vez antes de verificar a condição.
Exemplo:
do {
delay (100);
delay (100);
} While (sensorValue <512);
C.5.6. Break
Este termo permite que você deixe um loop e continuar a execução do código que aparece
após o loop. É também usado para separar as diferentes secções de um case switch.
Exemplo:
/ / LED pisca quando o sensor for inferior a 512

do {
/ / Deixa o loop se um botão é pressionado
if (digitalRead (7) == HIGH)
break;
delay (100);
delay (100);
} While (sensorValue <512);
C.5.7. continuar
Quando usado dentro de um loop, continue lhe permite ignorar o resto do código dentro dele
e forçar o estado a ser testado novamente.
Exemplo:
de luz (= 0; luz <255; luz + +)

{
/ / Pular intensidades entre 140 e 200
if ((x> 140) & & (x <200))
continuar;
analogWrite (PWMpin, luz);
atraso (10);
}
C.5.8. return
Pára de funcionar e retorna uma função dele. Você também pode usar isso para retornar um
valor de dentro de uma função.
Por exemplo, se você tem uma função chamada computeTemperature () e você deseja
retornar o resultado para a parte do código que invocou a função que iria escrever algo
como:
computeTemperature int () {
temperatura int = 0;
= temperatura (analogRead (0) + 45) / 100;
temperatura de retorno;
}
C.6. ARITHMETIC e fórmulas
Você pode usar o Arduíno para fazer cálculos complexos, utilizando uma sintaxe especial. +
E - funcionam como você aprendeu na escola, e multiplicação é representada com um * e
divisão com a /.
Existe um operador adicional chamado "módulo" (%), que retorna o resto de uma divisão
inteira. Você pode usar como muitos níveis de parênteses necessário para expressões
grupo. Ao contrário do que você poderia ter aprendido na escola, colchetes e chaves são
reservados para outros fins (dos índices e blocos, respectivamente).
Exemplos:
a = 2 + 2;
luz = ((12 sensorValue *) - 5) / 2;
remanescente = 3% 2 / / retorna 2 porque 02/03 tem um remanescente
C.7. Operadores de Comparação

Quando você especificar condições ou testes para que, quando, e por declarações, estes
são os operadores que você pode usar:
== Igual a
! = Não igual a
<Menos
> Maior
<= Menor ou igual a
> = Maior ou igual a
C.8. Operadores Booleanos

Estes são usados quando você deseja combinar várias condições. Por exemplo, se você
quiser verificar se o valor proveniente de um sensor é entre 5 e 10, você poderia escrever:
if ((sensor => 5) & & (sensor <= 10))
Existem três operadores: e, representado por & &; ou, representado por | |, e não por último,
representado por!.
C.9. Operadores de
Estes são os operadores especiais usados para tornar o código mais conciso para algumas
operações muito comuns, como incrementar um valor.
Por exemplo, ao valor de incremento de 1, você escreveria:
value = valor 1;
mas usando um operador composto, isto se torna:
valor + +;
C.9.1. incremento e decremento (- e + +)

Estes aumentar ou diminuir o valor por 1. Tenha cuidado, porém. Se você escrever i + +
incrementa esta i em 1 e avalia o equivalente a um i, i + + avalia o valor de i, em seguida,
incrementos i. O mesmo se aplica --.
C.9.2. + =, -=, *= E / =
Estes torná-lo mais curto para escrever certas expressões. As duas expressões seguintes
são equivalentes:
a = a + 5;
a + = 5;
C.10. Funções de entrada e OUTPUT

Arduíno inclui funções para manipulação de entrada e saída. Você já viu algum destes nos
programas de exemplo em todo o livro.
C.10.1. pinMode (pin, mode)
Reconfigura um pino digital se comportar tanto como entrada ou saída.
Exemplo:
pinMode (7, INPUT); / / pino 7 voltas em uma entrada
C.10.2. digitalWrite (pin, value)

Transforma um pino digital ligado ou desligado. Pinos deve ser feita explicitamente em uma
saída antes de utilizar pinMode digitalWrite terá qualquer efeito.
Exemplo:
digitalWrite (8, HIGH); / gira em torno de 8 pinos digital
C.10.3. digitalRead int (PIN)

Lê o estado de um pino de entrada, os elevados retornos se o pino sentidos alguma tensão
ou LOW, se não há tensão aplicada.
Exemplo:
val = digitalRead (7) / / lê o pino 7 no val
C.10.4. analogRead int (PIN)

Lê a tensão aplicada a um pino de entrada analógica e retorna um número entre 0 e 1,023,
que representa as tensões entre 0 e 5 V.
Exemplo:
val = analogRead (0) / / lê a entrada analógica 0 em val

C.10.5. analogWrite (pin, value)
Altera a taxa de PWM em um dos pinos marcados PWM. pino pode ser 11,10, 9, 6, 5, 3.
valor pode ser um número entre 0 e 255 que representa a escala entre 0 e 5 V de tensão de
saída.
Exemplo:
analogWrite (9128); / Dim um LED no pino 9 a 50%
C.10.6. shiftOut (dataPin, clockPin, bitOrder, value)

Envia dados para um registrador de deslocamento, os dispositivos que são utilizados para
expandir o número de saídas digitais. Este protocolo utiliza um pino para dados e outra para
o relógio. bitOrder indica a ordenação dos bytes (menos significativo ou mais importante) eo
valor real é o byte a ser enviado.
Exemplo:
shiftOut (dataPin, clockPin, LSBFIRST, 255);
C.10.7. pulseIn unsigned long (pin, value)

Mede a duração de um pulso vindo em uma das entradas digitais. Isso é útil, por exemplo,
para ler alguns sensores infravermelhos ou acelerómetros que a saída de seu valor como
impulsos de mudança de duração.
Exemplo:
= tempo pulsein (7, HIGH); / / mede o tempo nos próximos

/ / Pulso permanece elevada
C.11. Funções de tempo

Arduíno inclui funções para medir o tempo decorrido e também para interromper o esboço.
C.11.1. unsigned millis tempo ()
Retorna o número de milissegundos que se passaram desde que o desenho começou.
Exemplo:
= duração millis () lastTime; / / calcula o tempo decorrido desde a "lastTime"
C.11.2. delay (ms)

Interrompe o programa para a quantidade de milissegundos especificado.
Exemplo:
delay (500) / / pára o programa por meio segundo
C.11.3. delayMicroseconds (nós)

Pausa o programa de determinada quantidade de microssegundos.
Exemplo:
delayMicroseconds (1000) / / espera por um milissegundo
C.12. FUNÇÕES MATEMÁTICAS

Arduíno comum inclui muitas funções matemáticas e trigonométricas:
C.12.1. min (x, y)

Retorna o menor de xe y.
Exemplo:
val = min (10,20); / val / é agora 10

C.12.2. max (x, y)
Retorna o maior de xe y.
Exemplo:
val = max (10,20); / val / agora é 20
C.12.3. abs (x)

Retorna o valor absoluto de x, o que torna os números negativos em positivos. Se x é 5
retornará 5, mas se x é -5, que ainda retornará 5.
Exemplo:
val = abs (-5) / Val / é agora 5
C.12.4. constranger (x, a, b)

Retorna o valor de x, constrangido entre A e B. Se x é inferior a um, ele será apenas um
retorno e se x é maior que b, será apenas retornar b.
Exemplo:
val = constranger (analogRead (0), 0, 255); / rejeitar valores maiores que 255
C.12.5. mapa (valor, fromLow, fromHigh, toLow, toHigh)

Mapeia um valor no intervalo e fromLow maxLow ao intervalo e toLow toHigh. Muito útil para
processar valores de sensores analógicos.
Exemplo:
Mapa val = (analogRead (0), 0,1023,100, 200); / / mapeia o valor de

Analógico / / 0 para um valor
/ / Entre 100 e 200
C.12.6. pow duplo (base, expoente)

Retorna o resultado de elevar um número (base) para um valor (expoente).
Exemplo:
pow double x = (y, 32); / / define X a Y elevado à potência 32
C.12.7. sqrt dobro (x)

Retorna a raiz quadrada de um número.
Exemplo:
uma dupla = sqrt (1138); / aproximadamente 33,73425674438
C.12.8. duplo pecado (rad)

Retorna o seno de um ângulo especificado em radianos.
Exemplo:
sin seno dupla = (2); / aproximadamente 0,90929737091
C.12.9. cos duplo (rad)

Retorna o cosseno de um ângulo especificado em radianos.
Exemplo:
cosseno duplo = cos (2); / aproximadamente -,41614685058

C.12.10. tan duplo (rad)
Retorna a tangente de um ângulo especificado em radianos.
Exemplo:
tangente dupla = tan (2); / aproximadamente -2,18503975868
C.13. NÚMERO funções aleatórias

Se você precisa gerar números aleatórios, você pode usar o gerador de números pseudo
Arduíno.
C.13.1. randomSeed (semente)

Redefine Arduíno gerador de números pseudo-aleatórios. Embora a distribuição dos
números retornados por random () é essencialmente aleatório, a seqüência é previsível.
Assim, você deve redefinir o gerador para um valor aleatório. Se você tem um pino analógico
desligado, ele vai pegar o ruído aleatório do ambiente circundante (ondas de rádio, raios
cósmicos, a interferência eletromagnética dos telefones celulares e lâmpadas fluorescentes,
e assim por diante).
Exemplo:
randomSeed (analogRead (5)) / / usando o ruído aleatório do pino 5
C.13.2. tempo aleatório (max) de comprimento aleatório (min, max)

Retorna um pseudo valor inteiro longo entre min e max - 1. Se min não é especificado, o
limite inferior é 0.
Exemplo:
randnum longo = random (0, 100); / / um número entre 0 e 99

randnum longo = random (11) / / um número entre 0 e 10
C.14. COMUNICAÇÃO SERIAL
Como você viu no capítulo cinco, você pode se comunicar com dispositivos em uma porta
USB usando um protocolo de comunicação serial. Aqui estão as funções de série.
C.14.1. Serial.begin (velocidade)

Arduíno prepara para começar a enviar e receber dados seriais. Você geralmente usa 9600
bits por segundo (bps), com o monitor IDE Arduíno serial, mas outras velocidades estão
disponíveis, geralmente não mais de 115.200 bps.
Exemplo:
Serial.begin (9600);
C.14.2. Serial.print (dados) Serial.print (dados, codificação)

Envia alguns dados para a porta serial. A codificação é opcional, se não for fornecida, os
dados são tratados tanto como texto simples possível.
Exemplos:
Serial.print (75) / / Imprime "75"

Serial.print (75 de dezembro); / / O mesmo que acima.
Serial.print (75, HEX) / / "4B" (75 em hexadecimal)
Serial.print (75 de outubro); / / "113" (75 em octal)
Serial.print (75, BIN); / / "1001011" (75 em binário)
Serial.print (75 BYTE); / / "K" (o byte-primas acontece
/ / Se a 75 do conjunto ASCII)
C.14.3. Serial.println (dados) Serial.println (dados, codificação)

Mesmo que Serial.print (), exceto que ele adiciona um retorno de carro e avanço de linha (\ r
\ n), como se você tivesse digitado os dados e, em seguida, pressionado Enter.
Exemplos:
Serial.println (75) / / Imprime "75 \ r \ n"
Serial.println (75 de dezembro); / / O mesmo que acima.
Serial.println (75, HEX) / / \ "4B r \ n"
Serial.println (75 de outubro); / / "113 \ r \ n"
Serial.println (75, BIN); / / "1001011 \ r \ n"
Serial.println (75 BYTE); / / \ K "r \ n"
C.14.4. Serial.available int ()

Retorna quantos bytes estão disponíveis lidos na porta serial para leitura através do read ()
função. Depois de ter lido () tudo disponível, Serial.available () retorna 0 até que novos
dados chegam na porta serial.
Exemplo:
int count = Serial.available ();
C.14.5. Serial.read int ()

Retorna um byte de entrada de dados serial.
Exemplo:
dados int = Serial.read ();
C.14.6. Serial.flush ()
Como os dados podem chegar através da porta serial mais rápido do que seu programa
pode processá-lo, Arduíno mantém todos os dados recebidos em um buffer. Se você
precisar limpar o buffer e deixá-lo encher-se com novos dados, use a função flush ().
Exemplo:
Serial.flush ();
Até agora, usamos ilustrações muito detalhadas para descrever como montar os circuitos,
mas como você pode imaginar, não é exatamente uma tarefa rápida para chamar um desses
para qualquer experiência que você deseja documentar.
questões idênticas, mais cedo ou mais tarde, em cada disciplina. Na música, depois de
escrever uma música agradável, é preciso escrevê-lo usando a notação musical.
Engenheiros, sendo as pessoas concretas, desenvolveu uma maneira rápida de capturar a

essência de um circuito, a fim de ser capaz de documentá-la e depois reconstruí-la ou
passá-lo para outra pessoa.
Na eletrônica, diagramas esquemáticos permitem descrever o circuito de uma forma que é

compreendido pelo resto da comunidade. Os componentes individuais são representadas
por símbolos que são uma espécie de abstração de qualquer forma o componente ou a
essência delas. Por exemplo, o capacitor é composto de duas placas metálicas separadas
por ar ou de plástico e, portanto, seu símbolo é:
Outro exemplo claro é a indutor, que é construído pelo enrolamento de fio de cobre em torno
de uma forma cilíndrica, conseqüentemente símbolo é a seguinte:
As conexões entre os componentes são feitas geralmente usando fios ou trilhas na placa de
circuito impresso e são representados no diagrama, como linhas simples. Quando dois fios
estão conectados, a conexão é representada por um grande ponto colocado onde as duas
linhas se cruzam:
Isso é tudo que você precisa entender os esquemas básicos. Aqui está uma lista mais
abrangente dos símbolos e seus significados:
Você pode encontrar variações destes símbolos (por exemplo, ambas as variantes de
símbolos de resistência são mostradas aqui). Veja en.wikipedia.org / wiki / Electronic_symbol
para aumentar a lista de símbolos eletrônicos. Por convenção, os diagramas são
desenhados da esquerda para a direita. Por exemplo, um rádio seria elaborada a partir da
antena à esquerda, seguindo o caminho do sinal de rádio que faz seu caminho para o alto-
falante (que é desenhada à direita).
O esquema a seguir descreve o circuito botão mostrado anteriormente nesta tradução:

Os Adaptadores e tradutores.
Pessoal isso foi só uma Adaptaçao mais por favor não esqueçam da gente em suas
referências, bem como do Autor original, principamente, citando a sua obra preservando os
direitos autorais.
Cirineu Carvalho fernandes

Geilton Teles Lopes
Gosta de reggae,
Também formando em
Maranhense da Ilha,
Engenharia Mecatrônica,
Aficcionado por Tecnologia
está em trabalho conjunto
e Robótica, gosta de praia.
para o desenvolvimento do
Atualmente tentanto
robô RHEX Brasil, utilizando
Formar em Eng
a Tecnogia Arduino e
Mecatroncia, onde está
Zigbee. Atualmente
projentando o
desenvolvendo projetos na
desenvolvimento do Robo
Área Industrial de Cimento.
Rhex com tecnologia
Arduino e Zigbee

Introdução Ao Arduino - Get Starter Com Arduino

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Introdução Ao Arduino - Get Starter Com Arduino

Hochgeladen von

Copyright:

Verfügbare Formate

Introdução ao Arduíno

Adaptado por: CIRINEU CARVALHO FERNANDES E GEILTON TELES LOPES

1. Interação design de computação e física

Com um hardware barato e componente de software open-source que você pode

Safari Books Open Source Métodos C Microprocessadores Safari Books Engenharia de

Na realidade, quando eu estava na escola eu já sabia eletrônica de uma maneira muito

Comecei a construção de alguns kits vendidos por revistas de eletrônica.

Engenhocas, máquinas, objetos incompatíveis descontroladamente trabalhando em

Lá eu percebi que em muitas aplicações, os engenheiros não faziam mais os circuitos de

Quando voltei, comecei a poupar dinheiro, porque eu queria comprar um computador e

Ingressei no SENAI no ano de 1995, fazendo o curso de Eletricista de Manutenção

Arduíno é diferente de outras plataformas no mercado devido a estas características:

É um ambiente multiplataforma, que pode ser executado em Windows, Macintosh e Linux.

Baseia-se na programação de Processamento do IDE, um ambiente ao desenvolvimento

O projeto Arduíno foi desenvolvido em um ambiente educacional e, portanto, ideal para os

1.1.1. Interaction Design é a concepção de uma experiência interativa. No mundo de hoje,

A área específica do Design de Interação envolvidos com Arduíno é a Computação Física

1.2. O que é a computação física?

Com Arduíno, um designer ou artista pode facilmente conhecer as noções básicas de

O clássico da engenharia se baseia em um rigoroso processo para a obtenção de A para B,

Eu sempre fui fascinado pela modularidade e a capacidade de construir sistemas

Reduzir o número de interrupções no fluxo é muito importante para a criatividade, a mais

2.4. Testando um Circuito

Como tinkerers, podemos implementar novas formas de interagir com o software,

2.6. Nós amamos sucata!

2.7. Hacking Brinquedos

Os brinquedos são uma fantástica fonte de tecnologia barata de reutilização, como

Capítulo 3. A plataforma Arduíno

A placa Arduíno é uma placa do microcontrolador pequeno, que é um circuito pequeno (o

3.1.1. 14 pinos de E / S Digital (pinos 0-13)

3.1.2. 6 pinos analógico (pinos 0-5)

3.1.3. 6 saída analógica pinos (pinos 3, 5, 6, 9, 10 e 11)

Figura 3-1. O Duemilanove Arduíno

Figure 3-2. The Arduíno NG

O IDE (Integrated Development Environment) é um programa especial em execução no

O ciclo de programação Arduíno é basicamente o seguinte:

1. Ligue sua placa em uma porta USB no seu computador.

2. Escreva um esboço que trará a bordo a vida.

3.3. Instalando o Arduíno em seu computador

3.4. Instalação de drivers: Macintosh

Em seguida, instalar o software do pacote FTDIUSBSerialDriver clicando duas vezes nele.

3.5. Instalando Drivers: Windows

3.7. Port de Identificação: Windows

No Windows, o processo é um pouco mais complicado, pelo menos no início. Abra o

Agora você vai aprender a construir e programar um dispositivo interativo.

4.1. Anatomia de um dispositivo interactivo

Figura 4-1. O dispositivo interactivo

4.2. Sensores e atuadores

Sensores e atuadores são os componentes eletrônicos que permitem que um pedaço de

4.3. Piscando um LED

Exemplo 4-1. Programa LED piscando

#define LED 13 // LED connected to

Se você ainda estiver tendo problemas, consulte o Capítulo 7, solução de problemas.

4.4. Passe-me o queijo parmesão

4.6. Escrevendo comentários

4.7. O Código, Passo a Passo

#define LED 13 // conectar o LED

pinMode(LED, OUTPUT); // sets the digital

{ Esse fechamento das Chaves significa o fim da função setup ().

digitalWrite(LED, HIGH); // turns the LED on

delay(1000); // aguardar por um segundo

digitalWrite(LED, LOW); // turns the LED off

} Esta Chave marca o encerramento da função de loop.