Sunteți pe pagina 1din 103
Introdução ao Arduíno 1 ª Edição Adaptado por: CIRINEU CARVALHO FERNANDES E GEILTON TELES LOPES

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.

esses que acompanham a criança e o jovem carente no Brasil que ainda peca em nã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.

é uma das melhores maneiras de chegar a grandes resultados. 2.3. Patching Eu sempre fui fascinado

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

que você experimentá-los. 2.4. Testando um Circuito Circuit bending é uma das formas mais interessantes de

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

2.5. Teclado Hacks teclados de computador são ainda a principal forma de interagir com um computador

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.

técnica em que o manual, e eu tenho usado desde então. Capítulo 3. A plataforma Arduíno

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

encontrada entre o plugue do adaptador AC e à porta USB. Figura 3-1. O Duemilanove Arduíno

Figure 3-2. The Arduíno NG

encontrada entre o plugue do adaptador AC e à porta USB. Figura 3-1. O Duemilanove Arduíno

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

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.

Escolha a versão correta para seu sistema

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

na Figura 3-4. Figura 3-4. O Gerenciador de Dispositivos do Windows mostrando todas as portas seriais

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

em uma ação física. Figura 4-1. O dispositivo interactivo 4.2. Sensores e atuadores Sensores e atuadores

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

lista de instruções que damos o microcontrolador para ele fazer o que queremos. Figura 4-2. Ligar

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);

delay(1000);

// turns the LED off // waits for a second

}

Figura 4-3. O IDE Arduíno com o seu primeiro programa carregado

// turns the LED off // waits for a second } Figura 4-3. O IDE Arduíno

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

tátil: SparkFun COM-00097 Figura 4-6. Ligar um botão Nota: em vez de comprar fio jumper precut,

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

#define BUTTON 7 // the input pin where the (a variável BUTTON = a saída 7) // pushbutton is connected

int val = 0;

// the pin for the LED (a variável LED = a saída 13)

// 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

int state = 0;

// of the input pin // 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 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 LED 13

#define BUTTON 7 // the input pin where the // pushbutton is connected

int val = 0;

// the pin for the LED

// 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); pinMode(BUTTON, 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;

// tell Arduíno LED is an output // and BUTTON is an input

}

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

agitado. Figura 5-1. O interior de um sensor de inclinação Outro sensor que você pode querer

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

de detectar o movimento. Figura 5-2. sensor PIR típica Você deve experimentar agora, olhando para todos

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

Figura 5-3. PWM em ação Por exemplo, escrevendo analogWrite (9128) irá definir o brilho de um

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

Figura 5-4. LED ligado ao pino PWM Em seguida, crie um novo programa no Arduíno e

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);

delay(10); // Wait 10ms because analogWrite

// set the LED brightness

// 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

#define BUTTON 7 // input pin of the pushbutton

// the pin for the LED

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;

unsigned long startTime = 0; // when did we begin pressing?

// Stores the brightness value

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)

276-1657). Figura 5-5. resistor dependente da luz (LDR) Na escuridão, a resistência de um resistor dependente

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

Figura 5-6. Um circuito sensor analógico Exemplo 5-3. Blink LED a uma taxa especificada pelo valor

Exemplo 5-3. Blink LED a uma taxa especificada pelo valor da entrada analógica

#define LED 13 // the pin for the LED

int val = 0;

// coming from the sensor void setup() { pinMode(LED, OUTPUT); // LED is as an OUTPUT

// variable used to store the value

// 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

#define LED 9 // the pin for the LED

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

complexos. Figura 5-7. Um circuito de motor para Arduíno Safari Books Open Source Métodos C Microprocessadores

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

Fig. 6.1 A lâmpada acabado A luz, que você pode ver na Figura 6-1, é uma

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

int peace

int Arduíno = 0;

= 0;

= 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) if (love > 64)

if (Arduíno > 64) Arduíno = 64;

peace = peace * 4; love = love * 4;

Arduíno = Arduíno * 4; // colour that is made of 4 bytes (ARGB)

peace = 64; love = 64;

// multiply by 4 so that the max is 255, // which comes in handy when building a

}

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.

está

getstartedArduíno):

Aqui

o

esboço

Arduíno

(também

disponível

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

em

www.makezine.com

/

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;

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

LEDs têm um lado negativo achatada, como mostrado na figura.) Figura 6-2. O "Arduíno Networked Lamp"

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

e que geralmente é quando eu consertar tudo. Isto é muito importante, porque você vai

uma modificação em um momento"

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á aconte cendo.

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

Figura A-1. A breadboard solderless Apêndice B. Resistors Leitura e capacitores Em ordem para usar as

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,

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

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.

mais

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) { digitalWrite (13, HIGH); delay (100);

digitalWrite (13, HIGH); delay (100); sensorValue = analogRead (1);

}

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 { digitalWrite (13, HIGH); delay (100); digitalWrite (13, HIGH); delay (100); sensorValue = analogRead (1); } 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; digitalWrite (13, HIGH); delay (100);

digitalWrite (13, HIGH); delay (100); sensorValue = analogRead (1);

} 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ê escr everia:

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:

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 é:

por ar ou de plástico e, portanto, seu símbolo é: Outro exemplo claro é a indutor,

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

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:

por um grande ponto colocado onde as duas linhas se cruzam: Isso é tudo que você

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

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:

(que é desenhada à direita). O esquema a seguir descreve o circuito botão mostrado anteriormente nesta

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.

citando a sua obra preservando os direitos autorais. Cirineu Carvalho fernandes reggae, Ilha, Aficcionado

Cirineu Carvalho fernandes

reggae,

Ilha,

Aficcionado por Tecnologia

e Robótica, gosta de praia.

Maranhense

Gosta

de

da

Atualmente

tentanto

Formar

em

Eng

Mecatroncia,

onde

está

projentando

o

desenvolvimento

do

Robo

com Arduino e Zigbee

Rhex

tecnologia

do Robo com Arduino e Zigbee Rhex tecnologia Geilton Teles Lopes Também formando em Engenharia

Geilton Teles Lopes

Também formando em Engenharia Mecatrônica, está em trabalho conjunto para o desenvolvimento do robô RHEX Brasil, utilizando a Tecnogia Arduino e Zigbee. Atualmente desenvolvendo projetos na Área Industrial de Cimento.