Introdução ao Arduino Fernandes, Cirineu & Lopes, Geilton

Prévia do material em texto

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ímboloeletrô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 sentiro 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ínono 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 
 // pushbutton is connected 
int val = 0; // val will be used to store the state 
 // of the input pin 
int state = 0; // 0 = LED off while 1 = LED on 
 
 
 
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 if the input is HIGH (button pressed) 
 // and change the state 
 if (val == HIGH) 
 { 
 state = 1 - state; 
 } 
 
 if (state == 1) 
 { 
 digitalWrite(LED, HIGH); // turn LED ON 
 } 
 else 
 { 
 digitalWrite(LED, LOW); 
 } 
} 
 
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 valorantigo 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 LED 13 // the pin for the LED 
#define BUTTON 7 // the input pin where the 
 // pushbutton is connected 
int val = 0; // val will be used to store the state 
 // 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() { 
 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 
 // 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) { 
 digitalWrite(LED, HIGH); // turn LED ON 
 } else { 
 digitalWrite(LED, LOW); 
 } 
} 
 
 
 
 
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 255como 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 
#define LED 9 // the pin for the LED 
int i = 0; // We'll use this to count up and down 
 
void setup() { 
 pinMode(LED, OUTPUT); // tell Arduíno LED is an output 
} 
 
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 LED 9 // the pin for the LED 
#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() { 
 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 
 // 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