JavaScript On Things PDF

Machine Translated by Google
UAU! e-book
www.wowebook.org
Para obter informações on-line e encomendar este e outros livros de Manning, visite Topics
www.manning.com. A editora oferece descontos neste livro quando encomendado em quantidade.
Para mais informações por favor entre em contato

Tutoriais
Ofertas e promoções especiais do departamento

de vendas
Manning Publications Co.
Rua Baldwin, 20
Caixa Postal 761
Destaques
Shelter Island, NY 11964
E-mail: orders@manning.com Configurações
©2018 da Manning Publications Co. Todos os direitos reservados.

Apoiar
Nenhuma parte desta publicação pode ser reproduzida, armazenada em um sistema de
recuperação ou transmitida , de qualquer forma ou por meio eletrônico, mecânico, fotocópia ou outro,
sem permissão prévia por escrito do editor.
Muitas das designações usadas por fabricantes e vendedores para distinguir seus produtos são
reivindicadas como marcas registradas. Onde essas designações aparecem no livro, e a Manning
Publications estava ciente de uma reivindicação de marca registrada, as designações foram impressas
em letras maiúsculas ou todas em letras maiúsculas.
Reconhecendo a importância de preservar o que foi escrito, é política da Manning imprimir os livros
que publicamos em papel sem ácido, e envidamos nossos melhores esforços para esse fim. Reconhecendo
também nossa responsabilidade de conservar os recursos de nosso planeta, os livros Manning são
impressos em papel que é pelo menos 15% reciclado e processado sem o uso de cloro elementar.
UAU! e-book
www.wowebook.org
Editor de desenvolvimento: Susanna Kline

Editor de resenhas: Ivan Martinovic
Editor do projeto: Kevin Sullivan
Editor de texto: Andy Carroll
Revisora: Melody Dolab
Compositor: Gordan Salinovic
Designer de capa: Leslie Haimes
Ilustrações de capa e interior: Lyza Danger Gardner
ISBN 9781617293863
Impresso nos Estados Unidos da América
1 2 3 4 5 6 7 8 9 10 – EBM – 23 22 21 20 19 18
UAU! e-book
www.wowebook.org
listas de reprodução
História
Sumário
direito autoral
Tópicos
Sumário
Tutoriais
Índice
Ofertas e promoções
Prefácio
Destaques
Agradecimentos
Configurações
Sobre este livro
Suporte
1. Introdução ao hardware de um JavaScripter
Sair
Capítulo 1. Unindo JavaScript e hardware
Capítulo 2. Embarcando em hardware com Arduino
Capítulo 3. Como construir circuitos
2. Noções básicas do projeto: entrada e saída com JohnnyFive
Capítulo 4. Sensores e entrada
Capítulo 5. Saída: fazendo as coisas acontecerem
Capítulo 6. Saída: fazendo as coisas se moverem
3. Projetos mais sofisticados
Capítulo 7. Comunicação serial
Capítulo 9. Construindo suas próprias

coisas UAU!
e-book www.wowebook.org
4. Usando JavaScript com hardware em outros ambientes
Capítulo 10. JavaScript e hardware restrito
Capítulo 11. Construindo com Node.js e computadores minúsculos
Capítulo 12. Na nuvem, no navegador e além
Índice
Lista de Figuras
Lista de mesas
Lista de Listagens
UAU! e-book
www.wowebook.org
Índice
História
direito autoral
Tópicos
Sumário
tutoriais
Índice
ofertas e promoções
Prefácio
luzes
Agradecimentos
configurações
Sobre este livro
Suporte
1. Introdução ao hardware de um JavaScripter
Sair
1.1. A anatomia dos projetos de hardware
1.1.1. Entradas e saídas
1.1.2. Em processamento
1.1.3. Energia, circuitos e sistemas
1.1.4. Lógica e firmware
1.1.5. Invólucros e embalagens
1.1.6. Sistemas embarcados
1.2. Como o JavaScript e o hardware funcionam juntos
1.2.2. JavaScript embutido

UAU! e-book
www.wowebook.org
1.2.3. Outras combinações de JavaScript de hardware
1.3. JavaScript é uma boa opção para hardware?
1.4. Montando um kit de ferramentas de hardware
1.4.1. placas de desenvolvimento
1.4.2. Componentes de entrada e saída
1.4.3. Outros componentes eletrônicos
1.4.4. Energia, fios e acessórios
1.4.5. Ferramentas
Resumo
2.1. Conhecendo o Arduino Uno
2.1.1. Criando seu primeiro circuito com um Arduino Uno
2.2. Trabalhando com o fluxo de trabalho do Arduino
2.2.1. Pinos digitais do Arduino Uno
2.2.2. Esboços e o IDE do Arduino
2.2.3. Conectando o LED a um pino digital
2.2.4. Programando o LED para piscar
2.3. Controlando o Arduino com JavaScript
2.3.1. Configurando o Arduino como cliente
2.3.2. Instalando a estrutura JohnnyFive Node.js
2.3.3. Hello World LED piscando com JohnnyFive
2.3.4. Firmata, JohnnyFive e o método hostclient
UAU! e-book
www.wowebook.org
2.3.5. Estruturação de scripts com JohnnyFive
Resumo
3.1. Tensão, corrente e resistência
3.1.1. lei de ohm
3.1.2. Problemas e perigos
3.2. Construir circuitos
3.2.1. Usando breadboards para prototipar circuitos
3.2.2. Fiação de um circuito de LED simples em uma placa de ensaio
3.2.3. Expandindo um circuito em série com um botão
3.2.4. LEDs em série
3.2.5. Circuitos paralelos e divisores de corrente
3.2.6. Alimentando seu projeto com baterias
Resumo
2. Noções básicas do projeto: entrada e saída com JohnnyFive
4.1. Trabalhando com sensores analógicos
4.1.1. Conversão analógico-digital
4.1.2. Trabalhando com fotoresistores
4.1.3. divisores de tensão
4.1.4. Fiação e uso de um fotoresistor
4.1.5. Usando um sensor de temperatura analógico
UAU! e-book
www.wowebook.org
4.2. Entradas digitais
4.2.1. Usando um botão como uma entrada digital
Resumo
5.1. Iluminando as coisas
5.1.1. Fading LEDs com modulação por largura de pulso (PWM)
5.1.2. Animando LEDs com PWM
5.1.3. Combinando entrada com saída de LED
5.1.4. Tornando-se totalmente colorido com LEDs RGB
5.1.5. Construa sua própria “bola do tempo”
5.2. Trabalhando com monitores LCD paralelos
5.2.1. Fazendo um timer completo com LCD
5.2.2. Adicionando um “carrilhão” de LED visual
5.3. Fazendo barulho com um piezo
5.3.1. Adicionando um carrilhão piezo audível ao timer
Resumo
6.1. Fazendo os motores girarem
6.1.1. Como funcionam os motores
6.1.2. Controlando um motor com um botão de pressão
6.1.3. Controlando um motor com JohnnyFive
6.2. Fazendo os servos funcionarem
UAU! e-book
www.wowebook.org
6.2.1. Controlando um servo com JohnnyFive
6.3. Construindo seu primeiro robô!
6.3.1. robôs e motores
6.3.2. Construindo a base do chassi do robô
6.3.3. Controlando os motores do robô
Resumo
3. Projetos mais sofisticados
7.1. Comunicação de dados digitais em paralelo e em série
7.2. Noções básicas de comunicação serial
7.3. Comunicação serial assíncrona
7.3.1. UARTs
7.3.2. Experimentando serial de software com uma placa de fuga de GPS
7.3.3. Aprenda a soldar!
7.3.4. Construindo o circuito GPS
7.4. Comunicação serial síncrona
7.4.1. Interface Serial Periférica (SPI)
7.4.2. 2C
7.4.3. Fazendo uma bússola digital com um magnetômetro I2C
7.5. Juntando tudo: shaketochange widget multissensor
7.5.1. Passo 1: combinando uma bússola com saída LCD
7.5.2. Etapa 2: adicionar um multissensor ao dispositivo
UAU! e-book
www.wowebook.org
7.5.3. Passo 3: atualizar o display para mostrar temperatura e pressão
7.5.4. Etapa 4: adicionar um recurso de exibição shaketoswap com um acelerômetro
Resumo
Capítulo 8. Projetos sem fios
8.1. Por que você foi amarrado até agora
8.1.1. Troca de dados, camada de E/S e plug-ins de E/S
8.1.2. USB como fonte de alimentação
8.1.3. Opções para comunicação de projeto sem fio
8.2. Rumo a projetos sem fio usando o Tessel 2
8.3. Configurando seu Tessel
8.3.1. Configurando o Tessel
8.3.2. LED “Hello World” piscando no Tessel
8.3.3. Piscando um LED externo com o Tessel
8.3.4. Explorando os pinos e capacidades do Tessel
8.4. Projetos sem fios no Tessel
8.4.1. Dados sem fio: uma estação meteorológica remota
8.5. Alimentando projetos com baterias
8.5.1. Um robô movido a bateria com o Tessel
Resumo
Capítulo 9. Construindo suas próprias coisas
9.1. Hackear eletrônicos de consumo
9.1.1. Modificando interruptores de saída controlados por RF
UAU! e-book
www.wowebook.org
9.2. Controlando os interruptores remotos com um plug-in de componente JohnnyFive
9.2.1. Prototipando o projeto do switch
9.2.2. Escrevendo o plug-in RemoteSwitch
9.3. Escrever software para hardware sofisticado
9.3.1. Projeto: suporte JohnnyFive para sensor de gestos APDS9660
9.3.2. Implementando construtor e métodos de inicialização
9.3.3. Integrando o sensor de gestos e os interruptores remotos
9.3.4. Juntando todo o projeto
Resumo
4. Usando JavaScript com hardware em outros ambientes
10.1. A plataforma Espruino Pico
10.1.1. Configurando o pico
10.1.2. Hello World LED piscando
10.2. Conhecendo novas plataformas
10.2.1. Descobrindo os principais recursos de uma plataforma
10.2.2. Encontrar um diagrama de pinagem
10.2.3. Aprendendo sobre configuração e fluxo de trabalho
10.2.4. Encontrar exemplos e tutoriais
10.2.5. Usando a documentação da API de referência
10.3. Experimentando o Pico
10.3.1. O multissensor Pico e o BMP180
UAU! e-book
www.wowebook.org
10.3.2. O Pico e o Nokia 5110 LCD
10.3.3. Construindo um dispositivo meteorológico eficiente em termos de energia com o Pico
10.4. Experimentando a plataforma Kinoma Element
10.4.1. Os principais recursos do elemento
10.4.2. Diagrama de pinagem e hardware
10.4.3. Configuração, gerenciamento, fluxo de trabalho
10.4.4. Exemplos e tutoriais
10.4.5. Referência da API
10.4.6. Projeto de estudo de caso: atualização ao vivo das leituras da bússola
Resumo
11.1. Trabalhando com computadores minúsculos
11.1.1. A plataforma Raspberry Pi
11.1.2. Opção de configuração 1: a forma tradicional
11.1.3. Opção de configuração 2: sem cabeça
11.2. Conhecendo o Raspberry Pi 3
11.2.1. Recursos principais
11.2.2. Recursos e pinagens do GPIO
11.2.3. Configuração e fluxo de trabalho
11.2.5. Documentação da API
11.3. Escrevendo aplicativos JohnnyFive para diferentes plataformas
UAU! e-book
www.wowebook.org
11.3.1. Adaptação da mini estação meteorológica para o Pi 3
11.3.2. Adaptando a mini estação meteorológica para o Arduino Uno
11.4. Usando o Raspberry Pi como host
11.5. Estudo de caso: BeagleBone Black
11.5.1. Conhecendo o BeagleBone Black
11.5.2. Adaptação da estação meteorológica para o BeagleBone
Resumo
12.1. IoT e a nuvem
12.2. Implantação em contêineres com resin.io
12.2.1. Criando um aplicativo resin.io
12.2.2. Provisionando o BeagleBone Black
12.2.3. Adaptar o software de aplicação meteorológica
12.3. Hardware e o navegador da web
12.3.1. A API Web Bluetooth
12.3.2. A API do Sensor Genérico
12.3.3. A Web física
12.4. Explorando o Bluetooth LE com Puck.js
12.4.4. Exemplos, tutoriais e documentação da API
UAU! e-book
www.wowebook.org
12.4.5. Controlando o LED a partir de uma página da web
12.4.6. A Web física e o Puck.js
12.4.7. Uma campainha Bluetooth baseada na web
12.5. Ultrapassando as fronteiras do JavaScript e do hardware
Resumo
Índice
Lista de Figuras
Lista de mesas
Lista de Listagens
UAU! e-book
www.wowebook.org
Prefácio
História
Em um dia do final do verão de 2013, eu estava em um palco em uma grande tenda no Topics
Bletchley Park, na Inglaterra, o local onde os decifradores britânicos (incluindo Alan Turing) derrotaram a
máquina Enigma na Segunda Guerra Mundial. foi um dos melhores

Tutoriais
dias da minha vida, pois duas coisas maravilhosas haviam acabado de acontecer.
Ofertas e promoçõesde
Primeiro, alguma forma, consegui vencer um concurso de hackers (é por isso que eu estava no palco).
O National Museum of Computing – também localizado no terreno do Bletchley Park – Highlights estava
buscando
ajuda técnica para criar exibições de linha do tempo interativas baseadas na web. Fiquei acordado a noite
toda, estendendo uma biblioteca JavaScript de código aberto e construindo um protótipo de
configurações : essa foi minha inscrição, que foi, para minha grande alegria, declarada a melhor do show. A
segunda coisa maravilhosa foi que ganhei um prêmio — e não um prêmio qualquer.
Apoiar
A recompensa que recebi foi um dos kits originais do Arduino Uno - uma placa Arduino Sign Out , uma
coleção
de componentes eletrônicos e um livro de instruções. Mudou profundamente a minha vida. Mais tarde,
descobri que combinar minhas habilidades eletrônicas recém-adquiridas com as coisas que fazia todos os
dias – codificar sites e aplicativos de código aberto baseados em padrões – resultou em uma das
alquimias mais fascinantes que já experimentei: JavaScript on Things. Ou seja, eu poderia usar o
JavaScript que já conhecia como um turbo boost para hackers eletrônicos e internet das coisas (IoT).
Isso veio depois, no entanto. Inicialmente, aprendi a construir circuitos eletrônicos simples trabalhando com
os exemplos do livro do kit e, posteriormente, pesquisando avidamente na web para aprender mais. Aprendi
como aplicar o controle lógico a esses circuitos programando o microcontrolador do Arduino Uno,
escrevendo esboços simples (programas) na linguagem (muito) C/C++ do Arduino, otimizada para o
espaço de programa (muito) limitado da placa e
memória.
E então, no final de 2013, descobri o JohnnyFive. A estrutura Node.js de software livre era jovem na
época, mas já poderosa. Em vez de escrever código Arduino restrito e de nível inferior, eu poderia escrever
, . .
programas JavaScript de nível superior para controlar meu Uno. Eu pensei: “Uau, se eu tivesse descoberto
isso antes.”
.
UAU! e-book
www.wowebook.org
A combinação de JavaScript e microcontroladores não é apenas um truque de salão, executado para
revestir todo o mundo conhecido com JavaScript. A princípio, até eu, um adepto do Node.js, fiquei
cético: talvez isso seja inútil, talvez nunca crie raízes.
Não se preocupe. Não é, e aconteceu.
Adicionar JavaScript à mistura simplificou perversamente minha experiência e tornou a
prototipagem de pequenos projetos muito, muito mais rápida. Eu poderia usar fluxos de trabalho de
desenvolvimento que eram mais familiares para mim como desenvolvedor da web. Eu não precisava me
preocupar tanto com memória de nível inferior e otimização de recursos. O encapsulamento do
comportamento do JohnnyFive em classes de componentes de alto nível é intuitivo: o código
resultante pode ser mais limpo e fácil de trabalhar do que muitas bibliotecas do Arduino. E isso me permitiu
aproveitar as profundezas quase insondáveis do ecossistema mundial Node.js via npm. Eu poderia
simplesmente importar módulos, como qualquer outro script Node.js existente. Era
maravilhoso.
Quero ser bem claro: não há nada de errado com o Arduino ou com a programação de
microcontroladores mais “tradicional” baseada em C. Existem boas razões para se preocupar
com o gerenciamento de memória, por exemplo, especialmente se você estiver escrevendo firmware
ou fazendo dispositivos de produção. E o Arduino é um milagre: toda a sua razão de ser é tornar a
eletrônica embarcada acessível aos novatos. Começar do zero com o Arduino e a linguagem de
programação do Arduino é uma abordagem perfeitamente razoável e superável.
Mas o JavaScript pode ajudar os desenvolvedores da Web a se familiarizarem com a eletrônica mais
rapidamente. Por um lado, os materiais introdutórios para Arduino (e outras plataformas) geralmente
não assumem nenhum conhecimento pré-existente de programação, o que significa que você pode acabar
se debruçando sobre explicações sobre o que é um array e como os loops funcionam. As restrições
meticulosas e as particularidades dos microcontroladores podem ser uma distração quando você está
apenas aprendendo como as coisas funcionam. IDEs podem ser desajeitados. Em alguns casos, você
pode acabar gastando muito tempo configurando as coisas e pouco tempo fazendo as coisas realmente
acontecerem. O JavaScript tem o poder de abstrair muito disso, permitindo que você se concentre
nas novas coisas essenciais que precisa aprender.
A partir dessa noção, surgiu este livro: a ideia de que o JavaScript pode servir como uma porta de
entrada para a eletrônica, tornando mais fácil para mais pessoas aprender como fazer coisas legais
com um mínimo de esforço cognitivo. JavaScript é a linguagem de programação mais popular do mundo,
a linguagem de fato da web; e a internet das coisas e a cultura maker são tentadoras criativa e
comercialmente. Por que não fazer uma feliz mistura de

os dois?
UAU! e-book
www.wowebook.org
No final do dia, essas coisas são divertidas. É um prazer poder sonhar e tornar realidade suas
próprias invenções. É um aumento de confiança ter uma competência básica com circuitos
eletrônicos de baixa tensão e entender como os sistemas embarcados funcionam no mundo real.
Talvez você realmente ame isso como eu. Talvez você ajude a contribuir com projetos de
código aberto. Talvez você construa um gadget extremamente inteligente. Talvez você ensine a
outras pessoas o que aprendeu.
Talvez você simplesmente se divirta. Isso, por si só, é mais do que suficiente.
UAU! e-book
www.wowebook.org
Agradecimentos
História
Minha gratidão começa exatamente onde meu amor por hacking de hardware começou: com a
equipe da conferência Over the Topics Air e o National Museum of Computing (Reino Unido), de onde
meu Arduino Starter Kit inicial se originou. Nada disso teria acontecido sem isso
Tutoriais
evento fortuito. Dan Appelquist, Margaret Gold e Matthew Cashmore — obrigado por criarem uma
conferência tão esplêndida e até por me convidarem para ela, mais de uma vez!
Rick Waldron realiza mais em um dia do que eu em um mês. (Rick, seu JavaScript
O gênio
dos destaques é uma lenda.) Seu envolvimento com o TC39, o grupo de trabalho da ECMA responsável pela própria
linguagem JavaScript, significa que ele é literalmente indispensável. Ah, e ele também inventou o JohnnyFive, o principal
framework
Node.js de código aberto para robótica e IoT, em torno do qual gira grande parte deste livro. Eu poderia continuar por páginas,
capítulos, sobre Rick.

Apoiar
Escrever um livro leva um tempo ridiculamente grande. Agradeço imensamente aos líderes e colegas
do Sign
Out da Bocoup por me darem o tempo e o apoio de que eu precisava e por continuamente bombear
quantidades constantes de entusiasmo em minha direção, bem como aos parceiros e funcionários
da Cloud Four por sua paciência.
Grandes editores são um verdadeiro presente em um mundo que às vezes descarta o valor do
processo editorial e do feedback. Minha editora, Susanna Kline, forneceu apoio útil e
perspicaz ao longo do caminho. Brad Luyster, seu feedback de revisão técnica foi fenomenal;
é difícil agradecer o suficiente. Vários outros revisores também forneceram feedback útil sobre
o manuscrito em diferentes estágios: Alessandro Campeis, Amit Lamba, Andrew Meredith, Bruno
Sonnino, Earl Bingham e Kevin Liao. Também quero agradecer à editora de Manning, Marjan Bace,
e ao restante das equipes editorial e de produção que trabalharam nos bastidores do livro.
Agradeço também a Francis Gulotta pela contribuição técnica, Kyle Jackson da Manning por atender
às minhas necessidades de suporte técnico e meu amigo Chau Doan por compartilhar seu firmware e
sabedoria eletrônica.
.
As comunidades JohnnyFive e JavaScriptonThings relacionadas têm sido simplesmente
brilhantes. Obrigado, Derek Runberg da SparkFun! Obrigado, Donovan Buck, David
UAU! e-book
www.wowebook.org
Resseguie, Brian Genisio e todos os outros contribuidores do JohnnyFive!
A biblioteca Arduino de Shawn Hymel para o sensor APDS9960 - um belo trabalho - serviu como trampolim
para partes do capítulo 9. E os exemplos de rover nos capítulos 6 e
8 são adaptados do código escrito por Rick Waldron. (Mais uma vez, Rick, obrigado!)
Igualmente importante para aqueles que o ajudam em um projeto em si são aqueles que o ajudam a manter
sua sanidade enquanto o suportam: obrigado, minha esplêndida família e amigos.
Salvei este ponto extramelhor aqui para agradecer ao meu parceiro (e pessoa fantástica em geral)
Bryan Fox: sem sua presença alegre e constante, este livro não poderia
existir.
UAU! e-book
www.wowebook.org
Sobre este livro

História
“Tenho curiosidade sobre hardware, eletrônica e IoT, mas não tenho absolutamente nenhuma
ideia
de por onde começar.” Já ouvi essa noção, em muitas variações, de muitos (dezenas?—pelo
menos—talvez uma centena?) desenvolvedores web. Sim, certamente seria divertido poder
Tutoriais
construir robôs e engenhocas inteligentes. Sim, seria útil saber ler os dados dos sensores e fazer
coisas interessantes com os dados, para poder construir o seu próprio
dispositivos automatizados conectados à web (para alimentar seu animal de estimação no
horário, detectar a quantidade de chuva, exibir as últimas pontuações do rugby - a mente
realmente
se confunde com todas as possibilidades do Highlights ). Mas também, sim, pode parecer
uma nova paisagem assustadora, até mesmo avassaladora, se você nunca fez um LED piscar, muito
menos
escreveu e exibiu o firmware otimizado para um microcontrolador embutido.
Apoio
Boas notícias! Você pode tirar proveito de sua compreensão de JavaScript e metáforas gerais de programação para enquadrar sua
aventura de aprendizado e fazer com que envolver sua cabeça de saída neste novo mundo seja um pouco menos caótico. O
JavaScript
pode dar um toque de familiaridade, fornecendo uma pedra de toque para facilitar sua introdução à eletrônica,
hardware e internet das coisas (IoT).
Este livro ensina os fundamentos da eletrônica e dos sistemas embarcados para pessoas que se
sentem confortáveis com o JavaScript básico, mas que podem não ter nenhuma experiência em
conectar até mesmo o circuito mais simples. A ênfase é colocada nos tópicos que serão novos
para os desenvolvedores de software: os fundamentos críticos do projeto e construção de
circuitos, componentes de hardware (sensores, motores, resistores e similares) e a interface entre
hardware e software.
Ao longo deste livro, você terá contato direto com uma variedade de placas de desenvolvimento,
componentes de hardware e plataformas de software. Para os experimentos (pequenos projetos) nos
primeiros dois terços do livro, usaremos o framework Node.js de código aberto JohnnyFive
com a placa de desenvolvimento Arduino Uno. A API do JohnnyFive fornece muitas classes de
componentes intuitivas que você pode usar para prototipar rapidamente seus gadgets e invenções.
O Uno é a placa de hobby mais onipresente do mundo, apresentando estabilidade, simplicidade,
confiabilidade e uma enorme comunidade de usuários e educadores. O último terço do livro examina
uma gama mais ampla de plataformas, incluindo o Node.jscapable
UAU! e-book
www.wowebook.org
Tessel 2 e o muito popular Raspberry Pi.
No final do livro, você deve ter um kit de ferramentas fundamental — tanto mental quanto físico —
para planejar, projetar, implementar e estender seu próprio JavaScript.

criações eletrônicas controladas.
ROTEIRO
O livro é composto por 12 capítulos:
O Capítulo 1 define o que são sistemas embarcados e enumera os componentes físicos a
partir dos quais são construídos. Ele explica as maneiras pelas quais o JavaScript e o hardware podem
trabalhar juntos.
O Capítulo 2 apresenta a placa de desenvolvimento Arduino Uno e coloca você na prática, rapidamente,
com alguns LEDs piscantes básicos. Veremos brevemente como controlar o Uno com o Arduino IDE antes
de passar para JavaScript e JohnnyFive.
O Capítulo 3 dá um zoom nos fundamentos da eletrônica que servem de base para todos os
circuitos que você construirá. Você vai mergulhar nas profundezas da lei de Ohm e construir alguns
tipos diferentes de circuitos simples.
Os capítulos 4 a 6 são um passeio pelos principais conceitos e eletrônicos para
gadgets embutidos, explorando entrada (sensores), saída (atuadores) e movimento físico (motores
e servos). Usando o framework JohnnyFive, você terá a chance de construir vários experimentos
diferentes com uma placa Arduino Uno.
O Capítulo 7 examina a comunicação serial, que é usada para trocar dados mais sofisticados.
Você experimentará vários componentes seriais, incluindo uma bússola (magnetômetro), um
acelerômetro e um GPS, novamente usando JohnnyFive e o

Arduino Uno.
Os capítulos 8 e 9 apresentam a placa de desenvolvimento Node.jscapable Tessel 2. Em
No capítulo 8, você aprenderá como fazer projetos que não são amarrados por fios. No capítulo 9, você
explorará o processo de levar um projeto original desde a ideia até o início.
Os Capítulos 10 e 11 se aprofundam em outros hardwares integrados com capacidade de I/O e JavaScript.
O Capítulo 10 aborda JavaScript e ambientes semelhantes a JavaScript em plataformas restritas
como o Espruino Pico. O Capítulo 11 explora computadores de placa única (SBCs) de uso mais geral,
como o Raspberry Pi.
O Capítulo 12 aborda os serviços de nuvem e o controle de hardware do navegador e olha para o futuro.
Você aprenderá como usar um serviço de nuvem, resin.io, para gerenciar e
UAU! e-book
www.wowebook.org
implante um aplicativo JohnnyFive em um BeagleBone Black e você criará uma campainha sem
fio no navegador com o dispositivo Puck.js e a Web Bluetooth API.
QUEM DEVERIA LER ESSE LIVRO?
Este é um livro para pessoas que têm alguma experiência com JavaScript, mas que sabem pouco ou
nada sobre circuitos eletrônicos e programação de microcontroladores.
Os exemplos de código neste livro não são, em sua maioria, complexos. Minha filosofia é que é melhor
que o código seja legível e compreensível do que exibido e inteligente. Você certamente não precisa ter
uma profunda familiaridade com cada palavra na especificação ECMA262 (esse é o documento
que define a linguagem JavaScript); mas se você se sentir fraco ao ver as funções de seta ou ainda não
conhece Promises, por exemplo, você pode querer retocar um pouco ou manter um companheiro
amigável ao seu lado, como o excelente Secrets of the JavaScript Ninja, Second Edition, de John Resig,
Bear Bibeault e Josip Maras (Manning, 2016; www. .manning.com/books/secrets
ofthejavascriptninjasecondedition). Complexidade de código e uso de linguagem moderna
os recursos aumentam no final do livro.
Embora as instruções passo a passo para os experimentos forneçam todos os comandos necessários
para fazer suas criações funcionarem, você deve ter competência básica para instalar, gerenciar e usar o
Node.js e o gerenciador de pacotes npm. Você também deve se sentir confortável com a execução
de comandos de um ambiente de terminal.
Um conhecimento prático de HTML e compreensão geral de CSS é útil, embora não seja essencial.
(Você sempre pode recortar e colar a marcação de origem para esses componentes.)
O Capítulo 12 envolve o uso do software de controle de versão do Git — a experiência anterior com o Git é
útil, mas não crítica.
CONVENÇÕES DE CÓDIGOS E DOWNLOADS
Este livro inclui exemplos abundantes, que incluem vários recursos necessários para aplicativos e
experimentos: JavaScript, HTML, CSS, JSON e assim por diante. O código-fonte nas listagens ou no texto
está em uma fonte de largura fixa para separá-lo do texto comum.
Além disso, nomes de métodos ou classes, nomes de variáveis, propriedades de objetos,
parâmetros de métodos, elementos HTML e similares em texto também são apresentados usando uma fonte
de largura fixa.
JohnnyFive é de código aberto, lançado sob a licença de software (liberal) MIT. O livro faz uso de muitos
outros projetos de software de código aberto, incluindo cerca de uma dúzia de módulos npm de terceiros.
A maioria das plataformas de hardware exploradas também são de código aberto;

UAU! e-book
www.wowebook.org
uma exceção é o Raspberry Pi 3, abordado no capítulo 11. Para completar o exemplo de “bola do
tempo” no capítulo 5, você precisará de uma chave API (gratuita) do Dark
Sky (https://darksky.net/dev/register ).
Anotações de código acompanham muitas das listagens de código-fonte, destacando importantes

conceitos.
O código-fonte e os recursos de todos os exemplos deste livro estão disponíveis

em https://github.com/lyzadanger/javascriptonthings. A maioria dos exemplos no livro inclui todo o
código e marcação necessários no texto (o código-fonte para módulos de terceiros não está
incluído). Mas você pode encontrar a fonte completa de alguns exemplos mais longos no final do
livro, bem como ativos binários para exemplos (como o MP3 usado na campainha controlada pela
web no capítulo 12) , no repositório de código.
Um arquivo zip contendo o código-fonte no momento da publicação também estará disponível no

site da editora: www.manning.com/books/javascriptonthings.
FÓRUM DO LIVRO
A compra do JavaScript on Things inclui acesso gratuito a um fórum privado da Web administrado
pela Manning Publications, onde você pode fazer comentários sobre o livro, fazer perguntas
técnicas e receber ajuda do autor e de outros usuários. Para acessar o fórum, acesse https://
forums.manning.com/forums/javascriptonthings. Você também pode aprender mais sobre os
fóruns de Manning e as regras de conduta em
https://forums.manning.com/forums/about.
O compromisso de Manning com nossos leitores é fornecer um local onde possa ocorrer um
diálogo significativo entre leitores individuais e entre leitores e o autor. Não é um compromisso
com qualquer quantidade específica de participação por parte do autor, cuja contribuição ao fórum
permanece voluntária (e não remunerada). Sugerimos que você tente fazer algumas perguntas
desafiadoras ao autor, para que o interesse dela não se desvie! O fórum e os arquivos das discussões
anteriores estarão acessíveis no site da editora enquanto o livro estiver sendo impresso.
SOBRE O AUTOR
Lyza Danger Gardner gosta de descobrir como fazer as coisas. Por sua vez, ela também gosta
de ensinar aos outros como fazer coisas novas. Lyza foi cofundadora da Cloud Four, uma
consultoria web em Portland, Oregon. Ela vem construindo coisas na web há mais de 20 anos,
defendendo padrões elegantes, educação e compaixão em busca do melhor futuro possível da
web. Você pode encontrá-la online em www.lyza.com ou @lyzadanger no Twitter. Como um
UAU! e-book
www.wowebook.org
contraponto à sua vantagem técnica futurista, ela vive na floresta em Vermont e
gosta de hobbies anacrônicos. Ela lê e lê e lê.
UAU! e-book
www.wowebook.org
Parte 1. Introdução de um JavaScripter ao hardware

História
Esta parte do livro apresentará os fundamentos de sistemas embarcados e Tópicos circuitos

eletrônicos. No capítulo 1, você aprenderá o que são sistemas embarcados e como analisar seus
componentes constituintes. Passaremos algum tempo analisando o que isso significa
Tutoriais
para o JavaScript "controlar" o hardware e examinaremos as diferentes maneiras pelas
quais o JavaScript e a eletrônica podem trabalhar juntos.
Você conhecerá a placa de desenvolvimento Arduino Uno R3 no capítulo 2, que usaremos com todos
os destaques dos experimentos até o capítulo 7. Você aprenderá o que as principais partes das placas
de desenvolvimento fazem e como elas interagem com outros softwares e hardwares componentes.
Você
experimentará alguns experimentos básicos de LED com o Uno usando o Arduino IDE e a estrutura
JohnnyFive Node.js.
Apoiar
O Capítulo 3 ensinará os principais fundamentos dos circuitos eletrônicos, mergulhando na lei Sign
Out de
Ohm e nas relações entre tensão, corrente e resistência. Você trabalhará em uma breadboard,
construindo séries e circuitos paralelos que contêm vários LEDs.
Ao terminar esta parte do livro, você terá uma compreensão dos fundamentos básicos do
sistema embarcado e dos principais conceitos de circuito. Você estará pronto para começar a
criar pequenos projetos controlados por JavaScript com diferentes tipos de entradas e
saídas.
UAU! e-book
www.wowebook.org
História
Este capítulo cobre
Tópicos
Componentes e hardware envolvidos em projetos amadores e na “internet das

Tutoriais coisas”
Componentes comuns de sistemas embarcados

Diferentes métodos para usar JavaScript com sistemas embarcados

Destaques
Ferramentas e suprimentos necessários para começar a construir
Configurações Como um desenvolvedor web experiente em JavaScript, você faz a alquimia lógica acontecer todos os dias. Mas agora é
possível exercer suas habilidades de desenvolvimento de software de uma nova maneira, para programar o suporte e controlar as
coisas no
mundo real. Neste capítulo, você aprenderá sobre o hardware envolvido em diferentes tipos de projetos e dispositivos e também
verá como o JavaScript Sign Out e o hardware podem trabalhar juntos.
Estamos cercados por pequenas coisas mágicas que misturam o mundo físico com o reino do
lógico, conectado e virtual (figura 1.1). Um chaveiro que transmite sua localização sem fio para
que você possa encontrá-lo com um aplicativo em seu smartphone. Um vaso de plantas que
faz barulho quando precisa ser regado ou, melhor ainda, envia uma mensagem de texto
petulante. Bilhões desses objetos piscam, bipam, tuitam, diminuem automaticamente as luzes,
fazem bules de chá personalizados e realizam suas funções especializadas em todo o
planeta.
Figura 1.1. Oh, as coisas mágicas em nosso mundo!
UAU! e-book
www.wowebook.org
É divertido construir essas coisas. A criatividade envolvida na criação com esses tipos de dispositivos
físicos, o charme básico de projetos caseiros criativos - esses são os tipos de coisas que atraem os
desenvolvedores da web. Somos feitos para prototipagem, experimentando novas tecnologias e trilhando
nossos próprios caminhos.
Mas começar pode ser intimidante. Quando vemos todos os fios e componentes, ouvimos o jargão, ficamos
do lado de fora olhando para as comunidades de hackers de hardware, os tipos de habilidades envolvidas
podem parecer formidáveis, estranhos. Como desenvolvedor de JavaScript, você pode se deparar com alguns
obstáculos - complexidade percebida, informações superabundantes e dispersas, fusão de conceitos
de hardware e software - ao fazer suas primeiras tentativas de incursão no mundo do hardware físico.
Vamos usar seu know-how em JavaScript como uma vantagem, uma ajuda para aprender como projetar e
construir os tipos de coisas que compõem a “internet das coisas” (IoT) e inspirar hackers de hardware. Você
será capaz de usar suas habilidades de desenvolvimento de software para ignorar algumas distrações e se
concentrar rapidamente nas novas habilidades que precisa aprender.
Para ter uma ideia da jornada que estamos fazendo, vamos primeiro dar uma olhada nos tipos de coisas
que você aprenderá a construir. Vamos explorar o que queremos dizer, exatamente, quando dizemos coisas ou
hardware.
1.1. A ANATOMIA DOS PROJETOS DE HARDWARE
Poderíamos construir um pequeno dispositivo que ligasse automaticamente um ventilador quando esquentasse.
Este dispositivo de controle climático independente em miniatura monitoraria continuamente a temperatura
do ambiente ao redor. Quando fica muito quente, o ventilador liga.
Quando está bom e fresco novamente, o ventilador desliga.
Embora não ganhássemos nenhum prêmio de prestígio pela invenção deste

UAU! e-book
www.wowebook.org
artifício pedestre, seus ingredientes básicos são comuns às outras - mais inspiradoras - coisas que você
aprenderá a construir.
1.1.1. Entradas e saídas

A coisa mais importante - realmente a única - que nosso dispositivo acionado por temperatura
precisa fazer é ligar um ventilador quando estiver muito quentinho e desligá-lo novamente quando a área
ao redor esfriar. O ventilador motorizado é um exemplo de dispositivo de saída.
Para obter informações contínuas sobre a temperatura do ambiente imediato—

para que o dispositivo possa tomar decisões sobre quando ligar ou desligar o ventilador - precisamos
dados de uma entrada, neste caso um sensor de temperatura (figura 1.2).
Figura 1.2. O sistema de ventilador automático precisa receber informações de um sensor de

temperatura e gerenciar a saída de um ventilador motorizado.
As entradas fornecem dados de entrada para o sistema e os sensores são um tipo de entrada
que fornece dados sobre o ambiente físico. Existem todos os tipos de sensores que você pode usar
em projetos: sensores de luz, calor, ruído, vibração, vapores, umidade, cheiros, movimento,
chamas - você escolhe. Alguns, como o sensor de temperatura do nosso ventilador, fornecem dados
simples – apenas um único valor representando a temperatura – enquanto outros, como GPS
ou acelerômetros, produzem dados mais elaborados.
As saídas de um projeto representam sua funcionalidade líquida para alguém que o utiliza. Luzes
piscando, bipes irritantes, leituras de status em telas LCD, um braço robótico movendo-se
lateralmente - todos esses são tipos de saídas. Para este projeto, o ventilador é a única saída.
Nem todas as entradas e saídas necessariamente se manifestam no mundo físico. Um cliente

UAU! e-book
www.wowebook.org
encontrar um erro ao tentar solicitar um produto online (entrada virtual) pode fazer com que uma luz vermelha
acenda (saída física) em um dispositivo localizado na mesa de um técnico de suporte.
Por outro lado, uma mudança na umidade do solo (entrada do sensor físico) pode fazer com que um vaso de
planta envie uma mensagem de texto exigente (saída virtual).
1.1.2. Em processamento
Nosso ventilador automático também precisa de um cérebro, algo que preste atenção nas leituras
do sensor de temperatura e ligue o ventilador quando estiver muito quente. O tipo de cérebro de que ele
precisa é, na verdade, um minúsculo computador: um processador, um pouco de memória e a capacidade
de processar entradas e controlar saídas. Quando processador, memória e funcionalidade de E/S estão
contidos em um único pacote físico, chamamos o chip resultante de microcontrolador (figura 1.3).
Figura 1.3. O ventilador automático precisa de um cérebro. Uma opção popular é um

microcontrolador, que combina processador, memória e recursos de E/S em um único pacote.
Microcontroladores (MCUs) não são tão poderosos quanto os processadores de uso geral em laptops.
A maioria não pode executar um sistema operacional completo (a maioria, não todos, como você verá), mas
são baratos, confiáveis, pequenos e consomem o mínimo de energia - é por isso que são onipresentes
em projetos de hardware e produtos como nosso apócrifo ventilador automático.
1.1.3. Energia, circuitos e sistemas
Agora temos entrada, saída e um cérebro - hora de juntar os bits em um sistema.
Precisamos conectar os componentes usando um ou mais circuitos eletrônicos e fornecer alguma energia. A
construção de um sistema envolve tanto o projeto do circuito quanto a manipulação
UAU! e-book
www.wowebook.org
de componentes no espaço físico (figura 1.4).
Figura 1.4. Um desenho esquemático aproximado mostrando como as entradas, saídas e o

microcontrolador do ventilador estão conectados em um sistema com alimentação e circuitos. Não
se estresse se os símbolos forem novos para você - você aprenderá sobre circuitos à
medida que continuamos nossa jornada.
Conectar fios diretamente aos minúsculos pinos de um microcontrolador exigiria solda e uma
mão muito firme. Sem mencionar que acabaríamos com muitas peças soltas flutuando
desajeitadamente. Para auxiliar os desenvolvedores de hardware, os microcontroladores
geralmente são montados em placas físicas de desenvolvimento (figura 1.5). Entre outras coisas,
as placas facilitam a conexão de dispositivos de E/S ao microcontrolador.
Figura 1.5. Placas de desenvolvimento baseadas em microcontroladores tornam mais conveniente

conectar dispositivos de entrada e saída.
UAU! e-book
www.wowebook.org
Uma placa de desenvolvimento ajuda, mas ainda ficamos com vários fios e componentes soltos.
Para ajudar a controlar isso, os desenvolvedores de hardware usam uma ferramenta de prototipagem
chamada breadboard (figura 1.6) para projetar circuitos no espaço físico.
Figura 1.6. Uma protoboard fornece uma grade conectada eletricamente na qual
prototipar circuitos eletrônicos.
UAU! e-book
www.wowebook.org
1.1.4. Lógica e firmware

Nosso projeto de hardware está avançando, mas você pode estar se perguntando
como o microcontrolador sabe o que fazer. Há lógica envolvida aqui, conforme
mostrado na listagem a seguir: ouvir o sensor, tomar decisões, enviar instruções para ligar ou
desligar o ventilador.
Listagem 1.1. Pseudocódigo para lógica do ventilador acionado por temperatura
inicializar sensor de temperatura inicializar

saídaFan
inicializar fanThreshold para 30 (temperatura celsius)
laço principal
lê o valor do sensor de temperatura em currentTemp
UAU! e-book
www.wowebook.org
se currentTemp for maior que fanThreshold se outputFan estiver desligado
ligue o outputFan
else se currentTemp for menor ou igual a fanThreshold
se outputFan estiver ligado
desligue o ventilador de saída
A linguagem dominante para programar microcontroladores tem sido C (ou derivados de Clike).
Escrever C para microcontroladores tende a ser específico da plataforma e pode ser de baixo nível.
Referências a endereços de memória específicos e operações bit a bit são
comum.
O código é compilado para o código assembly específico da arquitetura. Para inserir o código no
projeto, ele é carregado fisicamente, ou atualizado, na memória do programa do microcontrolador.
Essa memória de programa geralmente é uma memória não volátil - ROM, o tipo de memória que permite
ao microcontrolador “lembrar” o programa mesmo se estiver desligado (em contraste com a RAM, que
só retém seu conteúdo se estiver ligada). O espaço disponível para programas é restrito, muitas
vezes da ordem de algumas dezenas de kilobytes, o que significa que os programas executados
em microcontroladores precisam ser cuidadosamente otimizados.
Depois que o programa é atualizado para o microcontrolador, ele funciona como o firmware do
microcontrolador - quando ligado, o microcontrolador executa o programa continuamente até que seja
programado com algo diferente (ou redefinido).
Para desenvolvedores de JavaScript acostumados à lógica de nível superior, essa especificidade de

nível inferior pode parecer desconcertante. Não se preocupe. É aqui que o JavaScript pode nos ajudar,
permitindo-nos escrever programas para hardware baseado em microcontrolador sem ter que usar
C ou nos enredarmos no âmago da questão dos endereços de registradores hexadecimais logo de cara.
O processo de colocar firmware de programa em microcontroladores também se tornou muito mais

fácil graças aos avanços na tecnologia de chip e à ampla disponibilidade de placas de desenvolvimento
amigáveis para amadores (figura 1.7).
Figura 1.7. Memória de programa não volátil (EEPROM e Flash) e placas de fácil
utilização facilitaram a programação de microcontroladores com firmware.
UAU! e-book
www.wowebook.org
EEPROM (ROM programável apagável eletricamente), exemplificado pelo bem conhecido meio
de memória flash, é comumente usado em microcontroladores. Esse tipo de memória regravável
torna possível reprogramar microcontroladores repetidamente com lógica diferente.
As placas de desenvolvimento, além de facilitar as conexões de E/S, também auxiliam os

hackers de hardware, fornecendo interfaces convenientes para programar o
microcontrolador da placa (USB é bastante comum). Isso alivia a necessidade de
dispositivos de programação de hardware especializados. Hoje em dia, programar
microcontroladores costuma ser tão fácil quanto conectar um cabo USB e clicar em um botão em um IDE.
1.1.5. Invólucros e embalagens

O design do nosso ventilador está quase pronto. Mas podemos levá-lo para o próximo nível
empacotando o autofan dentro de um bom gabinete - incorporando nosso sistema dentro de algo,
onde seus fios e circuitos ficarão ocultos (figura 1.8). Tada!
Figura 1.8. O ventilador automático completo e embalado é um exemplo de

sistema embutido. As entradas e saídas são processadas por um microcomputador
baseado em microcontrolador e suportadas por energia e circuitos. E a coisa toda
está escondida dentro de uma caixa bem chique, porque não?
UAU! e-book
www.wowebook.org
1.1.6. Sistemas embarcados

Embora o termo sistema embutido possa soar um pouco formal ou proibitivo, não é realmente muito
complicado. Um minúsculo computador que combina processador, memória e E/S forma o cérebro.
Como você viu com nosso ventilador automático, conectar as entradas, saídas e o
microcomputador juntos e fornecer energia a eles cria um sistema independente. Dizemos que está
embutido porque geralmente está escondido dentro de alguma coisa - um gabinete, um ursinho de
pelúcia, o painel de controle de uma máquina de lavar, um guarda-chuva.
Embora um ventilador automático, um guarda-chuva que acende quando chove e um ursinho de pelúcia
twittando não pareçam imediatamente semelhantes, eles têm mais em comum do que você imagina.
Esses exemplos, juntamente com a maioria dos projetos de hardware e dispositivos que formam a IoT,
podem ser descritos como sistemas embarcados.
Agora vamos ver como o JavaScript se encaixa na imagem.
1.2. COMO JAVASCRIPT E HARDWARE FUNCIONAM JUNTOS
Ao combinar JavaScript com sistemas embarcados, ainda construímos circuitos eletrônicos da mesma
forma que faríamos para outros tipos de projetos de hardware. Ainda há entradas e saídas, fios e
componentes. No entanto, em vez de usar código assembly ou C para definir o que o microcontrolador
ou processador do projeto faz, usamos JavaScript.
Existem várias maneiras de fazer isso, diferentes métodos para usar JavaScript para fornecer o
UAU! e-book
www.wowebook.org
lógica para projetos de hardware. Esses métodos são categorizados com base em onde a
própria lógica do JavaScript é executada: em um computador host separado do sistema
incorporado, no microcontrolador do sistema incorporado ou em algum outro lugar.
1.2.1. Método host-cliente

Para contornar as restrições de certos microcontroladores, o método hostclient permite que você
execute JavaScript em um computador host mais poderoso. À medida que o host executa o código,
ele troca instruções e dados com o hardware embarcado, que se comporta como um cliente (figura
1.9).
Figura 1.9. O método host-cliente de controle de hardware com JavaScript
UAU! e-book
www.wowebook.org
Muitos microcontroladores têm limitações que afetam sua capacidade de executar JavaScript.
A memória do programa é restrita, o que significa que programas complexos não cabem ou precisam
ser bastante otimizados. Além disso, muitos microcontroladores baratos são construídos com arquiteturas
de 8 ou 16 bits rodando em velocidades de clock que são baixas em relação, digamos, a computadores
desktop. A maioria não estaria à altura da tarefa de executar um sistema operacional, descartando a
capacidade de executar um Node.js ou outro tempo de execução JavaScript diretamente no chip.
Em vez disso, o método hostclient envolve a execução da lógica JavaScript em um computador host, como
seu laptop, que tem a força necessária para executar um sistema operacional completo. A máquina
host é capaz de executar Node.js e pode usar o ecossistema mundial de software JavaScript (incluindo
npm e a web).
O truque para fazer essa configuração funcionar é fazer com que o hardware do cliente (como o
microcontrolador) e o sistema host (seu laptop) se comuniquem usando uma “linguagem” mutuamente
inteligível – uma API comum (figura 1.10).
Figura 1.10. Para que o computador host e o hardware do cliente se comuniquem

nesse método, ambos precisam usar uma API comum.
UAU! e-book
www.wowebook.org
Para configurar nosso sistema de ventiladores automáticos para usar esse método, primeiro
precisamos preparar o hardware embarcado carregando um firmware especial na
memória do programa do microcontrolador. Em vez de um programa específico e de propósito
único para controlar o ventilador, este programa de firmware torna o microcontrolador capaz de
se comunicar com outras fontes que falam a mesma “linguagem” (a API). Ou seja, ele
transforma o hardware baseado em microcontrolador em um cliente, todo ouvidos e pronto para
fazer as ordens do computador host (figura 1.11).
Figura 1.11. Firmware específico converte o microcontrolador em um cliente.
O hardware agora está pronto para se comunicar - a próxima etapa é escrever o software
para o ventilador, usando o computador host. Para que o hardware e o software se entendam,
o computador host precisa emitir instruções em uma linguagem que o microcontrolador possa
compreender. Para que isso aconteça, podemos escrever código usando uma biblioteca ou
estrutura que implemente a API comum (figura 1.12).
Figura 1.12. O host também precisa se comunicar usando a API comum.

UAU! e-book
www.wowebook.org
O host é conectado ao hardware do cliente por meio de uma conexão física por cabo
(geralmente USB) ou sem fio (WiFi ou Bluetooth).
Em seguida, executamos o JavaScript de controle do ventilador no computador host. O

host comunica continuamente as instruções para executar o ventilador para o cliente. O
cliente também pode enviar mensagens de volta ao host, como dados do sensor de
temperatura (figura 1.13).
Figura 1.13. À medida que o host executa a lógica do JavaScript, as instruções e os dados são
continuamente trocados entre o cliente e o host, usando uma API comum.
UAU! e-book
www.wowebook.org
Não entre em pânico, você não terá que escrever um software API de protocolo de firmware de baixo
nível! Existem opções diretas e de código aberto para firmware e estruturas Node.js que implementam
esses protocolos de firmware, para que você possa escrever sua lógica JavaScript do lado do host com
o mínimo de confusão.
Os benefícios da abordagem hostclient são a facilidade de configuração e o suporte em várias plataformas.
Além disso, ele oferece acesso a todo o ecossistema Node.js, evitando as restrições de desempenho e
memória de microcontroladores baratos.
A desvantagem é que o hardware do cliente é indefeso sem o host - ele só pode fazer seu trabalho
quando o computador host estiver executando ativamente o software.
Iremos eventualmente sem fio, mas começaremos com a mais simples das opções de hostclient -
tethering USB. Isso significa que, por um tempo, seus projetos ficarão fisicamente conectados ao seu
computador.
1.2.2. JavaScript incorporado

Com JavaScript embutido, a lógica JavaScript para controlar o projeto roda diretamente no microcontrolador
do hardware.
Muitos microcontroladores não estão aptos a rodar JavaScript nativamente, mas alguns sim. Como seria
de esperar com o avanço da tecnologia, os microcontroladores baratos estão ficando mais avançados.
Tornou-se possível executar JavaScript, ou uma variante otimizada de JavaScript, diretamente
em certos processadores incorporados.
Cada plataforma JavaScript incorporada é uma combinação de hardware e software

UAU! e-book
www.wowebook.org
ingredientes trabalhando em conjunto. Do lado do hardware, as placas de desenvolvimento aptas a executar código
nativamente são baseadas em chips mais capazes (mas ainda baratos).
A maioria das plataformas também fornece um conjunto de ferramentas de software para complementar seu hardware.
Pode haver uma biblioteca ou estrutura a ser usada para escrever código JavaScript compatível e uma CLI (interface de
linha de comando) ou outro método para preparar o código e fazer o upload
para o microcontrolador.
Espruino (www.espruino.com) é um exemplo de plataforma embarcada baseada em JavaScript.
O tipo de JavaScript do Espruino combina o núcleo otimizado do JavaScript com uma API de recursos relevantes
para o hardware. Por exemplo, você escreve código para a placa Espruino Pico em um IDE baseado na web e carrega-o na
placa via USB (figura 1.14). Para adaptar nosso ventilador automático para uma placa Espruino, precisaríamos
escrever a lógica usando a API do Espruino.
Figura 1.14. A plataforma Espruino combina pequenas placas de hardware com um

ambiente de desenvolvimento IDE.
Outro exemplo de JavaScript embutido é o Tessel 2 (https://tessel.io/), uma plataforma de desenvolvimento baseada
em Node.js. Você pode controlar e implantar código em seu Tessel usando o módulo tesselcli npm — sem fio, se quiser,
porque o Tessel 2 possui WiFi integrado (figura 1.15).
Figura 1.15. O Tessel 2 é uma plataforma open source que roda Node.js nativamente.
UAU! e-book
www.wowebook.org
Ser capaz de executar o JavaScript diretamente no hardware incorporado pode ser eficiente em termos
de energia e autocontido. Os projetos são sistemas independentes que podem ser executados por
conta própria. Ao contrário da configuração hostclient, que requer firmware para traduzir de
JavaScript para código de máquina, há (geralmente) menos camadas de abstração entre seu JavaScript e o
hardware.
Isso parece ótimo, e você pode se perguntar por que não usaríamos essa abordagem
exclusivamente. Existem algumas desvantagens. Por um lado, há menos opções de hardware no
momento. Além disso, cada plataforma tem suas próprias técnicas específicas de plataforma
(software, ferramentas, metodologia), que podem turvar as águas ao aprender os fundamentos do
hardware. A maioria também tem certas limitações, seja no suporte ao recurso de linguagem
JavaScript ou nos tipos de entradas e saídas suportadas. Mas é um método inspirador com um
futuro muito brilhante.
1.2.3. Outras combinações hardware-JavaScript
Além do método hostclient e da execução de JavaScript incorporado, existem algumas outras

maneiras de combinar JavaScript com projetos de hardware.
Pequenos computadores de placa única (SBCs) combinam o host e o cliente em uma unidade. Os
serviços baseados em nuvem possibilitam escrever código JavaScript online e implantá-lo sem fio no
hardware. E recursos emergentes, novos e experimentais nos próprios navegadores da
Web podem oferecer um portal para o mundo do hardware para milhões de
desenvolvedores da Web.
UAU! eBook
Executando JavaScript em computadores minúsculos (SBCs) www.wowebook.org
Executando JavaScript em computadores minúsculos (SBCs)
Computadores de placa única (SBCs) como a família Raspberry Pi e BeagleBone Black podem executar
ambientes de sistema operacional completos (normalmente Linux) e, por extensão, Node.js. Em vez de
um microcontrolador de 8 ou 16 bits, os SBCs têm processadores de uso geral de maior desempenho.
Mas muitos SBCs também têm pinos de E/S e recursos embutidos na mesma placa (figura 1.16).
Figura 1.16. Vários computadores de placa única (SBCs): Intel Galileo, Gen 2 (superior), Raspberry Pi 2
Modelo B (canto inferior esquerdo) e Raspberry Pi Zero (canto inferior direito)
O uso de um SBC para controlar um projeto de hardware combina aspectos do método hostclient e da
execução de JavaScript incorporado. O processador precisa executar continuamente a lógica JavaScript para que
o projeto funcione (como no modelo hostclient), mas todo o pacote está contido em uma placa e se parece
mais com uma placa independente e incorporada
configurar.
Ao contrário dos microcontroladores que executam a lógica JavaScript incorporada, porém, o processador em um
SBC não executa um programa de propósito único - ele pode executar simultaneamente outros
UAU! e-book
www.wowebook.org
processos.
Esses computadores de placa única estão ficando baratos. Neste momento, há o Raspberry Pi Zero
de $ 5 (se você conseguir colocar as mãos em um - eles estão notoriamente esgotados) e o Pi Zero W
habilitado para WiFi por apenas um pouco mais. Não há mais um diferencial de custo tão grande entre hardware
de microcontrolador de baixa potência e minúsculos computadores legítimos com processadores
que rivalizam com tablets e smartphones.
Embora a execução de JavaScript em computadores de placa única com suporte a GPIO (E/S de uso geral)
ofereça várias opções em um único hardware integrado, ele apresenta algumas desvantagens. Os SBCs não
são tão de baixa potência quanto muitas placas baseadas em microcontroladores - o Raspberry Pi 2
Modelo B consome 4 watts. Os SBCs que veremos têm suporte GPIO, mas os mapeamentos e uso de pinos
podem ser confusos e a documentação superficial ou técnica, o que pode ser desafiador se você estiver
apenas aprendendo sobre hacking de hardware.
Você também precisará estar pronto para enfrentar os obstáculos de administração do sistema, pois
as distribuições Linux para SBCs, especialmente quando combinadas com Node.js, podem exigir alguma
depuração e paciência.
Serviços baseados em nuvem e o navegador
Esta última categoria abrangente para combinações de JavaScript de hardware é reconhecidamente embaçada.
As coisas estão mudando. Rápido. O crescimento atual de serviços comerciais baseados em nuvem para IoT
assumiu a forma proverbial de taco de hóquei, e estamos apenas vendo a vanguarda dos avanços que
nos permitirão interagir diretamente com o hardware do próprio navegador.
Os serviços baseados em nuvem tentam facilitar a complexidade do gerenciamento de frotas de dispositivos
IoT em escala. Muitos deles são direcionados à empresa. O Resin.io (figura 1.17), por exemplo, cria,
empacota e implanta código de aplicativo em contêiner para dispositivos provisionados, cuidando de algumas
das dores de cabeça de segurança e automação para você.
Figura 1.17. O serviço Resin.io ajuda a simplificar a implantação de aplicativos e o gerenciamento

de SBCs compatíveis com Linux.
UAU! e-book
www.wowebook.org
E há o próprio navegador, onde muitas das combinações de JavaScript de hardware mais

avançadas estão apenas começando a surgir. Alguns navegadores já permitem que você experimente
o Web Bluetooth, uma API que, embora não esteja atualmente no caminho dos padrões, pode ser
um prenúncio do que está por vir. O Web Bluetooth, como o próprio nome sugere, permite
conectar e controlar o hardware Bluetooth Low Energy (BLE), usando JavaScript, a partir do
navegador.
Outro projeto aberto do Google, o Physical Web, propõe uma ideia descomplicada: dar
a um pequeno dispositivo a capacidade de transmitir uma URL com Bluetooth Low Energy (BLE).
Um beacon usado dessa forma pode transformar um sinal de parada de ônibus em um rastreador
de chegadas em tempo real, transmitindo a URL para um aplicativo da web com essas
informações (figura 1.18). Um conceito simples, mas flexível.
Figura 1.18. Neste exemplo de aplicação da Web física, um sinal de parada de ônibus usa um
beacon BLE para transmitir uma URL uma vez por segundo (1); um ser humano nas
proximidades pode procurar por beacons disponíveis em seu dispositivo e selecionar aquele
correspondente ao ponto de ônibus (2); o dispositivo do passageiro do ônibus agora pode buscar
a URL transmitida pelo beacon e exibi-la no navegador (3).
UAU! e-book
www.wowebook.org
De todos os casamentos entre JavaScript e hardware, esta variante – a integração mais profunda
da web com o hardware – é a mais volátil. É ao mesmo tempo intrigante e imprevisível. É
provável que a demanda por mais formas de construir produtos IoT com JavaScript leve a uma
aceleração estonteante neste espaço.
1.3. O JAVASCRIPT É ADEQUADO PARA HARDWARE?
Então, talvez possamos usar JavaScript para hackear hardware de várias maneiras, mas deveríamos?
Existe utilidade aqui ou é apenas um truque de salão auto-indulgente?
Quando a ideia de usar JavaScript com hardware começou a surgir alguns anos atrás, não foi recebida
com entusiasmo universal. Foi visto por alguns como esperteza arbitrária e equivocada - nós
realmente temos que usar JavaScript em todos os lugares? cansaço.
Outros argumentaram que o desempenho do JavaScript em hardware restrito nunca seria aceitável
para nada além do uso de hobby. Uma certa quantidade de grosseria da velha guarda veio à
tona, tópicos de comentários atolados com escoriações apaixonadas contra qualquer coisa, exceto
C/C++, e pessimistas alertaram que uma linguagem de alto nível obscureceria nuances essenciais de
hardware de baixo nível dos recém-chegados.
E, no entanto, houve muitos que permaneceram de mente aberta. Por que usar JavaScript quando
C/C++ é bom o suficiente? teve um eco curioso de uma mudança de paradigma anterior em hardware:
por que usar C quando a linguagem assembly é boa o suficiente?
Seja incrível ou ruim — e não vamos discutir isso agora — JavaScript é a linguagem de programação
de fato da Internet. As pessoas conhecem, usam e está em toda parte. A onipresença do JavaScript dá a
ele um potencial único para servir como um
UAU! e-book
www.wowebook.org
gateway para milhões de desenvolvedores da web que com certeza adorariam entrar na IoT.
Certos aspectos da programação JavaScript se prestam bem ao hardware, especialmente sua
proficiência em manipulação de eventos e processos assíncronos. O JavaScript também é uma boa
ferramenta para prototipagem, uma vantagem para a iteração rápida.
Vai ser fascinante ver onde vamos parar. O trem do JavaScript está saindo da estação de hardware e muitas
pessoas estão embarcando no passeio.
1.4. MONTANDO UM KIT DE FERRAMENTAS DE HARDWARE
Você fez um rápido tour pelos ingredientes que compõem os sistemas embarcados e pelos métodos de
combinação de hardware com JavaScript. Vamos agora ser mais específicos sobre os tipos de hardware
físico, acessórios e ferramentas necessários para criar esses tipos de projetos. Então estaremos
prontos para estocar um kit de ferramentas básico para você começar.
Nossos projetos combinarão uma placa de desenvolvimento com hardware de entrada e saída. Para
construir circuitos e conectar os sistemas, você precisará de componentes eletrônicos de suporte,
bem como fios, energia e acessórios. Jogue em algumas ferramentas básicas e você está pronto para ir.
1.4.1. placas de desenvolvimento
Placas de desenvolvimento, também chamadas de placas de prototipagem ou apenas placas, são
plataformas físicas de desenvolvimento que combinam um microcontrolador ou outro componente de
processamento com recursos de suporte úteis (figura 1.19). Eles são o pão com manteiga do estilo
de vida hacker de hardware. As placas variam em custo de apenas alguns dólares a mais de US $ 100 para
SBCs de última geração.
Figura 1.19. Algumas placas típicas de desenvolvimento baseadas em microcontroladores, no

sentido horário a partir do canto superior esquerdo: um Tiva C-Series LaunchPad da Texas
Instruments, um Arduino Uno R3, um Adafruit Trinket (modelo 5V) e um Particle Photon
UAU! e-book
www.wowebook.org
As placas são centradas em torno de seu cérebro, uma combinação de processador, memória
e E/S. Os microcontroladores de 8 ou 16 bits estão no centro das placas de
prototipagem simples e básicas, como (a maioria) dos Arduinos (figura 1.20). Placas com
microcontroladores de 32 bits mais sofisticados podem executar JavaScript embutido.
Figura 1.20. Esta placa Arduino Uno é alimentada pelo AVR ATmega 328-P, um
microcontrolador de 8 bits.
UAU! e-book
www.wowebook.org
Nem todas as placas são baseadas em microcontroladores. Os SBCs mais poderosos são
alimentados por componentes que você normalmente encontraria na placa-mãe de um computador.
A arquitetura dessas placas é, portanto, mais complexa, envolvendo um ou mais sistemas miniaturizados
em um chip (SoCs) e interconexões adicionais como HDMI, áudio ou Ethernet. Embora os SBCs possam
ter interfaces físicas de E/S integradas - Raspberry Pis, por exemplo - seus processadores de uso geral
podem ser facilmente usados para alimentar projetos não centrados em hardware.
1.4.2. Componentes de entrada e saída
Oh, que coisa, existem tantos sensores e aparelhos que você pode conectar às suas placas para
aprimorar seus projetos! Isso é divertido, mas também pode parecer opressor no começo.
Muitos termos técnicos são usados e há muitos números, valores e especificações a serem absorvidos.
Você aprenderá a se orientar conforme avança neste livro.
A maioria dos componentes de entrada e saída com os quais trabalharemos são de design simples
e estão prontos para serem conectados a uma breadboard (ou seja, são compatíveis com breadboard).
Alguns são embalados como placas de breakout. Da mesma forma que as placas de
desenvolvimento facilitam a entrada/saída conectando os minúsculos pinos de um microcontrolador a
conexões mais convenientes, as placas breakout facilitam o trabalho com sensores de finalidade única
ou dispositivos de saída conectando seus pinos a conexões mais convenientes (figura 1.21). .
Figura 1.21. Uma variedade de componentes comuns de entrada e saída
UAU! e-book
www.wowebook.org
1.4.3. Outros componentes eletrônicos
A montagem de circuitos eletrônicos requer uma coleção de componentes eletrônicos de suporte.

componentes.
Embora possa parecer que há muitas peças pequenas, os componentes básicos como
resistores, capacitores, diodos e transistores são baratos e podem ser adquiridos em kits iniciais
convenientes (figura 1.22). Levaremos nosso tempo para conhecer essas partes - logo elas se sentirão
como velhas amigas.
Figura 1.22. Componentes comuns como esses ajudarão você a construir circuitos
eletrônicos funcionais.
1.4.4. Energia, fios e acessórios
UAU! e-book
www.wowebook.org
Uma coisa que você logo perceberá é que existem muitas maneiras de potencializar um projeto!
As placas de desenvolvimento podem ser alimentadas por USB ou conectadas a um adaptador DC (verruga na parede). Em
muitos casos, outros componentes do projeto podem aproveitar essa mesma fonte de energia (figura 1.23).
Figura 1.23. Uma amostra de fios e acessórios para alimentação e circuitos
As baterias são úteis para tornar os projetos sem fio, bem como para fornecer energia adicional em diferentes tensões.
Existem muitos tipos de encaixes de bateria e suportes para conectar baterias a projetos.
Para conectar as coisas, você precisará de fios. Os fios jumper são fios pré-cortados. Uma variedade particularmente
útil possui pinos em cada extremidade que deslizam facilmente nas placas de ensaio e nos pinos de E/S em muitas placas.
Os fios jumper são ótimos para prototipagem rápida.
Como alternativa, o fio de conexão geralmente vem em um carretel e pode ser cortado em comprimentos específicos conforme
necessário.
1.4.5. Ferramentas
Um alicate de ponta fina e uma ou duas chaves de fenda de precisão são companheiros úteis na construção de projetos.
Você vai querer um par de desencapadores de fios - que geralmente têm cortadores de fio embutidos - se estiver cortando ou
desencapando o fio de conexão (fios jumper pré-cortados não precisam

UAU! e-book
www.wowebook.org
para ser cortado ou descascado). À medida que avança, você pode querer colocar as mãos
em um multímetro, uma ferramenta para medir tensão, corrente e resistência.
Armazenando seus componentes eletrônicos
Ao começar a construir projetos, você acabará com muitas peças pequenas. Você pode encontrar
caixas de armazenamento compartimentadas ou unidades de gaveta em lojas de ferragens e hobby.
Caixas e estojos projetados para iscas de pesca podem ser recipientes especialmente úteis para peças
eletrônicas porque seus compartimentos são pequenos e suas divisórias se ajustam perfeitamente (figura 1.24).
Figura 1.24. Esta caixa de equipamentos compacta tem espaço na parte superior para ferramentas e
armazenamento de componentes em contêineres empilháveis e removíveis.
UAU! e-book
www.wowebook.org
É hora de começar nossa jornada. Hacking com hardware embutido de baixa potência pode ser divertido,
criativo e excitante - e é cada vez mais útil no mundo comercial. Os desenvolvedores da Web (como
você) já possuem habilidades que podem ser excelentes trampolins em seu caminho.
Você pode usar a linguagem onipresente da web, JavaScript, para começar e reduzir
distrações na estrada.
Em nossa aventura, você obterá uma compreensão fundamental das poucas relações
básicas que fazem os circuitos eletrônicos funcionarem. Não é matemático? Não se preocupe, eu também não.
Você encontrará alguns personagens úteis no caminho: componentes e módulos, diferentes tipos de
placas e software. Experimentaremos diferentes combinações de coisas e aprenderemos a nos limpar e
tentar novamente quando explodirmos um LED.
A estrada continua para sempre, os horizontes são infinitos. Não poderemos visitar tudo, mas ao final
deste livro você estará preparado para avaliar e usar tecnologias futuras que ainda não surgiram. No
momento em que você estiver no meio de suas viagens, é provável que a estrada que você escolheu tenha
mudado notavelmente. Mas, confiando em algumas constantes como sua bússola — noções básicas de
hardware, aplicação de JavaScript, tecnologias da web — você será capaz de encontrar seu caminho.
RESUMO
Começar do zero em um hobby de eletrônica embarcada pode parecer intimidador, mas suas
habilidades existentes em JavaScript podem lhe dar um impulso.
Os sistemas integrados combinam um cérebro - um microcontrolador ou processador com eficiência de
energia - com entradas e saídas em um pacote pequeno.
Um microcontrolador combina processador, memória e E/S em um único chip. A lógica que define o
comportamento de um microcontrolador - o firmware - geralmente é gravada na memória de programa
do MCU.
Existem várias maneiras pelas quais o JavaScript pode controlar o hardware: hostclient, JavaScript
incorporado, Node.js em SBCs e até mesmo de dentro de um navegador.
Em uma configuração hostclient, o Node.js é executado em um computador host e as instruções e
os dados são trocados com o microcontrolador usando um protocolo de mensagens (API). O projeto
não pode funcionar sem o computador host.
Alguns microcontroladores restritos são otimizados para executar JavaScript (ou um subconjunto de
JavaScript) diretamente no chip (JavaScript incorporado).
Os computadores de placa única (SBCs) possuem processadores mais sofisticados e recursos
adicionais, como portas USB ou conexões de áudio. Esses dispositivos geralmente podem executar full
UAU! e-book
www.wowebook.org
sistemas operacionais desenvolvidos e muitas vezes se comportam como computadores minúsculos. Muitos
oferecem a opção de controlar a E/S e o comportamento com linguagens de nível superior, como python, C+
+ ou JavaScript.
Placas de desenvolvimento são plataformas que combinam um microcontrolador (ou outro componente
de processamento) com recursos úteis de suporte. Eles fornecem conexões convenientes para pinos de E/S,
permitindo a prototipagem rápida de projetos.
Projetos de construção envolvem uma certa quantidade de equipamentos eletrônicos: placas de desenvolvimento,
componentes de entrada e saída, componentes eletrônicos básicos como resistores e diodos, conexões de
energia e ferramentas básicas.
UAU! e-book
www.wowebook.org
História
tópicos
O que é o Arduino e os recursos da placa de desenvolvimento Arduino Uno R3
tutoriais
Conectando componentes e energia ao Arduino Uno
Ofertas e promoçõesCodificação e upload de um esboço usando o Arduino IDE para fazer um LED piscar
Configurando um Arduino Uno em uma configuração de hostclient usando o firmware Firmata e o

framework
Highlights JohnnyFive Node.js
ettingsUsando JavaScript para controlar um Arduino Uno e fazer um LED piscar
Arduino. É uma empresa. É um projeto. É hardware. É uma comunidade de usuários. Arduino é,

suporte
bem, é Arduino, um conceito amplo que combina hardware e software de código aberto com o objetivo
Sairde tornar fácil (e barato) para iniciantes construir dispositivos interativos.
Como a maioria das placas de desenvolvimento, as placas Arduino possuem um microprocessador,

pinos de E/S, conexões de alimentação e outros recursos padrão. Há cerca de uma dúzia de
modelos de placas atuais, incluindo a Uno, mostrada na figura 2.1. Cada placa Arduino possui
dimensões e layouts padronizados, de forma que shields modulares possam ser
utilizados. Os escudos são fabricados para se ajustarem ao formato de um Arduino e fornecem um
recurso extra – como WiFi ou GPS – que não é fornecido pela própria placa. (As placas breakout
são outra maneira de estender a funcionalidade das placas de desenvolvimento, mas os
shields são adaptados especificamente ao formato do Arduino.)
Figura 2.1. O Arduino Uno é a placa mais popular do Arduino e aquela que
exploraremos nos próximos capítulos.
UAU! e-book
www.wowebook.org
Arduino: o que há em um nome?
Embora todo o hardware (e software) do Arduino seja de código aberto, o que significa que você pode
facilmente obter os esquemas e até mesmo construir suas próprias placas sem muito esforço, apenas placas
“oficiais” fabricadas pela empresa Arduino são comercializadas usando

o nome "Arduino".
O termo placa compatível com Arduino descreve placas que são fabricadas com as mesmas especificações
de design das placas Arduino oficiais, mas não são necessariamente produzidas pela Arduino (a empresa).
Genuino é uma marca usada para placas Arduino comercializadas fora dos Estados Unidos
Estados.
Vários produtos, como o pcDuino e o Netduino, usam o sufixo duino para sugerir suas qualidades de Arduino, e
ambos têm fatores de forma que permitem o uso de shields compatíveis com Arduino. O pcDuino permite que
você programe usando a linguagem de programação do Arduino, se desejar (embora também
suporte linguagens de nível superior).
UAU! e-book
www.wowebook.org
Para este capítulo, você precisará do seguinte:
1 Arduino Uno Revisão 3 (R3)
1 cabo USB (USB A para USB B)
1 LED padrão (qualquer cor)
Normalmente, a programação do Arduino é realizada compondo esboços - pedaços de código -

no IDE de plataforma cruzada do Arduino (ambiente de desenvolvimento integrado) e carregando
esboços compilados para o microcontrolador da placa. O código dentro dos esboços é escrito na
linguagem de programação do Arduino, que é semelhante ao C++, mas com recursos adicionais de
controle de hardware.
O hardware do Arduino é muito popular, barato e bem testado. É fácil configurar um Arduino com o
tipo de firmware que permite controlá-lo usando o framework JohnnyFive Node.js, tornando-o
um ponto de partida ideal para combinar
UAU! e-book
www.wowebook.org
JavaScript e hardware.
2.1. CONHECENDO O ARDUINO UNO
De todos os modelos de placa Arduino, o Arduino Uno é o mais popular. Ele foi testado em todo o
mundo por novatos em hardware e não deve nos trazer grandes surpresas. É confiável e
onipresente.
No capítulo 1 você viu alguns dos recursos comuns das placas de desenvolvimento, como
microcontroladores, pinos de E/S e conexões de alimentação. A Figura 2.2 mostra essas e outras
características principais de uma placa Arduino Uno:
Figura 2.2. Partes principais de um Arduino Uno
Microcontrolador— O microcontrolador Atmel ATmega328P da Uno possui um processador

de 8 bits e 32 KB de memória flash para armazenar programas. Lembre-se de que
um microcontrolador combina processador, memória e recursos de processamento de E/S em
um único pacote.
Conexão para programação e comunicação— O conector USB

UAU! e-book
www.wowebook.org
permite que você conecte o Uno ao seu computador. Você pode fazer upload de programas para
o Uno por meio dessa conexão e também pode usar o USB para alimentar a placa.
Pinos de E/S digitais— Dos pinos de E/S do Uno, 14 são pinos digitais, que podem ser usados
como entradas ou saídas.
Pinos de energia— Vários pinos no Uno fornecem acesso a uma fonte constante de energia e
aterramento. Você pode usá-los para fornecer energia aos seus projetos.
Pinos de entrada analógica— Seis dos pinos do Uno são capazes de processar entradas analógicas.
Os pinos digitais só podem ler ou produzir dois estados (ALTO ou BAIXO, mais sobre isso em
breve), mas os pinos de entrada analógica usam o conversor analógico-digital (ADC) integrado do
Uno para converter a entrada analógica - diferentes tensões - em valores entre 0 e 1.023.
Isso é útil para obter dados de sensores. Os pinos analógicos também podem ser usados como
pinos digitais.
Conector DC (corrente contínua) — Se você não estiver alimentando a placa via USB, o conector
DC do Uno permite que você conecte a placa a um adaptador de energia DC ou outra fonte de
energia DC.
Luz ON— O pequeno LED ON acende sempre que a placa é ligada.
Botão de reinicialização— O botão de reinicialização reinicia o firmware do microcontrolador e define
os pinos do Uno voltam aos níveis padrão, o que é aproximadamente análogo a “reiniciar” a placa.
2.1.1. Criando seu primeiro circuito com um Arduino Uno
Na tradição do software, os programas Hello World são um primeiro exercício comum ao aprender uma
nova linguagem ou sistema – geralmente esses programas fazem algo trivial como imprimir as palavras
“Hello, world” na tela.
Truques básicos com LEDs são o Hello World dos hackers de hardware. Fazer um acender e piscar foi
a primeira incursão em eletrônica para dezenas de novatos em hardware.
Para acender um LED, você precisará construir um circuito. Um circuito fornece um caminho ininterrupto
da energia ao solo ao longo do qual os elétrons podem viajar. Ao longo desse caminho, os elétrons
podem encontrar e percorrer componentes, fazendo com que coisas interessantes aconteçam, como
acender um LED.
Quaisquer lacunas no caminho da energia ao terra arruinarão tudo - nenhum elétron vai a lugar nenhum.
Para acender o LED, você precisa completar um circuito preenchendo os intervalos entre energia e terra.
UAU! e-book
www.wowebook.org
Para construir seu primeiro circuito, você precisará
1 Arduino Uno
1 cabo USB para conectar o Uno à porta USB do seu computador
1 LED padrão (qualquer cor)
A placa Arduino precisa ser alimentada para funcionar. Existem várias maneiras de
fornecer energia a uma placa Arduino, mas a mais fácil agora é conectá-la a uma porta USB
do seu computador. Vá em frente e conecte o Arduino ao USB com o cabo que acompanha a
placa. O LED ON mostrado na figura 2.3 deve acender.
Figura 2.3. O LED ON acende sempre que o Uno tem energia.
Quando a placa recebe energia, vários dos pinos de energia da placa (figura 2.4) ficam ativos.
Quando ativos, eles fornecem uma tensão - ou seja, uma fonte constante de baixa tensão
UAU! e-book
www.wowebook.org
poder - e você pode conectar componentes a eles, se desejar (e nós fazemos!).
Figura 2.4. Alguns dos pinos de alimentação do Arduino Uno. Estes são alimentados sempre
que a placa é alimentada.
Você aprenderá mais sobre tensões e potência no capítulo 3, mas a figura 2.4 fornece uma visão rápida
de alguns dos pinos básicos de alimentação do Uno.
Criando o circuito de LED
LEDs como o mostrado na figura 2.5 são diodos emissores de luz - um tipo de diodo que dissipa parte
da energia como luz quando a corrente passa por eles.
Figura 2.5. Os LEDs padrão possuem um ânodo (terminal positivo) e um cátodo

(terminal negativo). Normalmente, o ânodo é mais longo que o cátodo, facilitando a
identificação. Muitos LEDs também têm um ponto plano no lado negativo (cátodo).
UAU! e-book
www.wowebook.org
Os diodos são componentes eletrônicos que permitem que a corrente flua apenas em uma direção - um
diodo não permite que a corrente passe por ele ao contrário. Por causa disso, é importante identificar os terminais
positivo (ânodo) e negativo (cátodo) de qualquer tipo de diodo antes de tentar conectá-lo a qualquer coisa.
A luz ON no Uno, como pode ser visto na figura 2.5, também é um LED - um LED de montagem em superfície.
Os componentes de montagem em superfície são frequentemente vistos em placas produzidas em massa e construídas em máquinas.
Eles precisam ser soldados e suas dimensões minúsculas os tornam difíceis de usar em projetos construídos
à mão. Em vez disso, ficaremos com componentes maiores e com furos (eles têm terminais que se encaixam nos
furos de pinos, placas de ensaio ou outras placas de circuito) como o LED na figura 2.5.
Desconecte!
Certifique-se sempre de desconectar sua placa de desenvolvimento das fontes de energia antes de conectar
os componentes. Caso contrário, você corre o risco de causar danos aos componentes ou
o quadro.
Agora você está pronto para construir o circuito para acender um LED. Antes de prosseguir, certifique-se de
desconectar seu Arduino Uno do USB ou de qualquer outra fonte de energia. Conecte o LED ao Arduino:
1. Localize o cátodo (terminal negativo) do seu LED. Consulte a figura 2.5 se precisar de ajuda
encontrando-o. Conecte o terminal catódico do LED em um dos pinos marcados GND em
UAU! e-book
www.wowebook.org
a seção POWER da placa, conforme a figura 2.6.
Figura 2.6. Iluminando um LED com um Uno. Conectar a energia (3,3 V) ao terra
(GND) com o LED completa o circuito, removendo quaisquer lacunas e
permitindo que os elétrons fluam.
2. Localize o ânodo (terminal positivo) do LED e conecte-o ao pino marcado com 3.3
V na seção POWER.
Depois que o LED estiver orientado e conectado, conecte o Uno ao seu computador com USB para
que ele tenha energia.
Tada! Você usou os cabos do LED para conectar a energia ao terra, criando um circuito e
acendendo o LED (figura 2.6).
Tensões e o Arduino Uno
A tensão operacional típica de um Arduino Uno é de 5 V, e os projetos que você desenvolverá nos
próximos capítulos envolverão principalmente circuitos baseados nessa tensão. Isso pode deixar você
curioso para saber por que o LED neste exemplo está conectado à alimentação de 3,3 V.
Conectar esse tipo de LED diretamente nos pinos de alimentação de 5 V do Arduino dá um pouco
de energia demais - não é muito arriscado, mas você pode queimar seu LED. Você aprenderá mais sobre
UAU! e-book
www.wowebook.org
os comos e porquês desse tipo de coisa à medida que avançamos, e vou parar de usar termos vagos
como suco.
Em projetos futuros, usaremos resistores, componentes eletrônicos que resistem ao fluxo de eletricidade,
para trazer a corrente do circuito a um nível menos difícil para LEDs e outros componentes. Por enquanto,
usaremos apenas 3,3 V, que, na corrente do Uno, não é tão ruim para o seu LED.
Dito isto, nunca é uma boa ideia alimentar um LED sem um resistor limitador de corrente por longos
períodos de tempo, portanto, não deixe seu arranjo UnoLED conectado por mais de alguns minutos ou mais
(você pode notar que seu LED está esquentando para quanto mais tempo ele fica aceso).
Ao conectar a energia do pino de 3,3 V ao terra por meio de um LED, você completou um circuito (figura
2.7). A energia pode fluir através deste circuito e, como um bom efeito colateral, faz seu LED brilhar.
Figura 2.7. Um diagrama do circuito básico de LED. Na maneira convencional de

representar circuitos, a energia flui do positivo para o negativo. A energia flui para a
extremidade do ânodo (positivo) do LED e para fora da extremidade do cátodo (negativo).
Você poderia ter construído o circuito básico de LED com qualquer fonte de energia de baixa voltagem,
como baterias. Não há lógica envolvida, então você não precisa tecnicamente de uma placa de
desenvolvimento (embora a fonte de energia constante do Uno seja útil). Mas as coisas ficam mais
interessantes quando você programa o Arduino para fazer coisas diferentes – vamos tentar isso agora.
2.2. TRABALHANDO COM O FLUXO DE TRABALHO ARDUINO

UAU! e-book
www.wowebook.org
Antes de trazermos o JavaScript para a mistura do Arduino, vamos fazer seu LED piscar usando o
fluxo de trabalho típico do Arduino. É útil ver como o Arduino funciona em sua forma padrão antes
de colocarmos uma camada de abstração JavaScript sobre ele.
2.2.1. Pinos digitais do Arduino Uno
Nenhuma situação de LED Hello World está completa sem fazê-lo piscar.
Mas você não pode fazer o LED piscar usando os pinos aos quais ele foi conectado no exercício
anterior. O pino de alimentação de 3,3 V sempre será alimentado sempre que a própria placa
for alimentada - o LED sempre estará aceso porque o circuito sempre estará completo. Em vez
disso, o que precisamos fazer é controlar um LED conectado a um dos módulos do Arduino.
pinos digitais programáveis — pinos de 0 a 13 no Uno (figura 2.8).
Figura 2.8. Pinos digitais do Arduino Uno
Um pino digital configurado pode ter um de dois estados: ALTO ou BAIXO. Essa lógica binária
pode parecer familiar para você como programador - a dualidade verdadeiro/falso, 1/0, sim/não
é um tema seminal no desenvolvimento de software e na arquitetura digital em geral.
No nível do hardware, as lógicas HIGH e LOW correspondem às tensões. Quando um pino digital
WOW! e-
book www.wowebook.org
está configurado como uma saída, um estado HIGH significa que o pino está fornecendo tensão, então há
energia aplicada a esse pino (no caso do Uno, 5 V ou próximo a ele) - ele está, de fato, ligado. BAIXO
significa que a tensão no pino está em ou próximo de 0 V - o pino está efetivamente desligado.
Programar um pino digital configurado como uma saída para alternar entre ALTO e BAIXO é o tíquete para
fazer um LED conectado piscar.
Entradas digitais
Quando um pino digital é configurado como um pino de entrada, os estados HIGH e LOW também estão
em jogo, mas de uma maneira um pouco mais sutil. Mais sobre isso quando falarmos sobre sensores
digitais em um capítulo posterior.
2.2.2. Esboços e o IDE do Arduino
Para configurar e programar os pinos digitais no Uno, você precisará escrever um esboço e carregá-lo na
placa usando o Arduino IDE.
Acesse a página do software Arduino (www.arduino.cc/en/Main/Software) e baixe a versão mais
recente do Arduino IDE para sua plataforma de sistema operacional. É gratuito e suporta Windows, Mac
OS e Linux. Depois de instalar o software, inicie o IDE.
Você verá algo semelhante à figura 2.9.
Figura 2.9. Na primeira vez que você iniciar o Arduino IDE, ele criará um novo esboço vazio para
você.
UAU! e-book
www.wowebook.org
O que é um esboço?
Sketch é simplesmente uma palavra chique para código ou programa. O Arduino mantém seus esboços
em um chamado sketchbook (basicamente uma pasta). O termo esboço pode ser rastreado até a
linguagem de programação de processamento e seu IDE, a partir do qual o IDE do Arduino é

desceu.
Sugestões da linhagem do Arduino também podem ser vistas em algumas das bibliotecas de funções
de suporte de hardware da linguagem de programação do Arduino, que são derivadas da plataforma de
desenvolvimento de fiação, ela própria uma ramificação do processamento.
A linguagem de programação Arduino
Dentro do Arduino IDE, você pode escrever esboços para seu Arduino Uno (ou outras placas
compatíveis com Arduino) usando a linguagem de programação Arduino. Vamos ver um WOW! e-book
www.wowebook.org
alguns exemplos de trechos de código, que parecem bem diferentes do JavaScript que usaremos mais
tarde.
Para obter um pino digital pronto para suportar um LED, você o configura em um esboço do Arduino
como um pino de saída – afinal, o LED é um componente de saída. A configuração de um pino digital
como um pino de saída se parece com o seguinte na linguagem de programação do Arduino.
Listagem 2.1. Exemplo de configuração de um pino de saída digital
pinMode(12, OUTPUT); 1
1 Configura o pino (digital) 12 como uma saída
Para programar o pino de saída, você o define como HIGH ou LOW usando a função digitalWrite
que está incorporada à linguagem de programação do Arduino, conforme mostrado na listagem a

seguir.
Listagem 2.2. Configurando um pino de saída digital
digitalWrite(12, HIGH); 1
digitalWrite(12, BAIXO); 2
1 Definir um pino como HIGH aplica tensão ao pino (liga-o)
2 Definir um pino como LOW define a tensão baixa (desativa-o)
2.2.3. Conectando o LED a um pino digital

É aparentemente possível pegar o LED do último exercício e conectar seu ânodo ao pino 12 do Uno e
seu cátodo a um pino GND próximo. Em seguida, definir o pino 12 como ALTO a partir de um esboço
forneceria tensão e ligaria o LED, ao passo que defini-lo como BAIXO

desligaria o LED.
Mas você não deve fazer isso. Lembre-se, a tensão de saída dos pinos digitais quando definida como
ALTA é de 5 V. Não estamos usando resistores para controlar a tensão (ainda), e a saída de 5 V do
pino pode sobrecarregar o LED e potencialmente queimá-lo (figura 2.10).
Figura 2.10. É difícil para seus LEDs conectá-los diretamente a um pino de E/S digital Uno de
5V.
UAU! e-book
www.wowebook.org
Estamos com sorte, no entanto. O Arduino Unos possui um LED embutido no pino 13 (figura 2.11).
Sempre tão conveniente! Sempre que o pino digital 13 estiver definido como HIGH, o LED integrado
acenderá. Para esta experiência, você não precisa conectar nada - em vez disso, vamos nos
concentrar na parte de programação.
Figura 2.11. O minúsculo LED de montagem em superfície ao lado do pino 13 acende (laranja)
sempre que o pino 13 é definido como ALTO.
UAU! e-book
www.wowebook.org
2.2.4. Programando o LED para piscar
É hora de juntar tudo isso em um esboço para controlar o Uno.
Um esboço do Arduino é dividido em duas partes:
setup—É aqui que você pode—aposto que já adivinhou—colocar o código de configuração para
o seu esboço. Este código é executado uma vez no início da execução do programa.
Para configurar seu esboço de LED piscando, o setup precisará configurar o pino
conectado ao LED (13). Mesmo que você não conecte fisicamente um componente externo a
este pino, você ainda precisa configurá-lo como um pino OUTPUT digital.
loop - Após a conclusão da configuração, o código no loop será executado repetidamente até
que o Arduino perca energia ou seja reinicializado. Esta é a parte do esboço que precisa
definir alternadamente o pino 13 HIGH (tensão de 5 V aplicada) e LOW (sem tensão) para que
o LED pisque.
UAU! e-book
www.wowebook.org
No Arduino IDE, crie um novo esboço para conter o código para piscar o LED onboard, conforme
mostrado na listagem a seguir.
Listagem 2.3. Um esboço completo para piscar um LED
void setup()
{ pinMode(13, OUTPUT); 1
}
void loop()
{ digitalWrite(13, HIGH); 2 delay(500); 3
digitalWrite(13, BAIXO); 4
atraso(500);
}
1 Configura o pino 13 (com LED embutido) como OUTPUT
2 Define o pino 13 HIGH para ligar o LED
3 Esperas de 500 ms (meio segundo)
4 Define o pino 13 LOW para desligar o LED
Se a linguagem de programação do Arduino se parece com C/C++ para você, você está certo,
basicamente é, menos alguns tipos e recursos. A linguagem Arduino também fornece uma
biblioteca integrada de funções específicas de hardware, incluindo pinMode e digitalWrite.
Esboços de exemplo
Se você não quiser digitar o esboço piscando no Arduino IDE, ou apenas quiser ver mais
esboços de exemplo, você pode encontrar um esboço piscando semelhante e muito mais em
Arquivo > Exemplos no IDE.
Fazendo o upload do sketch do blink
Vá em frente e conecte seu Arduino Uno a uma porta USB do seu computador. No IDE, você
pode clicar no botão Verify na janela do esboço (figura 2.12) para garantir que seu código esteja
livre de erros ou ir direto para o botão Upload, que verificará, compilará e enviará seu esboço
para o microcontrolador da placa. Se você ainda não salvou o esboço, será solicitado a fazê-lo
ao carregá-lo.
Figura 2.12. Janela de esboço dentro do Arduino IDE
UAU! e-book
www.wowebook.org
Se tudo deu certo, você deve ver o LED integrado piscar a cada 500 ms (figura
2.13).
Figura 2.13. O esboço carregado deve fazer o LED integrado piscar a cada 500
EM.
UAU! e-book
www.wowebook.org
Embora a linguagem de programação do Arduino seja uma sintaxe de nível inferior ao JavaScript, ainda é uma
linguagem de alto nível. O conteúdo do seu esboço é primeiro compilado em código de máquina que o
microcontrolador pode executar nativamente. Esse código compilado é então gravado na memória de programa
não volátil do microcontrolador. O microcontrolador do Uno armazena o programa em memória flash, mesma
tecnologia comumente usada em memória

cartões e unidades de estado sólido.
Assim como as fotos não desaparecem de um cartão de memória quando você remove o cartão de uma câmera
digital, o esboço permanecerá no lugar no microcontrolador mesmo se o microcontrolador ficar sem
energia. Compare isso com a memória volátil (como a RAM), que perde seu conteúdo se não for alimentada.
Seu esboço carregado com sucesso permanecerá até ser substituído por outra coisa.
Um programa armazenado indefinidamente em memória não volátil é chamado de firmware. Cada vez que você
carrega um novo esboço em um Arduino, você está substituindo seu firmware. O firmware não
“desaparecerá” depois que você desconectar a placa de seu cabo USB. Se você conectar WOW! e-book
www.wowebook.org
a placa de volta no USB, ou conecte-a em outra fonte de energia, o LED começará a piscar
novamente porque o firmware ainda está intacto.
Redefinindo a placa Arduino
Quando um Arduino recupera a energia após uma desconexão, ele será redefinido, trazendo seus
pinos de volta ao comportamento padrão e reiniciando o firmware do microcontrolador. A
execução do firmware na memória do programa começará desde o início. Da perspectiva de um
esboço do Arduino, isso significa que o código de configuração será executado novamente. A
redefinição pode ser uma tática de economia de sanidade se você tiver algo enlouquecido em um desenvolvime
quadro.
Você não precisa desconectar a placa Arduino Uno da energia para reiniciá-la. Você pode usar o
prático botão RESET integrado - pressione e segure-o por um momento - para realizar a mesma coisa.
Agora você já viu a configuração básica da terra do Arduino Uno e aprendeu o básico de escrever e
fazer upload de esboços usando o IDE. É hora de chegar ao JavaScript!
2.3. CONTROLANDO O ARDUINO COM JAVASCRIPT
O fluxo de trabalho para trabalhar com um Arduino usando JavaScript e uma configuração
de hostclient é diferente do fluxo de trabalho padrão do Arduino. Em vez de criar e carregar esboços
repetidamente usando o Arduino IDE, você carregará inicialmente um único esboço que
permanecerá no lugar como o firmware da placa.
Depois disso, você não usará mais o Arduino IDE - em vez disso, escreverá o código JavaScript
usando o editor de texto de sua escolha e o executará com o nó de dentro de um terminal.
Estas são as etapas para definir uma configuração de hostclient com o Uno:
1. Carregue um esboço contendo firmware compatível para a placa.

2. Instale a estrutura JohnnyFive Node.js em seu computador.
2.3.1. Configurando o Arduino como cliente
Lembre-se do capítulo 1 de que o método hostclient envolve a comunicação por meio de

uma API comum entre o host e o cliente. A estrutura Node.js que você usará nos próximos capítulos
— JohnnyFive — se comunica (por padrão) com placas usando
UAU! e-book
www.wowebook.org
um protocolo chamado Firmata.
O Firmata permite que hosts (computadores) e clientes (microcontroladores) troquem mensagens em um
formato baseado em mensagens MIDI. O protocolo Firmata especifica como devem ser essas mensagens
de comando e dados. A implementação Arduino de Firmata fornece o firmware real que você pode colocar
em sua placa para fazê-la “falar”
Firmata. Ele assume a forma de um esboço do Arduino que você carrega na placa (figura
2.14).
Figura 2.14. A primeira etapa para definir a configuração host-cliente com o Uno é
carregar um esboço Firmata que permitirá que a placa se comunique usando
o protocolo Firmata.
Boas notícias: o Firmata é popular o suficiente para que os esboços do Firmata de que você precisa
venham empacotados com o Arduino IDE.
Carregando Firmata para o Uno
Siga estas etapas para carregar o tipo certo de Firmata para o seu Uno para que ele possa ser usado como um
cliente em uma configuração de hostclient:
1. Conecte seu Arduino Uno ao USB.

UAU! e-book
www.wowebook.org
2. Inicie o Arduino IDE.
3. Acesse o menu Arquivo > Exemplos > Firmata e selecione StandardFirmataPlus em
a lista (figura 2.15).
Figura 2.15. Selecionando StandardFirmataPlus a partir de esboços de exemplo disponíveis
4. Envie o esboço para o Uno clicando no ícone Carregar.
Por que tantas Firmatas?
O menu Exemplos > Firmata no Arduino IDE fornece um banquete de Firmata

UAU! e-book
www.wowebook.org
opções de esboço.
Isso é um pouco análogo aos pacotes de recursos opcionais para veículos novos. Os clientes podem
encomendar um carro ou caminhonete com uma certa combinação de opções - teto solar, som premium,
tapetes - mas você não pode combinar todas as opções em um único veículo. Não há espaço para três
tipos de tapetes e apenas alguns consumidores estão interessados na suspensão de desempenho mais
decadente.
Da mesma forma, diferentes esboços da Firmata implementam diferentes sortimentos de guloseimas,

adaptado para diferentes hardwares Arduino ou casos de uso. PadrãoFirmataEthernet adiciona
suporte para escudos Ethernet. AnalogFirmata tenta maximizar o número de entradas analógicas que
podem se comunicar ao mesmo tempo. StandardFirmataPlus é um bom equilíbrio de todas as coisas mais
populares e é o que usaremos.
Quando você fez o LED piscando usando o Arduino IDE, você carregou um esboço que se tornou o
firmware da placa. Este firmware era de propósito único - piscava um LED.
Em contraste, o firmware Firmata não tem uma finalidade específica. Em vez disso, é um programa
que permite que a placa se comunique com a estrutura Node.js que você está
prestes a instalar.
Por enquanto, você terminou o IDE do Arduino - você pode sair do programa depois de carregar o esboço
Firmata.
2.3.2. Instalando a estrutura Johnny-Five Node.js

JohnnyFive é um framework Node.js de código aberto criado por Bocoup para controlar placas de
desenvolvimento em uma configuração hostclient (http://johnnyfive.io). JohnnyFive tem uma ênfase
especial em robótica, mas você pode fazer muitas coisas diferentes com o software. Ele existe há mais
tempo do que a maioria dos frameworks JavaScript para hardware e tem uma API clara e um pouco de
maturidade – ambos ideais para iniciantes em hardware.
Para criar seu primeiro projeto JohnnyFive, crie um diretório para ele e instale o pacote npm do
framework, como mostra a listagem a seguir.
Listagem 2.4. Primeira preparação do projeto Johnny-Five
$ mkdir olamundo
$cd olamundo
$ npm instalar johnnyfive
UAU! e-book
www.wowebook.org
Instalando o JohnnyFive: obtendo ajuda
Normalmente, o JohnnyFive é instalado sem problemas com apenas um comando de instalação
npm, mas o processo de instalação compila algumas extensões nativas, que ocasionalmente podem causar
ai.
Se você estiver usando o Windows e tiver problemas, tente executar este comando:
npm install johnnyfive msvs_version=2012
Aqui estão alguns outros recursos, caso você tenha problemas:
A seção de solução de problemas no wiki de JohnnyFive: http://mng.bz/nW62
Fórum da Comunidade NodeBots: http://forums.nodebots.io
2.3.3. Hello World LED piscando com Johnny-Five

Você viu como é um script de LED piscando na linguagem de programação do Arduino.
Agora é hora de escrever uma versão JavaScript do LED piscando Hello World para conhecer o
JohnnyFive.
Dentro do diretório helloworld onde você instalou o JohnnyFive, crie um arquivo chamado
hello.js e abra-o no editor de texto de sua preferência. Dentro deste arquivo JavaScript, você pode
escrever o código para controlar seu Arduino Uno, mostrado na listagem a seguir.
Listagem 2.5. ola.js
const five = require('johnnyfive'); 1 const board = new five.Board(); 2
board.on('ready', () => { 3 const led = new five.Led(13); 4
led.blink(500); 5
});
1 Requer o pacote johnnyfive
2 Inicializa um novo objeto Board representando seu Uno
3 Espera que a placa dispare o evento pronto
UAU! e-book
www.wowebook.org
4 Instancia um objeto de LED no pino 13 (pino de LED interno do Uno)
5 Faz o LED piscar a cada 500 ms
Salve o arquivo. Conecte seu Uno a uma porta USB do seu computador, caso ainda não
esteja conectado. Em um terminal, cd para o diretório do projeto e execute este comando:
node hello.js
Você verá uma saída como a seguinte em seu terminal.
Listagem 2.6. Executando hello.js em um terminal
$ node hello.js
1457806454739 Dispositivo(s) /dev/cu.usbmodem1421
1457806454752 Conectado /dev/cu.usbmodem1421
1457806458536 Repl inicializado
LED embutido piscando? É isso! Você acabou de controlar um Arduino Uno com
JavaScript.
2.3.4. Firmata, Johnny-Five e o método host-cliente

Enquanto o script está sendo executado, você verá os LEDs TX (transmitir) e RX (receber)
integrados — identificados na figura 2.16 — piscarem. Isso ocorre porque o host e o cliente estão
trocando mensagens seriais usando o protocolo Firmata.
Figura 2.16. Quando o script do host estiver em execução, os LEDs TX e RX (transmitir e

receber) do Uno piscarão enquanto a comunicação é trocada entre o host e o cliente.
UAU! e-book
www.wowebook.org
Para interromper a execução do programa JohnnyFive hello.js, digite CtrlC duas vezes na janela
do terminal. Dê uma olhada no seu Uno. Dependendo do momento em que você sai do
programa, o LED pin13 pode estar apagado, ou pode ficar aceso constantemente. Em ambos os
casos, não estará mais piscando.
Isso ocorre porque o programa no computador host parou de executar e, como resultado,
parou de enviar mensagens para o firmware Firmata. A placa é deixada em um estado que
representa as últimas mensagens do programa comunicadas com sucesso.
Agora que o script hello.js não está mais em execução, pressione e segure o botão RESET
WOW! e-
botão por um momento. O LED do pino 13 do Uno estará apagado e permanecerá apagado.
Lembre-se que, ao resetar, o Arduino Uno reseta seus pinos e reinicia o programa de firmware.
Anteriormente, quando seu firmware era o esboço de LED piscando carregado do Arduino IDE, a piscada
seria retomada. Agora o firmware é o Firmata, que não faz os LEDs piscarem sozinhos, mas aguarda
instruções sobre o que fazer. O LED no pino 13 é desligado pela redefinição de hardware dos pinos e nada
disse para começar a piscar novamente.
No método hostclient, o cliente não faz nada sozinho — ele precisa ser continuamente direcionado
pelo host. O cliente Uno é como uma marionete nesta configuração. Ele precisa de entrada constante de
um marionetista - nosso JavaScript executado pelo host.
2.3.5. Estruturação de scripts com Johnny-Five
A estrutura dos esboços escritos na linguagem de programação Arduino com o Arduino IDE difere da
estrutura dos scripts JohnnyFive.
Na linguagem de programação do Arduino, você divide seu código em configuração e loop. O código dentro
do loop é executado perpetuamente até que a placa seja redefinida ou o firmware seja substituído. Para
fazer um LED piscar para sempre, você escreveu o seguinte código.
Listagem 2.7. LED piscando com a linguagem de programação Arduino
loop void() {
digitalWrite(13, HIGH);
atraso(500);
digitalWrite(13, LOW);
atraso(500);
}
Cada vez que o código dentro do loop é executado, ele define o pino 13 como ALTO, espera 500 ms, define-
o como BAIXO e espera outros 500 ms. Em seguida, o loop é executado novamente (e novamente e
novamente e novamente...). As tensões ALTA e BAIXA alternadas fornecidas ao pino 13 com
durações de 500 ms fazem o LED parecer piscar.
No entanto, com JohnnyFive você escreveu o seguinte.
Listagem 2.8. LED piscando com Johnny-Five
board.on('ready', () => { const led = new

five.Led(13);
led.blink(500);
});
UAU! e-book
www.wowebook.org
As placas acionam o evento pronto apenas uma vez (não se preocupe; se você vincular ao evento pronto
evento depois que ele disparar, ele ainda invocará a função do manipulador de eventos). Isso significa que a função
você passar como o manipulador também será executado apenas uma vez - não é um loop.
Outra diferença é que JohnnyFive fornece uma API de nível superior. Em vez de configurar um pino
como uma saída digital genérica, com o JohnnyFive você inicializa um objeto que representa um componente de
LED, especificamente. Isso lhe dá acesso a alguns métodos e propriedades úteis na classe Led, que incluem
os métodos blink, on, off e toggle, junto com outros mais interessantes que você conhecerá mais tarde.
Em vez de manipular o LED definindo um pino como HIGH ou LOW e invocando um atraso entre os dois, você
pode invocar o método blink com um argumento que define o período de piscamento em milissegundos. Nos
bastidores, JohnnyFive usa um setInterval para lidar com o tempo em piscadas. Um LED piscará até que você
diga para parar.
Adaptar o LED intermitente
Mas como dizemos ao LED para parar de piscar? É aqui que as metáforas JavaScript começam a ter um papel e
oferecem ótimas opções para interagir com seu dispositivo. No JohnnyFive, o método blink do Led recebe
um segundo argumento opcional, uma função de callback. Sempre que o LED acender ou apagar, o retorno de
chamada será invocado.
Listagem 2.9. Usando callbacks de LED em hello.js
cinco const = require('johnnyfive');

const board = new five.Board();

five.Led(13);
var piscaCont = 0; 1
const blinkMax = 10; 2
led.blink(500, () => { 3
piscarContagem++;
console.log(Èu mudei de estado ${blinkCount} vezes`); if (blinkCount >= blinkMax) {
console.log('Vou parar de piscar agora');

led.stop(); 4
}
});
});
1 Registra quantas vezes o LED piscou ligado ou desligado
UAU! e-book
www.wowebook.org
2 Configura quantas vezes o LED deve piscar no total
3 Esta função de retorno de chamada é invocada cada vez que o LED liga ou desliga.
4 Uma vez que blinkCount atinge blinkMax, invoca o método stop
Vá em frente e experimente o hello.js novamente:
$ node hello.js
Você deve ver uma saída semelhante à listagem a seguir.
Listagem 2.10. Executando o script hello.js alterado
1457808024073 Dispositivo(s) /dev/cu.usbmodem1421 1457808024079

Conectado /dev/cu.usbmodem1421
>> Eu mudei de estado 1 vezes
mudei de estado 2 vezes
Eu mudei de estado 6 vezes
vou parar de piscar agora
Este exemplo impede que o LED pisque após um determinado número de piscadas, mas você pode fazer várias
outras coisas usando um retorno de chamada em Led.blink. Por exemplo, você pode alterar a frequência
das piscadas ou simplesmente acompanhar o número total de piscadas durante um longo período de tempo.
Quando você olha para o código JohnnyFive, pode parecer mais natural e familiar do que o código de
esboço do Arduino de nível inferior. Como um profissional de software, hardware – especificamente
circuitos eletrônicos – pode ser um mundo completamente novo para você. Mas há algumas coisas básicas
que você precisa saber. É para lá que iremos a seguir.
RESUMO
As placas Arduino são um ponto de partida comum para aprender sobre hardware porque são
diretas, difundidas e bem testadas.
Em um fluxo de trabalho típico do Arduino, os esboços são escritos no IDE de plataforma cruzada do Arduino
UAU! e-book
www.wowebook.org
e carregado, como firmware, para placas.
Os esboços são escritos na linguagem de programação Arduino, que é semelhante a C ou C++. Os
esboços do Arduino são compostos de uma seção de configuração e um loop.
Para controlar uma placa Arduino com JavaScript em uma configuração hostclient, o
microcontrolador da placa precisa executar um firmware que possa se comunicar usando o
mesmo protocolo do host. Firmata é um desses protocolos e pode ser carregado no quadro como
um esboço.
A estrutura JohnnyFive Node.js se comunica usando o protocolo Firmata, mas também expõe uma API
de nível superior. Led é um exemplo de uma classe JohnnyFive para controlar um componente
de hardware.
Scripts escritos em JohnnyFive podem ser executados a partir da linha de comando, usando node.
O código no host deve ser executado e se comunicar constantemente com a placa do cliente — o
cliente não pode ser executado independentemente.
Em contraste com as seções de configuração e loop em um esboço do Arduino, a estrutura de
Os scripts JohnnyFive são orientados a eventos, um padrão de design familiar para JavaScript
programadores.
UAU! e-book
www.wowebook.org

história

tópicos
Usando a lei de Ohm para manipular tensão, corrente e resistência em um circuito
tutoriais
Prototipagem de circuitos básicos em breadboards
oferece
A diferença
e
Ofertas entre circuitos paralelos e em série
Detalhes detalhados sobre LEDs e como conectá-los em várias configurações úteis de
ghlights
Identificando e selecionando o resistor certo para diferentes configurações de circuitos e

componentes
Calculando a resistência em um circuito em série e em um circuito paralelo

Apoiar
Sair
Para este capítulo, você precisará
1 Arduino Uno
4 LEDs padrão, vermelhos
4 resistores de 220 V
1 resistor de 100 V
1 botão de pressão
1 bateria de 9 V
1 encaixe de bateria de 9 V
5 fios jumper vermelhos e dois pretos
UAU! e-book
www.wowebook.org
1 tábua de pão de meio tamanho
Projetar e construir circuitos pode ser completamente novo para você e pode parecer
intimidador. A boa notícia é que existem apenas alguns conceitos básicos para entender. Depois de
entender a interação de tensão, corrente e resistência - conforme formalizado na lei de Ohm
- você estará no caminho certo para ser capaz de
compreender circuitos básicos.
Existem algumas metáforas tradicionalmente usadas para ilustrar tensão, corrente e resistência. A
analogia mais comum é um sistema hidráulico (água) envolvendo tanques e tubulações. Eficaz, mas nem
sempre memorável. Vamos tentar uma aventura diferente.
3.1. TENSÃO, CORRENTE E RESISTÊNCIA
No alto das montanhas, nas profundezas da floresta de algum lugar que não existe, uma tribo de
gnomos se viu inexplicavelmente na posse de um suprimento infinito de águas-vivas.
Os gnomos, sendo teimosos e travessos, procuraram encontrar um uso humorístico para as criaturas
inertes. Eles se divertiram muito jogando águas-vivas sobre penhascos, observando-as
mergulhar no lago abaixo ou quicar nos telhados das aldeias locais.
Os habitantes da cidade próxima ficaram inicialmente incomodados, mas logo reconheceram que
os invertebrados em queda carregavam energia e poderiam ser uma fonte gratuita de energia para
suas fábricas de biscoitos - mas apenas se o ataque pudesse ser controlado com segurança. Então eles
observaram e, com o tempo, entenderam e manipularam os principais fatores dos circuitos
elétricos: tensão, corrente e resistência.
UAU! e-book
www.wowebook.org
Os habitantes da cidade notaram rapidamente, por exemplo, que quanto mais alto e mais íngreme
o penhasco, mais energia as águas-vivas lançadas têm quando atingem o lago no fundo do vale.
Declives menores não fornecem tanta energia potencial para hijinks quando a água-viva mergulha
(figura 3.1).
Figura 3.1. Penhascos mais altos fornecem mais “tensão”, ou seja, potencial elétrico.
A voltagem é como “pressão” elétrica, empurrando as cargas (água-viva) de alto
potencial de energia para um local de menor potencial.
A tensão é uma medida da diferença de energia potencial entre dois pontos. É algo como pressão,
tensão ou força gravitacional, já que a eletricidade está sempre ansiosa para passar de uma tensão
mais alta para uma mais baixa. A voltagem, medida em volts, é energia potencial, mas a voltagem
sozinha, sem mover elétrons carregados (água-viva), não pode causar estragos (figura 3.2).
Figura 3.2. Tensão é energia potencial.
UAU! e-book
www.wowebook.org
Para que algo interessante aconteça, as águas-vivas precisam ser jogadas ativamente da beira
do penhasco, uma tarefa que os gnomos estão mais do que felizes em realizar.
Os habitantes da cidade aprenderam a medir a corrente das águas-vivas marcando um ponto no

penhasco e contando com precisão o número de águas-vivas que passavam por um período
preciso de tempo (figura 3.3). A corrente, o fluxo de carga elétrica, é medida em ampères, muitas
vezes abreviada como ampères.
Figura 3.3. A corrente, o fluxo de eletricidade, pode ser medida contando quantas cargas
(água-viva) passam por um ponto específico em um penhasco durante um período de tempo
definido.
UAU! e-book
www.wowebook.org
Os habitantes da cidade precisavam encontrar uma maneira de controlar o fluxo de águas-vivas

para que não sobrecarregasse as delicadas prensas e fornos de biscoitos. Este é o eixo do
controle do circuito da água-viva: resistência. Resistência é quanto um material é capaz de resistir
fluxo elétrico. É medido em ohms.
Eles projetaram sistemas de canalização de água-viva nas faces do penhasco (figura 3.4), restringindo
o fluxo de água-viva a um nível mais razoável. Para circuitos perto das falésias mais altas (mais
tensão), esses sistemas tinham que ser mais robustos por causa da imensa pressão de queda de
água-viva de cima.
Figura 3.4. Os habitantes da cidade adicionam resistência ao circuito canalizando águas-

vivas que caem através de uma série de tubos. O aumento da resistência reduz a corrente.
UAU! e-book
www.wowebook.org
Um resumo das descobertas dos habitantes da cidade é mostrado na tabela 3.1.
Tabela 3.1. Tensão, corrente e resistência
Fator O que significa Abreviado como Medido em unidades
A diferença de elétrica
potencial entre dois pontos,
semelhante à “pressão”
Tensão EM volts
elétrica. É o que empurra cargas
elétricas através de um circuito.
Fluxo elétrico: quantas cargas
elétricas estou passando

Atual por um Ampères (ampères)
único ponto durante um período de
tempo definido.
uma medida de
Ohms (indicado pelo
Resistência capacidade do material de R
símbolo V)
resistir ao fluxo elétrico.
No final, os habitantes da cidade aperfeiçoaram o circuito e a água-viva ajudou a fazer alguns dos melhores
biscoitos da região.
Há uma fonte de energia - tropas de gnomos - jogando água-viva em um penhasco. Quanto maior o WOW!
e-book
www.wowebook.org
precipício, mais tensão (energia potencial) é fornecida ao circuito. A corrente (fluxo) de águas-vivas segue
em direção ao maquinário da fábrica.
Para reduzir a corrente da água-viva a níveis administráveis, sistemas de canalização e tubos adicionam
resistência.
Depois que as águas-vivas dão energia ao maquinário de biscoitos e chegam ao chão da fábrica, elas
atingem o ponto de menor potencial do circuito. Os gnomos usando jetpack agem como uma
espécie de bomba, içando a água-viva cansada de volta ao penhasco, onde podem ser jogadas
novamente. E de novo e de novo... (figura 3.5).
Figura 3.5. Um “circuito” completo de gnomos e medusas
Tensão, corrente e resistência são conceitos vitais de circuitos básicos. O próximo passo é
entender como esses fatores se relacionam e como eles se aplicam ao mundo real.
circuitos.
3.1.1. lei de ohm

Tensão, corrente e resistência estão relacionadas entre si de maneiras consistentes. Cada um
dos três fatores é como uma alavanca: ajuste um e você afetará os outros. Essas interações
tornaram-se tão importantes para a população da cidade que as fábricas começaram a produzir
biscoitos que ilustravam as relações (figura 3.6).
Figura 3.6. O novo cookie de assinatura dos habitantes da cidade mostra a

relação entre voltagem (V), corrente (I) e resistência (R).
UAU! e-book
www.wowebook.org
O portador do biscoito pode morder o fator que deseja determinar - então veja como ele pode ser
derivado dos outros dois fatores (figura 3.7).
Figura 3.7. Ao morder a borda do biscoito impresso com o fator que o comedor de
biscoito quer descobrir, eles podem ver rapidamente a equação que precisam resolver.
Por exemplo, se eles quiserem determinar a resistência (R), eles podem cortar isso e ver
que R = tensão (V) dividida pela corrente (I).
Georg Ohm descobriu essas relações-chave entre voltagem, resistência e corrente na década de
1820, bem antes dos espertos habitantes da cidade de biscoitos, e é por isso que a lei de Ohm
leva seu nome. Se você preferir sua matemática na forma não-cookie, estas são as equações
relevantes:
V = I x R (tensão é igual a corrente vezes resistência)

I = V / R (corrente é igual a tensão dividida pela resistência)
R = V / I (resistência é igual a tensão dividida pela corrente)
“OK”, você pode estar pensando, “mas como aplico isso no mundo real?”
Aplicando a lei de Ohm a circuitos do mundo real
UAU! e-book
www.wowebook.org
Projetar e construir circuitos básicos começa com o equilíbrio certo dos principais fatores: tensão, corrente e
resistência.
A Tabela 3.2 descreve alguns exemplos comuns de como ajustar tensão, corrente e resistência em
circuitos básicos. Os exemplos não são exaustivos (por exemplo, existem maneiras adicionais de ajustar a
tensão em um circuito), mas destacam os tipos de coisas que faremos a curto prazo para que nossos circuitos
funcionem corretamente.
Tabela 3.2. Ajustando tensão, corrente e resistência em eletrônicos de hobby
Exemplo de maneira comum de Exemplo de maneira comum de

Fator Relação
aumentar diminuir
Use uma fonte de alimentação com Use uma fonte de alimentação com
Tensão V = IS
uma tensão mais alta. uma tensão mais baixa.
Remova a resistência Adicione resistência adicionando
removendo resistores ou usando resistores ou usando resistores

resistores com menor com maior resistência.
Atual I = V/R
resistência. A corrente também pode A corrente também pode ser
ser aumentada aumentando a diminuída diminuindo a tensão da fonte
de alimentação. tensão da fonte de alimentação.
Adicione resistores ou use Remova os resistores ou use
Resistência R = V / I resistores com maior resistores com menor
resistência. resistência.
Uma das necessidades de cálculo mais comuns que surgem no hobby de hackers eletrônicos é “dada uma tensão
de alimentação, que resistor preciso usar para garantir que meu componente receba a corrente desejada” (figura
3.8)?
Figura 3.8. Um problema comum da lei de Ohm do mundo real: qual valor de resistor é
necessário para fornecer um LED com 20 mA de corrente em um circuito com uma tensão de
alimentação de 6 V?
UAU! e-book
www.wowebook.org
A tensão geralmente é definida pela fonte de alimentação do projeto - baterias, alimentação USB,
adaptador CC - e você sabe que deseja fornecer uma corrente específica a um componente do circuito.
Tensão e corrente são, então, definidas, o que significa que você precisa resolver para R,
resistência.
Digamos que você saiba que a tensão de alimentação será de 6 V e que você tem um componente
que precisa de 20 mA (0,02 A ou 20 milésimos de ampère) de corrente (figura 3.10). Resolver para R
(resistência em ohms) significa dividir V (tensão em volts) por I (corrente em amperes) porque R =
V / I:
R = 6 V / 0,02 A
então
R = 300 V
Cuidado com suas unidades!
Certifique-se de manter suas unidades consistentes ao usar as equações da lei de Ohm. A corrente
sempre deve ser medida em ampères (A), tensão em volts (V) e resistência em ohms (V). Volts e
ohms tendem a ser diretos, mas quando você está lidando com correntes em faixas de eletrônicos de
hobby - muitas vezes dezenas de miliamperes - não se esqueça de expressar esses valores em amperes
ou obterá a resposta errada:
300 (V) = 6 (V) / 0,02 (A)
mas
UAU! e-book
www.wowebook.org
300 (V) þ 6 (V) / 20 (mA)
OK! Quase pronto. Mas antes de começarmos a montar circuitos com esse novo
entendimento, vamos ter um momento adulto e nos proteger contra alguns problemas
potenciais.
3.1.2. Problemas e perigos

No tipo de hacking eletrônico que estamos fazendo, estamos trabalhando com tensões bastante
baixas – 5 V ou 3,3 V são exemplos típicos – usando componentes que consomem corrente
medida em dezenas de miliamperes (mA). Esses tipos de combinações de corrente e tensão não
vão jogá-lo pela sala (ou pior) se você fizer algo um pouco estúpido.
Mas há algumas coisas a serem observadas (e evitadas).
Evite muita corrente
O primeiro dos dois problemas surge quando você fornece muita corrente a um componente em um
circuito (geralmente usando um valor de resistor muito baixo ou esquecendo de adicionar um
ao circuito inteiramente). Parte dessa energia é convertida no que provavelmente é um resultado
desejado - luz no caso de um LED, por exemplo - mas o restante também precisa ser usado. Se
você fornecer 100 mA de corrente a um LED classificado para um máximo de 20 mA para uso
constante (sem piscar), isso não funcionará bem a longo prazo. O primeiro sinal de muita corrente
geralmente é o calor - o LED começará a ficar quente ao toque. Em um certo
ponto, ele ficará sobrecarregado e queimará completamente.
Evite criar um curto-circuito
O segundo “uh oh” tem potencial para ser muito pior. Se não houver carga em um circuito - ou seja,
nenhum componente ou resistor para atrair ou resistir à corrente - as coisas ficam realmente
complicadas. Se houver, digamos, um caminho indo diretamente do terminal positivo para o
negativo de uma bateria, não haverá resistência para limitar a corrente que passa pelo circuito.
Isso é um curto-circuito (figura 3.9) e faz com que uma quantidade imensa de corrente seja
descarregada pelo circuito muito, muito rapidamente. Essa energia pode causar calor, incêndio e até explosõ
Figura 3.9. Um curto-circuito não tem carga para moderar a corrente. Uma
ilustração comum de um curto-circuito é passar um fio diretamente do terminal
positivo para o negativo de uma bateria (não faça isso na vida real).
UAU! e-book
www.wowebook.org
As placas de desenvolvimento podem protegê-lo do pior disso. Se você causar um curto-circuito na
energia do Uno para aterrar (PS, não faça isso), não explodirá porque a placa possui limitadores de corrente
em seus pinos de saída (sua placa pode estar torrada, no entanto). O máximo de corrente que você obterá
de seu pino de 5 V é 450 mA; o máximo de um único pino de E/S é cerca de 40 mA.
Você não obtém essa proteção contra correntes ultrajantes se estiver trabalhando com baterias - você pode
causar um lamentável festival de faíscas, ou coisa pior. Por isso tem cuidado.
3.2. CIRCUITOS DO EDIFÍCIO
Agora que você foi interrogado, vamos experimentar! Ao começar a adicionar componentes aos circuitos,
você precisará de uma maneira de organizá-los sem enlouquecer. Torcer o fio ou tentar manter vários
componentes no lugar em um circuito com os dedos é impraticável (e talvez um pouco arriscado).
Em vez disso, as breadboards são ótimas bases para o layout de circuitos. Eles desempenham um papel
semelhante a uma base LEGO, fornecendo uma grade para conectar componentes e fios.
3.2.1. Usando breadboards para prototipar circuitos
Placas de ensaio para circuitos de prototipagem são sem solda, o que significa que você pode colocar coisas
diretamente na placa sem necessidade de solda. Eles vêm em várias formas e tamanhos, mas são
consistentes em como as conexões da placa são conectadas. A Figura 3.10 mostra o layout de uma protoboard
de tamanho médio (as protoboards de tamanho normal são como duas protoboards de tamanho
médio conectadas ponta a ponta; elas têm o dobro do comprimento).
Figura 3.10. Uma breadboard típica e as conexões dentro dela
UAU! e-book
www.wowebook.org
Uma breadboard típica combina fileiras de terminais horizontais (um termo técnico que realmente significa
“pontos para conectar componentes”) com trilhos de alimentação verticais (orifícios destinados à conexão
de energia entre fontes de alimentação e componentes) em ambos os lados.
As fileiras de terminais geralmente têm um entalhe entre cada conjunto de cinco furos. Um terminal tenhole
linha - dois conjuntos de cinco orifícios conectados divididos por um entalhe - é um layout comum. Cada
orifício em uma linha de cinco unidades é conectado eletricamente, mas as conexões não continuam ao longo
do entalhe.
Os trilhos de alimentação têm dois orifícios por linha: um para positivo e outro para negativo. Eles
geralmente são marcados para você em vermelho (positivo) e azul ou preto (negativo).
As conexões nos trilhos de energia correm verticalmente ao longo do comprimento da placa. O power rail de
um lado da placa não está conectado ao power rail do outro lado da placa
quadro.
Vamos ter uma ideia de como essas conexões funcionam usando uma placa de ensaio para religar o
circuito de LED simples do último capítulo.
3.2.2. Fiação de um circuito de LED simples em uma placa de ensaio
O que você precisará
UAU! e-book
www.wowebook.org
1 Arduino Uno e cabo USB
Fios jumper: dois vermelhos, um preto
1 LED vermelho padrão
1 resistor de 220 V
Primeiro, vamos verificar a lei de Ohm para descobrir o que precisamos ajustar para fazer o circuito
funcionar corretamente. Aqui está o que sabemos:
O Arduino fornecerá uma tensão de alimentação de 5 V.
A corrente máxima que devemos passar pelo LED é algo em torno de 20 mA (0,02 amperes) - para a
maioria dos LEDs padrão, 20 mA é uma regra geral.
Selecionando um resistor para o LED
Como temos uma tensão fixa e uma corrente alvo, o valor variável é a resistência.
Qual valor do resistor é necessário para criar o circuito? Lembrar,
R = V/I
então
R = 5 V / 0,02 A
R = 250 V
Os resistores vêm em certos valores de resistência comuns e 250 V não é um resistor comumente
produzido. Calcular um valor de resistência necessário apenas para descobrir que não existe esse
resistor acontece o tempo todo - não se preocupe. Normalmente, a regra geral é arredondar para o
próximo valor de resistor comum (ter muita resistência é mais seguro do que não o suficiente,
normalmente).
Por enquanto - acredite em mim, explicarei brevemente - faremos o oposto e arredondaremos um

pouco para o resistor comum mais próximo: 220 V.
UAU! e-book
www.wowebook.org
Encontrando o resistor certo
Os resistores são codificados por cores de maneira padrão para ajudar na identificação. Existem dois sistemas de
distribuição por aí: resistores de quatro bandas e resistores de cinco bandas. Os resistores de quatro bandas são um
pouco mais comuns.
Cada resistor tem bandas de cores que representam dígitos iniciais no valor do resistor.
Os resistores de quatro bandas têm duas dessas bandas, enquanto os resistores de cinco bandas têm três.
As duas últimas bandas de um resistor são sua banda multiplicadora e sua banda de tolerância,
respectivamente.
A cor da banda do multiplicador indica quantos zeros devem ser adicionados após o valor indicado pelas
bandas de dígitos anteriores. Em outras palavras, multiplicar os dígitos iniciais por esta potência de dez fornece o valor
do resistor.
A cor da faixa de tolerância indica a precisão da resistência garantida. Uma tolerância de +/5% (ouro) é comum para
os tipos de resistores que estamos usando.
Um resistor de quatro bandas tem bandas de dois dígitos. O resistor de quatro bandas na figura a seguir é codificado da
seguinte forma:
1 Primeiro dígito: 2 (vermelho)
2 Segundo dígito: 2 (vermelho)
3 Multiplicador: 1 (marrom) = 101
4 Tolerância: +/ 5% (ouro)
UAU! e-book
www.wowebook.org
Os resistores são codificados com faixas coloridas para indicar sua resistência e tolerância.
seu valor é
22 * 10^1 = 220 V @ +/5%
O resistor de cinco bandas na figura é codificado da seguinte forma:
1 Primeiro dígito: 1 (marrom)
2 Segundo dígito: 0 (preto)
3 Terceiro dígito: 0 (preto)
4 Multiplicador: 1 (marrom)
5 Tolerância: +/5% (ouro)
o valor é
100*10^1= 1000 V (ou 1 kV) @ +/ 5%
Diagramas e esquemas de circuitos
Existem algumas maneiras de representar um circuito visualmente, para fornecer a outros construtores um
“mapa” para recriar o circuito. A forma mais formal de representar um circuito é através de um esquema,
conforme a figura 3.11. Um esquema é uma representação gráfica de componentes usando
notação e símbolos padronizados. Pode ser pensado como uma espécie de gráfico visual abstrato: a posição
dos componentes em um esquema não corresponde necessariamente ao seu layout no espaço físico.
Figura 3.11. Esquema do circuito de LED simples. Esquemas são representações

concisas e padronizadas de circuitos, mas não mostram como posicionar os componentes
no espaço físico.
UAU! e-book
www.wowebook.org
Existem muitas maneiras possíveis de implementar fisicamente o esquema da figura 3.11, portanto,
um diagrama de fiação pode ser uma ferramenta útil. Diagramas, como o da figura 3.12 (criado com
o aplicativo de desktop Fritzing de código aberto), mostram uma implementação específica do
circuito e como ele poderia ser disposto (neste caso, em uma placa de ensaio).
Figura 3.12. Diagrama de fiação do circuito de LED simples, mostrando um layout físico
específico para implementar o circuito a partir de seu esquema. Este diagrama foi criado
no aplicativo de desktop Fritzing de código aberto.
Os esquemas podem parecer matemáticos e abstratos no início, mas são usados universalmente no
UAU! e-book
www.wowebook.org
comunidade eletrônica. Você conhecerá mais símbolos e convenções à medida que continuarmos
nossa jornada, e eles começarão a se sentir mais à vontade. Para melhorar sua compreensão dos
esquemas, crie o hábito de comparar os diagramas de fiação de volta aos seus

esquemas de fonte.
Conectando as coisas da maneira certa: polaridade
Os LEDs são polarizados, o que significa que precisam ser conectados de uma certa maneira para
funcionar corretamente. Como você aprendeu anteriormente, o ânodo é o terminal positivo e o cátodo é o
terminal negativo.
Os resistores não são polarizados, o que significa que não importa em que direção você os conecta. Eles
funcionam bem orientados de qualquer maneira.
Outra coisa a observar é que, embora eu forneça coordenadas precisas de linha e coluna neste exercício,
você pode conectar os componentes com sucesso em qualquer linha ou coluna, desde que as conexões
funcionem no final (as linhas terminais estão conectadas horizontalmente; trilhos de força,
verticalmente).
Hora de montar o circuito. Consultando a figura 3.12, comece conectando os componentes nas fileiras de
terminais. Conecte o ânodo do LED vermelho no orifício 5C (linha 5, orifício C) e seu cátodo no orifício 5D
(a próxima linha abaixo). Conecte uma extremidade do resistor no orifício 5B, próximo ao cátodo do LED.
Alimentando o circuito
O circuito precisa estar conectado à energia. Primeiro, você precisará conectar os componentes
nas fileiras de terminais ao barramento de alimentação — lembre-se de que as fileiras de terminais
são isoladas (por um bom motivo!) dos trilhos de alimentação.
Conectando as coisas da maneira certa: cores de fios de jumper
Se você tiver um pacote de jumpers coloridos, pode estar se perguntando quais cores são para qual finalidade.
Por convenção, as conexões de energia geralmente são feitas com fios vermelhos (positivos) e
pretos (terra). Outras cores que você pode ver representando conexões de energia negativa incluem
branco ou outras cores escuras (marrom ou roxo).
Verde e amarelo são frequentemente usados para conexões de entrada e saída, que surgirão
UAU! e-book
www.wowebook.org
em capítulos posteriores. Embora haja uma consistência generalizada no uso de vermelho e
preto/branco para conexões de energia, diferentes hackers usam diferentes combinações de cores para
várias outras coisas. Resumindo: não há regras rígidas e rápidas, mas tente ser consistente em qualquer
combinação que você implemente.
Os fios jumper não são polarizados. Eles podem ser conectados em qualquer direção.
Use um fio jumper vermelho para conectar o orifício 5B—conectado eletricamente ao ânodo do LED—a
um orifício na coluna vermelha (positiva) do barramento de alimentação. A quarta linha abaixo deve
funcionar bem se você não conseguir decidir sobre um favorito. Conecte a extremidade livre do resistor
diretamente no barramento de alimentação negativo, conforme mostrado na figura 3.12. Agora há um
caminho ininterrupto que vai do trilho de alimentação positivo, passando pelo fio vermelho até o LED,
saindo do LED e passando pelo resistor de volta ao trilho de alimentação negativo.
A corrente está fluindo... para que lado agora?
Os tipos de projetos que estamos construindo com placas de desenvolvimento e sistemas embarcados
usam circuitos DC (corrente contínua). O fluxo de corrente em um circuito CC ocorre em uma única
direção, geralmente processada como indo da fonte positiva (energia potencial mais alta) para
negativa ou terra (energia potencial mais baixa).
Tecnicamente, isso não está correto - a corrente pode ser descrita com mais precisão como fluindo do
negativo para o positivo, e mesmo isso é uma simplificação exagerada. Mas a convenção de
desenhar circuitos com fluxo na direção positiva para negativa (+ em direção a ) está profundamente
arraigada e não há nada inerentemente prejudicial em representar o fluxo de corrente CC dessa maneira
tradicional, desde que você seja consistente. Curiosidade: a prática de visualizar o fluxo de corrente
do positivo para o negativo foi estabelecida por ninguém menos que o pioneiro da eletricidade, Benjamin
Franklin.
Além da CC, o outro tipo de fluxo de corrente é a CA (corrente alternada), na qual o fluxo da corrente inverte
os sentidos periodicamente. A energia da tomada é AC, oscilando na direção 50 ou 60 vezes por segundo,
dependendo da parte do mundo em que você vive.
Desconecte o Uno!
Como sempre, verifique se o Uno está desconectado do USB ou da tomada antes de conectá-lo
UAU! e-book
www.wowebook.org
a componentes ou circuitos.
O Uno pode fornecer bons e estáveis 5 V de seu pino de alimentação de 5 V. Usando um fio jumper
vermelho, conecte uma extremidade no pino de 5 V do Uno e a outra na linha superior do barramento de
alimentação positivo. Passe um fio jumper preto do pino GND do Uno até a linha superior do barramento
de energia negativo. Isso completa a fiação do circuito.
Agora conecte seu Uno em USB ou na tomada. Seu LED deve acender!
Solução de problemas do circuito
Se o seu LED não acender, há algumas coisas a verificar. A razão mais comum para um circuito como
este falhar é que é um circuito aberto, o que significa que há uma lacuna no caminho entre as extremidades
positiva e negativa do circuito. Verifique as posições de seus componentes e fios e certifique-
se de que os fios estejam bem conectados aos orifícios da placa de ensaio.
Certifique-se de que nenhum dos terminais de metal expostos nos componentes estejam se tocando.
Verifique também se o LED de energia do seu Uno está aceso.
Se essas etapas não funcionarem, tente trocar seu LED por um novo, caso o LED esteja morto.
Ocasionalmente, as conexões de uma breadboard podem ser instáveis (embora isso seja mais comum
em breadboards que você usa há muito tempo). Como último recurso, tente conectar os componentes em
uma parte diferente da placa de ensaio ou tente com outra placa de ensaio.
Circuitos série e paralelo
Este circuito de LED simples (figura 3.13) é um circuito em série. Um circuito em série tem apenas um
caminho para os elétrons - a corrente, aquelas medusas individuais que fluem do mundo dos gnomos - seguir.
Como só há uma rota possível, todas as águas-vivas/elétrons percorrem toda a rota; eles não podem
se perder em algum atalho ou estrada secundária. Isso significa que a corrente é a mesma em todos
os pontos do circuito (figura 3.13).
Figura 3.13. Um circuito em série tem apenas um caminho possível para as cargas (água-
viva) fluirem - não há ramificações. A corrente é a mesma em qualquer ponto de um
circuito em série, o que significa que os pontos 1, 2, 3 e 4 têm corrente igual.
UAU! e-book
www.wowebook.org
Ao modificar a corrente de um circuito em série com resistores, não importa se você usa, digamos, um
resistor classificado em 200 V ou dois resistores em 100 V. Os valores dos resistores se somam e
modificam a corrente em todo o circuito (figura 3.14).
Circuitos de tensão e série
Embora a corrente seja a mesma em qualquer ponto de um circuito em série, a tensão pode diferir
de ponto a ponto. Falaremos sobre isso quando construirmos divisores de tensão no capítulo 4.
Figura 3.14. Os valores do resistor se somam em um circuito em série.
UAU! e-book
www.wowebook.org
Um detalhe desses circuitos em série que pode ter causado uma pausa é a posição do(s) resistor(es) limitador(es) de
corrente (um resistor limitador de corrente é aquele que é colocado para moderar a corrente no circuito).
Na figura 3.14, os resistores são conectados entre o LED e o terra, ou seja, são posicionados “depois” do LED. Acontece
que não importa onde os resistores estão posicionados em relação ao LED em um circuito em série.
Um resistor limitador de corrente colocado em um circuito em série afeta a corrente em todo o circuito, não importa
sua posição - lembre-se, a corrente é a mesma em todos os pontos de um circuito.
circuito em série.
3.2.3. Expandindo um circuito em série com um botão
1 LED vermelho padrão
1 resistor de 220 V
3 fios de jumper
UAU! e-book
www.wowebook.org
No circuito simples de LEDs em série que você conectou, toda a corrente passa pelo LED,
depois pelo resistor e depois pelo terra (figura 3.14). Uma única lacuna em um circuito em
série fará com que todo o circuito pare de funcionar, porque é uma lacuna no único caminho
através do circuito. Isso torna possível ativar e desativar todo o circuito com um interruptor.
Você pode ver como isso funciona adicionando um botão ao circuito. Um botão é um tipo de
interruptor que só completa uma conexão quando é pressionado (às vezes, os botões são
chamados de interruptores momentâneos) (figura 3.15).
Figura 3.15. Os pinos em lados opostos do botão estão sempre conectados

eletricamente, enquanto os pinos que compartilham um único lado são conectados apenas quando
o botão é pressionado.
Na figura 3.16, o botão está conectado a uma protoboard, orientada de forma que os pinos
“sempre conectados” atravessem o entalhe no meio. Isso significa que as conexões
destacadas da linha superior estão sempre conectadas eletricamente, assim como as
destacadas na linha inferior. Enquanto o botão está inativo (não pressionado), as duas
linhas ficam isoladas uma da outra. Quando o botão é pressionado, no entanto, é feita uma
conexão entre os pinos superior e inferior no lado esquerdo do botão e os pinos superior e
inferior no lado direito. O efeito é que ambas as linhas destacadas são conectadas
eletricamente uma à outra enquanto o botão é pressionado.
Figura 3.16. Um botão de pressão conectado a uma breadboard, abrangendo o entalhe central.
Quando não pressionado, os pares de pinos na parte superior e inferior do botão são
conectados eletricamente (horizontalmente). Quando pressionado e mantido, os pares de
pinos nos lados esquerdo e direito do botão são conectados eletricamente (verticalmente).
UAU! e-book
www.wowebook.org
Quando um botão conectado corretamente é pressionado e mantido, o circuito é fechado,

completando o caminho e permitindo que os elétrons fluam através do circuito. Quando liberado, o
circuito está aberto - tem uma lacuna e nenhuma corrente flui. O esquema do circuito que
você precisa construir é mostrado na figura 3.17.
Figura 3.17. Esquema do circuito atualizado, integrando um botão de pressão
UAU! e-book
www.wowebook.org
Monte o circuito: botão e LED
Para construir o circuito de botão da figura 3.18, siga os seguintes passos:
1. Desconecte o Uno da energia.

2. Remova o LED e o resistor da breadboard.
3. Usando um fio jumper preto, conecte GND no Uno à linha superior do negativo
power rail no lado direito da breadboard.
4. Conecte o botão à breadboard. Seu botão pode ter um tamanho e ajuste diferentes
mais confortavelmente entre linhas diferentes, o que é bom.
5. Conecte o ânodo do LED (perna mais longa) em um slot na mesma linha das duas pernas inferiores
do botão.
6. Conecte o cátodo do LED em uma fileira abaixo.

7. Conecte o resistor de um slot na mesma linha do cátodo do LED ao
trilho de energia negativo. Você pode deixar o fio vermelho conectando o power rail esquerdo à
linha 4 no mesmo lugar que estava no exercício anterior.
8. Reconecte a alimentação do Uno.
O LED não deve estar aceso inicialmente. Aperte o botão. O LED deve acender enquanto você
mantiver o botão pressionado.
Figura 3.18. Diagrama de fiação do circuito de LED adaptado com um botão de pressão
UAU! e-book
www.wowebook.org
3.2.4. LEDs em série

Há mais uma parada no tour de descoberta do circuito da série. Vamos construir um circuito
contendo vários LEDs ligados em série, ou seja, vários LEDs em um circuito que possui apenas um
caminho. Aqui é onde posso esclarecer os detalhes deixados de fora no cálculo do resistor de
LED que fizemos anteriormente no capítulo.
Para refrescar sua memória, o cálculo visava encontrar o valor correto do resistor para um
LED—corrente alvo 20 mA—em um circuito de 5 V:
R = 5 V / 0,02 A
R = 250 V
Em vez de arredondar para o próximo valor de resistor comum, arredondamos para 220 V.
A razão pela qual um resistor de 220 V é mais do que suficiente para um LED em um circuito de 5 V
a 20 mA é que, devido a uma característica dos LEDs, não precisamos levar em conta os 5 V completos
ao calcular o valor correto do resistor. Na verdade, 220 V é um pouco alto.
Existe uma lei relevante, chamada lei de voltagem de Kirchoff (KVL para quem conhece). Afirma WOW!
e-book
www.wowebook.org
que toda a tensão no circuito deve estar em equilíbrio: a quantidade gerada deve ser igual à
quantidade usada. Tensão de entrada, tensão de saída.
No circuito da série LED, 250 V seria o resistor aproximado correto a ser usado se o resistor
fosse a única coisa no circuito “usando” alguma tensão. Mas isso não. Os LEDs têm uma
métrica chamada queda de tensão direta. Há um pouco de detalhe nisso, mas para nossos
propósitos é a quantidade aproximada de voltagem que o LED usará no circuito (figuras
3.19 e 3.20).
Figura 3.19. À medida que a eletricidade passa por um LED, alguma voltagem é usada ou diminuída.
A quantidade de tensão usada é chamada de tensão direta do LED. Ela varia entre cerca de 1,8 V e
3,5 V, dependendo da cor do LED – quanto maior a frequência da luz emitida, maior a queda de
tensão.
Figura 3.20. Voltando à analogia da tensão como inclinação ou altura do penhasco, o mesmo
circuito de LED em série pode ser visto de uma perspectiva diferente. À medida que a
corrente da água-viva passa pelo LED, 1,8 V é “consumido”, reduzindo a tensão
restante para 3,2 V (reduzindo a inclinação). Esses 3,2 V são então usados pelo resistor limitador
de corrente. Quando a água-viva atinge o ponto de menor potencial elétrico, toda a tensão no
circuito foi contabilizada.
UAU! e-book
www.wowebook.org
Embora a maioria dos LEDs padrão comuns tenham uma corrente direta consistente (para fins de
brevidade, você pode pensar nisso como “aproximadamente a corrente que deve receber”) de 20 mA,
a tensão direta difere entre os LEDs, principalmente relacionada à cor do LED.
Os LEDs vermelhos têm uma tensão direta que varia na maior parte entre 1,8 e 2 V. Se o LED no circuito
tiver uma queda de tensão direta de 1,8 V, podemos subtrair isso da tensão do sistema de 5 V, que é a
tensão que o resistor precisa levar em conta:
5 V (tensão de alimentação)
1,8 V (tensão direta do LED vermelho)
ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
= 3,2 V (tensão restante)
Dado que queremos apontar para essa corrente de 20 mA (0,02 A), a equação da lei de Ohm
resultante é
R = 3,2 V / 0,02 A
ou
R = 160 V
Um resistor de 220 V tem um valor próximo o suficiente para ser excelente - arredondando para o
próximo valor de resistor comum conforme a convenção. Agora, 220 V é mais resistência do que 160 V, então
UAU! e-book
www.wowebook.org
você pode se perguntar que efeito o uso de um valor de resistência mais alto tem no LED e no circuito.
Maior resistência com tensão constante significa que a corrente diminui (porque, como sempre, a lei de
Ohm):
I = V/R
I = 3,2 / 220 V
I = 0,0145 A
No final, o LED recebe menos corrente do que 20 mA – cerca de 15 mA (0,0145 A). A quantidade de
corrente fornecida a um LED é diretamente proporcional ao seu brilho: um LED recebendo 15 mA não
será tão brilhante quanto um recebendo 20 mA.
Qual é a situação se outro LED vermelho idêntico for adicionado a este circuito em série?
Qual o resistor necessário? Precisamos levar em conta a queda de tensão de ambos os LEDs (figura
3.21).
Figura 3.21. Cada um dos dois LEDs reduz parte da tensão no circuito e,
novamente, a tensão restante é reduzida pelo resistor.
Felizmente, esta é uma questão de aritmética direta. Depois de subtrair a

queda de tensão de cada LED da tensão total do circuito, ficamos com 1,4 V:
5 V (alimentação) 1,8 V
(LED 1)
1,8 V (LED 2)
ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
= 1,4 V
UAU! e-book
www.wowebook.org
R = 1,4 V / 0,02 A
R = 70 V
Arredondando para o próximo valor de resistor comum, um resistor de 100 V funcionará bem,
conforme mostrado no esquema da figura 3.22.
Figura 3.22. Os dois LEDs são ligados em série com um resistor de 100 V. Há apenas
um único caminho através deste circuito quando o botão é pressionado: através do
primeiro LED, através do segundo LED, através do resistor e de volta ao terra.
Monte o circuito: dois LEDs em série
1 Arduino Uno e cabo USB UAU!

e-book
www.wowebook.org
2 LEDs vermelhos padrão
1 resistor de 100 V
3 fios de jumper
Para construir o circuito da figura 3.23, siga estes passos:
1. Desconecte seu Uno da energia.
2. Desconecte o resistor de 220 V da breadboard e guarde-o.
3. Conecte o ânodo de um segundo LED na mesma linha que o cátodo do primeiro LED
(linha 7 na figura 3.23).
4. Conecte um resistor de 100 V do barramento de alimentação negativo à linha que contém o

cátodo do segundo LED (linha 8).
Figura 3.23. Esquema elétrico de dois LEDs em série
Se você conectar seu Uno à energia e pressionar o botão, os dois LEDs devem acender.
Eles são ligados em série, o que pode ser mais fácil de visualizar olhando a figura 3.22 novamente.
E se você adicionar um terceiro LED? Pergunta capciosa: você realmente não pode. Não se você quiser
produzir luz confiável e brilhante. Há apenas 1,4 V “sobrando” após a queda de tensão dos dois
primeiros LEDs. Isso não é suficiente para alimentar um terceiro LED - um LED requer pelo menos seu valor
de queda de tensão para acender. Você pode conseguir que os três LEDs acendam fracamente, mas eles
não seriam robustos.
UAU! e-book
www.wowebook.org
É possível alimentar continuamente mais de dois LEDs com 5 V, mas para isso é necessário um
circuito paralelo.
3.2.5. Circuitos paralelos e divisores de corrente
Em um circuito em série, há apenas um caminho para os elétrons seguirem, mas em um circuito

paralelo, há dois ou mais caminhos possíveis, ou ramificações (figura 3.24).
Figura 3.24. Em um circuito paralelo, há mais de um caminho, ou ramificação, que a corrente

pode seguir. Neste exemplo, existem duas ramificações: cada uma tem seu próprio LED
e resistor.
À medida que os elétrons se movem pelo circuito e encontram uma bifurcação na estrada, cada um deles
toma uma decisão sobre qual ramo seguir. A corrente prefere um caminho com menos resistência
(figura 3.25).
Figura 3.25. Como os dois ramos desse circuito paralelo têm a mesma resistência (100
V), metade da corrente passará por um ramo e a outra metade pelo outro.
UAU! e-book
www.wowebook.org
Ao calcular quanta resistência existe no circuito paralelo, as coisas ficam um pouco estranhas e
contra-intuitivas. Observe novamente o circuito paralelo na figura 3.25. Qual é a resistência total
fornecida pelos dois resistores de 100 V?
A resistência total dos circuitos em série é fácil de descobrir - basta somar e voilà!
Você tem a resistência total. É tentador fazer o mesmo no início com circuitos paralelos — assumir
que a resistência total é de 200 V. Não. Ou talvez você tenha percebido que qualquer carga
que passa pelo circuito está passando apenas por um resistor, não por ambos. Então isso deve
significar que há uma resistência total de 100 V? Além disso, desculpe, não.
A resposta correta é 50 V.
Eu sei eu sei. Isso não parece certo, mas é verdade: em um circuito paralelo, a resistência
total sempre será menor que o menor valor do resistor. Vamos nos armar com a lei de Ohm e
algumas respirações profundas e examinar como isso pode acontecer. Calcular a resistência
equivalente em circuitos paralelos é um dos conceitos mais desafiadores para hackers
eletrônicos novatos, portanto, não puxe os cabelos ainda.
Vamos decompô-lo e colocá-lo de volta juntos. O circuito em série de 5 V com um resistor de 100 V
mostrado na figura 3.26 consumirá 50 mA de corrente (I) porque
0,005 A (I) = 5 V (V) / 100 V (R)
Figura 3.26. Este circuito em série consome 50 mA porque 5 V / 100 V = 0,05 A.
UAU! e-book
www.wowebook.org
Agora digamos que você duplique o mesmo caminho - 5 V e um resistor de 100 V - e o coloque no
circuito. Esse segundo caminho também consumirá independentemente 50 mA porque a tensão
de alimentação (5 V) e a resistência (100 V) permanecem as mesmas (figura 3.27).
Figura 3.27. Cada ramificação de um circuito paralelo isoladamente atua como seu próprio
circuito em série. Podemos usar a lei de Ohm para verificar se esse ramo também consumirá 50 mA.
UAU! e-book
www.wowebook.org
Somadas, a corrente consumida pelos dois ramos é de 100 mA — a corrente

consumida total do circuito aumentou (figura 3.28).
Figura 3.28. A corrente total que entra no circuito é de 100 mA (ponto A). Ele se divide
igualmente em duas ramificações - cada ramificação recebe 50 mA (pontos B, C). A
corrente volta e no ponto D é novamente 100 mA. Em um circuito paralelo, a tensão
fornecida é constante para cada ramificação, mas a corrente varia.
UAU! e-book
www.wowebook.org
Olhando para o circuito como um todo agora, sua corrente total é de 100 mA (0,1 A) e a tensão de
alimentação é, como sempre, 5 V. Conectando isso à lei de Ohm,
Resistência total (R) = 5 V (V) / 0,1 A (I)
R = 50 V
A resistência fornecida por cada resistor em um circuito paralelo é reduzida porque cada ramificação
em um circuito paralelo aumenta a corrente total no circuito. A corrente está subindo enquanto a tensão é
constante: a resistência diminui.
divisores atuais
Qualquer circuito que divide a corrente proveniente da fonte de alimentação em mais de um ramo é
chamado de divisor de corrente. O circuito paralelo na figura a seguir é um exemplo de um divisor
de corrente: alguma corrente segue um ramo enquanto o restante segue o outro.
Se os ramos tiverem resistência desigual, a corrente fluirá proporcionalmente através de cada um

UAU! e-book
www.wowebook.org
filial.
Se uma carga se encontra em uma bifurcação na estrada e ambos os caminhos disponíveis têm a
mesma resistência, a carga tem a mesma probabilidade de seguir qualquer rota (como o circuito
paralelo na figura 3.28). Mas se a resistência for desigual, mais cargas irão optar pelo caminho com menor
resistência – ou seja, mais corrente irá pegar o ramal de menor resistência.
Você pode calcular a resistência total no circuito mostrado nesta figura observando cada ramificação
isoladamente e descobrindo o consumo total de corrente do circuito:
Filial 1:
5 V / 200 V = 0,025 A (25 mA) porque I = V / R
Filial 2:
5 V / 100 V = 0,05 A (50 mA) porque I = V / R
0,025 A (ramo 1)
+ 0,05 A (ramo 2)
=========================
= 0,075 A (75 mA) corrente total
R(Total) = 5 V / 0,075 A porque R = V / I

R(Total) = 66,667 V
Fazer cálculos para resistência total dessa maneira pode se tornar complicado à medida que o número
de ramificações aumenta. Não iremos arquitetar divisores de corrente complexos com muitos ramos com
diferentes resistências, mas se você for do tipo curioso, existe uma fórmula para calcular a
resistência equivalente (total) em qualquer circuito paralelo:
1 / R(Total) = 1 / R1 + 1 / R2 + 1 / R3 ... + 1/Rn
Alguns desses cálculos de circuitos paralelos podem parecer inutilmente complicados, mas têm
aplicações úteis.
Aqui está o problema: cada ramificação do circuito paralelo é fornecida com a mesma voltagem. Portanto,
se pegarmos o LED do circuito em série e adicionarmos mais ramificações a ele (transformando-o em
um circuito paralelo – figura 3.29), cada ramificação obtém “seus próprios” 5 V para trabalhar. Dessa
forma, podemos conectar três, quatro ou até mais LEDs no mesmo circuito e não ficar sem tensão como nós
faria em um circuito em série.
Figura 3.29. No esquema do circuito de LED paralelo, cada um dos ramos A,

B, C e D é alimentado com 5 V. Cada ramo recebe 1/4 da corrente total no
WOW! e-
o circuito.
o circuito.
Monte o circuito: LEDs em paralelo
6 fios de jumper
A Figura 3.30 mostra um layout físico do mesmo circuito. Para conectar quatro LEDs no mesmo circuito,
comece com uma breadboard nova e limpa e siga estas etapas:
1. Conecte os terminais do ânodo de quatro LEDs a um orifício nas fileiras 2, 9, 16 e 23.
2. Conecte as extremidades do cátodo na mesma fileira de terminais, mas do outro lado do espaço
(de modo que não estejam conectados eletricamente).
3. Passe quatro fios de jumper vermelhos do trilho de alimentação positivo no lado esquerdo da placa
à linha de ânodo de cada LED.
4. Conecte um resistor de 220 V da linha de cátodo de cada LED ao barramento de alimentação negativa em
lado direito do tabuleiro.
5. Conecte os trilhos de alimentação aos pinos 5 V e GND do Uno (usando um vermelho e preto
UAU! e-book
www.wowebook.org
jumper, respectivamente).
6. Conecte o Uno à alimentação USB ou DC.
Figura 3.30. A fiação de LEDs em paralelo permite que você conecte mais em um único
circuito porque cada ramificação recebe a mesma tensão (5 V).
Se tudo correr bem, todos os quatro LEDs devem acender alegremente.
Os circuitos paralelos têm outro recurso útil. Se você removesse o fio vermelho entre o LED
na linha 2 e o barramento de alimentação, os outros 3 LEDs ainda acenderiam. O circuito ainda tem
três outros caminhos completos que pode usar. Compare isso com um circuito em série, onde
uma única lacuna impede que a corrente flua para qualquer componente.
3.2.6. Alimentando seu projeto com baterias

Até agora, você forneceu energia à breadboard usando a alimentação de 5 V integrada do
Arduino Uno, mas existem outras maneiras de fornecer energia aos projetos. Uma opção
(óbvia) é usar baterias.
Uma única bateria de 9 V é uma fonte de alimentação conveniente e, no caso dos circuitos de LED
que você construiu, elimina a dependência de uma placa de desenvolvimento.
UAU! eBook
Construa o circuito: LEDs alimentados
por 9 V www.wowebook.org
Monte o circuito: LEDs alimentados por 9 V
1 tábua de pão
Bateria de 9 V e encaixe, com fios
4 fios jumper
Com uma bateria de 9 V, a tensão de alimentação é (obviamente) diferente dos 5 V do Arduino.
Isso significa que precisaremos usar resistores diferentes para os LEDs no circuito paralelo.
Lembre-se de que cada ramificação em um circuito paralelo “obtém” toda a tensão de alimentação de 9 V para
trabalhar, portanto, você pode calcular o resistor necessário em cada ramificação usando a lei de Ohm:
R = 9 V / 20 mA
R = 450 V
Um resistor de 560 V é o valor de resistor comum mais próximo e funcionará bem (você notou que há um
pouco de espaço para fudge, desde que você arredonde?).
Desconecte os trilhos de alimentação da placa de ensaio do Arduino e troque cada um dos resistores de 220
V em favor dos resistores de 560 V mais robustos. Agora conecte os fios positivo e negativo da caixa da
bateria nos trilhos de alimentação da breadboard (figura 3.31). Tudo feito!
Figura 3.31. Alimentar o circuito de LED paralelo com uma bateria de 9 V envolve a troca de
alguns resistores e a conexão de um encaixe de bateria de 9 V aos trilhos de alimentação.
UAU! e-book
www.wowebook.org
RESUMO
As relações entre tensão, corrente e resistência — conforme formalizadas na lei de Ohm — são as
chaves para entender os circuitos básicos.
As placas de ensaio fornecem uma plataforma de prototipagem tangível e conveniente, com padrões
de conexão padrão, para testar circuitos.
Um circuito em série fornece um único caminho para o fluxo elétrico. Um circuito paralelo tem dois
ou mais caminhos.
Os LEDs têm uma característica chamada queda de tensão direta. Ao calcular o resistor correto
para um LED conectado em série, primeiro subtraia essa queda de tensão direta da tensão de
alimentação.
Em um circuito em série, a corrente é igual em todos os pontos do circuito, enquanto em

um circuito em paralelo, todos os ramos têm tensões iguais.
Em um circuito em série, é fácil calcular a resistência total no circuito: some os valores do resistor.
Um circuito com mais de um caminho divide a corrente no circuito e é chamado de divisor de

corrente. A determinação da resistência total em tal circuito paralelo pode ser realizada usando
uma fórmula de divisão de corrente.
UAU! e-book
www.wowebook.org
UAU! e-book
www.wowebook.org
História
Parte 2. Noções básicas do projeto: entrada e saída com Johnny-Five
Esta parte do livro é onde as coisas realmente começam a cozinhar: você aprenderá como adicionar
sensores, saídas de tópicos e partes móveis a projetos, construindo um monte de pequenos
experimentos ao longo do caminho com sua placa Arduino Uno e JohnnyFive.
Tutoriais
No capítulo 4, você conhecerá tudo sobre entradas (sensores), tanto analógicas quanto digitais. Você vai
tente ler dados de um simples sensor de temperatura e um resistor fotossensível e você aprenderá a
detectar o pressionamento de botões.
Destaques
O Capítulo 5 trata das saídas, com base em suas experiências anteriores com LEDs. Você irá além
de LEDs piscando para LEDs animados e LEDs RGB coloridos.
Configurações Você exibirá o texto em um módulo LCD paralelo e construirá sua própria “bola meteorológica” (uma exibição
simplificada de condições meteorológicas com suporte ).
Sair Se
você estava esperando pela parte dos robôs, é o capítulo 6! Este capítulo é sobre movimento:
motores e servos. Investigaremos como os motores funcionam e como alimentá-los e controlá-los. No
final do capítulo 6, você construirá um robô itinerante simples usando um kit de chassi de robô
barato.
Ao final desta parte do livro, você terá pesquisado todos os principais tipos de entradas e saídas simples
para pequenos projetos incorporados. Você poderá ler dados ambientais de sensores e emitir luz e
som. Você estará pronto para construir projetos mais sofisticados e sem fios.
UAU! e-book
www.wowebook.org

História

Tópicos
O papel dos sensores em projetos como transdutores, convertendo fenômenos físicos em sinais
Tutoriais elétricos
Como os microcontroladores usam a conversão analógico-digital (ADC) para interpretar

sinais analógicos
Construindo
Destaques circuitos divisores de tensão para ler sensores resistivos como fotoresistores
Usando a classe Sensor genérica do JohnnyFive para ler os dados do sensor e ouvir os dados
Configurações e alterações
Apoiar Aproveitando o termômetro e o botão específicos do JohnnyFive

Aulas
Sair
Gerenciando níveis lógicos digitais padrão usando resistores suspensos
Para construir dispositivos bacanas, sejam eles ventiladores automáticos com controle de temperatura
ou invenções mais interessantes, você precisa ser capaz de coletar informações e informações do
mundo físico real.
1 fotoresistor
1 sensor de temperatura analógico TMP36
UAU! e-book
www.wowebook.org
1 resistor de 10 kV
Fios jumper pretos, vermelhos e verdes
Sensores analógicos e digitais prestam atenção a um fenômeno específico no

ambiente físico – temperatura, brilho, umidade, pressão, vibração – e emitem
informações sobre mudanças na intensidade desse fenômeno como um sinal. No
exemplo do ventilador automático no capítulo 1, um sensor de temperatura traduziu
as mudanças de temperatura em um sinal elétrico que o firmware do microcontrolador
poderia ler e processar (figura 4.1).
Figura 4.1. O ventilador de temperatura controlada do capítulo 1 usou um

sensor de temperatura analógico para coletar informações sobre mudanças de
temperatura no ambiente ao redor.
UAU! e-book
www.wowebook.org
Essa conversão de entrada física em saída elétrica significa que os sensores são um tipo de
transdutor, que é qualquer dispositivo que converte uma forma de energia em um sinal (ou vice-
versa).
Sensores e entradas são classificados com base no tipo de sinal que produzem: analógico, um
conjunto contínuo e suave de valores sem lacunas, ou digital, que consiste em um conjunto discreto
e finito de valores (figura 4.2).
Figura 4.2. Um sensor analógico como um sensor de temperatura (em cima) traduz as mudanças de
temperatura em um sinal analógico suave. Uma entrada digital como um interruptor de
inclinação (parte inferior) pode ter apenas dois valores de saída discretos: um quando orientado
normalmente (desligado, BAIXO, 0 ou falso) e outro quando invertido (ligado, ALTO, 1, verdadeiro).
UAU! e-book
www.wowebook.org
4.1. TRABALHO COM SENSORES ANALÓGICOS
Nossa realidade física é analógica: vivemos em um mundo de infinito. Há um número infinito de

temperaturas entre 0 e 20 graus Celsius, um número infinito de cores, um número infinito de
frequências sonoras. É claro que, como humanos, não podemos discernir 280,3984 Hz de 280,3985
Hz, mas existem dois valores diferentes.
Os sensores analógicos são sensíveis a essas entradas analógicas do mundo real. Sua
saída é um sinal suave, geralmente de voltagem variável que corresponde à intensidade do que
estão medindo (figura 4.3).
Figura 4.3. O sinal de saída de um sensor analógico de temperatura varia em tensão ao

longo do tempo conforme a temperatura muda.
UAU! e-book
www.wowebook.org
4.1.1. Conversão de analógico para digital
Sensores analógicos como o sensor de temperatura no ventilador fornecem um sinal analógico, mas nosso
mundo de programação é digital. Os sinais de entrada analógica precisam ser, de alguma forma,
amostrados e normalizados — quantizados — em valores digitais discretos para que possam ser
processados com lógica digital.
Fazer essa conversão de amostras de sinal de analógico para digital requer um pouco de hardware
e processamento. O microcontrolador do Arduino Uno fornece capacidade de conversão analógica para
digital (ADC) integrada em seis de seus pinos. Os pinos de entrada analógica—aqueles com suporte ADC—
são prefixados com “A” no Uno (figura 4.4).
Figura 4.4. O ADC é suportado pelo microcontrolador ATmega328P em pinos específicos

(disponíveis como A0-A5 no Uno). Os ADCs convertem sinais analógicos em valores
digitais discretos.
UAU! e-book
www.wowebook.org
O número de valores possíveis que podem ser derivados de um sinal analógico de entrada
depende da largura de banda do hardware ADC no microcontrolador. O ATmega328P no
Uno fornece ADC de 10 bits para cada um de seus seis pinos ativados. Isso significa que ele
10
pode resolver 1024 (2) possíveis valores digitais interpretados. Uma entrada analógica de 0 V será
interpretada como 0, 5 V como 1023, e qualquer valor entre escalado para o valor de passo
(inteiro) mais próximo.
Um sensor analógico responde a um estímulo físico ao qual é sensível, transduzindo essa energia
física em um sinal de saída de tensão variável. Esse sinal pode ser amostrado por um pino
de entrada analógica em um microcontrolador e convertido em valores digitais usando a capacidade
analógico-digital (ADC) do MCU. Para ver como isso funciona em ação, vamos experimentar um
sensor analógico básico.
4.1.2. Trabalhando com fotoresistores

Um fotorresistor, também chamado de fotocélula ou resistor dependente de luz (LDR), é um sensor
simples. Seu nome revela que na verdade é um tipo de resistor, mas sua condutividade muda
dependendo do brilho da luz incidente que o atinge - é fotocondutor.
Quando as coisas estão escuras, o fotoresistor tem maior resistência, chegando a cerca de 10 kV
quando está totalmente escuro. À medida que a quantidade de luz à qual é exposto aumenta, ele
se torna mais condutivo – sua resistência diminui – até cerca de 1 kV quando as coisas estão
bastante brilhantes (figura 4.5).
UAU! eBook
Figura 4.5. À medida que as condições de luz mudam, a resistência do fotoresistor muda. www.wowebook.org
Figura 4.5. À medida que as condições de luz mudam, a resistência do fotoresistor muda.
Ele se torna mais condutor - ou seja, menos resistente - quando mais luz o atinge. Quando está
mais escuro, a resistência é maior.
Tensões em um circuito
Digamos que queremos ser capazes de usar o pino A0 compatível com ADC do Uno para
ler um sinal que representa valores variáveis de luz ambiente. Precisamos de um circuito
que contenha o fotorresistor e que esteja conectado à alimentação, terra e pino A0 no Uno.
Mas o circuito mostrado na figura 4.6 não vai funcionar. Lembre-se da lei de tensão de
Kirchoff (KVL) do capítulo 3? Toda a tensão em um circuito precisa ser usada. O único componente
no circuito da figura 4.6 que “consome” qualquer tensão é o próprio fotoresistor.
Figura 4.6. Com um circuito como este, não haverá nenhuma variação de tensão significativa no
pino A0.
UAU! e-book
www.wowebook.org
Isso significa que não importa qual seja o valor real da resistência do fotorresistor em um determinado
momento, ele vai consumir toda a tensão do circuito de qualquer maneira - o que significa que a
tensão em A0 não mudará.
No capítulo 3, você também viu como a corrente é a mesma em todos os pontos de um circuito em
série. O circuito mostrado na figura 4.7 assume uma queda de tensão direta de 2 V no LED, deixando
3 V para os resistores cuidarem. A resistência total no circuito é de 200 V (os dois
Resistores de 100 V somados), então
I = V/R
por isso
0,015A = 3V / 200V
Figura 4.7. Em um circuito em série, a corrente é a mesma em todos os pontos.
UAU! e-book
www.wowebook.org
A corrente em todos os pontos do circuito medirá 15 mA.
A chave para descobrir nosso problema de fotorresistor aqui é que a tensão é

dividida entre os componentes do circuito (figura 4.8) e não é constante em todos
os pontos.
Figura 4.8. Em um circuito em série, a tensão pode diferir em pontos diferentes.

Cada componente consome ou reduz sua própria parcela da tensão disponível no circuito.
UAU! e-book
www.wowebook.org
Vamos separar o circuito da figura 4.7 e analisá-lo para ver para onde está indo a tensão.
2 V da fonte de 5 V está sendo mastigado pelo LED por causa de sua queda de tensão
direta. Isso deixa 3 V que precisam ir... para algum lugar. Ele é dividido entre os
demais componentes do circuito.
A quantidade de tensão alocada para cada componente resistivo restante - os

dois resistores,
1
R e2R - é uma razão da resistência do componente dado para o total
resistência no circuito.
Vamos calcular a tensão atribuída a R: 1
Valor de resistência R1 = 100 V

Resistência total do circuito = 200 V
Tensão proporcional R1 = 100 V / 200 V = 1/2 Assim, tensão através de
R1 = (1/2) * 3 V restantes = 1,5 V
Como há dois resistores e eles têm a mesma resistência, a tensão restante será
distribuída de 50 a 50 entre eles. Os resultados seriam diferentes se os resistores
tivessem valores diferentes (por exemplo,
1
se R fosse 300 V2 e R fosse 100 V, suas
tensões atribuídas seriam 1,125 V e 0,375 V, respectivamente).
UAU! e-book
www.wowebook.org
No circuito representado na figura 4.9, os dois resistores
1
R 2e R têm resistência
igual - cada um fornece metade da resistência total do circuito. Assim, a tensão
restante (3,0 V) no circuito será dividida igualmente (50–50) entre eles - 1,5 V cada.
Figura 4.9. A lei de tensão de Kirchoff afirma que somar todas as tensões em um
circuito sempre produz 0. Ou seja, toda a tensão no circuito precisa ser contabilizada
(ser usada).
Uma maneira mais formal de dizer que “toda a tensão em um circuito precisa ser usada” é que
todas as tensões em um circuito devem somar 0. Percorrendo o circuito na figura 4.9, começamos
na fonte de alimentação: +5 V . Em seguida, R diminui sua parcela, 1,5 V; o LED diminui 2,0
1 2
V; e R diminui 1,5 V. Tudo isso soma 0:
(+5 V) + (–1,5 V) + (–2 V) + (–1,5 V) = 0 V
Como sabemos quanta tensão cada componente do circuito está consumindo, podemos
derivar a tensão em diferentes pontos do circuito (figura 4.10).
Figura 4.10. As tensões em pontos diferentes em um circuito em série variam com base
na quantidade de tensão que caiu nos componentes do circuito.
UAU! e-book
www.wowebook.org
Portanto, quando houver apenas um componente em um circuito, ele consumirá toda a tensão.
Se você ligar o fotoresistor sem quaisquer outros componentes (figura 4.11), ele fornecerá
100% da resistência no circuito (tecnicamente, isso não é bem verdade por causa de um resistor
que veremos mais adiante que está escondido dentro do microcontrolador, mas é perto
o suficiente).
Figura 4.11. Com apenas o fotoresistor no circuito, não há ponto de

referência para ler mudanças de tensão mensuráveis.
UAU! e-book
www.wowebook.org
Precisamos de uma maneira de criar um circuito que tenha um ponto de referência, um ponto em
que a tensão varie de maneira previsível e possa ser lida.
4.1.3. divisores de tensão
Divisores de tensão para o resgate! Um circuito divisor de tensão possibilita a leitura de valores úteis do
fotoresistor. Para entender como, vamos primeiro ver o que é um divisor de tensão e como ele
funciona.
Um divisor de tensão é um circuito que usa um par de resistores para converter uma tensão de
alimentação mais alta em uma tensão de saída mais baixa. Embora a tensão do circuito como um todo
seja a tensão de alimentação (5 V em nossos exemplos), a tensão entre os dois resistores é uma nova
tensão de saída (figura 4.12).
Figura 4.12. Um divisor de tensão fornece uma nova tensão mais baixa nos pontos , disponível em
V de saída entre dois resistores, R e R . Existem várias maneiras de desenhar um esquema de divisor
1
de tensão 2 ; os dois circuitos descritos aqui são funcionalmente idênticos.
Se os dois resistores usados no divisor de tensão tiverem resistência igual e forem os únicos
componentes no circuito, é intuitivo que a tensão disponível em V na figura 4.13 será metade
fora
da tensão de alimentação original - R diminui sua parcela proporcional da tensão de alimentação ,
1
50%, à medida que a eletricidade flui através dele.
Figura 4.13. Quando R e R têm 2 resistência igual em um circuito, V é metade

fora de V em ,
1, pois cada resistor cai 50% da tensão de alimentação.
UAU! e-book
www.wowebook.org
Figura 4.14. V é 1/5 (20%) da tensão de alimentação porque R fornece

1 80% da
resistência total do circuito.
UAU! e-book
www.wowebook.org
Por outro lado, se R permanecesse em 100 V, mas R mudasse a resistência para 400 V, 80%
2 1
da tensão disponível cairia em R (figura 4.14), de modo que a tensão de saída no ponto V é
1
agora 20% da tensão de alimentação. tensão.
fora
Voilà! Mudanças na proporção de resistência que R fornece ao circuito são refletidas como
1
mudanças de tensão em V . Aí está o ponto de referência que precisamos!
fora
Fórmula do divisor de tensão
A fórmula para circuitos divisores de tensão - isto é, o método para determinar qual tensão
estará em V entre os dois resistores - é a seguinte:
fora
V(saída) = V(entrada) * (R2 / (R1 + R2))
V é o que “sobra” da tensão de alimentação após R ter diminuído sua porção da tensão do
fora 1
circuito.
Estaremos usando um resistor fixo de 4,7 kV como R (figura 4.15). O fotorresistor fará o papel
2
de R . Sua resistência varia entre 1 kV e 10 kV, dependendo da luminosidade do
1
ambiente.
UAU! eBook
Figura 4.15. O esquema do circuito fotoresistor www.wowebook.org
Figura 4.15. O esquema para o circuito fotoresistor
Como a resistência de 1R (o fotoresistor) muda proporcionalmente ao total do circuito

resistência, a tensão de saída em A0 também irá variar. Podemos medir essa voltagem
com o Uno e ver como os níveis de luz estão flutuando.
Calculando a faixa de tensão de V fora
Você pode calcular a faixa de tensões possíveis em V usando

fora
a fórmula do divisor de
tensão.
Na maior resistência do fotoresistor, quando está escuro, R terá

1
uma resistência de 10 kV
(lembre-se, R é sempre
2
4,7 kV). Essa resposta de resistência mais alta à escuridão
produzirá a menor tensão na faixa:
R1 = 10000V
R2 = 4700V
V(fora)
= 5 V * (4700/14700)
= 5 V * 0,32
= 1,6 V
Quando está claro, a1 menor resistência possível de R é de 1 kV, resultando na maior

tensão na faixa:

UAU! e-book
www.wowebook.org
R1 = 1000V
R2 = 4700V
V(saída) = 5 V * (4700/5400)
= 5 V * 0,825
= 4,125 V
Usando um circuito divisor de tensão com o fotoresistor, você pode criar um sinal de tensão de saída
legível para o pino A0 que varia de 1,6 V a 4,125 V.
4,125 – 1,6 V = 2,525 V, ou apenas um pouco mais de 50% da faixa total de 0 a 5 V. Isso significa que
você obterá uma distribuição decente de valores - variando de (mais ou menos) cerca de 328 (~1,6
V) a 845 (~4,125 V) da faixa possível de 10 bits (0–1023).
4.1.4. Fiação e uso de um fotoresistor
1 fotoresistor
1 resistor de 4,7 kV (ou 10 kV também funcionará)
Fios jumper vermelho (2), preto (2) e verde (1)
Como os outros resistores com os quais você está trabalhando, os fotoresistores não são polarizados,
então você não precisa se preocupar com a orientação positivo-negativo. Conecte a fotocélula e o resistor
de 4,7 kV à protoboard conforme mostrado na figura 4.16.
Figura 4.16. Diagrama de fiação para o circuito divisor de tensão do

fotoresistor. O jumper conectado a A0 precisa ter sua outra extremidade ,
conectada a V out entre o fotoresistor
4,7 kV (R(R). )1e o resistor de 2
UAU! e-book
www.wowebook.org
A saída do divisor de tensão, V , está disponível em qualquer orifício da fileira de terminais entre a
fora
fotocélula e o resistor (lembre-se de que os cinco orifícios em cada fileira de terminais na
breadboard são conectados eletricamente).
Conecte uma extremidade de um fio jumper verde em um desses orifícios e a outra extremidade no pino
A0 no Uno. Conecte a energia ao barramento de energia dos pinos GND e de energia de 5 V do Uno.
Agora você pode deixar sua placa de ensaio de lado por um momento e vamos nos voltar para o
lado do software.
Assim que o circuito do fotoresistor for alimentado (ainda não! A propósito), um sinal de tensão
variável estará presente no pino A0. Então, como podemos ler os valores desse sinal usando nossa útil
estrutura JavaScript JohnnyFive?
Processando entrada de sensor analógico com Johnny-Five
A API do JohnnyFive contém uma coleção de classes que podem ser usadas para interagir com sua placa
de desenvolvimento e componentes. Você viu Led, por exemplo. Muitas das classes de
componentes, como Led, são para tipos específicos de dispositivos, como Acelerômetro e Servo. Existem
também algumas classes mais genéricas que têm uso mais amplo, incluindo uma que pode ser usada com
sensores analógicos como o sensor fotoresistor.
Mantendo-se atualizado com a API do Johnny-Five
JohnnyFive, como muitos outros softwares de código aberto, está em constante evolução. Novos
recursos e classes são adicionados e a API também evolui. Você pode manter-se atualizado com a API
JohnnyFive atual em http://johnnyfive.io/api.
Usando a classe Sensor do Johnny-Five
UAU! e-book
www.wowebook.org
A classe Sensor pode ser usada para ler e processar dados de sensores analógicos. Primeiro, crie um novo objeto
Sensor em um script JohnnyFive Node.js, conforme mostrado na listagem a seguir.
Listagem 4.1. Instanciando um novo objeto Sensor com Johnny-Five

board.on('ready', () => { const sensor =

new five.Sensor({
pino: 'A0' 1
});
});
1 Ao instanciar um Sensor, “pin” é a única propriedade necessária para o objeto de opções passado.
As partes internas do Sensor cuidam da configuração do pino indicado como um pino de entrada analógica e, em seguida, da
leitura automática e contínua dos dados ADC desse pino.
Então, o que você pode fazer com um objeto Sensor? Você pode desconectar seu valor, como mostra a listagem a seguir —
value é um dos vários parâmetros disponíveis em objetos Sensor e contém o valor lido mais recentemente.
Listagem 4.2. Registrando o valor de um sensor
board.on('ready', () => { const sensor =

new five.Sensor({
pino: 'A0' });
console.log(sensor.value); 1
});
1 Isso será registrado apenas uma vez (o evento pronto é acionado uma vez).
Mas o código na listagem 4.2 registrará o valor do sensor apenas uma vez - isso é de uso limitado.
É muito mais útil observar os valores do sensor ao longo do tempo. Este é um trabalho para JavaScript orientado a eventos.
O evento de dados Sensor em Johnny-Five
Diferentes objetos no JohnnyFive fornecem diferentes eventos aos quais seu código pode se vincular.
Você pode manipular esses eventos, quando eles ocorrerem, usando uma função de retorno de chamada.
UAU! e-book
www.wowebook.org
A classe Sensor, por exemplo, possui um evento de dados que é acionado toda vez que o valor
do pino é lido com sucesso, conforme mostrado na listagem a seguir.
Listagem 4.3. Registrando valores usando o evento de dados
sensor.on('dados', () => { 1
console.log(sensor.value); });
1 O evento de dados é acionado toda vez que um valor é lido com sucesso do pino.
Testando o fotoresistor
Vamos montar nosso circuito fotoresistor aprimorado por divisor de tensão com algum código
JohnnyFive para detectar mudanças nas condições de luz ao redor. Crie um novo arquivo,
photoresistor.js, e preencha-o com o seguinte código.
Listagem 4.4. Photoresistor.js

board.on('ready', () => { const sensor = new

five.Sensor({
pino: 'A0'
});
sensor.on('dados', () => {
console.log(sensor.value);
});
});
Conecte o cabo USB do Arduino ao seu computador - agora a placa e o circuito breadboard têm
energia. Execute o script do fotoresistor:
node photoresistor.js
Depois que o script estiver em execução, aumente e diminua a quantidade de luz que atinge o
fotorresistor colocando sua mão sobre ele ou diminuindo as luzes. Ao fazer isso, você deve ver os
valores na alteração de saída registrada, que se parecerá com o seguinte.
Listagem 4.5. Saída de registro de dados do fotoresistor
UAU! e-book
www.wowebook.org
$ node photoresistor.js 1464612512404

Dispositivo(s) /dev/cu.usbmodem1421 1464612512416 Conectado /dev/
cu.usbmodem1421
>> 354
354
355
355
355
355
354
353
432
Ajustando frequência, escala e limiar
Os valores do fotorresistor estão rolando muito rápido. Por padrão, o Sensor lerá, calculará
e escalará os dados ADC uma vez a cada 25 ms. É por isso que o registro do valor do fotorresistor
está rolando tão rapidamente. É possível ajustar a frequência dessas leituras com o parâmetro freq,
como mostra a listagem a seguir.
Listagem 4.6. Parâmetro de frequência do sensor
sensor const = novo cinco.Sensor({

pino: 'A0', frequência:
1000 1
});
1 Os valores estão em milissegundos: serão lidos uma vez por segundo.
Vinculação do evento JohnnyFive e isso
Os eventos do objeto Sensor ligam isso ao objeto Sensor, o que significa que você pode escrever
um código como o seguinte:
sensor.on('data', function () { console.log(this.value); //

`this` é vinculado a `sensor`
});
Observe que, devido à ligação que ocorre com as funções de seta usadas como retornos de chamada
anônimos, o seguinte não funcionará:
sensor.on('data', () =>
{ console.log(this.value); // > undefined WOW! eBook www.wowebook.org
});
Uma abordagem mais elegante é vincular ao evento de alteração em vez do evento de dados. O evento
change é acionado sempre que o valor mais recente do sensor difere em mais de um valor limite do
valor lido anteriormente.
O valor do limite é padronizado para 1, o que significa que - porque os valores do sensor de leitura são
inteiros — qualquer alteração no valor acionará o evento change. threshold é um atributo na instância do
objeto Sensor e pode ser alterado a qualquer momento para alterar o limite para acionar eventos de
alteração. A listagem a seguir combina isso em um script que efetua logout sempre que o sensor altera
o valor em 5 ou mais (lembre-se, os valores possíveis variam de 0 a 1023).
Listagem 4.7. Registrando a alteração dos valores do fotoresistor
var const = require('johnnyfive');

var const = new five.Board();
board.on('pronto', () => {
sensor const = novo cinco.Sensor({
pino: 'A0' });
console.log(sensor.value); 1
sensor.threshold = 5; 2
sensor.on('alterar', () => { 3
console.log(sensor.value);
});
});
1 Desconecta o valor inicial do sensor
2 Você pode ajustar o atributo de limite; o padrão é 1
3 mudanças disparam quando o valor muda em >= limite
Como a tensão real em V para o circuito do fotorresistor varia dependendo de qual resistor é usado
fora
em R , os valores de alteração do fotorresistor são mais relativos (está ficando mais claro, está ficando
2
mais escuro) do que absolutos (em footcandles ou qualquer intensidade de luz medida). . Outros
tipos de sensores fornecem uma tensão de saída calibrada que pode ser convertida diretamente em
unidades fixas, como graus Celsius no caso de analógico
sensores de temperatura.
UAU! e-book
4.1.5. Usando um sensor analógico de temperatura www.wowebook.org
4.1.5. Usando um sensor de temperatura analógico
O TMP36 é um sensor analógico de temperatura fabricado pela Analog Devices. É abundante,

barato e fácil de trabalhar. Como outros sensores analógicos, ele fornece um sinal de tensão variável.
Você não precisa construir um divisor de tensão para usá-lo: ele fornece uma tensão de saída
variável em um terceiro pino. Tudo o que você precisa fazer é conectar o sensor a +5 V e o terra
e, em seguida, ler a tensão no terceiro pino de tensão de saída (figura 4.17).
Figura 4.17. O esquema para o circuito TMP 36
Com o TMP36 e outros sensores de temperatura analógicos semelhantes, a tensão de

saída pode ser usada para calcular um valor de temperatura “real”. A tensão do sensor
TMP36 aumenta linearmente com a temperatura - dada uma leitura de tensão do
TMP36, a temperatura Celsius pode ser obtida multiplicando a tensão atual por 100 e
subtraindo 50. Por exemplo, se a tensão de saída do sensor for 0,7 V,
Temperatura em Celsius = 0,7 V * 100 – 50 = 20 UAU! e-book
www.wowebook.org
Para realizar este cálculo, no entanto, você precisa converter a leitura de 10 bits do ADC
de volta para a tensão (aproximada) e também colocar a aritmética em seu código. Para
tornar isso conveniente para nós, JohnnyFive oferece a classe Thermometer, que suporta
vários tipos diferentes de sensores de temperatura.
Construindo o circuito: sensor de temperatura TMP36
1 sensor TMP36
Fios jumper vermelho (2), preto (2) e verde (1)
O circuito para o TMP36 é mostrado na figura 4.18. Conecte o TMP36 à energia usando
fios jumper vermelho e preto e, em seguida, conecte seu pino de saída (meio) a A0 com
um fio jumper verde.
Não conecte o TMP36 ao contrário!
Os sensores TMP36 não gostam de ser conectados ao contrário. Certifique-se de

verificar a orientação do lado plano do sensor ao colocá-lo no circuito. Depois de aplicar
energia ao seu circuito, toque no sensor TMP36. Se estiver desagradavelmente quente ao
toque — uh oh! Desconecte a energia imediatamente e verifique a orientação do sensor.
Figura 4.18. Fiação do sensor TMP36
UAU! e-book
www.wowebook.org
Registrando e inspecionando dados TMP36
A instanciação de um objeto Thermometer é semelhante a usar a classe Sensor, mas precisa de

informações sobre que tipo de sensor de temperatura (controlador) está sendo usado. Um
exemplo simples de registro de temperatura é mostrado na listagem a seguir.
Listagem 4.8. temperatura.js
var cinco = require('johnnyfive');

var board = new five.Board();
board.on('ready', () => { const tmp36 = new

five.Thermometer({ controller: 'TMP36', 1
pino: 'A0' 2
});
tmp36.on('data', () =>
{ console.log(tmp36.celsius); 3
});
});
1 O termômetro requer um parâmetro do controlador - cerca de 15 sensores de temperatura

diferentes são suportados.
2 Como o sensor, o termômetro precisa saber em qual pino está.
3 celsius, fahrenheit e kelvin são todos atributos no termômetro

instâncias.
Interagindo com componentes usando o Johnny-Five REPL
Quando um script JohnnyFive está em execução, você pode interagir com ele na janela do
terminal. Ou, você poderia, se todo aquele material do console.log não estivesse rolando. Às
vezes, o console.log é tudo o que você precisa, mas para uma depuração ou inspeção mais
conveniente sem precisar reiniciar o script ou alterar o código, você pode aproveitar o REPL
(loop readevaluateprint) do JohnnyFive. UAU! e-book
www.wowebook.org
Se você removesse o manipulador de eventos de dados console.loging de temperature.js e
executasse o script, veria algo como o seguinte.
Listagem 4.9. REPL de Johnny-Five
$ node temperature.js 1464614001498

Dispositivo(s) /dev/cu.usbmodem1421
>>
Você pode digitar expressões JavaScript no prompt de seta dupla e pressionar Enter no teclado
— é um prompt interativo. Talvez você queira ver qual é o valor do sensor de temperatura tmp36,
em Fahrenheit, conforme mostrado na listagem a seguir.
Listagem 4.10. E se você quiser obter informações de um componente

Johnny-Five...?
>> tmp36.fahrenheit
ReferenceError: temp36 não está definido
na repetição:1:1
em REPLServer.defaultEval (repl.js:264:27) em vinculado (domain.js:287:14)
em REPLServer.runBound [como eval]
(domain.js:300:12) em REPLServer.<anonymous> (repl. js:431:12)
em emitOne (events.js:77:13)
em REPLServer.emit (events.js:169:7)
em REPLServer.Interface._onLine (readline.js:211:10) em REPLServer.Interface._line
(readline.js:550:8) em REPLServer.Interface._ttyWrite (readline.js:827:14)
Este não é o fim do jogo; apenas perdemos uma etapa. “Injetar” algo no escopo do REPL do
JohnnyFive exige que sejamos explícitos sobre isso.
Dentro de seu script JohnnyFive, você pode injetar seletivamente coisas no REPL que gostaria
de ter disponíveis para inspeção ou manipulação quando o script estiver em execução, conforme
Listagem 4.11. Injetando no REPL
board.repl.inject({ 1 tmp36: tmp36, 2
foo: 'barra' 3
});
1 As coisas são injetadas no REPL como pares de valor-chave.

UAU! e-book
www.wowebook.org
2 Isso torna a referência de objeto tmp36 disponível (como tmp36).
3 Isso torna a string 'bar' disponível como foo.
Tornar a string 'bar' disponível como foo é meio bobo, mas o ponto é que você pode
disponibilizar qualquer tipo de valor que desejar dentro do REPL. Você pode usar o REPL
como um console para interagir com esses itens, como mostra a listagem a seguir.
Listagem 4.12. Alteração de temperature.js para usar injeção de REPL

board.on('ready', () => { const tmp36 = new

five.Thermometer({ controller: 'TMP36',
pino: 'A0'
});
board.repl.inject({
tmp36: tmp36
});
});
Agora, ao executar o node temperature.js, você não verá o registro de dados, mas receberá um
prompt REPL assim que a placa for inicializada. Então você pode interagir com o objeto tmp36.
Tente digitar isto:
>> tmp36.celsius
Ou isto:
>> tmp36.fahrenheit
Isso pode ser útil, especialmente ao depurar ou explorar configurações mais complexas
componentes.
O fotorresistor é um bom ajuste para medir mudanças relativas a um estímulo ambiental -

é mais brilhante, agora é mais escuro, agora é mais brilhante novamente. O sensor TMP36 é
um bom ajuste para medir o estímulo ambiental como unidades fixas - graus Celsius ou
Fahrenheit. Ambos produzem sinais de tensão de resolução analógica infinita (em teoria,
pelo menos), e a faixa de valores disponíveis para processamento do software é definida
pelo ADC do microcontrolador (10 bits, no caso do Uno).
UAU! e-book
www.wowebook.org
Para alguns tipos de detecção ambiental, porém, você não precisa de um conjunto contínuo de valores
como entrada. Para esses tipos de aplicações, você pode usar componentes que geram sinais digitais.
4.2. ENTRADAS DIGITAIS
Os pinos de 0 a 13 no Uno são pinos digitais. Cada um pode ser configurado como um pino de entrada ou
um pino de saída. Quando configurado para entrada, um pino digital pode avaliar, com base na tensão
presente, se está em um estado lógico ALTO ou BAIXO.
Botões e algumas chaves são bons exemplos de componentes que fornecem sinais digitais simples
porque são binários. Um botão está pressionado ou não está: está ligado ou está desligado. Isso corresponde
aos pinos de entrada digital, cujos estados também são binários (BAIXO ou ALTO).
4.2.1. Usando um botão como uma entrada digital
Nosso desafio é construir um circuito que faça corretamente com que um pino digital esteja em um estado
ALTO quando um botão (também conhecido como interruptor momentâneo) é pressionado, mas em um
estado BAIXO caso contrário. Dessa forma, nosso software pode determinar quando um botão está sendo
pressionado e fazer algo com essa informação.
Atualizador de conexão de botão
Os pinos que compartilham um lado de um botão são conectados eletricamente apenas quando o
botão é pressionado. Mas os pinos em lados opostos do botão são sempre eletricamente
conectado.
UAU! e-book
www.wowebook.org
As conexões de pinos de um botão de pressão típico
Entendendo os níveis lógicos
O microcontrolador do Arduino determina se um determinado pino de entrada digital é ALTO ou BAIXO

com base na tensão presente no pino no momento em que é lido. Como você pode esperar no caso
do Uno, 5 V presentes em um pino de entrada o tornarão logicamente ALTO e 0 V o tornará logicamente
BAIXO. Há algumas nuances aqui que você precisa conhecer, no entanto, porque isso afetará o design
do circuito do botão.
Digamos que você tenha um pino de entrada digital configurado no Arduino, mas ainda não tem
nada conectado a ele. Que estado você esperaria que o pino tivesse se lesse seu valor?
Acontece que é impossível prever. Pode ser ALTO, pode ser BAIXO. Se você o lesse ao longo do
tempo, veria LOWs e HIGHs praticamente aleatórios. Esse tipo de comportamento desconectado é
chamado de flutuante.
Tensões e níveis lógicos
Um pino digital não precisa ter exatamente 5 V presentes para ler ALTO. Da mesma forma, baixa
tensão de, digamos, 0,8 V, resultará em um BAIXO lógico. Cada microcontrolador possui um
conjunto de faixas de tensão que resultarão em um estado BAIXO ou ALTO, bem como uma margem de ruído
No meio.
Faixas de tensão para estados lógicos nos pinos do Arduino Uno. Qualquer tensão abaixo de 1,5 V é
BAIXA; qualquer coisa acima de 3 V, ALTA. Tensões entre 1,5 V e 3 V caem na margem de ruído e
devem ser evitadas.
No caso do ATmega 328P do Uno, as tensões de entrada de cerca de 0–1,5 V resultarão em um

estado BAIXO, enquanto as tensões superiores a 3 V serão lidas como ALTO.
UAU! e-book
www.wowebook.org
Isso ocorre por causa da alta impedância do pino, na qual é necessária apenas uma pequena
quantidade de corrente para mover o pino entre um nível lógico e outro. Isso é útil e eficiente - o pino
pode detectar alterações nos componentes conectados sem precisar gastar muita corrente para fazer isso.
No entanto, pequenos blips comumente decorrentes de ruído elétrico no ambiente ou interferência
de outros pinos no mesmo microcontrolador são suficientes para fazer o pino alternar entre LOW
e HIGH basicamente de forma aleatória.
Conectando um botão com um resistor pull-down
1 resistor de 10 kV
4 fios jumper
O que precisamos fazer é construir um circuito seguro (que não tenha risco de curto-circuito) que
estabeleça um nível lógico “padrão” confiável quando o botão não for pressionado - BAIXO ou ALTO,
mas que não t flop em torno de aleatoriamente. Uma maneira de fazer isso é puxando o pino de entrada
para o terra (0 V) com o auxílio de um resistor adicional.
Quando um resistor pulldown está presente no circuito, há sempre uma conexão entre o pino 2
e o terra, mesmo quando o botão não está pressionado (figura 4.19).
Figura 4.19. Um resistor pull-down “puxa” o pino digital para nível lógico LOW quando o componente
(botão) não é pressionado (conectado).
UAU! e-book
www.wowebook.org
Isso resolve o problema de flutuação - se alguma corrente parasita aparecer sem ser convidada
quando o botão não for pressionado, ela será desviada para o terra através do resistor (lado
esquerdo da figura 4.19). O pino 2 lerá continuamente LOW (0 V) quando o botão não for pressionado.
Quando o botão é pressionado (lado direito da figura 4.19), a corrente flui a 5 V através do botão
e, em seguida, para o pino 2 e para o terra - o pino 2 indicará ALTO. O resistor pulldown
desempenha aqui outra função: evita um curto-circuito quando o botão é pressionado,
limitando a corrente que circula.
Um divisor de corrente disfarçado
Ao usar um resistor suspenso no circuito, você estará criando um divisor de corrente, mesmo
que não seja imediatamente óbvio. Lembre-se do capítulo 3 que a divisão de corrente é uma
característica dos circuitos paralelos (o circuito na figura é um circuito paralelo porque há mais
de um caminho que uma carga individual pode seguir). Quando há mais de um caminho para
escolher, a corrente será dividida proporcionalmente com base na resistência em cada caminho.
UAU! e-book
www.wowebook.org
Usar um resistor pulldown em combinação com um pino de entrada na verdade cria um divisor de corrente.
Internamente, o circuito de pinos do microcontrolador inclui um resistor com alta resistência (da ordem de
100 kV a vários megohms) quando um pino é configurado para entrada (estado de alta
impedância). Este resistor interno fará o papel de R . Para R , temos o resistor pulldown de 10 kV - alta
2 1
resistência, mas cerca de uma ordem de magnitude menos resistente que o resistor interno (R ).
Quando a corrente flui através do circuito (o botão é pressionado), muito mais dela passará pelo caminho
do resistor de 10 kV (R ) do que pelo caminho com o resistor interno

1
(R).
2
Em um divisor de corrente, cada caminho recebe uma distribuição de corrente diferente, mas ambos
recebem a mesma tensão. O bit de corrente que atinge o pino 2 está em ou próximo de 5 V, o que definirá o pino
para ALTO.
O diagrama elétrico resultante (figura 4.20) não é muito complexo. Vá em frente e conecte o botão na
breadboard conforme mostrado, certificando-se de conectar um resistor de 10 kV entre o pino 2 e o terra.
Figura 4.20. O circuito do botão com um resistor pull-down de 10 kV
UAU! e-book
www.wowebook.org
Classe Button de Johnny-Five
A classe Button do JohnnyFive cuida da configuração de um pino de saída digital e fornece vários
recursos que você deseja em um botão, incluindo a capacidade de ouvir pressionamentos de
botão, conforme mostrado na listagem a seguir.
Listagem 4.13. botão.js

pushButton const = new five.Button(2);
pushButton.on('down', () => { console.log('Fui
pressionado!'); });
});
Experimente o código da Listagem 4.13. Conecte seu Arduino à alimentação USB e execute o script:
$ node button.js
Depois que a placa for inicializada, toda vez que você pressionar o botão para baixo, deverá ver isto:
>> Fui pressionado!
Neste capítulo, você viu alguns tipos de entradas básicas: dois tipos de sensores analógicos e
entrada digital com um botão de pressão. Entradas e sensores são vitais para coletar
informações sobre o ambiente físico, mas fica consideravelmente mais divertido quando você
realmente faz algo com essas informações - quando você cria uma saída. Isso é o que você fará a
seguir.
UAU! e-book
RESUMO www.wowebook.org
RESUMO
Os sensores analógicos geram sinais de tensão variável com resolução (teoricamente) infinita
e os microcontroladores convertem esse sinal em equivalentes de valor digital usando a
conversão analógico-digital (ADC).
O Arduino Uno possui seis pinos de entrada analógica, que fornecem ADC de 10 bits (1024
valores). Seus 14 pinos digitais podem ser configurados como entrada ou saída e possuem
níveis lógicos binários: LOW ou HIGH.
Cada componente em um circuito em série recebe a mesma quantidade de corrente, mas a tensão
é distribuída com base na resistência proporcional do componente. Um divisor de tensão usa esse
princípio para converter uma tensão de entrada mais alta em uma tensão de saída mais baixa,
usando dois resistores conectados em série.
Um circuito divisor de tensão cria um ponto de referência no qual você pode detectar mudanças na
resistência como mudanças na tensão. Essa abordagem pode ser usada para ler dados de
sensores resistivos como um fotoresistor.
Classes como Sensor, Thermometer e Button em JohnnyFive ou estruturas JavaScript de nível
superior equivalentes podem adicionar conveniência ao abstrair a configuração de pinos e

cálculos tediosos e fornecer eventos relevantes aos quais se vincular.
Cada ramificação em um circuito paralelo recebe a mesma quantidade de tensão, mas a corrente é
distribuída com base na resistência proporcional da ramificação. Um divisor de corrente usa esse
princípio usando resistores conectados em paralelo.
Usar um resistor pulldown é uma forma de evitar uma situação flutuante de nível lógico indeterminado
quando as entradas digitais estão desconectadas ou inativas.
UAU! e-book
www.wowebook.org

História

Tópicos
Dominando técnicas de controle de LED mais avançadas - animando LEDs e usando LEDs RGB
Tutoriais coloridos
Usando o suporte de modulação por largura de pulso (PWM) para fazer sinais de saída digital
comportar-se mais como sinais de saída analógicos
Destaques
Noções básicas de bitshifting e operações binárias em JavaScript
Integrando uma API meteorológica de terceiros para criar uma “bola meteorológica” LED multicolorida
Gadget de
configurações
Apoiar Conectando e controlando um módulo LCD paralelo com JohnnyFive e o Uno
Desconectar
Combinando vários componentes de entrada e saída para construir um temporizador avançado
dispositivo
Fazendo barulhos e tocando músicas com componentes piezo e JohnnyFive
Agora é hora de fazer algo barulhento. Ou algo brilhante. Ou algo piscante ou expressivo. Você
experimentou alguns truques básicos de LED, mas agora vamos dar uma olhada mais abrangente em
algumas das maneiras pelas quais você pode integrar saídas em projetos.
Arduino Uno e cabo USB
y, qualquer cor
2 LEDs padrão,
1 fotoresistor
UAU! e-book
www.wowebook.org
1 LED RGB de cátodo comum
3 botões de pressão
1 módulo LCD paralelo 16x2
1 potenciômetro rotativo
1 piezo
3 resistores de 10 kV
23 fios jumper em várias cores
5.1. ILUMINANDO AS COISAS
Os LEDs parecem fazer muito mais truques do que apenas ligar ou desligar. Se você olhar em volta
para os componentes eletrônicos embutidos em seus próprios dispositivos eletrônicos, verá que eles pulsam
ou desaparecem. Você pode até vê-los mudar de cor.
Esses comportamentos comuns de LED são, tecnicamente, ilusões (figura 5.1). Um LED pode emitir
apenas um comprimento de onda de luz - só pode ser de uma cor. E ainda, LEDs ao nosso redor
UAU! e-book
www.wowebook.org
certamente parecem escurecer ou assumir tons diferentes.
Figura 5.1. Os LEDs emitem uma única cor e estão ligados ou desligados.
Hora de se tornar um mágico do LED - existe uma técnica eletrônica que podemos aproveitar para fazer os
LEDs adquirirem profundidade e intriga.
5.1.1. Fading LEDs com modulação por largura de pulso (PWM)
OK, então um LED só pode estar ligado ou desligado a qualquer momento. Você fez uma piscada, que na
verdade é apenas um ciclo de liga e desliga periódicos. Vamos ficar mais caprichados com o piscar,
com o objetivo de enganar os olhos humanos.
1 tábua de pão
2 LEDs padrão, qualquer cor que você gosta
Fios jumper amarelo (2) e preto (1)
UAU! e-book
www.wowebook.org
Primeiro, construa o circuito mostrado na figura 5.2. Em seguida, crie um arquivo e adicione o
código mostrado na listagem a seguir.
Listagem 5.1. experimenta-led.js

board.on('ready', () => { const led1 = new

five.Led(2); 1
const led2 = novos cinco.Led(3); 2
placa.repl.inject({ led1: led1, 3
led2: led2
});
});
1 Instancia um objeto Led no pino 2
3 Injeta as instâncias do objeto Led no REPL
Figura 5.2. Diagrama de fiação para experimentação de LED
Este código realmente não faz muito. Ele instancia dois objetos Led e os
disponibiliza no REPL do JohnnyFive como led1 e led2. Execute o script:
UAU! e-book
www.wowebook.org
$ node experimentLED.js
Assim que estiver funcionando, você poderá digitar comandos no prompt do REPL. Primeiro - e sei que este é
um território pelo qual passamos antes - faça um dos LEDs piscar.
Digite o seguinte no prompt REPL e pressione Enter:
>> led1.blink()
O primeiro LED deve estar piscando agora, em períodos de 100 ms (ligado por 100 ms, desligado por 100 ms) —
este é o comprimento de fase padrão (velocidade dos períodos de piscada) para o método de piscada, se você
não especificar o contrário.
Agora, quero que você pegue cuidadosamente o Arduino e a breadboard com os LEDs em uma mão e agite-
os na frente do seu rosto. Você saberá que está acenando freneticamente quando o LED parece não
piscar mais, mas é apenas uma linha manchada.
Você está enganando seus próprios olhos. Quando as coisas se movem muito rapidamente, seus olhos e
cérebro não conseguem acompanhar. Seu cérebro, na verdade, conecta os pontos para você e decide que você
está vendo uma linha contínua de luz. Se você é um fotógrafo, pode pensar nisso como uma espécie
de análogo à velocidade do obturador - sua própria “velocidade do obturador” não é rápida o suficiente e você
acaba com um desfoque de movimento. É por isso que filmes e filmes podem parecer fluidos em 24 quadros
individuais por segundo ou mais.
O mesmo vale para a detecção de piscadas individuais. Se uma luz piscar rápido o suficiente, os
humanos não conseguirão ver o piscar (figura 5.3). Diferentes seres humanos têm diferentes limiares de
percepção - isso explica por que fico mal-humorado com velhas lâmpadas fluorescentes ou CRTs com
frequências de atualização lentas, enquanto alguns de meus colegas não se incomodam nem um pouco.
Mas todos perdem de forma confiável a capacidade de discernir piscadas individuais em torno de 100 Hz (cem
ciclos por segundo).
Figura 5.3. Perdemos a capacidade de discernir piscadas individuais quando um LED está se movendo
rapidamente.
UAU! e-book
www.wowebook.org
Então, ótimo, qual é o sentido de fazer um LED piscar tão rápido que as piscadas são invisíveis e parece
que está sempre ligado? Não podemos simplesmente acender um LED continuamente para obter o
mesmo efeito?
Acontece que coisas interessantes acontecem se você mexer na proporção de tempo que o LED fica ligado
(versus desligado). Se você piscar o LED muito rápido, os humanos não conseguirão perceber a piscada
– isso nós cobrimos. Mas se o LED estiver ligado apenas um quarto do tempo (desligado nos outros três
quartos), ele também parecerá consideravelmente mais escuro.
Faça parar!
Se o LED piscando estiver deixando você maluco, você sempre pode parar de piscar com o método
de instância Led.stop:
> led1.stop()
Dependendo de quando o comando é emitido, o resultado pode ser um LED apagado ou um LED
permanentemente aceso. Se o LED estiver aceso e você quiser apagá-lo, use isto:
> led1.off()
Você precisará usar os dois métodos - você não pode simplesmente pular para o método off. A parada
limpará o intervalo que faz com que a piscada aconteça—off não.
Vamos fazer isso acontecer. Tente (novamente no REPL):
UAU! e-book
www.wowebook.org
>> led1.on()
>> led2.brightness(64)
brilho é um método de instância em objetos JohnnyFive Led que assume um valor de 8 bits (0–255).
Um valor de 64 é, então, um quarto do valor mais brilhante possível. O resultado da chamada para
led2.brightness(64) é que o LED passa 75% do tempo desligado e fica aceso 25% do tempo. Tudo isso
liga e desliga está acontecendo em frequências muito rápidas para o olho captar. Você notará que o
led2 agora parece menos brilhante que o led1—
é mais escuro.
O microcontrolador do Uno ajuda aqui. Ele fornece suporte de hardware para uma técnica chamada
modulação por largura de pulso (PWM), que faz malabarismos de liga e desliga mais rapidamente do
que o software pode fornecer facilmente. A porcentagem de tempo em que um sinal PWM é ALTO
(ligado) é chamada de ciclo de trabalho. Diz-se que uma saída que é ALTA um quarto do tempo
tem um ciclo de trabalho de 25% (figura 5.4).
Figura 5.4. Um ciclo de trabalho de 25%
O suporte de hardware PWM é comum porque é bastante útil, mas seu suporte varia de placa para placa
e normalmente está disponível apenas em determinados pinos. É o caso do Arduino Uno. PWM está
disponível apenas nos pinos 3, 5, 6, 9, 10 e 11.
Não se preocupe, você não precisa memorizar isso. Se você olhar para o seu Arduino, verá que
esses números de pinos são serigrafados com um til (~) próximo a eles (figura 5.5). Isso indica que o
PWM é suportado nesse pino.

UAU! eBook
Figura 5.5. Apenas alguns dos pinos digitais do Arduino Uno suportam PWM. Eles são www.wowebook.org
Figura 5.5. Apenas alguns dos pinos digitais do Arduino Uno suportam PWM. Eles são
marcados com ~.
Agora, de volta ao REPL, tente isto:
Isso não vai funcionar. Você receberá uma exceção que começa com algo como
Erro: Pin Error: 2 não é um pino PWM válido (Led)
Isso é JohnnyFive e firmata - o software inclui mapeamentos de quais pinos

o que em quais placas.
Tudo bem, vimos várias coisas em nossa exploração aqui. As pessoas não conseguem discernir
as piscadas se forem muito rápidas. Alterar o ciclo de trabalho do sinal em um LED faz com que
seu brilho pareça mudar. Uma última coisa, e então faremos algo com esse conhecimento.
Certifique-se de usar pinos com suporte PWM para recursos que o exijam
Métodos como brilho e vários outros que você precisará em instâncias de Led exigem o WOW! e-
book
www.wowebook.org
componente a ser conectado a um pino que suporta PWM. JohnnyFive lançará um erro se você
tentar invocar um método PWMrequiring em um pino que não o suporte.
Ao projetar seus circuitos, é bom ter em mente quais pinos suportam PWM para
economize tempo e dores de cabeça mais tarde.
Tente isso no REPL:
>> led1.on()
128 está exatamente no meio da faixa de brilho, portanto, você pode esperar que essas duas
expressões JavaScript resultem no segundo LED brilhando com metade do brilho em
comparação com o primeiro, que está no máximo. Mas, a menos que você aperte os olhos com
muita força, os dois LEDs parecem iguais. Você pode ser capaz de ver uma pequena diferença, mas não mui
Isso porque o brilho vence. o brilho (128) resulta em um ciclo de trabalho de 50% - o LED fica ligado
apenas na metade do tempo - mas o cérebro o direciona para o brilho. Dito de outra forma, a
escala de brilho de 8 bits de JohnnyFive de 0 a 255 parece não linear, inteiramente devido à
percepção humana.
5.1.2. Animando LEDs com PWM

Agora você sabe como ligar ou desligar um LED, piscá-lo e, supondo que esteja conectado a um
pino que suporte PWM, defina seu brilho. Para complementar este pequeno estábulo de truques,
você também pode animar o brilho de um LED, fazendo-o parecer pulsar, pular, respirar ou
adormecer lentamente - sua imaginação é o limite aqui.
JohnnyFive inclui uma classe Animation, que oferece controle refinado sobre as animações de
- no momento da escrita - o brilho dos LEDs e os movimentos dos servos (encontraremos os
servos no capítulo 6).
Trabalhar com animações no JohnnyFive envolve algumas etapas, mostradas na listagem a seguir.
Listagem 5.2. Etapas para animar componentes no Johnny-Five
const pulsingLED = new five.Led(3); const options = { /*

detalhes da animação */ }; 1 const animation = new five.Animation(pulsingLED); 2
animation.enqueue(options); 3
UAU! e-book
www.wowebook.org
1 Cria um objeto de opções contendo detalhes de animação—mais sobre isso em breve
2 Instancia um objeto Animation e passa a ele um componente de destino - o destino será animado
3 Inicia a animação com enqueue
Vamos dar uma volta fazendo um LED parecer pulsar. JohnnyFive precisa de nós primeiro
para definir como queremos que a animação se comporte.
O LED pulsante deve aumentar e diminuir novamente em loops que usam easing atraente. As
funções de atenuação são funções que variam a taxa de uma animação durante sua duração. Por
exemplo, uma animação que suaviza começa movendo-se rapidamente, mas fica mais lenta à medida
que avança.
As funções atenuantes são tipicamente não lineares, integrando seno, cúbico, exponencial e outras curvas
na equação. Um easing inoutsine cria uma animação com um ritmo como o mostrado na figura 5.6. As
funções de atenuação podem tornar uma animação mais realista ou dar a ela diferentes qualidades de
movimento. Obviamente, os LEDs não se movem, mas as mudanças em seu brilho podem
definitivamente ser animadas.
Figura 5.6. inOutSine é uma das dezenas de opções de função de easing

disponíveis no Johnny-Five por meio de sua dependência do pacote npm do
componente easy.
A atenuação inOutSine é o que usaremos para pulsar, pois as mudanças no brilho começam
lentas e depois aceleram no meio do brilho do LED. Um pulso é uma animação metronômica, o
que significa que, uma vez que a animação avança, ela deve retroceder, movendo-se entre seus
pontos inicial e final em um loop para frente e para trás.
Também precisamos informar à animação o que ela está atenuando definindo quadros-chave
UAU! e-book
www.wowebook.org
(figura 5.7). Os quadros-chave definem os estados específicos (como quadros estáticos) entre os
quais a animação deve preencher os quadros intermediários usando a função easing. O processo de
criação desses quadros ou estados intermediários entre os quadros-chave é conhecido como interpolação.
Para esse pulso simples, os quadros-chave são simples: totalmente desativados (brilho 0) e totalmente
ativados (brilho 255).
Figura 5.7. A animação de pulso fará um loop metronomicamente entre dois

quadros-chave básicos (brilho 0 e brilho 255) com easing inOutSine.
Finalmente, precisamos dar uma duração à animação, em milissegundos. Cada segmento da

animação – indo do escuro para o claro ou do claro para o escuro – deve levar um segundo.
Juntas, as opções de animação se parecem com o código a seguir.
Listagem 5.3. Opções de animação para pulsar
opções const = {
easing: 'inOutSine',
metronômico: verdadeiro,
circuito: verdadeiro,
quadros-chave: [0, 255],
duração: 1000
};
Vamos ver o que isso parece, não é? Você pode usar o circuito do último conjunto de
experimentos para esta parte (você não usará o primeiro LED). Crie um novo arquivo
chamado animateLED.js. Cole o conteúdo de experimentLED.js em animateLED.js como
ponto de partida e edite o código para criar um único LED no pino 3. Adicione o objeto de
opções após a instanciação do objeto Led pulsante da seguinte maneira.
UAU! Listagem
de e-books 5.4. animate-led.js www.wowebook.org
Listagem 5.4. animate-led.js
board.on('ready', () => { const

pulsandoLED = new five.Led(3);
opções const = {
easing: 'inOutSine',
metronômico: verdadeiro,

duração: 1000
};
// ...
});
As etapas 2 e 3 são as próximas: criar um objeto Animation e fazê-lo entrar na fila.
Listagem 5.5. Instanciação e enfileiramento de animação
const pulsandoLED = novo five.Led(3);
opções const = { easing : 'inOutSine',
metronomic: true,

duração: 1000
};
const animation = new five.Animation(pulsingLED); 1 animation.enqueue(options); 2
});
1 Passa o alvo - a coisa a animar. Neste caso, o LED (PulsingLED).
2 Enfileira a animação e passa as opções de animação.
Agora execute o script:
$ node animateLED.js
E aí está. Bem, mais ou menos. Eu fiz você fazer isso da maneira mais difícil, porque como
UAU! e-book
www.wowebook.org
acontecer, o código na listagem a seguir faz a mesma coisa.
Listagem 5.6. Maneira mais fácil de pulsar um LED

board.on('ready', () => { const pulsandoLED

= new five.Led(3);
pulsandoLED.pulse(1000); 1
});
1 Led.prototype.pulse leva uma duração em ms (padrão 1000).
Por baixo, a implementação do pulso é semelhante ao que fizemos anteriormente, mas é um uso tão
comum que foi simplificado em um método para usuários do JohnnyFive.
Os LEDs pulsantes podem ser uma boa maneira de chamar a atenção sem serem muito invasivos. Usando o
que abordamos, você pode criar um cronômetro simples usando apenas algumas linhas de código - ele
começará a pulsar quando o tempo acabar, como mostra a listagem a seguir.
Listagem 5.7. O cronômetro mais simples do mundo

board.on('ready', () => { const pulsingLED

= new five.Led(3); const timerLength = 10000; 1
setTimeout(() => { 2
pulsandoLED.pulse();
}, timerLength);
});
1 Define a duração do temporizador em milissegundos (aqui 10 segundos)
2 Define um tempo limite para começar a pulsar o LED após 10 segundos
Claro, este temporizador é de uso limitado. Você não pode alterar a duração do cronômetro ou quando o
cronômetro inicia ou iniciar um novo cronômetro. Não se preocupe, vamos melhorar daqui a pouco.
5.1.3. Combinando entrada com saída de LED
Obviamente, a saída é mais interessante se estiver respondendo a algum tipo de entrada significativa.
As conexões entre entrada e saída são o que faz a internet das coisas funcionar.
UAU! e-book
www.wowebook.org
Um desses acoplamentos poderia ser um fotoresistor e um LED para criar uma luz noturna com
reconhecimento de brilho. Quando as leituras do fotoresistor são mais baixas, o LED pode ser
mais brilhante, ou seja, a “luz noturna” acende à “noite”, quando está mais escuro.
1 LED padrão, qualquer cor (você pode reutilizar o LED pulsante de cima)
1 fotoresistor
1 resistor de 10 kV
1 resistor de 220 V
Fios jumper amarelo (1), vermelho (2), verde (1) e preto (1)
Deixe o LED conectado ao pino 3 da protoboard (o LED pulsante do último exemplo), mas remova o
outro LED e adicione um fotorresistor e um resistor de 10 kV conforme mostrado na figura 5.8 .
Figura 5.8. Diagrama de fiação para luz noturna automática
UAU! e-book
www.wowebook.org
A Listagem 5.8 mostra uma primeira tentativa de uma luz noturna sensível à luz usando
Light, uma classe em JohnnyFive que fornece recursos para trabalhar com fotoresistores
(ldr significa resistor dependente de luz, outro nome para fotoresistor).
Listagem 5.8. Uma luz noturna ingênua
const five = require('johnnyfive'); const board = new

five.Board();
board.on('ready', () => { const nightlight =

new five.Led(3);
const ldr = new five.Light({ pin : 'A0', freq: 500 }); 1
ldr.on('change', () =>
{ nightlight.brightness((ldr.value >> 2) ^ 255); 2
});
});
1 Verificar os níveis de luz duas vezes por segundo (a cada 500 ms, o valor de freq) deve
ser mais do que suficiente.
2 Define o brilho do LED para “o oposto” do valor do fotoresistor
A linha a seguir pode ter feito seus olhos se cruzarem se você não passou muito tempo no
mundo dos operadores bit a bit:
UAU! e-book
www.wowebook.org
nightlight.brightness((photoresistor.value >> 2) ^ 255);
Lembre-se de que o microcontrolador do Arduino Uno fornece leituras ADC como inteiros de 10 bits (0–1023).
Enquanto isso, o método de brilho no objeto Led espera um número de 8 bits (0–255).
A expressão valorresistor.foto >> 2 desloca valor.resistor.foto para a direita em dois bits. Isso significa que dois
bits saltam do lado direito do número e nunca mais são ouvidos (figura 5.9). No caso de photoresistor.value
>> 2, entra um número de 10 bits, seus dois dígitos menos significativos são inicializados e o que é retornado
é um número de 8 bits.
Figura 5.9. Deslocar um número de 10 bits para a direita por 2 resulta em um número de 8 bits.
Você pode pensar no número de 10 bits como sendo muito preciso para uma entrada de 8 bits; o
deslocamento de bits para a direita em 2 “arredonda” para uma resolução mais baixa que o brilho pode usar.
A parte ^ 255 usa o operador bit a bit XOR (OU exclusivo) (^) para obter o que chamarei vagamente de
número de 8 bits “oposto” do argumento à esquerda. XOR realiza uma comparação em cada par de bits e
retorna 1 no lugar do dígito somente quando os dígitos avaliados são diferentes – quando um é 1 e o outro é 0
(figura 5.10).
Figura 5.10. A operação XOR compara cada dígito binário, produzindo um 1 se os dígitos
binários forem diferentes.
UAU! e-book
www.wowebook.org
A expressão (photoresistor.value >> 2) ^ 255 significa, então, deslocar photoresistor.value

2 bits para a direita (tornando-o um número de 8 bits) e posteriormente XOR o valor
resultante com 255.
Bitshifting em todo o lugar
Bitshifting e operações bit a bit podem parecer estranhos para desenvolvedores de software que
geralmente trabalham em código de nível superior, mas surgem em todos os lugares ao
trabalhar com hardware. A Mozilla Developer Network tem uma boa referência de operadores
JavaScript bit a bit, que contém as principais coisas que você deseja saber (http://mng.bz/CLvy).
A primeira versão do nightlight tem algumas deficiências, que você pode ver em ação ao executá-
lo:
$ node nightlight.js
Por um lado, o LED está sempre ligado com algum brilho, mesmo quando as leituras do
fotoresistor estão próximas dos valores mais brilhantes possíveis. Não queremos que o LED acenda
apenas quando está mais escuro? Não precisamos dele em plena luz do dia. A segunda
versão do código nightlight aborda isso substituindo o que acontece dentro da função de
retorno de chamada de alteração, conforme mostrado na listagem a seguir.
Listagem 5.9. Luz noturna ligeiramente melhorada
ldr.on('change', () => { if (ldr.level < 0.5)

{1
nightlight.brightness((ldr.value >> 1) ^ 255); 2
} outro {
UAU! e-book
www.wowebook.org
nightlight.off(); 3
}
});
1 As instâncias leves têm um valor de nível, que é uma porcentagem entre 0,0 e 1,0.
2 Altera o cálculo do brilho do LED
3 LED está desligado se nível >= 0,5
Nesta variante, o LED é totalmente desligado se o nível do fotoresistor for maior ou igual a
0,5 (nightlight.off()).
Se o photoresistor.level for menor que 0,5 (50%), sabemos que seu valor de 10 bits também
deve ser menor que 512 (porque 511 é o meio da faixa de possíveis valores de 10 bits,
0–1023). Isso significa que photoresistor.value é um número inteiro entre 0 e 511, inclusive.
Todos os números nesse intervalo são números de 9 bits (0 a 511). Isso significa que
só precisamos deslocar um bit para a direita para converter o valor em um número de
8 bits (0–255).
O resultado final é que o LED ficará cada vez mais brilhante à medida que os valores do
fotorresistor diminuem de 511 para 0.
Mas ainda podemos fazer melhor. Como você viu no capítulo 4, mesmo ao escolher o melhor
valor de resistor possível para o divisor de tensão do circuito fotoresistor, você não conseguirá
obter toda a gama de tensões de 0 a 5 V. Seria melhor se a luz noturna pudesse calibrar
baseado na gama real de condições e leituras que está encontrando, conforme mostrado na
próxima listagem.
Listagem 5.10. Luz noturna autocalibrável

board.on('ready', () => { const nightlight =

new five.Led(3); const ldr = new five.Light({ pin : 'A0', freq:
500 }); var dimmest = 1024,
mais brilhante = 0;
ldr.on('alterar', () => {
if (ldr.value < dimmest) { dimmest = ldr.value; }
if (valor.ldr > mais brilhante) { mais brilhante = valor.ldr; }
const parenteValue = five.Fn.scale(ldr.value, mais escuro, mais brilhante, 0, 511); if (relativeValue <= 255) {
UAU! e-book
www.wowebook.org
nightlight.brightness((relativeValue >> 1) ^ 255); } else {
nightlight.off();
}
});
});
1 Acompanha as leituras mais escuras e brilhantes que vê
2 Atualiza mais escuro e mais brilhante se encontrar valores mais baixos e mais altos
3 Dimensiona o valor atual para um número de 9 bits entre as leituras mais escuras e mais
brilhantes
O código da luz noturna na listagem 5.10 faz duas alterações. Primeiro, ele rastreia os valores
reais mais escuros e brilhantes vistos durante a vida útil do script da luz noturna. Em seguida, ele
aproveita o método de utilidade de escala disponível no objeto Fn a bordo
instâncias.
scale(value, fromLow, fromHigh, toLow, toHigh) pega um valor que
atualmente existe em um intervalo entre fromLow e fromHigh (os valores mais escuros e mais
claros vistos) e o remapeia para um intervalo entre toLow e toHigh (0 e 511), proporcionalmente.
O número resultante será um número de 9 bits (entre 0 e 511). Agora podemos prosseguir, sabendo que
valores <= 255 estão na metade inferior dos valores observados. A luz noturna continuará a se ajustar
(calibrar baixo e alto) à medida que funciona com o tempo.
5.1.4. Tornando-se totalmente colorido com LEDs RGB
Tudo bem, essa é uma cobertura extensa de escurecimento de um LED, mas e os LEDs que parecem
mudar de cor? Claro, um único LED pode ter apenas uma cor - um comprimento de onda - mas se você
agrupar LEDs vermelho, verde e azul em um único pacote e controlar o brilho (ciclo de
trabalho) de cada LED componente, voilà! Todas as cores do arco-íris.
Os LEDs RGB têm quatro pernas. Há uma perna para cada LED (vermelho, verde, azul). A quarta
perna é um cátodo ou um ânodo. LEDs RGB de catodo comum - onde todos os LEDs de três cores
compartilham uma única perna de cátodo - são do tipo que usaremos (figura 5.11). LEDS RGB de
ânodo comum , que possuem uma perna de ânodo compartilhada, também estão disponíveis.
Figura 5.11. Os LEDs RGB de cátodo comum têm três LEDs componentes (vermelho, verde,
azul) em um pacote. A perna mais longa é o cátodo compartilhado.
UAU! e-book
www.wowebook.org
Como os LEDs comuns, os LEDs RGB permitem controlar o brilho com PWM, mas agora existem
três LEDs que representam as cores primárias da luz. Para LEDs de cátodo comum, um ciclo de
trabalho de porcentagem mais alta em um LED de cor de componente tornará essa cor mais brilhante,
enquanto um ciclo de trabalho menor o tornará mais escuro.
5.1.5. Construa sua própria “bola do tempo”
Eu cresci em Portland, Oregon, e quando era criança, avistar a bola do tempo no topo do Standard
Insurance Plaza sempre foi um pouco emocionante. A bola meteorológica fornecia uma representação
visual codificada muito básica da previsão do tempo para as próximas 24 horas.
A bola meteorológica montada em um poste era grande o suficiente para ser vista por toda a cidade e
estava coberta de luzes.
Só tinha seis estados possíveis. A tendência de temperatura prevista foi representada pela cor:
vermelho se a previsão é de que fique mais quente, branco se estiver ficando mais frio, verde se
permanecer o mesmo. Se a precipitação estivesse próxima, ela piscaria. Simples e, no entanto, notavelmente
claro e útil. Vamos fazer um.
1 LED RGB de cátodo comum
1 resistor de 220 V
Fios jumper vermelho (1), verde (1), azul (1) e preto (1)
1 tábua de pão
UAU! e-book
www.wowebook.org
Conecte um circuito de LED RGB conforme mostrado na figura 5.12.
Figura 5.12. Diagrama de fiação para a bola do tempo
Agora precisamos da previsão do tempo! O serviço Dark Sky fornece uma API de previsão do tempo que,
no momento da escrita, fornece resultados gratuitos para até 1.000 consultas por dia. Você precisa se inscrever
para obter uma chave de API, o que pode ser feito em https://darksky.net/dev/register.
Pode ser necessário fornecer um número de cartão de crédito para se inscrever no serviço.
Assim que tiver uma chave de API de desenvolvedor, anote-a e guarde-a em algum lugar razoavelmente
seguro. Você também precisará de sua latitude e longitude, que você pode encontrar em
http://mygeoposition.com/.
Crie um novo arquivo chamado weatherBall.js. Primeiro, vamos coletar algumas configurações para a bola do
tempo, conforme mostrado na listagem a seguir.
Listagem 5.11. Configurações para a bola do tempo
const API_KEY = 'SUA CHAVE DE API AQUI';

const LAT = '43.3463760'; 1
const LONG = '72.6395340';
const API_URL = 'https://api.darksky.net/forecast'; 2
UAU! e-book
www.wowebook.org
1 Estou em Vermont. Altere os valores LAT e LONG para sua própria localização.
2 Você não precisa alterar este URL.
Hora de cuidar das nossas dependências:
$ npm instala solicitação johnnyfive
Usaremos o pacote de solicitação para fazer chamadas de API para o Dark Sky. Adicione
requer ao topo do arquivo e vá em frente e instancie um quadro com JohnnyFive. Observe na
próxima listagem que JohnnyFive fornece um tipo especial de classe de componente Led para RGB
LEDs: Led.RGB.
Listagem 5.12. Instanciando uma placa
const five = require('johnnyfive'); const request = require('pedido');
// CONFIGURAÇÕES COMO ANTES

board.on('ready', () => { console.log('Powered
by Dark Sky: https://darksky.net/poweredby/'); const rgb = new five.Led.RGB({ pinos: [ 3, 5, 6] }); // Faz requisição à API });
Em seguida, precisamos obter alguns dados sobre a previsão solicitando-os da API Dark Sky
na próxima listagem.
Listagem 5.13. Solicitando dados da API Dark Sky
//...
board.on('ready', () => { console.log('Powered
by Dark Sky: https://darksky.net/poweredby/'); const rgb = new five.Led.RGB({ pinos: [ 3, 5, 6] }); const requestURL = `$
{API_URL}/${API_KEY}/${LAT},${LONG}`; 1
request(requestURL, função (erro, resposta, corpo) {

se (erro) {
console.error(erro);
} else if (response.statusCode === 200) { 2 const forecast = JSON.parse(body); 3 console.log(forecast); 4 }
});
});
UAU! e-book
www.wowebook.org
1 Reúne a URL da solicitação
2 Se a resposta voltar OK...
3 Analisa o corpo da resposta como JSON
4 Registra o objeto de previsão no REPL
Assumindo que tudo correu bem, agora você terá dados para trabalhar. Vamos fazer a bola do
tempo funcionar, conforme mostrado na listagem a seguir.
Listagem 5.14. Faça a bola do tempo ir
request(requestURL, função (erro, resposta, corpo) { if (erro) {
console.error(erro);
} else if (response.statusCode === 200) {
previsão const = JSON.parse(body);
const diário = previsão.diário.data;
const willBeDamp = daily[1].precipProbability > 0,2;
const tempDelta = diária[1].temperaturaMax diária[0].temperaturaMax;
console.log(previsão);
if (tempDelta > 4) {
rgb.color('#ff0000'); // mais quente
} else if (tempDelta < 4) { rgb.color('#ffffff'); //
mais frio
} outro {
rgb.color('#00ff00'); // aproximadamente o mesmo
}
if (willBeDamp) { rgb.strobe(1000); } }
});
1 daily.data é um Array com sete elementos dayforecast.
2 diárias[1] é amanhã. É provável que chova?
3 diárias[0] é hoje. Quanto a temperatura está variando?
4 Define a cor do LED RGB com base em quanto a temperatura está mudando
5 strobe é o mesmo que blink—blink é um alias para strobe.
Solução de problemas do circuito
UAU! e-book
www.wowebook.org
Para flexibilidade máxima, os métodos relacionados às cores nas instâncias do objeto do componente JohnnyFive
- mais relevante, Led.prototype.color neste caso - aceitam vários formatos de cores diferentes, como estes:
Hex (string)— Familiar para desenvolvedores web, valores hexadecimais RGB como "#00ff00" (verde
brilhante) podem ser usados. Funciona com ou sem o # inicial.
Nome da cor CSS (string)— “red” ou “darksalmon” ou “lemonchiffon” ou qualquer

outro nome de cor CSS válido funciona.
Matriz de valores R, G, B (array) — Cada elemento da matriz deve ser um valor de 8 bits, como [0x00, 0xff, 0x00]
ou [0, 255, 0].
Objeto de valores RGB (objeto)— Novamente, valores de 8 bits devem ser usados, como {
vermelho: 0x00, verde: 0xff, azul: 0x00}
Mantenha-se atualizado com as últimas novidades em http://johnnyfive.io/api/led.rgb/.
Agora execute sua bola meteorológica:
$ node weatherBall.js
Os sensores e saídas que usamos nos exemplos até agora exigiram apenas alguns fios e tiveram conexões
simples. Na próxima seção, você encontrará um componente que possui vários fios, mas não é difícil de trabalhar,
desde que você preste atenção.
5.2. TRABALHANDO COM DISPLAYS LCD PARALELOS
LCDs (displays de cristal líquido) podem exibir caracteres e formas, tornando-os saídas úteis para vários projetos.
Sua resolução geralmente é definida em termos de quantos caracteres eles podem exibir. O módulo LCD 16x2
que usaremos nos experimentos a seguir pode exibir até 32 caracteres no total: 16 cada em 2 linhas.
Cada slot de “caractere” é, na verdade, sua própria matriz de pontos 5x7; formas não-caracteres também podem
ser representadas.
Os módulos LCD estão disponíveis com diferentes interfaces, incluindo várias opções seriais (você aprenderá
sobre comunicação serial no capítulo 7). O módulo mostrado na figura 5.13 possui uma interface paralela.
Figura 5.13. Módulos LCD paralelos 16x2 estão disponíveis em muitos fabricantes.
Eles têm 16 pinos e uma luz de fundo LED.
UAU! e-book
www.wowebook.org
Não entre em pânico ao ver os diagramas de fiação nesta seção. Conectar LCDs paralelos requer um punhado
de jumpers, mas trabalhar com eles não é complicado. Certifique-se de prestar atenção em quais fios vão para
onde quando estiver conectando as coisas e você ficará bem. Melhorar o projeto do temporizador do início do
capítulo requer mais fios de jumper do que você já viu em um só lugar, mas é um bom exercício para juntar
circuitos mais complexos.
5.2.1. Fazendo um timer completo com LCD
1 módulo LCD paralelo 16x2 5 V, como qualquer um dos módulos paralelos 16x2 5 V básicos do SparkFun
Módulos LCD
1 LED padrão, qualquer cor
3 botões de pressão (interruptores momentâneos)
1 potenciômetro rotativo
1 resistor de 220 V
3 resistores de 10 kV
1 piezo (opcional)
23 fios de jumper
UAU! e-book
www.wowebook.org
Este temporizador mais inteligente permitirá que você ajuste a duração do temporizador usando botões
(mesmo quando o temporizador estiver funcionando!) e fará a contagem regressiva do tempo restante no
LCD. Você também pode pausar e reiniciar o cronômetro. Quando o tempo acabar, um LED pulsará
para (suavemente) chamar sua atenção.
Construindo o circuito
O circuito totalmente construído terá a aparência da figura 5.14. Vamos dividi-lo em algumas etapas para
torná-lo menos intimidador.
Figura 5.14. O temporizador LCD totalmente construído
UAU! e-book
www.wowebook.org
Botões de conexão e teste
Vamos começar com alguns botões que permitirão ao usuário controlar o cronômetro. Da esquerda para
direita, os botões da figura 5.15 são
1. Um botão para baixo (representado por downButton no código a seguir), que irá
subtrair um segundo do cronômetro atual
2. Um botão para cima (upButton), que adicionará um segundo ao cronômetro atual 3. Um botão
alternar Go (goButton), que iniciará e pausará o cronômetro
UAU! e-book
www.wowebook.org
Certifique-se de que os botões estejam alinhados com o entalhe central e orientados conforme mostrado
na figura 5.15. Cada botão é conectado ao terra por meio de um resistor suspenso de 10 kV e ao barramento
de alimentação de +5 V com um fio jumper.
Crie um novo arquivo chamado timeradvanced.js e comece adicionando o seguinte código para lidar
com pressionamentos de botão.
Figura 5.15. Diagrama de fiação mostrando apenas os botões: Down, Up e Go
Listagem 5.15. Teste os botões em timer-advanced.js
UAU! e-book
www.wowebook.org

board.on('pronto', () => { const downButton

= new five.Button(2);
const upButton = new five.Button(3);
const goButton = new five.Button(4);
downButton.on('press', () => {
console.log('inativo');
});
upButton.on('press', () => {
console.log('up'); });
goButton.on('press', () => {
console.log('ir');
});
});
Começando com alguns manipuladores de botão simples, você pode validar se seus botões estão
conectados corretamente antes de passar para outras partes do dispositivo. Execute o script
(nó timeradvanced.js) e verifique se pressionar os diferentes botões registra a mensagem correta
no console.
Solução de problemas dos botões
Se pressionar os botões não estiver dando os resultados esperados, certifique-se de que os

fios jumper da saída do botão estejam conectados ao Arduino corretamente - especificamente, que
o lado da placa de ensaio da conexão esteja em um orifício entre a perna de saída do botão e o
resistor.
Verifique novamente se a perna de entrada do botão está conectada à energia e se os resistores

pull-down de 10 kV conectam cada botão ao terra. Certifique-se também de que a orientação
do botão de pressão esteja correta - a maioria dos botões se encaixa mais confortavelmente no
entalhe central em uma orientação (a correta), mas existem muitos tipos diferentes de botões por aí.
Conectando o LCD
Com os botões afastados, podemos passar a conectar o módulo LCD à breadboard, conectando
a maioria de seus 16 pinos (figura 5.16).
Figura 5.16. Um módulo LCD paralelo 16x2
UAU! e-book
www.wowebook.org
Vá em frente e conecte o LCD à protoboard conforme mostrado no diagrama de posicionamento

do LCD (figura 5.17), certificando-se de que o pino mais à esquerda do módulo LCD esteja
conectado à linha mais à esquerda da protoboard, como no diagrama de fiação. Os pinos do
LCD são numerados de 1 a 16, começando da esquerda nesta orientação.
Pinagem do módulo LCD
Os módulos paralelos 16x2 mais comuns têm a mesma orientação dos pinos, com o pino 1 à
esquerda e o 16 à direita, quando na orientação mostrada no diagrama de posicionamento do LCD
( figura 5.17). Verifique novamente se o seu módulo LCD tem a mesma orientação de pinos - pode
ser necessário virar o LCD, caso contrário.
Figura 5.17. Diagrama de fiação do temporizador, incluindo potenciômetro e posicionamento do LCD
UAU! e-book
www.wowebook.org
Em seguida, conecte o potenciômetro à protoboard.
Conectando um potenciômetro de controle de contraste
Assim como os fotoresistores, os potenciômetros são um tipo de resistor variável (figura 5.18).
Os potenciômetros têm três pinos: dois pinos de alimentação e um terceiro pino do meio. Como o botão
é WOW! e-
ligado um potenciômetro rotativo (ou deslizado em outros tipos de potenciômetros), a tensão em seu pino do
meio muda. Os potenciômetros têm divisores de tensão internos, de modo que suas tensões de saída
podem ser lidas diretamente - não precisamos construir um divisor de tensão como fazemos com os fotoresistores.
Figura 5.18. Potenciômetros são resistores variáveis. Eles vêm em várias formas e
tamanhos.
Neste circuito, o pino do meio do potenciômetro é conectado diretamente ao pino 3 do LCD.
A eletrônica interna do LCD lê a voltagem naquele pino para determinar o contraste do display. Girar o
potenciômetro irá, portanto, ajustar o contraste.
Seu potenciômetro pode ter um tamanho ou formato diferente daquele mostrado no diagrama de posicionamento
do LCD (figura 5.17): tudo bem. Conecte seus pinos externos à energia e ao aterramento - você não
pode invertê-lo, pois os potenciômetros não são polarizados. Qualquer orientação funciona. Em
seguida, conecte a perna do meio do potenciômetro ao pino 3 do LCD (lembre-se, as conexões não
continuam no entalhe central).
Concluindo as conexões do LCD
Avante! O LCD tem várias conexões de alimentação (figura 5.19). Conecte os pinos 1, 5 e 16 do LCD ao
barramento de alimentação de aterramento e os pinos 2 e 15 ao barramento de alimentação da fonte.
Figura 5.19. Diagrama de fiação mostrando as conexões de alimentação da breadboard ao

LCD
UAU! e-book
www.wowebook.org
As conexões aos pinos 1 e 2 do LCD alimentam o próprio LCD, e os pinos 15 e 16 do LCD

alimentam a luz de fundo de LED do monitor.
O pino 5 é um pino de leitura/gravação (R/W). Quando é puxado para o chão, ele coloca o LCD no
modo de gravação, que é o que geralmente se deseja ao usar um LCD - gravar nele.
O restante dos pinos que usaremos no LCD se conectará diretamente aos pinos do Arduino
(figura 5.20).
Figura 5.20. Diagrama de fiação mostrando todas as conexões do LCD
UAU! e-book
www.wowebook.org
O pino 4 do LCD é o pino de seleção de registro (RS). Em determinados momentos, o software

subjacente do JohnnyFive precisa enviar instruções ao LCD para dizer como se comportar. Em
outros momentos, ele precisa enviar os dados específicos para exibição. Este pino permite
alternar entre os dois registros de memória diferentes para instruções e dados. Ele deve ser
conectado ao pino 7 do Arduino.
O pino 6 no LCD é o pino de habilitação (EN). Ele deve ser conectado ao pino 8 do
Arduino. Escrever uma voltagem para este pino solicita que o LCD leia os dados recebidos
esperando por eles nos pinos de dados.
Pinos de dados, hein? Essas são as últimas conexões LCD restantes. Os pinos 7 a 14 no LCD são
pinos de dados paralelos (D0–D7), que representam os valores de bit dos dados gravados nos
registradores do dispositivo. Você só precisa conectar quatro dos oito - D4 a D7 (pinos 11, 12, 13
e 14 do LCD, conectados aos pinos 9, 10, 11 e 12 no Arduino WOW! eBook
www.wowebook.org
respectivamente). Ufa. São muitos fios!
Controlando o LCD com Johnny-Five
Você pode dar uma volta no seu LCD usando a classe JohnnyFive LCD. Por padrão, o
construtor de objeto LCD do JohnnyFive tratará o LCD como um LCD paralelo. Ele espera uma
matriz de seis números de pinos para fios conectados a diferentes pinos no LCD: seleção de
registro (RS), habilitação (EN) e quatro conexões de dados (D4, D5, D6 e D7).
Os detalhes da interação com LCDs paralelos são de baixo nível, mas JohnnyFive abstrai
muito disso para você. Métodos LCD úteis no JohnnyFive incluem estes:
cursor(linha, coluna)—Posiciona o cursor antes de exibir o texto
print(str)—Exibe o texto começando na posição atual do cursor
clear()—Limpa o conteúdo do LCD
Experimente adicionando mais código ao seu script timeradvanced.js, conforme mostrado

na listagem a seguir.
Listagem 5.16. Teste o LCD
const five = require('johnnyfive'); const board = new five.Board();
const downButton = new five.Button(2);
const goButton = new five.Button(4); const lcd = new five.LCD([7, 8,
9, 10, 11, 12]); 1
/** funções do manipulador de botões... **/
lcd.cursor(0, 0).print('olá, mundo'); 2 lcd.cursor(1, 0).print('olá, de novo'); 3 });
1 Instancia um objeto JohnnyFive LCD
2 Posiciona o cursor na 0ª linha, 0ª posição (canto superior esquerdo) e imprime “hello, world”
3 Escreve “olá, de novo” na segunda linha do LCD, posição 0
Execute o script (nó timeradvanced.js) e, uma vez executado, gire o dial do potenciômetro
para ajustar o contraste no LCD.
O LCD deve exibir “hello, world” na primeira linha e “hello, again” na segunda WOW! e-book
www.wowebook.org
linha.
Solução de problemas do LCD
Se o seu LCD parece não funcionar direito, ou de todo, a primeira coisa a fazer é verificar novamente todas as
conexões dos fios e certificar-se de que estão conectadas aos pinos corretos no
Arduino.
Se o seu LCD não acender, verifique as conexões de energia nos pinos 15 e 16 (alimentação da luz de fundo).
Certifique-se de que o módulo LCD esteja encaixado corretamente e que os pinos estejam alinhados com precisão.
Programando a lógica do timer
Nosso circuito LCD está pronto. É hora de programar o timer. Vamos dividir isso em partes, mas uma visão geral
da estrutura final do cronômetro é mostrada aqui.
Listagem 5.17. Visão geral da estrutura do aplicativo de timer

// constantes
board.on('ready', () => { // Inicializa

componentes J5 para botões e LCD // Inicializa algumas variáveis
função inicial () {
// inicializa o temporizador
}
function showRemaining () { // formata a

duração restante do timer e // atualiza o display LCD
function ajusteTime (delta) { // adiciona ou remove

delta milissegundos
// para/de duração do temporizador
}
function start () { // inicia o cronômetro
// use setInterval para invocar tick()

UAU! e-book
www.wowebook.org
}
function pause() { // pausa o

timer }
function tick () { // atualiza os

valores do timer internamente // se o timer acabou,
chime() e reseta o timer // caso contrário, showRemaining()
função carrilhão () {
// pulsa o LED indicador
}
// adiciona manipuladores de pressionamento de botão
// inicializa o timer
});
Saltando de cima para baixo, uma seção de inicialização de variável configura alguns dos valores
que precisaremos para operar o timer, conforme mostrado na listagem a seguir. Adicione-os ao
timer advanced.js.
Listagem 5.18. Configurando alguns valores

five.Board();
const DEFAULT_TIMER = 60000; 1 const UPPER_LIMIT = 99 * 60000; 2 const

LOWER_LIMIT = 1000; 3
board.on('pronto', () => { const

downButton = new five.Button(2);
const upButton = new five.Button(3);const goButton = new
five.Button(4);
const lcd = new five.LCD([7, 8, 9, 10, 11, 12]);
const alertLED = novo five.Led(6);
var restante, timer, timeString, lastTimeString, timestamp, lastTimestamp;
// ...
});
1 60 segundos é a duração do temporizador padrão, em ms. Você pode mudar isso se quiser.
2 O limite superior do cronômetro é de 99 minutos.

UAU! e-book
www.wowebook.org
3 Você não pode fazer o cronômetro ser menor que um segundo.
O limite superior de 99 minutos é baseado na forma como o tempo restante é formatado no LCD
(mm:ss). Durações mais longas não caberiam.
Falando em formatação de exibição, vamos começar. É hora de adicionar uma função para
inicializar um timer e mostrar o tempo restante no timer atual no LCD. O próximo trecho de código a
ser adicionado define as funções init() e showRemaining().
Listagem 5.19. Inicializando e exibindo o tempo restante do temporizador
// ...
board.on('ready', () => { // ...
componentes e função de inicialização variável init () { 1
restante = DEFAULT_TIMER; lastTimeString =

'00:00'; timeString = '';
mostrarRestante();
}
função mostrarRestante () { 2
var minutos, segundos, minPad, secPad;
minutos = Math.floor(restante / 60000); segundos = Math.floor((restante
% 60000) / 1000); minPad = (minutos < 10) ? '0' : '';
secPad = (segundos < 10) ? '0' : '';

timeString = `${minPad}${minutos}:${secPad}${segundos}`;
if (timeString != lastTimeString) { 3
lcd.cursor(0, 0).print(timeString);
}
}
// ...
});
1 Inicializa um novo temporizador e algumas variáveis
2 Formata e exibe o tempo restante neste timer
3 Só atualiza o LCD se a string formatada foi alterada
A função showRemaining será invocada com frequência quando o cronômetro estiver realmente em
execução. A verificação para garantir que a sequência de tempo foi alterada antes de atualizar o LCD
(timeString != lastTimeString) melhorará o desempenho. O tempo restante no cronômetro atual será
exibido no canto superior esquerdo (posição do cursor 0, 0) do LCD.
Avante! upButton e downButton devem ajustar a duração do timer quando pressionados,
adicionando ou removendo um segundo, UAU!

respectivamente.
e-book A função AdjustTime() (em
www.wowebook.org
Listagem 5.20) usa um delta em milissegundos e ajusta a duração do cronômetro por esse valor,
certificando-se de manter a duração total dentro dos limites.
Os manipuladores de botão precisam ser registrados para invocar o AdjustTime(), e esse também é um bom
local para inicializar o cronômetro (init()).
Adicione AdjustTime() e os manipuladores de botão da seguinte maneira.
Listagem 5.20. Adicionar funções do manipulador de ajuste de tempo
// ...
// ... variável e função de inicialização de componente init () { /* ... */ }
function showRemaining () { /* ... */ }
function ajusteTempo (delta) { restante +=

delta; if (restante < LOWER_LIMIT)
{ restante = LOWER_LIMIT; } else if (restante >
UPPER_LIMIT) { restante = UPPER_LIMIT; }
mostrarRestante(); 1
}
downButton.on('press', () => { // remove um segundo ajusteTime(1000);
});
upButton.on('press', () => { // adiciona um segundo
ajusteTempo(1000);
});
calor(); 2
});
1 A duração do timer foi alterada, então o display do LCD precisa ser atualizado.
2 Não se esqueça de inicializar o timer.
Agora, vamos ligar o botão Go. Esse botão deve alternar o cronômetro (reproduzir/pausar).
Isso significa que também precisaremos de lógica para ativar o timer — invocar a função tick() a cada
250 ms — e pausá-la, conforme mostrado na listagem a seguir.
Listagem 5.21. Fazendo o timer funcionar
// ...
UAU! e-book
www.wowebook.org
board.on('ready', () => { // ... variável
e função de inicialização de componente init () { /* ... */ }
function showRemaining () { /* ... */ } function adjustTime (delta)

{ /* ... */ }
início da função () {
lcd.clear(); 1
timestamp = Date.now(); timer =
setInterval(tick, 250); 2
carrapato(); 3
}
função pausa () {
timer = clearInterval(timer); 4
lcd.cursor(0, 9).print('PAUSADO'); 5
}
função carrapato () {
lastTimestamp = timestamp; timestamp =
Date.now();
restante = (timestamp lastTimestamp);
if (restante <= 0) {
timer = clearInterval(timer);
aquecer();
}
mostrarRestante();
}
downButton.on('press', () => { /* ... */ }); upButton.on('press', () => { /

* ... */ });
goButton.on('press', () => {
if (!temporizador) { 6
começar();
} outro {
pausa(); }
});
aquecer();
});
1 Limpa qualquer coisa atualmente exibida no LCD
2 Define um intervalo para invocar o tick quatro vezes por segundo ou mais
3 Inicia o cronômetro com um tique
4 Limpa o intervalo do cronômetro para que o cronômetro pare de funcionar
5 PAUSED será apagado quando o timer for reiniciado por lcd.clear().
6 Certifique-se de que não haja um cronômetro em execução antes de iniciar
UAU! e-book
www.wowebook.org
Agora você pode iniciar e pausar o cronômetro, mas o que acontece quando o tempo acabar? Precisamos
de algo para alertar o usuário de que seu tempo acabou.
5.2.2. Adicionando um “carrilhão” de LED visual
Como parte final da construção deste circuito, você pode adicionar um LED conforme mostrado na figura 5.21.
Ele deve ser conectado através de um resistor de 220 V ao terra, e seu ânodo deve ser conectado ao
pino 7 do Arduino.
Figura 5.21. O diagrama de fiação completo, com LED
UAU! e-book
www.wowebook.org
Precisaremos fazer alguns ajustes nas funções start e tick, e adicionaremos uma nova
função chime, mostrada na listagem a seguir.
Listagem 5.22. Adicionar um toque visual
// ...
board.on('pronto', () => { const
downButton = new five.Button(2);
const goButton = new five.Button(4);
const lcd = new five.LCD([7, 8, 9, 10, 11, 12]);
const alertLED = novo five.Led(6);
var restante, timer, timeString, lastTimeString, timestamp, lastTimestamp;
function init() { /* ... */ }

function showRemaining () { /* ... */ } function adjustTime (delta)
{ /* ... */ }
início da função () {
alertLED.stop().off();
lcd.clear();
timestamp = Date.now(); timer =
setInterval(tick, 250);
marcação();
}
função pausa () { /* ... */ }
função carrapato () {
lastTimestamp = timestamp; timestamp =
Date.now(); restante = (timestamp lastTimestamp);
if (remaining <= 0) {
timer = clearInterval(timer);
carrilhão();
aquecer();
}
mostrarRestante();
}
alertLED.pulse();
lcd.cursor(0, 9).print('CONCLUÍDO!');
}
downButton.on('press', () => { /* ... */ }); upButton.on('press', () => { /* ...

*/ }); goButton.on( 'pressione', () => { /* ... */ }); init();
});
UAU! e-book
www.wowebook.org
2 Sempre que o cronômetro estiver em contagem regressiva, o chimeLED deve estar desligado.
3 Alguma lógica para determinar se o tempo acabou e, em caso afirmativo, para limpar o intervalo e
breve
4 carrilhões()...
5 Pulsos o LED! Acabou o tempo!
6 Exibe “DONE!” também
Como init() é chamado novamente quando o tempo se esgota, o cronômetro pode ser usado várias
vezes sem reiniciar o programa (figura 5.22). Tente!
$ nó timeradvanced.js
Arquitetura de código para o temporizador
A lógica do cronômetro acontece dentro do retorno de chamada pronto para o objeto da placa
JohnnyFive e está começando a parecer difícil de manejar. Provavelmente seria mais elegante
encapsular a lógica em um módulo externo. Você verá exemplos disso em capítulos posteriores.
Figura 5.22. O cronômetro, marcando o tempo!
UAU! e-book
www.wowebook.org
5.3. FAZENDO BARULHO COM UM PIEZO
Em primeiro lugar, não vou tentar convencê-lo de que os piezos (figura 5.23) fazem ruídos
adoráveis e suaves. Eles podem produzir tons, baseados em frequências simples, mas soam
minúsculos e ásperos. Ainda assim, você pode fazer um tocar uma música e é divertido brincar
com eles. Se quiser adicionar um piezo ao seu timer, você pode trocar o LED por um piezo (como
você verá na figura 5.24). Então você estará pronto para se divertir e irritar os amigos com seu
piezo!
Figura 5.23. Alguns piezos têm fios condutores e outros têm pernas. Piezos têm
dois pinos: + e -.
Quando a tensão é aplicada a um piezo, ela causa mudanças físicas na forma de uma
superfície dentro do piezo. Os piezos transformam a energia elétrica em energia mecânica, e nós,
UAU! e-book
www.wowebook.org
como humanos, detectam essa energia mecânica como ondas sonoras. A aplicação de tensões
em frequências específicas cria vibrações que correspondem a diferentes notas musicais.
Esse fenômeno é conhecido como efeito piezoelétrico reverso – a eletricidade é convertida em
movimento mecânico.
Piezos também podem ser usados como sensores. Usados como entrada, os piezos podem
detectar batidas ou outros tipos de vibração. Isso demonstra o inverso do efeito piezoelétrico
reverso, ou seja, o efeito piezoelétrico.
Piezos: temporização e frequências
Para fazer um piezo soar uma nota requer uma combinação de PWM e temporização. Para
fazer um piezo fazer barulho, você fornece tensão em um ciclo de trabalho de 50% - isso cria
ondas quadradas (on off on off). Para fazer um piezo tocar uma nota específica, você ajusta a
frequência desses ciclos PWM.
Por exemplo, a nota A4 ou A440 é uma nota de afinação de referência comum. Chama-se A440
porque vibra a 440 Hz. A cada 1/440 de segundo, há um período de onda completo. Na vida real,
essas são ondas analógicas suaves. Com um piezo, são ondas digitais quadradas. Aplicando uma
tensão de ciclo de trabalho de 50% a um piezo 440 vezes por segundo, você pode aproximar A4.
As oitavas contidas em um teclado de piano padrão de 88 teclas. A4 (também conhecido como

A440) é o A acima do C central (o A na quarta oitava).
UAU! e-book
www.wowebook.org
As frequências musicais dobram a cada oitava, de modo que, quando você chega ao A7, está
olhando para 3520 Hz.
A frequência dobra a cada oitava. A3 (220 Hz) é metade da frequência de A4 (440 Hz), enquanto
A5 (880 Hz) é o dobro da frequência de A4. A's têm boas frequências redondas.
As notas intermediárias também têm frequências previsíveis que dobram a cada oitava, como dó
central (C4) a 261,626 Hz e C5 a 523,521 Hz.
Em JohnnyFive, A4 (A440) é criado escrevendo alternadamente HIGH e LOW no pino do piezo

em intervalos iguais 880 vezes por segundo. Sim, 880 – é o dobro da frequência, porque
uma “onda” completa (onoff) deve acontecer 440 vezes por segundo.
UAU! e-book
www.wowebook.org
A nota A4 tem uma frequência de 440 Hz. Um período de onda completo é 1/440 de segundo.
Ao contrário das ondas sonoras analógicas naturais, que têm curvas suaves, os piezos emitem ondas quadradas
ondas.
As frequências envolvidas aqui excedem em muito a resolução do que você pode fazer com temporizadores JavaScript
embutidos (setInterval, setTimeout), então JohnnyFive depende de um pacote npm chamado nanotimer. Isso permite
um comportamento semelhante ao setInterval, mas com uma precisão muito mais precisa e refinada.
5.3.1. Adicionando um carrilhão piezo audível ao timer
Dependendo do tipo de piezo que você possui, conecte-o diretamente na breadboard ou conecte seus fios na
breadboard (figura 5.24). Não se esqueça de remover também o resistor de 220 V.
Figura 5.24. Diagrama de fiação mostrando a substituição do LED por um piezo
UAU! e-book
www.wowebook.org
Tocando músicas no piezo
As alterações de código para o cronômetro são mínimas. Dentro de timeradvanced.js, instancie

um Piezo em vez de um Led e remova a referência a alertLED de start()
função, conforme mostrado na listagem a seguir.
Listagem 5.23. Instanciando um piezo
var alertChime = new five.Piezo(6);
A classe Piezo do JohnnyFive fornece algumas ferramentas úteis para fazer os piezos tocarem
músicas, lidando com as complexas conversões de tempo e frequência. As notas são expostas
por seus nomes (como 'e5') para que você não precise memorizar frequências. Você pode
passar um objeto representando uma “melodia” para o método play, com propriedades como
andamento (BPM) e uma música (array de notas e suas durações).
UAU! e-book
www.wowebook.org
Atualize a função chime() para reproduzir uma música, conforme mostrado na listagem a seguir.
Listagem 5.24. A nova função chime()
ÿÿalertChime.play({ ÿÿÿÿtempo:ÿ120,ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ1
música: [ ['e5', 1], 2
['g#5', 1], ['f#5', 1],
['b4', 2],
['e5',1], ['f#5',1], ['g#5',1],
['e5', 2],
['g#5', 1], ['e5', 1],
['f#5', 1],
['b4', 2],
['b4', 1], ['f#5', 1], ['g#5', 1],
['e5', 2]
]
});
lcd.cursor(0, 9).print('CONCLUÍDO!');
}
1 andamento é uma propriedade opcional.
2 Isso tocará a nota e5 por 1 “tempo”.
Você terá que tentar isso para descobrir qual é a melodia do tempo!
RESUMO
Um LED pode emitir apenas um comprimento de onda (cor) e só pode estar desligado ou ligado a qualquer
momento, mas a modulação por largura de pulso (PWM) pode ser usada para enganar o olho e pensar que
um LED está brilhando em diferentes brilhos.
O suporte a PWM é um recurso de hardware e apenas alguns pinos nas placas de desenvolvimento
suporta PWM.
O brilho dos LEDs pode ser “animado” para criar efeitos e comunicar informações. O uso de
diferentes funções de easing e o fornecimento de diferentes opções de animação podem gerar diferentes
resultados com o JohnnyFive.
Os LEDs RGB combinam três LEDs (vermelho, verde, azul) em diferentes brilhos - via WOW! e-book
www.wowebook.org
PWM—para criar cores diferentes. Os LEDs RBG de cátodo comum têm três
LEDs componentes que compartilham uma única perna de cátodo.
Os LCDs paralelos têm muitas conexões. JohnnyFive fornece uma interface simplificada para LCDs por meio de
sua classe LCD.
Os potenciômetros são outro tipo de resistor variável, como os fotoresistores. Ao contrário dos fotoresistores,
eles têm seus próprios divisores de tensão internos, portanto, a mudança de tensão pode ser lida no terceiro
pino.
Os piezos aproveitam o efeito piezoelétrico reverso para transduzir tensões em diferentes frequências em
movimento mecânico e, como resultado, ondas sonoras.
UAU! e-book
www.wowebook.org
História

Tópicos
Como funcionam os motores e o que os faz girar

Tutoriais
As características indutivas dos motores e como construir circuitos de motores com segurança
Usando
Ofertas e promoções diodos, capacitores e transistores em circuitos para controlar motores e proteger
componentes
Destaques
Como posicionar as coisas, precisamente, com servos
Configurações Como controlar motores usando um circuito Hbridge e drivers de motor
Como construir seu primeiro robô itinerante básico

Apoiar
A essa altura, você provavelmente já está batendo os pés com impaciência e se perguntando: “Quando é que
vamos
fazer Sign Out para fazer robôs?” Bem, seu navio chegou. É hora de aprender como fazer as coisas se moverem.
Os motores e servos que você vai conhecer fornecem o controle fundamental dos movimentos dos robôs. Há muito
o que aprender, mas ao final deste capítulo você terá construído um robô itinerante básico.
Fazer os robôs se moverem envolve coreografar movimentos controlados eletronicamente.
Os motores giram, fazendo as rodas rolarem. Os servos permitem o posicionamento preciso dos
componentes: câmeras, braços robóticos e assim por diante. Vamos nos mexer.
1 motor CC de 9 V
UAU! e-book
www.wowebook.org
1 bateria de 9 V e encaixes
1 diodo 1N4001
1 Nchannel MOSFET, como FQP30N06L
1 capacitor de 100 ÿF
1 micro servo de 4,8 V
1 Texas Instruments SN754410 Quádruplo HalfH Driver
Kit Actobotics Peewee Runt Rover (ou 2 motorredutores, 2 rodas, chassis)
Pinos de cabeçalho macho separatistas
Fios de jumper
6.1. FAZENDO MOTORES GIRAR
Os motores convertem energia elétrica em energia mecânica (figura 6.1). A corrente

entra e o movimento sai, geralmente de forma rotativa, como um eixo giratório.
UAU! eBook
Figura 6.1. Um típico hobby DC
motor www.wowebook.org
Figura 6.1. Um típico motor DC de passatempo
No coração da alquimia da eletricidade ao movimento de um motor? Ímãs!
Fluxo de corrente real
Lembre-se de como as representações convencionais de corrente mostram a corrente elétrica

fluindo do positivo para o negativo, mas, na realidade, o oposto está mais próximo da verdade? A
direção real do fluxo de corrente é relevante para alguns dos tópicos abordados neste capítulo e,
como tal, os diagramas conceituais mostram a corrente fluindo do negativo para o positivo.
6.1.1. Como funcionam os motores
Quando uma corrente elétrica passa por um fio, um campo magnético também é criado. O campo
magnético é orientado em ângulo reto com a direção da corrente (figura 6.2).
Figura 6.2. A corrente elétrica através de um fio cria um campo magnético em ângulo reto com o
fluxo de corrente.
UAU! e-book
www.wowebook.org
O campo magnético induzido por corrente perto de um único fio reto é fraco,
relativamente falando. Mas é possível concentrar o efeito magnético enrolando um
pedaço de fio ao redor (e ao redor e ao redor) de um pedaço de metal. Quando a corrente
é aplicada à bobina de fio, o campo magnético coletivo em ângulo reto tem força suficiente
para puxar alguns dos átomos anteriormente desorganizados no núcleo de metal para um
alinhamento norte-sul. E, voilá! Você criou um ímã usando eletricidade: um eletroímã (figura 6.3).
Figura 6.3. A corrente através da bobina cria um campo magnético que

magnetiza o núcleo de ferro do eletroímã.
UAU! e-book
www.wowebook.org
Se você inverter a direção da corrente que passa pelo fio enrolado, a polaridade
do eletroímã também mudará — os pólos magnéticos norte e sul trocarão de
lugar (figura 6.4). Corte a corrente do fio e o campo magnético se dissipará - você
pode desligar o ímã!
Figura 6.4. A inversão do fluxo de corrente inverte a polaridade do eletroímã.
UAU! e-book
www.wowebook.org
Vamos imaginar nosso eletroímã imaginário sendo colocado em uso teórico. No lado
esquerdo da figura 6.5, um eletroímã não energizado é montado em um eixo e
suspenso entre dois ímãs estacionários. Assim que a corrente é aplicada ao eletroímã (no
meio da figura 6.5), o eletroímã desejará se alinhar conforme as forças magnéticas
determinam - seu pólo norte em direção ao ímã estacionário com o pólo sul voltado para dentro.
O que ele vai querer fazer é girar meia volta para que isso aconteça, como à direita na
figura 6.5. Claro, este motor hipotético não vai funcionar: a bateria está atrapalhando e as
coisas estão se emaranhando.
Figura 6.5. Um eletroímã em um eixo entre dois ímãs fixos vai querer se
orientar – girando – conforme as forças magnéticas determinam.
Sem mais intervenção, as coisas parariam aqui - os ímãs estão alinhados de maneira
feliz. Mas se pudéssemos mudar a direção da corrente através do eletroímã novamente
exatamente neste ponto, o movimento poderia ser forçado a continuar, pois o ímã busca se
alinhar corretamente mais uma vez. Inverter
manter a polaridade da corrente a cada meia volta pode
WOW! e-book www.wowebook.org
as coisas vão para sempre. Na verdade, esse conceito é como os motores funcionam. Um motor
conectado como o mostrado na figura 6.5 rapidamente se tornaria um emaranhado de baterias e fios,
então um motor real envolve algumas melhorias de projeto.
A Figura 6.6 mostra um motor CC com escovas - ainda simplificado demais. A parede do motor
contém ímãs fixos. Conexões de energia positiva e negativa da fonte de energia são conectadas
a duas escovas estacionárias, que “escovam” a energia em uma determinada polaridade à medida
que o eixo do motor gira e entram em contato com diferentes partes de um anel bipartido chamado
comutador. A corrente - e, portanto, o campo magnético - muda de polaridade conforme o motor
gira, mantendo tudo em movimento. Os motores com escovas são muito comuns, mas os motores
sem escovas usam os mesmos conceitos gerais - eletricidade e ímãs - para realizar a mesma
coisa.
Figura 6.6. Os eletroímãs de um motor com escovas são conectados a um anel dividido
chamado comutador (A). O comutador e os eletroímãs giram conforme o motor gira.
As escovas de posição fixa (B) são conectadas à fonte de alimentação e
“escovam” polaridades alternadas no comutador conforme ele gira abaixo delas,
alterando a polaridade dos eletroímãs na armadura do motor (C).
UAU! e-book
www.wowebook.org
6.1.2. Controlar um motor com um interruptor de botão
Vamos facilitar o controle do motor com cuidado, construindo um circuito básico que alimenta um motor,
controlado por um botão de pressão. Em breve, adicionaremos a capacidade de controlar o motor com o Arduino
Uno e o JohnnyFive.
1 bateria de 9 V
1 encaixe de bateria de 9 V com cabos
UAU! e-book
www.wowebook.org
1 pequeno motor DC, nominal até 9 V
1 diodo 1N4001
1 fio jumper (preto)
Os motores recebem eletricidade e eliminam a rotação mecânica. Mas o inverso também é

verdadeiro: se o eixo de um motor for girado (energia mecânica for aplicada), o motor gerará energia
elétrica – ele atuará como um gerador. É assim que a água pode gerar energia (hidrelétrica), por
exemplo. A água corrente gira fisicamente o eixo de um motor (gerador) e a eletricidade sai.
Assim, os motores também absorvem energia mecânica e liberam eletricidade (figura 6.7). Esse
conjunto de fenômenos – a criação de tensão ou movimento por meio de interações com
campos magnéticos – é chamado de indutância. Um motor é indutivo
componente.
Figura 6.7. Quando um motor é girado por uma força externa, uma corrente
elétrica é gerada.
As características dos componentes indutivos são relevantes para o seu circuito. Digamos
que você aplique corrente a um motor e ele esteja girando alegremente. Remova a corrente
- desligue a energia - e o motor continuará girando sozinho por um tempo. Durante esse
breve período, ele estará gerando energia, e uma coisa importante a ser observada é
que um motor (ou qualquer indutor) gerará tensão na direção oposta à tensão de
entrada ( figura 6.8).
Figura 6.8. Quando um motor éUAU!

conectado a uma fonte de alimentação, a corrente
e-book
flui do negativo (baixo potencial) para o positivo (potencial mais alto). o fluxo atual
www.wowebook.org
negativo (potencial baixo) para positivo (potencial mais alto). O fluxo de corrente
faz com que o motor gire. Quando o fluxo de corrente é removido do motor, a inércia
faz com que o motor continue girando brevemente. Durante este tempo, o motor atua
como um gerador, gerando eletricidade com tensão oposta à tensão de entrada
anterior.
Isso significa que o fluxo de eletricidade pode “se mover para trás” em seu circuito, e o pico de
tensão negativa pode ser enorme (embora por um período de tempo muito curto). Sem
intervenção, essa tensão de retorno (também chamada de força eletromotriz de retorno ou EMF
de retorno) pode fazer coisas desagradáveis, como danificar componentes ou causar faíscas reais!
Um circuito sem proteção contra esta contratensão funciona bem quando o circuito está fechado
e a corrente está fluindo através do motor (figura 6.9), mas pode ser problemático quando a
corrente através do motor muda (figura 6.10), que muda quando o botão é pressionado. liberado
(a chave é aberta, interrompendo o circuito).
Figura 6.9. No circuito desprotegido mostrado aqui, o fluxo de corrente é controlado com
um botão (interruptor). Quando o interruptor é pressionado e mantido, a corrente flui
conforme o esperado, alimentando o motor. O motor consome a tensão fornecida.
UAU! e-book
www.wowebook.org
A grande tensão negativa gerada brevemente na figura 6.10 quer tanto criar um caminho
para a tensão de +9 V que pode fazer coisas malucas, como pular no ar ou através
de outros materiais não condutores para chegar lá. Temos que proteger nosso circuito
contra esse tipo de pico de tensão indutiva.
Figura 6.10. Ao soltar o botão (interruptor aberto), o motor continua girando por
um tempo. Durante este tempo está gerando tensão negativa. O condutor
anteriormente conectado ao terminal positivo da bateria (através do interruptor)
pode acumular um potencial negativo muito grande – centenas de volts,
digamos – que é muito, muito menor do que os +9 V da bateria.
UAU! e-book
www.wowebook.org
Gerenciando a tensão de retorno com diodos flyback
Temos que administrar essa situação de contratensão para a saúde e a segurança de nosso circuito.
Precisamos ter certeza de que a voltagem negativa não é permitida vagando pelo circuito por vontade
própria, ferindo componentes inocentes.
Existe um método padrão para fazer isso, usando um diodo (figura 6.11). Você conheceu
rapidamente os diodos no capítulo 2 — os LEDs são uma espécie de diodo. Um diodo é um
componente semicondutor que permite apenas que a corrente flua através dele em uma direção.
Figura 6.11. Os diodos são componentes semicondutores que permitem apenas que a corrente
flua em uma direção.
UAU! e-book
www.wowebook.org
A colocação do diodo no diagrama de fiação do circuito para o motor controlado por botão que
estamos prestes a construir - com o cátodo do diodo conectado ao barramento de alimentação
positivo - olha para trás, e é (figura 6.12).
Figura 6.12. Diagrama de circuito de um motor básico controlado por botão, incluindo um
diodo de proteção
A maneira como o diodo é orientado (“para trás” ou, mais tecnicamente, com polarização reversa)
no circuito significa que a corrente será impedida de fluir através dele - geralmente. Mas
quando surge a situação de contratensão e o fluxo através do circuito é invertido, o diodo
torna-se temporariamente polarizado diretamente - é momentaneamente orientado para que a
corrente
UAU! e-book www.wowebook.org
pode fluir através dele. Nesses momentos, ele pode criar um caminho para “afastar” a perigosa
corrente de tensão negativa e redirecioná-la através do motor repetidamente até que a tensão
negativa se dissipe naturalmente por conta própria (não se preocupe, ela irá, e rapidamente).
Um diodo usado dessa maneira é chamado de diodo flyback ou diodo snubber (figura 6.13).
Figura 6.13. Se um diodo flyback for usado em um circuito com um indutor como um motor, ele
pode fornecer um caminho para a tensão negativa reprimida que está tentando seguir o caminho errado.
Ele pode encaminhá-lo de volta pelo motor em um loop até que se dissipe.
Alimentando motores em circuitos
Elementos indutivos como motores precisam de corrente, especialmente quando estão sendo ligados ou
desligados (a esta altura você provavelmente já deve ter percebido que os indutores têm algumas
características interessantes quando estão ligando ou desligando). O consumo máximo de corrente possível de
um único pino do Arduino Uno é de apenas 20 mA - isso não é suficiente!
Além disso, muitos motores de hobby são classificados em 6 V ou até 9 V - mais do que o Uno pode fornecer, em
termos de tensão. Usaremos uma fonte de energia estável e separada para nosso motor - uma bateria de 9 V -
para garantir que nosso motor receba a carga de que precisa.
Para o motor mostrado na figura 6.12 girar, você precisará criar um caminho fechado a partir do WOW! e-book
www.wowebook.org
fonte de energia (terminal positivo da bateria) ao terra (terminal negativo da bateria). Pressionar o botão
de pressão conectará este caminho - o motor funcionará quando o botão for pressionado.
Monte o circuito conforme a figura 6.12, tomando cuidado para orientar corretamente o diodo
flyback. Se você invertê-lo, ficará muito quente (no mínimo) ou possivelmente até explodirá ou danificará
a bateria.
Depois de construir o circuito, você poderá ligar o motor pressionando o botão. Esses pequenos
motores de passatempo giram rápido!
Girando motores para trás
Seu motor pode ter fios vermelhos e pretos, indicando que existe uma maneira “correta” ou
“polarizada” de conectar o motor a um circuito. Isso é um pouco enganador: os motores ficam felizes
conectados em qualquer orientação - trocar as conexões simplesmente inverterá a direção em que o
motor gira. Você pode tentar reorientar os condutores do seu motor no circuito e ver se consegue fazê-
lo funcionar "ao contrário". Alterar a direção da corrente através de um motor para alterar a direção
do motor é uma parte fundamental do controle robótico, como você verá a seguir.
6.1.3. Controlando um motor com Johnny-Five

Nosso primeiro experimento motor tem algumas deficiências: não há nenhuma lógica controlando
o motor - apenas nossos próprios dedos - e o motor está ligado (velocidade total!) ou desligado -
não há nada intermediário.
JohnnyFive tem uma classe de componente Motor que pode lhe dar mais controle sobre a
velocidade do motor. Ele oferece ainda mais controle se você usar circuitos integrados ou controladores
de motor mais sofisticados - mas vamos começar pelo básico.

UAU! e-book
www.wowebook.org
1 bateria de 9 V
1 encaixe de bateria de 9 V com cabos
1 pequeno motor DC de 9 V
1 diodo 1N4001
1 Nchannel MOSFET, como o FQP30N06L
4 fios jumper
Neste experimento, queremos substituir o botão de pressão humano por um mecanismo de comutação que pode ser
controlado pela saída de um dos pinos do Uno.
Você já sabe que o motor precisa de mais do que a alimentação integrada do Arduino pode fornecer - tanto em
termos de tensão quanto de corrente - mas qualquer sinal de saída de um pino Uno será de 5 V. Vamos acabar com
circuitos que combina duas fontes de energia separadas: 9 V (bateria) e 5 V (lógica Arduino).
Usando transistores como interruptores
MOSFETs são transistores de efeito de campo de metalóxido semicondutor (uau, não é de admirar que as pessoas
apenas digam MOSFET). Transistores são componentes semicondutores que desempenham uma de duas funções:
amplificar ou comutar sinais. Há mais coisas a saber sobre transistores, mas em nosso caso imediato, vamos usar
um MOSFET como um interruptor muito rápido e confiável.
Quando uma pequena tensão é aplicada ao pino gate do MOSFET (figura 6.14), os outros dois pinos (fonte e dreno)
são conectados e a corrente pode fluir entre eles – o MOSFET é ligado. O Uno pode alcançar com um “dedo”
de 5 V mais fraco e “empurrar” o pino do portão, completando o circuito de 9 V conectado à fonte e ao dreno. Ou
seja, você pode usar um sinal com baixa tensão e potência para controlar um sinal com maior tensão e potência. O
circuito do motor resultante tem duas fontes de alimentação de entrada: a bateria de 9 V e a entrada de 5 V
vinda do Uno.
Figura 6.14. Um MOSFET e seu símbolo de circuito. Uma pequena tensão aplicada ao pino gate (G) fará
uma conexão entre os pinos dreno (D) e fonte (S).
UAU! e-book
www.wowebook.org
Pinagem MOSFET
Embora a maioria dos transistores de efeito de campo (FETs) desse tipo (Nchannel) use a pinagem mostrada
na figura 6.14, certifique-se de verificar a folha de dados do seu componente para confirmar quais pinos
são o gate, o dreno e a fonte.
Uma última coisa: você precisa conectar as duas fontes de energia a um aterramento comum.
Embora as fontes de energia de entrada sejam segregadas - o barramento de energia positivo é apenas para
energia de 9 volts - o aterramento de ambos está conectado.
Certifique-se de que a guia de metal do MOSFET esteja orientada conforme mostrado no diagrama de fiação
do motor MOSFETswitched (figura 6.15) - a guia deve estar voltada para a direita.
De cima, o primeiro pino é o portão: este deve ser conectado ao pino 6 do Uno.
Conecte o pino inferior - a fonte - ao terra. O pino de drenagem do MOSFET (pino do meio) deve ser conectado
a um dos condutores do motor e ao diodo flyback conforme mostrado (o diodo está em paralelo com o motor).
Figura 6.15. Diagrama de circuito para um controle de motor comutado por transistor
UAU! e-book
www.wowebook.org
Quando a tensão é aplicada ao pino do portão, a corrente poderá fluir entre os pinos de
fonte e dreno, permitindo que o motor gire.
Levando o motor para dar uma volta
Crie um arquivo JavaScript chamado motorbasic.js em sua área de trabalho JohnnyFive

com o seguinte código. Este script instancia um Motor no pino 6 e o disponibiliza para o
REPL para seu controle manual.
Listagem 6.1. teste de motor

five.Board();
board.on('ready', () => { const motor = new

five.Motor({ pin: 6 }); 1
board.repl.inject({
motores: motores 2
});
});
1 O pino 6 controlará a velocidade do motor com PWM.
2 Você terá acesso ao motor do REPL.
A classe de componente Motor do JohnnyFive tem mais do que isso, mas estamos começando com a
instanciação mais básica: identificar um único pino para controlar a velocidade de um motor em um
único WOW!
direção. Isso é chamado de motor não direcional.
Execute o script e interaja com o motor no REPL:
$ node motorbasic.js
Depois que a placa e o REPL forem inicializados, você poderá experimentar a referência de objeto do motor
disponível digitando no REPL. Aqui estão alguns métodos úteis:
speed(0255)—Faça seu motor girar a uma determinada velocidade; por exemplo,
motor.speed(100).
stop()—Para o motor; por exemplo, motor.stop().
start()—Dar partida no motor usando a velocidade previamente definida; por exemplo,
motor.start().
A velocidade do motor é controlada com modulação por largura de pulso (PWM), então é bom termos uma
chave rápida (o MOSFET) que pode abrir e fechar o circuito em altas frequências.
Vá além: faça seu próprio ventilador com temperatura controlada
Agora você tem todas as ferramentas necessárias em seu kit de construção para construir o ventilador
com controle de temperatura mencionado pela primeira vez no capítulo 1.
Desafio: Em vez de usar o REPL para controlar um motor, adicione um sensor TMP 36 ao seu circuito e
use alterações em seu valor para ligar ou desligar o ventilador ou alterar sua velocidade. Você pode se
divertir mais se cortar uma pá de ventilador de papel duro ou papelão e prendê-la ao eixo do motor!
6.2. FAZENDO SERVOS IR
Os servos são mecanismos para posicionar as coisas com precisão e são indispensáveis na robótica e
em outros dispositivos que exigem que as coisas sejam movidas com precisão (figura 6.16).
Figura 6.16. Um servo e suas partes básicas. Os chifres vêm em diferentes formas e tamanhos:
discos, estrelas, braços simples.
UAU! e-book
www.wowebook.org
O movimento de um servo é alimentado por um motor DC, semelhante aos que

experimentamos neste capítulo. Mas um servo precisa de mais algumas peças para fazer
seu trabalho. Um conjunto de engrenagens traduz a rotação rápida, mas fraca, do motor em
uma rotação mais lenta, porém mais precisa e forte (torque maior). Os circuitos integrados
adicionais monitoram os sinais de entrada para informar ao servo em que ângulo ele deve se
posicionar e permite que o servo detecte quando está na posição correta.
A maioria dos servos tem cerca de 180 graus de rotação. Eles têm uma posição “neutra” (90
graus ou “para cima”) e podem girar cerca de 90 graus a partir dessa posição neutra em
qualquer direção (figura 6.17). Os 180 graus de rotação são o melhor caso: servos baratos de
baixa potência têm apenas ~ 150 graus de rotação.
Figura 6.17. Um servo (com chifre anexado) posicionado em um ângulo mínimo,

um ângulo neutro e um ângulo máximo. Diferentes servos têm diferentes faixas de
ângulo da vida real.
O circuito dentro do pacote servo responde a sinais codificados no fio de sinal do

servo. O sinal usado para controlar a posição de um servo é um tipo específico de PWM.
UAU! e-book
www.wowebook.org
PWM com sabor de servo
A posição de um servo, ou ângulo, é controlada pelo envio de PWM através de seu fio de sinal, mas é
um “sabor” especial de PWM. Um servo espera receber um pulso a cada 20 ms. O período de tempo
que o pulso persiste - a quantidade de tempo em que o sinal é ALTO - determina a posição do servo.
Quanto menor a duração do pulso, mais à esquerda será a posição resultante.
Normalmente, um pulso de 1,5 ms fará com que o servo aponte para sua direção neutra (90°). Um pulso
de 1 ms ou mais direcionará o servo para a esquerda (0°), enquanto um pulso de 2 ms o posicionará
totalmente para a direita (180°).
A duração de um pulso PWM determina o ângulo do servo. Um pulso de 1,5 ms posiciona o servo
em um ângulo neutro. Pulsos mais curtos equivalem a ângulos mais agudos e pulsos mais longos
a ângulos obtusos.
6.2.1. Controlando um servo com Johnny-Five
UAU! e-book
www.wowebook.org
1 micro servo (4,8 V)
1 capacitor de 100 ÿF (microfarads)
3 pinos de cabeçalho macho, se necessário
3 fios jumper (vermelho, preto, amarelo)
1 tábua de pão
Pinos de cabeçalho para conectar seu servo
A maioria dos fios dos servos termina em um conector fêmea com três terminais.
A maneira mais fácil de conectá-los a uma placa de ensaio é obter alguns pinos de cabeçalho separáveis.
Essas tiras de pinos vêm em fileiras de 16 a 40 pinos e você retira o número de pinos necessário para conectar
um determinado componente. Alguns são mais resistentes do que outros e podem exigir um alicate para
se separar.
Procure por pinos de cabeçalho macho em um passo de 0,1 "(o passo de 0,1" os torna compatíveis
com breadboard).
Os pinos de cabeçalho separatistas machos vêm em tiras. Você “quebra” (quebra) o número de pinos
que precisa para um determinado componente.
UAU! e-book
www.wowebook.org
Como os motores, os servos consomem muita energia quando se movem e podem causar
flutuação de tensão no circuito. No entanto, é possível alimentar micro servos de baixa voltagem—
aqueles classificados para 4,8 V ou menos—diretamente da fonte de alimentação do Uno se você tomar
algumas precauções.
Proteção de circuitos com capacitores de desacoplamento
Capacitores (figura 6.18) são componentes eletrônicos passivos que agem como baterias: eles
armazenam uma certa quantidade de carga, medida em unidades chamadas farads (abreviadas
como F). Um farad é muito; a maioria dos capacitores para eletrônicos de hobby são medidos
em micro, nano ou mesmo picofarads.
Figura 6.18. Os capacitores vêm em vários pacotes e tamanhos diferentes; capacitores

eletrolíticos e capacitores cerâmicos são bastante comuns. Tome cuidado: alguns capacitores,
mas não todos, são polarizados.
Um capacitor carregado ficará inquieto se houver uma flutuação de tensão entre a fonte de alimentação
e o terra. Por exemplo, se a tensão cair repentinamente para 4,5 V, o capacitor descarregará parte de sua
carga armazenada para “suavizar” a tensão.
Isso significa que um capacitor pode atuar como uma pequena bateria de reforço, esguichando carga extra
conforme necessário para manter a tensão estável. Um capacitor usado dessa maneira é chamado de
capacitor de desacoplamento, pois desacopla o restante do circuito do ruído de tensão causado por
componentes.
Cuidado com capacitores
UAU! e-book
www.wowebook.org
Atenção! Capacitores são diabinhos sorrateiros e podem ser absolutamente perigosos em
certos casos. Eles merecem mais respeito e cuidado.
Uma coisa importante a saber é que os capacitores podem reter sua carga por longos períodos de
tempo, mesmo que a corrente não esteja passando por eles. Eles são, novamente, como baterias
a esse respeito. Isso significa que se você acidentalmente completar um circuito através de um
capacitor - e, sim, você pode causar essa situação com os dedos - ele pode descarregar imediata
e violentamente. Se você se pegar desconstruindo televisões antigas ou flashes de câmeras
eletrônicas, tenha muito cuidado. Se um desses poderosos capacitores descarregar em você
inesperadamente, você pode estar prestes a ir para o hospital, ou coisa pior.
Uma coisa mais cotidiana a ter em mente é que os capacitores eletrolíticos, como o usado
neste experimento, são polarizados. Eles não toleram ser conectados ao contrário e têm o hábito
bastante teimoso de explodir quando usados em uma orientação inversa. Em nosso mundo de
baixa voltagem e baixa capacitância, essas são explosões bastante brandas, mas ainda
podem assustar você, ou derreter componentes e placas que você prefere não derreter.
Construindo o circuito servo
Conecte a alimentação, o aterramento e os fios de controle do seu servo à placa de ensaio, usando
os pinos de cabeçalho, se necessário (consulte a figura 6.19). Diferentes fabricantes de servos
usam cores de fios diferentes, mas a conexão de alimentação positiva deve ser um fio vermelho.
A maioria dos servos usa preto para o fio negativo, mas alguns têm um fio marrom ou marrom.
Finalmente, o fio de sinal pode ser branco, amarelo, laranja ou mesmo azul. Resumindo, o fio
vermelho é a alimentação, o fio mais escuro é o terra e o que sobra é o fio de sinal (figura 6.20).
Figura 6.19. Diagrama de fiação para um servo com um capacitor de desacoplamento
UAU! e-book
www.wowebook.org
Figura 6.20. Os fios de servo vêm em várias cores e possuem conectores diferentes.
Deve haver um fio vermelho - ele se conecta a Vcc (fonte de alimentação). O fio mais
escuro — preto ou marrom — é o terra. O fio restante é o fio de sinal – aqui abreviado
como S – para controlar a posição do servo.
Conecte um capacitor eletrolítico de 100 ÿF em paralelo com as conexões de alimentação do

servo - ou seja, conecte o ânodo do capacitor na mesma fileira da placa de ensaio da conexão
de alimentação do servo e seu cátodo na mesma fileira da conexão de aterramento do servo.
UAU! e-book
www.wowebook.org
Conecte o fio de sinal do servo ao pino 6 no Uno. Por fim, conecte a alimentação do servo à alimentação
de 5 V do Uno e o terra do servo ao pino GND do Uno.
Levando o servo para um test drive
Você já deve ter adivinhado que JohnnyFive tem uma classe Servo para controlar servos.
Com certeza sim!
Crie um novo arquivo, servobasic.js, e adicione o seguinte JavaScript. Isso é semelhante ao test drive do
motor: ele disponibilizará uma referência ao servo para você no REPL.
Listagem 6.2. Teste de servo

board.on('ready', () => { const servo = new

five.Servo({ pin: 6 }); 1
board.repl.inject({
serviço: serviço
});
});
1 Os servos requerem sinais de controle PWM - certifique-se de usar um pino habilitado

para PWM!
Execute o script:
$ nó servobasic.js
Agora você pode aproveitar os métodos do Servo:
to(deg)—Move o servo para o valor deg (entre 0 e 180). Por exemplo,

servo.to(50)
center()—Mova o servo para sua posição central/neutra, 90 graus por padrão.
Por exemplo, servo.center()
Se você tentar posicionar seu servo nos extremos de sua faixa - 0 ou 180 ou próximo a esses valores
- ele provavelmente protestará, fazendo sons triturantes tristes. Isso porque o alcance efetivo do
servo é inferior a 180 graus. Tente experimentar para determinar os valores de ângulo mais baixo e mais
alto que seu servo pode alcançar confortavelmente.
Este pequeno test drive é apenas uma breve introdução aos servos. Se a próxima seção - construindo
um WOW! e-
robô!—atrai você, e a robótica é uma área na qual você deseja mergulhar, você terá muito mais encontros
com servos enquanto explora.
6.3. CONSTRUINDO SEU PRIMEIRO ROBÔ!
É hora de construir um robô. Para construir um robô que se mova sobre rodas, você precisa de algumas
peças básicas (figura 6.21):
Um chassi – Todo robô precisa de um corpo. Um chassi é uma estrutura na qual você pode conectar
motores, rodas e outros componentes.
Pelo menos dois motores com engrenagens— Os motores para acionar robôs precisam ter alguma
redução de engrenagem para fornecer algum torque. Caso contrário, eles não serão capazes de
superar os obstáculos mais mínimos. O eixo de acionamento de um motor de engrenagem é
geralmente (mas nem sempre) em ângulo reto com o giro do próprio motor.
Rodas ou trilhos— Estes traduzem o movimento dos motores. As rodas encaixam no
eixos de acionamento de motoredutores.
Um cérebro— Um microcontrolador ou processador para definir a lógica do robô.
Circuito do motor— Seu robô precisa de alguns componentes para traduzir o desejado
movimento em movimento motor.
Figura 6.21. Um robô básico precisa de um chassi (corpo). Dois ou mais motores de engrenagem
se conectam a rodas ou trilhos para impulsionar o bot. Claro, você também precisará de circuitos, um
cérebro (microcontrolador) e uma fonte de alimentação.
Uma das coisas que podem ser desconcertantes em entrar na robótica básica é a
UAU! e-book
www.wowebook.org
despesa combinada de várias partes. O chassi pode custar até algumas centenas de dólares (!), e
blindagens, placas ou outros circuitos disponíveis no mercado para controlar os motores podem custar uma
um pouco também.
Nosso primeiro robô itinerante usará peças bastante baratas. Você pode encontrar o kit de
chassi Actobotics Peewee Runt Rover sugerido por cerca de US $ 16 on-line e em eletrônicos
lojas de abastecimento.
[1]
Se por acaso você tiver um cabo USB A para USB B mais longo do que o que veio com o seu Arduino, este seria um
bom momento para usá-lo.
[2]
1 kit de robô Actobotics Peewee Runt Rover ou similar
Contém chassis, 2 motorredutores e 2 rodas.
Bateria de 9 V e encaixes
1 Texas Instruments SN754410 Quádruplo HalfH Driver
15 fios de jumper
Fita dupla face, fita isolante, fita isolante ou outro adesivo (opcional)
Outras opções para construir seu primeiro bot
O kit Actobotics Peewee Runt Rover é uma opção útil para um primeiro robô porque é barato e inclui
um chassi, rodas, motoredutores e suportes - as peças básicas de que você precisará. Mas outros
quadros ou kits de chassi de duas rodas também são bons. O chassi Shadow do SparkFun é
outra opção barata (embora você precise comprar motores e rodas
UAU! e-book
www.wowebook.org
separadamente). Seja o que for que você faça, certifique-se de ter um chassi, motoredutores e rodas.
As instruções a seguir para a construção de um robô móvel assumem o kit Peewee, mas a construção não
deve diferir muito para kits semelhantes.
6.3.1. robôs e motores

Em nossos experimentos recentes, você viu como a velocidade de um motor pode ser controlada com
PWM e como a direção de um motor pode ser invertida trocando suas conexões de alimentação e terra.
Você também viu como os circuitos do motor são um pouco mais complexos do que outros circuitos:
você precisa de diodos para proteger os outros componentes do circuito e provavelmente precisará de
uma fonte de alimentação mais robusta para um motor do que uma placa de desenvolvimento pode fornecer.
Fica um pouco mais complicado. Um robô itinerante precisa de pelo menos dois motores para ser dirigível,
e você precisa ser capaz de operar esses motores em uma direção para frente e para trás (sem
desconectar fisicamente e trocar os cabos, é claro). Múltiplos motores em um único circuito também
devem ser isolados com capacitores de desacoplamento para que picos repentinos causados por um
motor não afetem o outro motor ou componentes. Os detalhes estão começando a se encaixar.
Controle de motores com drivers ponte H
Uma Hbridge é um circuito com quatro interruptores e uma carga no meio - a carga sendo um motor,
em nosso caso. Em conceito, é apresentado aproximadamente na forma da letra H, conforme

mostrado na figura 6.22.
Figura 6.22. Um circuito de ponte H contém quatro interruptores, com o motor no centro.
Diferentes combinações de estados de comutação podem direcionar a corrente através
do motor em diferentes direções.
UAU! e-book
www.wowebook.org
A disposição das chaves (isto é, transistores) em uma Hbridge permite que a direção
do motor seja controlada sem que você tenha que alterar fisicamente sua fiação. Fechar
as chaves 1 e 4 (figura 6.23, esquerda) permite que a corrente flua através do motor
em uma direção, enquanto fechar as chaves 2 e 3 (figura 6.23, direita) permite que o
motor gire na direção oposta.
Figura 6.23. Ativando diferentes interruptores em uma ponte H, um motor pode

girar para frente ou para trás.
UAU! e-book
www.wowebook.org
Existem 16 estados possíveis (combinações de chaves) em que um circuito Hbridge pode estar,
dos quais os dois na figura 6.23 são os mais obviamente úteis. Vários outros são inócuos, permitindo
que o motor pare por inércia (quando não há passagem pelo circuito) ou freando o motor (ambos
os condutores do motor conectados à mesma tensão).
Existem seis combinações de interruptores que são más notícias, causando uma situação chamada
“dispare”, mais simplesmente descrita como um curto-circuito (figura 6.24). Isso não é bom e vai fritar
as coisas.
Figura 6.24. Fechar os dois interruptores em ambos os lados da ponte H causa um

"disparo" - um curto-circuito!
UAU! e-book
www.wowebook.org
Para o nosso robô, precisaríamos construir um circuito Hbridge por motor, sem mencionar a
adição de diodos e capacitores de proteção adicionais - isso está começando a parecer
um monte de conexões e complicações. Felizmente, Hbridges estão disponíveis de forma
barata como chips de circuito integrado (IC) (figura 6.25). Melhor ainda, muitos ICs baratos
agrupam circuitos Hbridge junto com diodos internos e outros dispositivos para proteger
o circuito do motor, bem como evitar estados de disparo. Esses chips são chamados de
drivers de motor ou apenas drivers.
Figura 6.25. Drivers de motor baratos, como este Texas Instruments SN754410,
fornecem controle lógico sobre circuitos internos de ponte H. Eles também incluem outros
componentes, como diodos, tornando o controle do motor mais simples e menos sujeito a
erros. O SN754410 é uma ponte H dupla - pode controlar dois motores.
UAU! e-book
www.wowebook.org
O Driver Quadruple HalfH SN754410 da Texas Instruments custa apenas alguns dólares e está
disponível em vários revendedores de suprimentos eletrônicos. Sim, seu nome é um bocado
(dica bônus: uma meia-ponte quádrupla é equivalente a dois circuitos Hbridge completos),
mas faz tudo o que precisamos para acionar os dois motores do nosso primeiro robô itinerante.
Antes de mergulharmos nos detalhes dos pinos do IC do driver do motor e circuitos relacionados,
vamos começar com as peças fundamentais do nosso primeiro robô.
6.3.2. Construindo a base do chassi do robô
Você vai querer prender os suportes laterais (isso pode levar algum esforço) e sua placa
de ensaio à placa inferior do chassi do robô (figura 6.26). Se você tiver o kit Peewee, os suportes laterais
são as peças de plástico com os orifícios retangulares maiores no
meio.
Figura 6.26. A placa inferior do chassi Peewee Runt Rover, com suportes laterais
anexados e breadboard. Se você estiver usando um chassi diferente, parecerá um
pouco diferente, é claro.
UAU! e-book
www.wowebook.org
Fixando a protoboard ao chassi
A maioria das protoboards de tamanho médio tem adesivo que pode ser exposto descascando um pedaço de
papel de apoio, e isso pode ser útil para aderir a protoboard ao chassi do robô para evitar que ele se mova. Se
você não puder enviar permanentemente uma protoboard ao robô - talvez esta seja sua única protoboard! -
ou se sua protoboard não tiver adesivo, você pode prendê-la temporariamente ao chassi do robô usando
fita dupla face, fita isolante, gaffer's fita adesiva ou adesivo removível de sua escolha. Você
também poderia usar laços de arame.
Vá em frente e centralize a protoboard e prenda-a ao chassi. O buraco no centro
da placa deixará um pouco do adesivo exposto (se você estiver fixando permanentemente sua placa de ensaio).
Você pode cortar um pedaço do papel de apoio no formato do buraco e recolocá-lo para cobrir a superfície
gomosa exposta, se quiser. Não conecte a placa superior do chassi ainda.
Os motorredutores feitos para robôs têm um eixo de saída com engrenagem para as rodas motrizes
que (normalmente) está em um ângulo reto em relação ao giro do motor. Rodas anexadas ao eixo de saída,
UAU! e-book
www.wowebook.org
voltado para fora do robô, enquanto o eixo giratório do motor está orientado para cima
(como no kit Peewee, figura 6.27) ou para trás (como no SparkFun Shadow Chassis). Em
todos os casos, você desejará ter os fios dos motores por dentro.
Figura 6.27. A placa superior do chassi Peewee Runt Rover, mostrada com motores de
engrenagem conectados, rodas, suporte para placa de desenvolvimento e Arduino Uno.
Certifique-se de que os fios dos motores estejam voltados para dentro do chassi. Os
fios do motor podem passar por baixo do Uno e pelo orifício central da placa do chassi.
Pegue a placa superior do chassi Peewee e prenda os motoredutores a ela. Os condutores dos
motores podem então ser direcionados para baixo através do orifício circular no meio da placa
superior, para acesso à placa de ensaio abaixo. O kit Peewee também vem com dois suportes
de placa de desenvolvimento, em forma de nós largos e rasos. Estes devem ser anexados à placa
superior agora, e você pode aninhar o Arduino neles, com a conexão USB voltada para o que será
a parte traseira do robô (a placa é simétrica da frente para trás, então você pode decidir agora onde
a parte traseira do seu bot é).
Agora você pode deslizar as rodas nos eixos do motoredutor. Neste ponto, você deve ter uma placa
inferior com breadboard e suportes laterais anexados e uma placa superior com Arduino, motores e
rodas conectados.
6.3.3. Controlando os motores do robô

Se você orientar o acionador do motor SN754410 com a cavidade semicircular na parte superior,
os pinos serão ordenados de 1 a 16, conforme mostrado na figura 6.28. Pinos diferentes têm
finalidades diferentes e fornecem conexões para coisas diferentes dentro do chip. Vamos
andar WOW!
através deles enquanto construímos o circuito.
Figura 6.28. A pinagem do driver do motor SN754410
SN754410 ligar e habilitar conexões
A primeira etapa para conectar o SN754410 é conectar alguns de seus pinos à alimentação e ao
aterramento (figura 6.29).
Figura 6.29. O SN754410 precisa ser conectado a uma fonte de alimentação do motor em
VCC2 (pino físico 8) e à fonte de alimentação lógica em VCC1 (pino físico 16). Os dois pinos
de habilitação devem ser conectados diretamente a 5 V para defini-los como ALTO. Existem
também quatro pinos GND que, sem surpresa, precisam se conectar ao terra.
UAU! e-book
www.wowebook.org
O driver precisa estar conectado a duas fontes de energia separadas. A bateria de 9 V alimentará os próprios
motores (fonte de alimentação do motor), enquanto a lógica de controle dos motores será de 5 V do
Uno (fonte de alimentação lógica).
Além disso, existem dois pinos de habilitação no chip: um para cada driver do motor. Você precisa “ligar”
cada driver conectando cada pino de habilitação (EN) — pinos físicos 1 e 9 — a 5 V (ou seja, nível lógico ALTO).
Faça as conexões aos pinos de alimentação e habilitação conforme mostrado no diagrama de fiação de
alimentação do motor (figura 6.30). Observe que os trilhos de aterramento são interligados (terra compartilhado),
mas as fontes de alimentação são isoladas: o trilho esquerdo para a fonte de alimentação do motor (9 V), o
trilho direito para a fonte de alimentação lógica (5 V).
Figura 6.30. Fiação das conexões de energia do SN754410 na placa de ensaio do robô
SN754410 conexões lógicas
No SN754410, cada motor é controlado por meio de dois pinos de entrada. Dois correspondentes WOW!
e-book
www.wowebook.org
pinos de saída são conectados ao motor (figura 6.31).
Figura 6.31. Cada um dos dois drivers de motor tem dois pinos de entrada e dois pinos de saída.
Diferentes combinações de nível lógico nos dois pinos de entrada de um motor fazem com que coisas
diferentes aconteçam com cada motor, graças aos interruptores e circuitos Hbridge internos. Para
cada motor, um pino de entrada pode ser usado para controlar a direção enquanto o segundo pino de
entrada pode ser usado para controlar a velocidade do motor. Vamos dar uma olhada em como isso
pode acontecer, examinando como o primeiro dos dois motores é controlado (o segundo motor
é controlado de forma idêntica).
Controlando a direção do motor
Usaremos o pino 1A (pino físico 2 no SN54410) para controlar a direção do primeiro motor (figura
6.32).
Figura 6.32. O primeiro controlador de motor: dois pinos de entrada e dois pinos de saída.
Usaremos um dos pinos de entrada para controlar a direção do motor e o outro para controlar
sua velocidade.
UAU! e-book
www.wowebook.org
Quando o pino 1A é definido como ALTO e o pino 2A é BAIXO, a corrente de 9 V

poderá fluir pelos dois pinos de saída (1Y, 2Y) e o motor girará na direção direta (figura 6.33).
Figura 6.33. Quando a primeira entrada for definida como ALTA e a segunda entrada for definida
como BAIXA, o motor girará na direção direta.
UAU! e-book
www.wowebook.org
Da mesma forma, quando o pino de direção 1A é definido como BAIXO, o motor girará na direção
reversa (o fluxo de corrente de 9 V é invertido) sempre que o pino 2A estiver em ALTO (figura 6.34).
Figura 6.34. Quando a primeira entrada é BAIXA e a segunda é ALTA, o motor

gira na direção oposta (reversa).
Dito de outra forma, sempre que 1A e 2A tiverem níveis lógicos opostos, o motor será alimentado para
girar na direção ditada pelo nível lógico do pino 1A. Mas se ambos os pinos de entrada tiverem o mesmo
nível lógico, nenhuma corrente fluirá pelo motor (detalhado na tabela 6.1).
Tabela 6.1. Controle de direção do driver do motor para o motor 1
Valor 1A (pino de direção) Valor de 2A (pino de velocidade) Resultado
O motor gira na direção 1 (para

ALTO BAIXO
frente)
ALTO ALTO Sem corrente através do motor
O motor gira na direção 2 (para

BAIXO ALTO
trás)
BAIXO BAIXO Sem corrente através do motor
Controlando a velocidade do motor
O pino 2A (SN54410 pino 7) controlará a velocidade do primeiro motor, usando PWM. Digamos que o pino
1A, o pino de direção, esteja definido como BAIXO, indicando uma direção reversa para a rotação do motor,
UAU! e-book
www.wowebook.org
enquanto o PWM com um ciclo de trabalho de 25% é aplicado ao pino 2A, o pino de velocidade (figura 6.35).
Setenta e cinco por cento das vezes, 1A e 2A terão os mesmos níveis lógicos (BAIXO/BAIXO),
durante os quais nenhuma corrente fluirá pelo motor. No entanto, 25% do tempo, a combinação BAIXO/ALTO
permitirá que a corrente flua, alimentando o motor.
Isso resulta no que queremos: o motor girando na direção inversa a uma configuração de velocidade de 25%.
Figura 6.35. Com a direção definida como LOW (reversa) no pino 1A e um ciclo de trabalho
de 25% no pino 2A (velocidade), o motor será alimentado 25% do tempo na direção reversa.
O mesmo vale para o controle de velocidade na direção de avanço, mas há uma ruga. Digamos que 1A (direção)
seja definido como ALTO — para frente — e 2A (velocidade) seja definido como um PWM de ciclo de trabalho de 25%.
O que pretendemos é que o motor gire para frente na velocidade de 25%, mas o que vai acabar acontecendo é
que ele gire para frente na velocidade de 75% (figura 6.36).
Figura 6.36. Com a direção definida como HIGH (para frente) no pino 1A e um ciclo de
trabalho de 25% no pino 2A (velocidade), o motor será alimentado 75% do tempo na
direção para frente.
Para levar em conta isso, o sinal PWM precisa ser invertido quando a direção do motor for para frente.
Alguns drivers de motor lidam com isso para você, invertendo automaticamente o PWM quando o
motor está configurado para girar para frente. O SN54410, no entanto, não, então teremos que
considerá-lo em nosso código.
UAU! eBook
Completando o circuito do
motor www.wowebook.org
Completando o circuito do motor
O restante do circuito envolve conexões com o Arduino, fonte de alimentação do motor de 9 V e os dois
motores (figura 6.37). As conexões com o Arduino e os motores devem ser roteadas através do orifício
central da placa superior do chassi. Ao terminar de fazer essas conexões, você pode colocar a placa
superior do chassi na placa inferior do chassi e colocar a bateria de 9 V dentro, mas não encaixe as peças
ainda - você precisa testar os motores

primeiro.
Figura 6.37. Diagrama de circuito para o circuito do motor completo do rover
Testando os motores com Johnny-Five
Antes de montar o robô, você deve testar se o circuito do motor está funcionando conforme o esperado.
Crie um arquivo chamado motortest.js em seu diretório de trabalho e coloque o seguinte código nele.
Listagem 6.3. Test drive do motorista

UAU! e-book
www.wowebook.org

board.on('ready', function () { const motores = new

five.Motors([
{ pinos: { dir: 12, pwm: 11 }, invertPWM: verdadeiro },
{ pinos: { dir: 4, pwm: 5}, invertPWM: verdadeiro }
]);
board.repl.inject({
motores: motores
});
});
Vamos ampliar a instanciação de um objeto JohnnyFive Motors na próxima listagem.

Motors é uma classe de coleção de componentes JohnnyFive, semelhante a Leds. Ele pode controlar
vários componentes do motor ao mesmo tempo.
Listagem 6.4. Instanciando motores
motores const = novos cinco.Motors([

{ pinos: { dir: 12, pwm: 11 }, invertPWM: verdadeiro }, 1 { pinos: { dir: 4, pwm: 5}, invertPWM: verdadeiro }
2]);
1 Opções e pinos para o primeiro motor
2 opções e pinos para o segundo motor
Para o construtor Motors, você passa um array contendo opções para cada Motor.
Agora que cada motor é controlado por dois pinos, JohnnyFive precisa saber quais pinos
fazem o quê: um para direção (dir) e outro para velocidade (pwm).
Lembre-se que o sinal PWM precisa ser invertido quando o motor avança.
O hardware não faz isso automaticamente, mas você pode informar ao JohnnyFive que
isso precisa ser feito, e o JohnnyFive fará isso por você, usando a opção invertPWM.
Não deixe seu bot fugir!
Antes de executar os motores no script de teste, levante seu robô parcialmente construído
do chão para que as rodas fiquem no ar. Caso contrário, pode escorrer!
UAU! e-book
www.wowebook.org
Execute o script:
$ node motortest.js
Quando a placa e o REPL forem inicializados, insira o seguinte comando e pressione

Digitar:
> motores.forward(100)
Agora olhe para os seus motores. Eles estão correndo para frente, bem devagar? Há uma chance
razoável de que um ou ambos estejam girando na direção errada. Não é um problema.
Elimine o script, desconecte a energia e troque a conexão entre os cabos do motor e os pinos de
saída no driver do motor para qualquer motor que esteja indo para o lado errado. Em seguida, tente
novamente.
Finalizando a construção do chassi
Prenda as pequenas protuberâncias de plástico na parte inferior da placa inferior, na frente e atrás.
É neles que o bot repousa quando não está em movimento. Confiante de que seus motores
estão girando conforme o esperado? Bom. Agora você pode encaixar as placas superior e inferior
do chassi (figura 6.38).
Figura 6.38. O robô completo, visto de frente
UAU! e-book
Escrevendo o software do robô
www.wowebook.org
Escrevendo o software do robô
O software do rover permitirá que você use as setas do teclado para dirigir o bot (e use a barra de espaço
para pará-lo). O código consistirá em alguns scripts (módulos) e uma dependência extra (o módulo npm
keypress). Vamos ser um pouco mais organizados sobre a área de trabalho do projeto:
1. Crie um novo diretório chamado rover e cd para esse novo diretório.
2. Execute este comando: npm init yes. Isso inicializará um arquivo package.json
com alguns padrões sensatos.
3. Execute este comando: npm install save johnnyfive keypress. Isso vai
instale os dois módulos listados e salve as informações sobre as dependências em package.json.
Crie um arquivo chamado Rover.js (listagem 6.5). Este módulo conterá uma classe JavaScript que define
os movimentos básicos do rover. O Rover não sabe sobre os pinos específicos ou a configuração dos
motores no objeto Motors passado para seu construtor; esses detalhes são abstraídos.
Listagem 6.5. A classe Rover
classe Rover { 1
construtor (motores) { 2
this.motors = motores;
}
avançar () {
console.log('A toda velocidade!');
this.motors.forward(255);
}
para trás () {
console.log('Reverse!'); this.motors.reverse(255);
esquerda () {
console.log('À esquerda!'); this.motors[0].reverse(200); 3
this.motors[1].forward(200); 4
}
certo () {
console.log('À direita!');
this.motors[0].forward(200);
this.motors[1].reverse(200);
}
UAU! e-book
www.wowebook.org
stop()
{ this.motors.stop();
console.log('Parando motores...');
}
}
module.exports = Rover; 5
1 Organizar o comportamento com sintaxe de classe pode tornar o código mais legível.
2 O construtor cria uma referência aos motores (this.motors).
3 Cada Motor em um objeto Motors pode ser acessado com notação de matriz.
4 A direção envolve acionar um motor para frente e outro para trás.
5 Exporta a classe Rover para consumo externo
Agora o robô precisa de uma interface e uma forma de controlá-lo. Crie outro arquivo
chamado index.js, mostrado na listagem a seguir.
Listagem 6.6. Estrutura de index.js
// Requer dependências const five

= require('johnnyfive'); const board = new five.Board();
const keypress = require('keypress'); const Rover =

require('./Rover');
board.on('ready', function () { // 1. Instanciar

Motores
// 2. Instanciar Rover, usando Motors // 3. Configurar
`keypress` para gerar eventos em keypresses no REPL // 4. Ouvir eventos `keypress` e invocar métodos Rover
apropriados
});
Expandindo as etapas 1 e 2 na listagem anterior, vamos instanciar os Motors e depois o Rover

na próxima listagem.
Listagem 6.7. index.js: configurando os motores e o rover
// ...
board.on('pronto', function () {
// 1. Instanciar motores
{ pinos: { dir: 12, pwm: 11 }, invertPWM: verdadeiro }, 1
{ pinos: { dir: 4, pwm: 5}, invertPWM: verdadeiro } 2
]);
UAU! e-book
www.wowebook.org
// 2. Instanciar Rover, com motores

rover const = new Rover(motores); 3
// 3. Configure `keypress` para gerar eventos em keypresses no REPL // 4. Ouça os eventos `keypress` e invoque
os métodos Rover apropriados });
1 Detalhes do motor esquerdo
2 Detalhes do motor direito
3 Passa Motores para o construtor Rover
Para controlar o robô, você precisa ouvir os pressionamentos de tecla relevantes para entrada de direção. A terceira
tarefa em index.js é configurar o pressionamento de tecla.
Listagem 6.8. index.js: configurando pressionamento de tecla
//...
motores (como antes)
// 2. Instanciar Rover, com motores (como antes)
// 3. Configure `keypress` para gerar eventos em teclas pressionadas no REPL
keypress(processo.stdin);
process.stdin.setEncoding('utf8'); // 4. Ouça os eventos `keypress` e invoque os métodos Rover apropriados
});
1 Diga ao pressionamento de tecla para gerar eventos para process.stdin (entrada padrão, por meio do teclado)
2 Seja explícito sobre a codificação de caracteres.
Finalmente, você precisa ouvir e lidar com os pressionamentos de tecla.
Listagem 6.9. index.js: manipulação de pressionamentos de tecla
//...
motores (como antes)
// 2. Instanciar Rover, com motores (como antes)
// 3. Configure `keypress` para gerar eventos em pressionamentos de tecla no REPL // 4. Ouça os eventos
`keypress` e invoque os métodos Rover apropriados process.stdin.on('keypress', function (ch, key) { 1
if (!chave) { return; } 2
UAU! e-book
www.wowebook.org
switch (key.name) { case 'q': 3
rover.stop(); console.log('Tchau!');
process.exit(); 4
quebrar;
caso 'acima': 5
rover.forward();
quebrar;
caso 'para baixo':
rover.backward();
quebrar;
caso 'esquerda':
rover.left();
quebrar;
caso 'certo':
rover.right();
quebrar;
caso 'espaço': 6
rover.stop(); break;
padrão: 7
retornar;
}
});
});
1 Ouça eventos de pressionamento de tecla. Você se preocupa com o argumento-chave aqui.
2 Se não houver nada útil na chave, retorne (não faça nada).
3 Pressionar a tecla q encerrará o robô. Primeiro, os motores são parados.
4 process.exit() encerrará o processo do robô.
5 'up' refere-se à seta para cima do teclado (e assim por diante com 'down', 'left' e assim por
diante).
6 O robô pode ser parado com a barra de espaço.
7 O caso padrão para a instrução key switch é não fazer nada.
Dirigindo seu robô
Coloque seu robô onde ele tenha um pouco de espaço para se movimentar e execute o script:
$ node index.js
Depois que o quadro e o REPL forem inicializados, você poderá usar as teclas de seta (para cima, para baixo, para a
esquerda,
WOW! eBook www.wowebook.org
direita) para orientar o robô e a barra de espaço para fazê-lo parar.
Você pode sentir sentimentos mistos de triunfo (viva! primeiro robô!) e restrição (as aventuras são limitadas
pelo comprimento do seu cabo USB). Há boas notícias: à medida que avançamos, você poderá desamarrar
seus robôs e torná-los mais interessantes.
Antes de fazermos isso, entretanto, você irá completar os principais tópicos de entrada e saída aprendendo
como trabalhar com dados seriais.
RESUMO
Os eletroímãs fazem os motores girarem. Um motor alimentado com corrente converterá essa energia
elétrica em energia mecânica - ele girará. Girar o eixo de um motor faz com que ele atue como um
gerador, convertendo energia mecânica em energia elétrica.
Construir circuitos com motores envolve cuidados adicionais. Os circuitos do motor geralmente combinam
várias tensões e as fontes de alimentação do motor tendem a ser isoladas dos circuitos lógicos de baixa
tensão.
A direção do motor pode ser revertida invertendo a direção do fluxo de corrente através do motor, e a
velocidade do motor pode ser controlada com PWM.
Transistores como MOSFETs podem ser usados como interruptores de alta velocidade, usando lógica de
baixa tensão para comutar circuitos de alta tensão.
Diodos e capacitores são dois componentes que podem ajudar a construir circuitos de motor mais seguros.
Os diodos só permitem que a corrente flua através deles em uma direção. Um diodo, orientado para ser
polarizado reversamente em paralelo com um motor, pode proteger o circuito, atuando como um diodo
flyback.
Os capacitores armazenam carga elétrica e podem ser colocados em paralelo com os componentes para
isolá-los do circuito e suavizar as mudanças de tensão que causam. Quando usados dessa forma, eles
são chamados de capacitores de desacoplamento.
Os servos permitem um posicionamento preciso, convertendo sinais PWM em posição angular.
A maioria dos alcances dos servos são, aparentemente, 180 graus, mas o alcance utilizável é mais estreito
em servos baratos.
Os circuitos Hbridge fornecem a capacidade de direcionar a corrente através de uma carga (motor) em
várias direções, permitindo que você inverta a direção do motor. Hbridges, combinados com outros
recursos, são empacotados em ICs de driver de motor.
Os robôs itinerantes básicos combinam um microcontrolador com um acionador de motor, motoredutores,
rodas, uma fonte de energia e um chassi.
UAU! e-book
www.wowebook.org
História
Parte 3. Projetos mais sofisticados
Esta parte do livro aumenta a aposta e abre novas possibilidades por meio da
comunicação serial Topics e da elegante placa de desenvolvimento Node.jscapable Tessel 2.
Tutoriais
Para usar sensores mais sofisticados e trocar dados mais complexos, você precisará entender
como funciona a comunicação serial, que é o tópico do capítulo 7. Você obterá uma
chance de experimentar alguns sensores bacanas, incluindo um acelerômetro, um GPS e uma
bússola. Ao longo do caminho, você aprenderá a diferença entre assíncrono e
2
Destaca a
serial síncrona e você conhecerá os protocolos IC e SPI. Você também aprenderá a
solda.
Configurações
No capítulo 8, você desvinculará seus projetos, ficando sem fio com a placa de
desenvolvimento Tessel 2 Support . Você conhecerá o Tessel, que pode executar seus scripts
JohnnyFive nativamente, e construirá experimentos mais complexos que fazem uso crescente de
pacotes
npm de terceiros Sign Out .
Ao continuar sua aventura, você provavelmente começará a pensar em suas próprias coisas para
construir. O Capítulo 9 percorre as etapas de adaptação do hardware existente e da criação de seu
próprio suporte de software para os componentes. Você hackeará um interruptor de tomada com
controle remoto e a placa de detecção de gestos APDS9960.
Esta parte do livro é um passo em direção a mais independência e sofisticação para seus projetos.
Você alcançará a independência dos fios por meio do Node.js nativo do Tessel e do WiFi
integrado e experimentará componentes mais sofisticados usando comunicação serial.
UAU! e-book
www.wowebook.org
História
Tópicos
O que é comunicação serial, o que ela pode fazer e onde é usada

Tutoriais
Como trabalhar com componentes seriais assíncronos como módulos GPS
Uma introdução às principais habilidades de soldagem

Os fundamentos da comunicação serial síncrona e os protocolos mais populares para

Destaques 2
eletrônicos de passatempo: SPI e IC
Configurações Construindo projetos mais complexos combinando vários componentes de dispositivos seriais
Apoiar
Sair
1 placa de fuga Adafruit Ultimate GPS
1 placa de magnetômetro Adafruit HMC5883L (bússola)
1 placa multissensor Adafruit BMP180
1 placa de acelerômetro Adafruit ADXL345 TripleAxis

2
1 módulo LCD paralelo 16x2 ou, opcionalmente, módulo LCD Grove RGB habilitado para IC
1 potenciômetro rotativo (para LCD paralelo)
Pinos de cabeçalho macho separatistas
Ferro de solda e suprimentos de solda
Fios de jumper
UAU! e-book
www.wowebook.org
2 tábuas de pão de meio tamanho
Em nossos experimentos até agora, conseguimos reunir alguns dados divertidos, mas diretos,
sobre o mundo ao nosso redor, como temperatura (figura 7.1) ou intensidade da luz ambiente.
E ouvindo a variação em um sinal digital básico (HIGH vs. LOW), poderíamos dizer se um botão
foi pressionado.
Figura 7.1. Com um sensor analógico simples como o TMP36, você pode obter um valor
para um único ponto de dados (temperatura) amostrando a tensão do sinal em diferentes
pontos no tempo (A, B, C).
Mas há muito mais informação por aí do que pode ser (plausivelmente) retransmitida com
um único sinal analógico. Na verdade, muitos dos dados interessantes são
consideravelmente mais complicados e precisam de uma coordenação mais refinada (figura
7.2). E se você quiser detectar movimento físico em três direções simultaneamente, como em um acelerôm
UAU! e-book
www.wowebook.org
E quanto à leitura de informações de chips de GPS? Coordenadas e direções precisas
da bússola? Dados mais sofisticados exigem métodos mais estruturados e sofisticados
de comunicação digital entre os componentes.
Figura 7.2. Os dados digitais complexos de sensores como acelerômetros, bússolas

e módulos GPS requerem um método mais sofisticado de troca de dados.
7.1. COMUNICAÇÃO DE DADOS DIGITAIS EM PARALELO E EM SÉRIE
Comunicação serial: é um conceito único com inúmeras manifestações. O conceito único

em seu núcleo é absolutamente simples: serial significa simplesmente que as informações -
dados - são enviadas um bit por vez, um bit após o outro. Isso contrasta com a
comunicação paralela, na qual vários bits são enviados ao mesmo tempo (figura 7.3).
Figura 7.3. Na comunicação serial (topo), um bit é enviado de cada vez sequencialmente.
Em contraste, a comunicação paralela (abaixo) transmite vários bits ao mesmo
tempo.
UAU! e-book
www.wowebook.org
Os benefícios da comunicação em paralelo podem ser bastante evidentes: por que lançar bits um de
cada vez se você pode abrir as comportas e lançar uma série de bits simultaneamente? É
verdade, a comunicação paralela pode ser muito rápida. Mas há algumas pegadinhas.
Na verdade, você já viu uma das desvantagens da comunicação paralela. Lembra-se do experimento
do cronômetro LCD no capítulo 5? Esse circuito usava um componente LCD paralelo.
Pense por um momento no circuito. Uma de suas características era que exigia um rebanho inteiro
de fios. Quatro desses fios eram responsáveis por enviar dados, em paralelo, para o LCD, e esse
circuito usava apenas quatro dos oito pinos de dados paralelos possíveis no LCD. Desvantagem
número um para paralelo: toneladas de fios.
O hardware paralelo também requer mais bits e peças físicas do que o hardware serial.
Mais fios levam a circuitos mais caros e complexos - e muitas peças significam que há mais coisas
que podem quebrar.
Também é complicado organizar todos esses bits paralelos e garantir que eles cheguem ao mesmo
lugar ao mesmo tempo. No final, a complexidade do paralelo pode ser mais problemática do que
vale a pena. E serial, apesar de sua simplicidade, é mais do que rápido o suficiente. Serial está ao
nosso redor: HDMI, USB, Ethernet. Serial é o método de troca de dados para uma vasta gama
de componentes eletrônicos. Então, vamos falar sobre serial.
7.2. O BÁSICO DA COMUNICAÇÃO SERIAL

UAU! e-book
www.wowebook.org
Embora o conceito básico de comunicação serial não seja difícil de entender - um bit de cada vez - há
um número assustador de maneiras pelas quais isso pode realmente acontecer. Quão rápido esses
bits devem se mover? Quantos bits compõem cada agrupamento discreto (quadro) de dados
entregues? Como os erros são detectados e corrigidos? Se houver mais de dois componentes se
comunicando, como os dados são enviados (endereçados) para o componente correto? Um
componente é responsável (o mestre) por vários componentes conectados?
Todos os componentes que conversam no mesmo canal de comunicação serial, ou barramento,
precisam estar de acordo sobre como essa conversa vai funcionar (figura 7.4) – eles precisam usar o
mesmo protocolo. Existem muitos protocolos seriais e isso pode parecer opressor. A boa notícia
é que apenas um punhado é comumente usado em componentes eletrônicos de hobby. Obtenha

2
um controle conceitual sobre serial assíncrono básico, IC e talvez SPI, e você estará em boa forma. E
se você estiver se sentindo especialmente cauteloso, observe que quase toda a complexidade de baixo
nível pode ser abstraída para você por bibliotecas como JohnnyFive.
Figura 7.4. Para que os dispositivos troquem dados usando comunicação serial, eles
precisam saber como se comunicar.
7.3. COMUNICAÇÃO SERIAL ASSÍNCRONA
Quando as pessoas se referem a serial sem qualquer qualificação adicional, elas geralmente
se referem à comunicação serial assíncrona - dois dispositivos transmitindo (TX) e recebendo (RX)
dados entre si (figura 7.5). No entanto, mesmo uma configuração tão simples quanto essa precisa
tem algumas regras.
Figura 7.5. A troca de dados seriais assíncronos: cada um dos dois dispositivos
conectados pode transmitir dados (TX) e receber dados (RX) do outro componente.
Observe que o TX de um dispositivo se conecta ao RX do outro e vice-versa. Uma
placa de breakout de GPS como a da Adafruit é um exemplo de componente que comunica
seus dados usando serial assíncrona.
UAU! e-book
www.wowebook.org
Serial assíncrono é assim chamado porque não há sinal de clock gerenciado compartilhado pelos componentes. Cada
dispositivo deve ser seu próprio cronometrista. Tudo bem, mas deve haver um acordo comum entre os componentes
sobre quantos bits são enviados por unidade de tempo. Dito de outra forma, cada componente precisa saber
quanto tempo um bit de dados levará - por exemplo, quanto tempo um sinal permanecerá ALTO para indicar um
único valor de 1 bit?
(Sem saber disso, como um receptor seria capaz de dizer a diferença entre dois bits 1 sequenciais e um único bit 1
longo?). A velocidade dos bits geralmente é expressa em bits por segundo (bps) ou taxa de transmissão.
Mas espere, tem mais! Os dados não são enviados em fluxos intermináveis de 1s e 0s. Em vez disso, os dados são
empacotados em breves segmentos chamados frames. Cada quadro de dados enviado é composto de várias
partes: os próprios dados (de 5 a 9 bits), mas também um bit de início, um bit de parada (ou dois) e talvez (embora
não com tanta frequência) um bit de paridade para auxiliar na detecção de erros (figura 7.6).
Figura 7.6. Um quadro de dados seriais assíncronos. Um único bit de início é seguido por 5 a 9
bits de dados. Um bit de paridade pode ser usado para detecção de erro. Em seguida, um ou
dois bits de parada indicam o fim do quadro.
Cada configuração de protocolo assíncrono define as especificidades de como seus quadros de dados
serão estruturados, bem como a taxa de transmissão. Por exemplo, 9600/8N1, uma configuração
de protocolo comum, indica uma taxa de dados de 9600 baud, blocos de dados de 8 bits, sem paridade
UAU! e-book
www.wowebook.org
bit e um bit de parada (figura 7.7).
Figura 7.7. A estrutura do quadro de dados de 9600/8N1: bit de início, 8 bits de dados, sem bit de
paridade, um bit de parada
Firmata, serial e um pouco mais sobre como funciona o JohnnyFive
A arquitetura do JohnnyFive faz uma distinção clara entre a API JS de alto nível exposta para
componentes e a implementação de I/O real sob as capas que gravam dados e os lêem desses
componentes conectados.
JohnnyFive assume que as placas de desenvolvimento compatíveis têm a capacidade de executar um

conjunto de operações de E/S. Por exemplo, a lógica dentro da classe Led assume que é possível
ativar uma gravação digital em um pino (para configurá-lo como ALTO ou BAIXO), mas não se importa
especificamente como essa gravação digital é implementada. Em vez disso, é responsabilidade dos plug-
ins de E/S compatíveis definir como essas operações realmente ocorrem.
Ao instanciar um objeto Board, opcionalmente, você pode declarar qual plug-in de E/S usar. Por
exemplo, se você quiser usar JohnnyFive com a placa Tessel 2 (e faremos isso no próximo capítulo),
você pode definir uma propriedade de opção io.
Listagem 7.1. Usando um plug-in de E/S diferente com Johnny-Five
const five = require('johnnyfive'); const Tessel =

require('tesselio'); // Um módulo de plug-in de E/S de terceiros
para J5
const board = new five.Board({

io: new Tessel() // diga ao JohnnyFive para usar este plug-in de E/S });
Você provavelmente notou que, até agora, não fornecemos uma opção io em nossas instanciações
do Board. Se a opção não estiver definida, JohnnyFive, por padrão, usa Firmata para I/O. Essa camada
de E/S padrão da Firmata é compatível com uma série de placas Arduino, incluindo o Uno.
Ao executar um script JohnnyFive Node.js em seu computador host, é o Firmata que traduz a lógica de
seu aplicativo em comandos de E/S para enviar à placa. Também é UAU! e-book www.wowebook.org
rodando na placa como firmware e faz a tradução na outra direção: enviando dados
da placa de volta para o computador host.
A execução de Firmata é um exemplo de serial assíncrono em ação. Os dados Firmata

são transmitidos em blocos de 8 bits (8N1) entre o computador host e a placa Arduino em
uma taxa de transmissão rápida. Quando você executa um programa JohnnyFive Node.js
não compatível em seu computador host (“compatível” significando que usa o Firmata I/
O padrão), os dados do Firmata são enviados e recebidos por meio do cabo USB
conectado. (USB significa Universal Serial Bus, afinal!) No final do Arduino, receber e
transmitir dados seriais Firmata é tratado pelo único Receptor/Transmissor
Assíncrono Universal (UART) integrado do Uno (figura 7.8).
Figura 7.8. Um UART é um hardware especializado para comunicação serial

assíncrona e conversão paralela para serial.
Para os curiosos: embora o protocolo Firmata defina a estrutura das mensagens e a

implementação do Firmata lide com o empacotamento e o processamento dessas
mensagens, a mecânica real da troca de dados seriais por meio da porta USB do seu
computador é suportada por um pacote npm chamado nodeserialport.
7.3.1. UARTs
Um receptor/transmissor assíncrono universal (UART) é uma peça de hardware para
lidar com a comunicação serial assíncrona (figura 7.8). Um UART pode pegar um monte de
dados paralelos - digamos, dados vindos de vários pinos de E/S ou outras fontes - digeri-
los e WOW!
cuspi-lo em um protocolo serial desejado. Também acontece o contrário: um UART também pode
decodificar dados seriais de entrada e disponibilizá-los como dados paralelos. Entrada paralela, saída
serial — e vice-versa. Os UARTs podem ser configurados para falar diferentes tipos de serial
assíncrono: diferentes taxas de transmissão e assim por diante. Isso torna os UARTs bits de hardware
altamente flexíveis e úteis.
O termo transistortransistor logic (TTL), neste caso, refere-se ao uso de comunicação

serial assíncrona via UARTs. Com TTL, o ALTO lógico é representado como o Vcc do microcontrolador
(+5 V no caso do Uno) e o BAIXO é representado como 0 V - ou seja, a faixa de tensão é sempre limitada
às tensões apropriadas para o
microcontrolador em mãos.
Os múltiplos significados de TTL
O termo transistortransistor logic (TTL) geralmente se refere a um método para construir circuitos digitais
usando transistores para lógica - por exemplo, portas AND, inversores lógicos, portas XOR e assim
por diante. As tensões padrão usadas em componentes TTL parecerão familiares: +5 V para indicar um
ALTO lógico e 0 V para BAIXO. ICs TTL, especialmente aqueles compatíveis com a popular família
Texas Instruments 7400, foram amplamente usados na década de 1990. Eles ainda estão muito
disponíveis e são úteis para projetos de hobby ou sistemas embarcados mais simples, embora
tenham sido substituídos por outras tecnologias para a maioria dos eletrônicos sofisticados
produzidos em massa (por exemplo, semicondutor de óxido de metal complementar, que é abreviado
para algo que você pode reconhecer: CMOS ).
Talvez de forma confusa, o termo TTL também é aplicado a um dispositivo ou circuito que pode
ser conectado a outro dispositivo ou circuito sem nenhuma tradução ou interface extra. Neste contexto,
indica que o sinal entre os dois se comunicará logicamente usando os níveis lógicos HIGH (+5 V) e
LOW (0 V). É esse uso que leva à convenção de se referir alternadamente ao serial assíncrono
como serial TTL.
Seu fiel Arduino Uno possui um UART (mais precisamente, seu microcontrolador ATmega
328P possui um UART). Enquanto um script JohnnyFive está sendo executado em seu computador
host, o UART do Uno está ocupado recebendo e transmitindo mensagens no Firmata
formatar.
Há um conflito potencial aqui. Digamos que você tenha um componente de dispositivo que deseja usar
em seu projeto que comunique dados usando serial assíncrono. Mas o UART do seu Uno já está
ocupado, monopolizado pela comunicação Firmata que ele precisa para continuar no WOW! e-book
www.wowebook.org
para fazer os programas JohnnyFive funcionarem.
Felizmente, há uma maneira! O trabalho que um UART realiza é certamente mais eficiente e rápido
quando implementado em hardware, mas pode ser emulado em software. O chamado serial de
software permite que você se comunique em serial assíncrono por meio de pinos do microcontrolador
que normalmente não o suportariam no nível do hardware. O serial de software pode exigir muito do
processador e não é tão rápido quanto um UART, mas pode ser rápido o suficiente e fazer o trabalho.
7.3.2. Experimentando serial de software com uma placa de fuga de GPS
1 tábua de pão
1 placa de fuga Adafruit Ultimate GPS
Fios jumper vermelho, preto, amarelo e branco
É aqui que fica divertido - a primeira vez que você conecta um GPS e vê os dados recebidos, é incrível.
A leitura de dados de GPS com um Arduino Uno costumava parecer um pouco misteriosa - muitas
cópias e colagens de código do Arduino e dependência de bibliotecas de baixo nível criadas por
membros da comunidade. Funcionou, mas não foi muito intuitivo para o especialista não-C.
Interagir com GPS usando JohnnyFive hoje em dia, no entanto, é tão simplificado que parece quase
mágico. Seu pequeno chip GPS está ouvindo satélites! É difícil acreditar que algo tão sofisticado
possa ser controlado e amostrado com apenas algumas linhas claras de JavaScript. A tecnologia é legal.
Dados GPS e sentenças NMEA
Muitos chips de GPS emitem dados em conformidade com um padrão chamado NMEA 0183.
A National Marine Electronics Association (NMEA) mantém esse padrão, que define a estrutura
de dados dos tipos de hardware que você pode esperar encontrar a bordo de uma embarcação
marítima: sonar, giroscópios, radar marinho - e GPS.
UAU! e-book
www.wowebook.org
Os dados NMEA são comunicados por serial assíncrona como caracteres ASCII - os caracteres
ASCII têm 7 bits, que se encaixam perfeitamente em um byte de dados - e esses caracteres são
reunidos em sentenças NMEA limitadas por vírgula. Embora o padrão mencione uma configuração
específica (4800 8N1), os dados NMEA podem ser enviados por várias configurações. A quebra
do GPS da Adafruit é padronizada para 9600 baud, mas alguns GPS
os módulos podem transmitir ainda mais rápido.
Exemplo de sentença NMEA e alguns de seus campos explicados. Os dados transmitidos do

GPS são enviados em ASCII commadelimited em conformidade com o padrão NMEA.
A classe GPS do JohnnyFive analisa as sentenças NMEA do hardware GPS usando o

software serial e as organiza em propriedades úteis como latitude e
longitude.
A boa notícia é que a construção de um circuito com uma placa de GPS requer conexões
mínimas. Você descobrirá que os componentes eletrônicos de suporte geralmente são integrados
a placas de distribuição - capacitores, resistores e assim por diante - deixando apenas conexões de
energia e dados para conectar.
Por outro lado, você precisará aprender a soldar agora. A placa de breakout GPS Adafruit
precisa ser soldada nos conectores para que você possa conectá-la a uma breadboard (figura 7.9).
A soldagem não é difícil, mas, como qualquer nova habilidade essencial para a vida, pode levar algumas tentativas antes que
você tenha suas pernas do mar de solda.
Figura 7.9. Antes de poder usá-lo em uma breadboard, o GPS precisa ter alguns pinos
de cabeçalho soldados a ele.
UAU! e-book
www.wowebook.org
7.3.3. Aprenda a soldar!
A solda é uma liga metálica destinada a fazer — fundir — ligações permanentes entre pedaços de
metal (figura 7.10). A solda derrete a uma temperatura mais baixa do que as pernas e conexões de
seus componentes, permitindo que ela flua, líquida, em torno dessas conexões sem danificá-
las. Depois que endurece - isso acontece quase instantaneamente - você tem uma
conexão permanente. É como uma cola condutora de metal. A solda vem em comprimentos longos e
finos em um carretel, como arame.
Figura 7.10. A solda vem em um carretel enrolado, como um fio.
UAU! e-book
www.wowebook.org
Para fornecer o calor necessário para derreter a solda e fazer essas conexões, você precisará
de um ferro de solda (figura 7.11). Os ferros de solda variam de dez dólares (EUA) a várias
centenas. Sem surpresa, você obtém o que você paga. Ferros de solda baratos se comportam
de maneira bem barata e não são ajustáveis. Mas um ferro de solda barato fará o trabalho muito
bem se você não estiver pronto para investir em um modelo de qualidade.
Figura 7.11. Um ferro de solda barato comum. Os baratos normalmente não

têm configurações de controle de temperatura - eles apenas obtêm um sabor quente.
UAU! e-book
www.wowebook.org
Certifique-se de que seu ferro de solda tenha um suporte para colocá-lo quando não estiver em suas
mãos (figura 7.12). Você também precisará de uma esponja para limpar a ponta do ferro de solda entre
as soldas e para estanhar a ponta (mais sobre isso em breve). Boas esponjas de solda são de latão,
mas esponjas domésticas comuns também funcionam. Se você usar uma esponja doméstica de
celulose, certifique-se de umedecê-la antes de usá-la com o ferro.
Figura 7.12. Seu ferro de solda precisa de um suporte para segurá-lo quando não estiver em uso e para
proteger as coisas ao seu redor contra queimaduras.
Montando seu kit de solda
Se a lista de suprimentos de solda necessários parecer onerosa (figura 7.13), você pode
considerar um kit “aprender a soldar”, vendido por varejistas de eletrônicos on-line, que vem
com a maioria dos itens necessários e um projeto prático para iniciar.
Figura 7.13. Principais coisas que você precisa para começar a soldar
UAU! e-book
www.wowebook.org
A solda, tradicionalmente, é feita de uma liga contendo uma alta porcentagem de chumbo. Como você
provavelmente sabe, o chumbo é ruim para os humanos. Desde 2006, o uso de chumbo em eletrônicos foi
restrito na UE por meio da Diretiva de Restrição de Substâncias Perigosas (RoHS), que praticamente
eliminou o uso de chumbo na fabricação de solda. A solda sem chumbo é definitivamente boa para as
pessoas e para a terra, mas também é um pouco mais difícil de trabalhar - ela não flui tão suavemente
quanto a solda com chumbo. Estão disponíveis solda sem chumbo e com chumbo; alguns acham que
aprender a soldar com solda com chumbo é mais fácil do que com chumbo
livre.
Você também pode pegar um carretel de pavio de solda (também conhecido como trança de
dessoldagem). Este fio de cobre trançado atua como um aspirador químico para desfazer soldas ruins:
reaqueça a junta soldada e use a trança de solda para remover a solda mal colocada.
Como soldar, passo a passo
Leia estas instruções completamente antes de começar a soldar, para que você esteja preparado e pronto
para o rock:
1. Antes de começar, configure seu espaço de trabalho usando uma terceira mão (figura 7.14) ou algum
outro método para proteger seu trabalho e deixar suas mãos livres - encaixar pinos de cabeçalho em
uma placa de ensaio e posicionar a placa no lugar no topo também é uma opção.
Tenha as ferramentas e peças que você espera precisar à mão para não ficar se debatendo com um
ferro de solda quente mais tarde.
Figura 7.14. Proteja seus componentes antes de soldar. Uma terceira mão é uma
ferramenta conveniente para isso.
UAU! e-book
www.wowebook.org
2. Conecte o ferro de solda e deixe-o aquecer por alguns minutos. Agora, especialmente se você tiver um
modelo barato, espere mais alguns minutos - ou seja, seja paciente.
Trabalhar com um ferro de solda que não está quente o suficiente é uma receita para frustração e
placas chamuscadas.
3. Prepare (estanho) a ponta do seu ferro de solda. Derreta um pouco de solda na ponta do ferro e limpe
o excesso com a esponja. Isso deve resultar em uma ponta brilhante e brilhante em seu ferro de
solda. Se a solda não derreter facilmente quando você tocá-la na ponta do ferro, o ferro não está quente
o suficiente. Aguarde mais alguns minutos e tente novamente.
4. Segure o ferro de solda na mão dominante e a solda na outra mão.
Pressione a ponta do seu ferro quente no pino do cabeçalho e na almofada de conexão por cerca de um
segundo (figura 7.15).
Figura 7.15. Coloque a ponta do ferro de solda na placa de conexão de metal e o

pino para aquecê-los.
UAU! e-book
www.wowebook.org
5. Mantenha o ferro no lugar e aplique a ponta da solda no lado oposto da junta

(figura 7.16). Você não derreterá a solda diretamente com o ferro - a solda, em
vez disso, entrará em contato com o pino aquecido e a conexão da placa.
Mantenha o ferro de solda na parte inferior do pino; ignore a tentação de movê-lo
em direção à solda.
Figura 7.16. O pino aquecido fará com que a solda derreta e flua ao redor da
junta.
6. A solda derreterá e fluirá ao redor da junta. Depois de ter uma boa aparência
monte de solda em forma de montanha (figura 7.17), remova o ferro de solda e
pronto! Você descobrirá com o tempo que o tipo de solda naturalmente “quer” fluir para
aquela forma de vulcão.
Figura 7.17. Uma conexão bem soldada se assemelha a um pequeno vulcão de solda.
UAU! e-book
www.wowebook.org
Soldar não é complicado, mas pode levar algumas rodadas para acertar. O YouTube e a web são
seus amigos: existem muitos vídeos e tutoriais para aprender a soldar.
É uma daquelas habilidades que podem ser mais fáceis de entender se você a observar em movimento.
O tutorial “ThroughHole Soldering” do SparkFun é claro e direto (http://mng.bz/cv1Z).
Desafios comuns para iniciantes em soldagem
Como qualquer nova habilidade física, a soldagem leva um tempo para dominar. Aqui estão
algumas das coisas comuns que podem atrasá-lo:
Uma pistola de solda que você sabe que está quente não parece “querer” derreter a solda
ou “simplesmente não parece funcionar”— Certifique-se de manter a ponta do seu ferro de
solda estanhado, isto é, revestido com apenas um pouco de solda. Você pode dizer que uma
ponta está enlatada porque ela ficará brilhante. Se a ponta do seu ferro de solda for preta
ou com textura fosca, ela está oxidada e você precisa retiná-la. Esse processo pode ser
tedioso: você precisa derreter a solda para cobrir a ponta, mas as partes não estanhadas da
ponta não causam a reação química que faz com que a solda flua corretamente. Tome seu
tempo, seja paciente e faça isso direito, usando sua esponja para ajudar a direcionar a solda e
limpar o excesso. A melhor maneira de corrigir isso é evitar que isso aconteça: verifique o
ferro após cada algumas juntas soldadas e retoque a ponta com alguma solda adicional se
começar a parecer oxidada em qualquer ponto. Observe que a solda sem chumbo fará com
que seu ferro de solda oxide consideravelmente mais rápido do que com chumbo
solda.
Placas enegrecidas, empenadas ou chamuscadas— A solda não danifica os

componentes se você não aplicar muito calor, mas é muito fácil estragar isso tocando o ferro de
solda na placa (em vez das conexões de metal), usando também uma configuração de
temperatura alta, segurando o ferro por muito tempo contra um componente e WOW! e-book
www.wowebook.org
breve. Você ficará melhor nisso com a prática. Freqüentemente, placas ou componentes
com aparência chamuscada ainda funcionarão bem, mas às vezes você pode descobrir que
realmente fritou alguma coisa. Vá devagar, mire com cuidado e experimente suas primeiras tarefas de
soldagem em componentes baratos, apenas por precaução.
Juntas soldadas não funcionam direito — Uma junta sem solda suficiente (uma “junta fria”) não
conduz — conecte seu ferro de solda novamente e tente novamente. Outro problema comum é
acidentalmente usar muita solda e soldar a conexão a uma conexão vizinha também,
causando vários problemas com o circuito. Uma superabundância de solda pode ser limpa com pavio
de solda.
A solda simplesmente não gruda no que você está tentando colar— Soldar é um processo químico.
Você não pode soldar em superfícies não metálicas como plásticos, e mesmo alguns metais não
podem ser soldados.
7.3.4. Construindo o circuito GPS

Uma vez que os pinos de cabeçalho são soldados na placa de fuga do GPS, construir o circuito é um piscar
de olhos. Conecte o GPS na protoboard. Conecte a alimentação e o GND aos pinos 5 V e GND do Uno,
respectivamente. Conecte o pino TX da placa ao pino 11 do Uno, e o RX ao pino 10 (figura 7.18).
Figura 7.18. Diagrama de fiação do circuito GPS
UAU! e-book
www.wowebook.org
Lendo dados de GPS com Johnny-Five
O código necessário é incrivelmente simples. Em seu diretório de trabalho JohnnyFive, crie

um novo arquivo chamado gps.js e adicione o seguinte código.
Listagem 7.2. Johnny-Five GPS
UAU! e-book
www.wowebook.org

board.on('ready', function () { const gps = new

five.GPS([11, 10]); 1
board.repl.inject({ gps: gps 2
});
});
1 O serial de software é suportado nesses pinos - e somente nesses pinos - no Uno.
2 Disponibiliza o objeto GPS (gps) no REPL
Assim que a placa GPS estiver conectada à energia, ela começará a tentar obter uma posição de satélite.
Até que seja corrigido, você verá um LED integrado piscar cerca de uma vez por segundo.
O GPS tem uma antena embutida, mas não será capaz de obter uma posição de satélite sem exposição
a uma ampla fatia do céu. Muito provavelmente, você precisará sair. Com sorte, esse requisito não será muito
complicado - pegue seu laptop, Uno e breadboard e vá para o ar livre por alguns minutos. Então,
novamente, estava 24 graus (F) fora e cuspindo bolas de neve quando testei este código. Ou talvez você
esteja trabalhando em um computador de mesa, que não será adequado para ambientes externos.
Você pode ter sorte ao lado de uma grande janela com uma visão clara do céu ou pode usar um cabo USB mais
longo para que o Uno e a breadboard possam ficar do lado de fora enquanto o computador está dentro.
Demora cerca de 30 a 60 segundos para obter uma posição de satélite sólida (“coldstart”).
“Mas espere”, você diz, “meu telefone pode obter minha posição GPS em apenas alguns segundos... e funciona
por dentro. O que da?"
Seu smartphone usa alguns truques extras para derivar sua localização: onde está em relação a torres de
telefonia celular locais e redes Wi-Fi próximas. Na verdade, para o seu telefone obter um bloqueio de GPS real
- do tipo satélite - pode demorar tanto ou mais do que esses chips autônomos - até vários minutos.
Uma vez que seu chip GPS tenha uma posição de satélite, o LED integrado parará de piscar tão rapidamente,
diminuindo para uma piscada a cada 15 segundos. Não importa quando você inicia o script gps.js - antes que o
chip seja corrigido ou depois - mas, obviamente, os dados de localização não serão
UAU! e-book
www.wowebook.org
disponível até que a correção seja sólida:
$ node gps.js
Supondo que você tenha uma correção, agora você pode começar a interagir com seu GPS e desconectar dados,
conforme mostrado na listagem a seguir.

1479058388413 Repl inicializado >> gps.latitude
42.38
>>
Tudo bem, legal - quase fácil demais! Você pode tentar inspecionar outras propriedades em seu objeto gps, como
longitude. Consulte a documentação do JohnnyFive GPS para obter as informações mais recentes sobre o que você
pode fazer (http://johnnyfive.io/api/gps/).
Legal. Você dominou a conectividade serial assíncrona básica usando serial de software.
Vamos ver o que mais o serial pode fazer.
7.4. COMUNICAÇÃO SERIAL SÍNCRONA
Serial assíncrono é direto e útil, mas não é o ajuste certo para tudo. Para levar em conta pequenas diferenças
potenciais nos relógios de cada um dos componentes, cada bloco de dados deve ser cercado por bits de início e
parada, e talvez um bit de paridade também seja inserido. Essa é uma sobrecarga considerável: na melhor das
hipóteses (um bit de início, um bit de parada, sem paridade), são necessários 10 bits para transmitir 8 bits de informação.
O hardware UART é complexo e as implementações de software são mais lentas e exigem muito do processador. Obter
a taxa de transmissão e outros detalhes classificados entre os componentes pode ser complicado. Finalmente, a serial
assíncrona é realmente cortada apenas para permitir que dois dispositivos se comuniquem.
Protocolos seriais síncronos adicionam uma linha de relógio compartilhada além de conexões de dados para sincronizar
componentes. Como o sinal do clock determina a velocidade da transmissão de dados, a taxa de dados dos
componentes não precisa ser configurada antecipadamente.
Certos protocolos seriais síncronos também tornam possível e conveniente a comunicação entre muitos
dispositivos no mesmo barramento de comunicação. Também existem desvantagens; por exemplo, os protocolos SPI
2
e IC que você está prestes a conhecer exigem que os fios de conexão sejam curtos - por exemplo, você não pode se
2
comunicar razoavelmente usando IC em um cabo de 20 pés.
UAU! e-book
www.wowebook.org
Serial Peripheral Interface (SPI) é um protocolo serial síncrono originalmente desenvolvido pela
Motorola na década de 1980. Ele permite que um dispositivo “mestre” controle e coordene a
troca de dados entre ele e um ou mais dispositivos “escravos”. Para uma conexão mestre-escravo
um-para-um, apenas três fios podem ser usados (figura 7.19), mas quatro ou mais são necessários
se houver vários dispositivos escravos (figura 7.20).
Figura 7.19. Em uma configuração SPI simples - um mestre, um escravo - apenas três fios podem
ser usados para troca de dados: uma linha de relógio compartilhada (SCK) gerenciada pelo
mestre, mestre-saída-escravo-entrada (MOSI) e mestre-escravo. in-slave-out (MISO).
Figura 7.20. Quando mais dispositivos são adicionados, pelo menos uma linha adicional—
slave select (SS)—é necessária, embora algumas configurações SPI exijam uma linha SS por
dispositivo escravo.
UAU! e-book
www.wowebook.org
A maior vantagem do SPI é que ele permite taxas de transmissão de dados realmente rápidas. O
hardware de recebimento também é significativamente mais simples que um UART. Os cartões de memória
SDCard são um exemplo popular de uso do protocolo SPI no mundo real.
Os componentes SPI estão amplamente disponíveis para criadores de hobby. JohnnyFive tem suporte para
um determinado barômetro SPI, por exemplo. Além disso, trabalharemos com um módulo LCD (Nokia 5110)
no capítulo 10 que possui uma interface SPI. Mas os componentes SPI não são tão comuns quanto o
2
protocolo bighitter: I C. É onde colocaremos nossa atenção.
Um aparte sobre a terminologia
Não sou fã da terminologia arcaica masterslave para descrever certas metáforas em eletrônica e ciência
da computação. Mas é totalmente difundido em protocolos seriais - por exemplo, é embutido em
acrônimos como MOSI e MISO. Assim, estou usando a linguagem mestre-escravo aqui, relutantemente, pois
fazer o contrário poderia levar a confusão.
Observe também que nessas discussões sobre diferentes configurações seriais, o hardware serial da placa
de desenvolvimento está desempenhando o papel de “mestre” e os dispositivos conectados são os

“escravos”.
2 7.4.2. CI
2
InterIntegrated Circuit (mais comumente escrito como IC, pronunciado “IsquaredC”) é um protocolo serial
síncrono criado pela Philips Semiconductor (que agora é NXP).

2
Embora não seja tão rápido quanto o SPI, o IC compensa isso com flexibilidade e simplicidade - apenas dois
fios (figura 7.21)!
2
Figura 7.21. Não importa quantos dispositivos estejam conectados juntos, com IC
sempre há apenas duas linhas: SCL (relógio) e SDA (dados).
UAU! e-book
www.wowebook.org
2
Com IC, você pode ter até, oh, cerca de mil dispositivos em um único barramento (1008 se você usar endereçamento
de 10 bits; o endereçamento de 7 bits mais comum permite até 127). Isso significa que você está de volta à
simplicidade de conexão da serial assíncrona - fios mínimos - mas obtém os benefícios da serial sincronizada - vários
dispositivos e nenhuma configuração avançada.
Todos os dados de todos os componentes conectados são transportados em uma única linha SDA (dados seriais).
O segundo fio é o SCL (relógio serial), que, assim como o SDA, é compartilhado por todos os componentes
conectados. Conecte cada dispositivo às linhas SDA e SCL (e dê a eles um pouco de energia!), e você está
pronto para começar.
2
Como os dispositivos IC conversam entre si
2 2
Como geralmente há muitos componentes IC no mesmo barramento, as mensagens IC precisam ser mais
estruturadas e algo precisa assumir o controle do tráfego direcionado. Um ou mais dispositivos mestres no
barramento possuem esta autoridade. O mestre ativo (pode haver mais de um dispositivo mestre em um barramento,
mas apenas um pode estar ativamente no comando em um determinado momento) gera o sinal de clock e informa
aos outros dispositivos quando transmitir ou receber

dados.
Para dar o pontapé inicial, o mestre ativo primeiro transmite um quadro de endereço (primeiro quadro à esquerda na
figura a seguir) para determinar qual dispositivo escravo conectado precisa

UAU! e-book
www.wowebook.org
executar a ação subsequente.
2
Estrutura de alto nível de quadros IC
Cada dispositivo conectado no barramento tem seu próprio endereço exclusivo. Normalmente, este é um
endereço de 7 bits, e o quadro de endereço completo (8 bits) consiste em 7 bits de endereço seguidos
por um bit R/W (leitura/gravação). O bit R/W designa se o dispositivo indicado deve ler ou escrever dados.
Espera-se então que o dispositivo endereçado transmita um único bit ACK para indicar que todos os
sistemas estão ativados. Então quadros de dados podem ser transmitidos, cada quadro seguido por
um bit ACK. Tudo isso é coreografado pelo sinal de clock compartilhado.
Os prós e contras dos detalhes do protocolo são um pouco mais complicados - por exemplo, você
precisaria usar endereços de 10 bits para exercitar o barramento máximo de 1008 dispositivos (números de 7 bits
não ultrapasse 127 e cada dispositivo precisa ter um endereço único) e a mecânica exata de um
processo readfromslave requer a identificação de coisas como de qual registro de memória ler. Se
2
você quiser aprender mais, recomendo o tutorial “IC” do Sparkfun (https://learn.sparkfun.com/tutorials/i2c).
2
Muitos dispositivos IC são fornecidos com endereços definidos por hardware. Isso significa que você não
pode alterar o endereço do dispositivo: se você tiver outro dispositivo com o mesmo endereço (com fio),
não poderá colocá-los no mesmo barramento. Mas alguns dispositivos têm configurações configuráveis
endereços.
2
7.4.3. Fazendo uma bússola digital com um magnetômetro IC
UAU! e-book
www.wowebook.org
1 magnetômetro HMC5883L (bússola) 5 placa V-friendly, como

Adafruit
Fios jumper vermelho, preto, amarelo e branco
2
O Honeywell HMC5883L é um popular chip de magnetômetro de eixo triplo IC - ou seja, uma bússola
- disponível em uma placa de fuga amigável de 5 V da Adafruit. Determinar sua orientação está a
momentos de distância, combinando a classe Compass de JohnnyFive com um quadro de fuga
centrado no chip Honeywell.
Você terá que exercitar suas habilidades de solda novamente - a placa de separação precisará ser
soldada nos pinos de cabeçalho (figura 7.22) antes de encaixar em uma placa de ensaio.
Figura 7.22. A placa de fuga da bússola, como a fuga de GPS, precisará ser
soldada nos pinos de cabeçalho.
Cuidado com as tensões de operação!
Placas breakout para o HMC5883L estão disponíveis em vários revendedores de eletrônicos,

mas certifique-se de que a placa escolhida pode tolerar 5 V. Muitas, incluindo a variante do
Sparkfun, são feitas para tensões de nível lógico de 3,3 V. Conectando uma bússola de 3,3 V
ao 5 WOW!
A potência V e as saídas de pinos podem fritar o chip. A placa breakout HMC5883L da Adafruit tem
um regulador de energia integrado, o que a torna segura para fornecer de 3 a 5 V DC — é o chamado
componente “5 Vsafe”. Embora existam maneiras de fazer com que os componentes de
3,3 V funcionem com segurança com uma placa de 5 V como o Uno, isso requer algumas etapas e
hardware extras; portanto, por enquanto, certifique-se de ter uma placa de 5 V compatível.
Tal como acontece com a placa breakout do GPS, uma vez que os cabeçalhos são soldados, a fiação
é simples para este circuito: conecte o pino SDA da placa breakout ao pino A4 do Uno e o SCL ao
pino A5 do Uno. Conecte o VIN à alimentação de 5 V do Arduino e conecte o pino de aterramento
ao GND (figura 7.23).
Figura 7.23. Diagrama de fiação para bússola
UAU! e-book
www.wowebook.org
2
Suporte de hardware IC no Arduino Uno
Observe que os números dos pinos para este circuito não são arbitrários: os pinos Uno A4 e
2
A5 têm suporte de hardware para IC; outros pinos não. O pino A4 do Uno fornece SDA; A5 é SCL.
A classe Compass do JohnnyFive suporta vários chips diferentes, portanto, você precisará informá-
lo, durante a instanciação, qual controlador específico usar; consulte a listagem 7.4. A
documentação do JohnnyFive Compass identifica os componentes suportados (http://
johnnyfive.io/api/compass/). Você não precisa definir em quais pinos a bússola está
UAU! e-book 2
www.wowebook.org
Machine Translated by Google 2
conectado, pois há apenas uma maneira de conectar dispositivos IC à placa Uno (pinos A4 e A5).
Listagem 7.4. Instanciando uma bússola com um controlador específico
const compass = new five.Compass({ controller: 'HMC5883L' });
Usar uma opção de controlador para diferenciar entre diferentes hardwares suportados é um padrão
comum em muitas das classes de componentes do JohnnyFive. Você o viu pela primeira vez no capítulo
4, com o sensor de temperatura analógico TMP36.
Dentro do diretório de trabalho JohnnyFive, crie um arquivo chamado compass.js, conforme mostrado
na listagem a seguir.
Listagem 7.5. compass.js: lendo dados HMC5883L com Johnny-Five

board.on('ready', () => { const compass =

new five.Compass({ controller: 'HMC5883L' }); 1
compass.on('mudar', () => { 2
console.log(compass.bearing); 3
});
});
1 Instancia uma bússola para o chip HMC588L
2 As instâncias do objeto Compass, como a maioria dos outros objetos do componente J5, possuem
um evento change.
3 A propriedade rumo é um objeto com informações sobre a orientação da bússola.
Agora execute o script:
$ node compass.js
Depois que a placa e o REPL inicializarem, você verá a saída em seu terminal como esta:
$ node compass.js
UAU! e-book
www.wowebook.org
>> { nome: 'East', abreviatura: 'E', baixa: 84,38, alta: 95,62, proa: 94 }
{ nome: 'Leste', abreviatura: 'E', baixa: 84,38, alta: 95,62, proa: 91 }
Cada objeto de rumo que está sendo registrado contém várias propriedades (abbr, cabeçalho e assim
por diante). Essa bússola digital seria mais inteligente se tivesse uma saída — faremos uma agora.
7.5. JUNTOS: WIDGET MULTISENSOR DE AGIR PARA MUDAR
2
Este próximo experimento combina vários sensores IC juntos e exibe a saída em um LCD. Existem
sensores suficientes aqui que é difícil exibir toda a saída de uma vez no LCD, então usaremos um
acelerômetro para criar um recurso de exibição shaketoswap. Ao agitar o dispositivo, você pode
alternar quais dados são exibidos no LCD: uma tela com dados de temperatura e pressão ou uma
tela com o rumo atual da bússola.
2
Os pinos A4 e A5 são os únicos pinos compatíveis com IC no Arduino Uno, mas tudo bem - o
2
protocolo IC permite um monte de dispositivos em um único barramento. Ou seja, você pode controlar
2
vários dispositivos IC usando apenas esses dois pinos.
1 HMC5883L (bússola) 5 Placa de suporte Vfriendly, como a da Adafruit

2
1 LCD 16x2: LCD IC paralelo ou compatível com JohnnyFive, como o JHD1313M1
compatível com Grove
2
Placa de fuga Adafruit 5 Vready BMP180 (temperatura IC, sensor de pressão atmosférica)
Acelerômetro de eixo triplo Adafruit ADXL345
Fios de jumper
2 breadboards de tamanho médio ou 1 breadboard de tamanho normal
Misturar e combinar sensores

UAU! e-book
www.wowebook.org
As especificações do código e da fiação deste experimento são baseadas nos itens mencionados na lista
2
de suprimentos, mas você pode misturar e combinar outros IC compatíveis com JohnnyFive
sensores:
Outros sensores “múltiplos” (combinando temperatura, pressão, altímetros e, às vezes, umidade):

BME 280, BMP 280, HTU21D e assim por diante. Veja o JohnnyFive “Multi”
2
Página da API para mais dispositivos IC suportados: http://johnnyfive.io/api/multi/.
Outros acelerômetros. Consulte a página da API "Accelerometer" do JohnnyFive para obter

2
mais acelerômetros I C suportados: http://johnnyfive.io/api/accelerometer/.
Obviamente, você precisará adaptar os exemplos de código para usar os controladores corretos para o
hardware escolhido.
Observe que a maioria desses sensores vêm em placas de fuga que exigem que você solde os pinos
de cabeçalho.
2
Se você tem um IC LCD compatível com JohnnyFive, como o módulo LCD Grove RGB, está com
2
sorte: é muito fácil conectar LCDs IC. Um LCD paralelo também funcionará bem neste circuito, mas,
como você sabe, requer muito mais fios.
7.5.1. Passo 1: combinando uma bússola com saída LCD

O diagrama de fiação na figura 7.24 mostra como orientar a bússola e o LCD em duas breadboards.
(Conforme você adiciona sensores a este projeto, não haverá espaço suficiente em uma única
breadboard.)
Por que não usar o GPS neste experimento?
Usar o GPS breakout neste projeto de sensor combinado parece ser uma boa ideia. No entanto, o
suporte JohnnyFive para serial de software é relativamente novo e algumas das complicações da
implementação de serial de software significam que pode ser difícil prever quantos dados um sensor
irá comunicar (a troca de dados não é estruturada como IC a esse respeito ). Por causa disso, no
2
momento da redação deste artigo, combinar um GPS com outros sensores ou saída pode causar
problemas de lixo com a exibição do LCD e outros comportamentos imprevisíveis.
Figura 7.24. Diagrama de fiação, etapa 1. Os fios na breadboard com a bússola breakout
board são dispostos para dar espaço para os sensores que serão
UAU! e-book
adicionado mais tarde.
www.wowebook.org
adicionado mais tarde.
Configurando a declinação magnética para melhor precisão
Uma coisa que gosto de fazer com os rumos da minha bússola é corrigi-los para minha declinação
magnética local. Uma bússola sempre dará leituras relativas ao norte magnético, que está em lugares
diferentes em relação ao norte verdadeiro (geográfico), dependendo de onde você está na superfície
da terra. Na minha localidade, o norte verdadeiro está a cerca de 14 graus a oeste do norte magnético -
ou seja, há uma declinação magnética aqui de -14,28 graus. Você pode encontrar sua declinação
magnética visitando www.magneticdeclination.com—a usaremos em
o código do dispositivo.
Construindo o código multisensor
Crie um script chamado multisensor.js e comece com este código de configuração.
Listagem 7.6. multi-sensor.js: configuração
DECLINAÇÃO const = 14,28; 1
const UPDATE_FREQ_MS = 1000; 2 var lastDisplay = nulo; 3 WOW! e-book

www.wowebook.org
1 Sua declinação magnética local: este deve ser o valor de

www.magneticdeclination.com.
2 Com que frequência atualizar a exibição do LCD
3 Mantém o controle da última coisa exibida no LCD
Em seguida, adicione uma função auxiliar para corrigir as leituras da bússola para a
declinação local. A aritmética na função de correção de declinação a seguir garantirá que o valor
retornado seja uma medida de grau válida entre 0 e 360.
Listagem 7.7. multi-sensor.js: corrigindo a declinação
function correctForDeclination (cabeçalho, declinação) { 1

var corrigido = direção + declinação; // Lembre-se: a declinação pode ser negativa
corrigido += 360; 2
enquanto (corrigido >= 360) { 3
corrigido = 360;
}
retorno corrigido;
}
1 Esta função corrige um cabeçalho (Número) para declinação local.
2 Garante que o valor corrigido seja positivo
3 Subtrai unidades de 360 (graus) do valor corrigido até que seja menor que 360
E agora, uma função auxiliar de formatação para formatar a exibição das leituras feitas pelos
sensores do projeto. Nesta primeira rodada, mostrada na listagem a seguir, ele formatará uma
propriedade de cabeçalho - iremos preenchê-la em breve com os dados da bússola.
Listagem 7.8. multi-sensor.js: formatação de exibição para a direção da bússola
função formatDisplay (leituras) { 1

var displayLine1, displayLine2; displayLine1 =
'HEADING: '; displayLine2 =
Math.round(readings.heading) + ':circle:'; 2 return [displayLine1, displayLine2];
1 Pega um objeto de leitura e retorna o que exibir em cada um dos

UAU! e-book
www.wowebook.org
As duas linhas do LCD
2 :círculo: é um caractere especial que pode ser exibido no LCD.
Agora, vamos terminar esta rodada de código.
Listagem 7.9. multi-sensor.js: exibindo a direção da bússola
/* ... */
function correctForDeclination (cabeçalho, declinação) { /** ... **/ } function formatDisplay (leituras) { /** ...
**/ }
const compass = new five.Compass({ controller: 'HMC5883L' }); const lcd = new five.LCD({ pins: [7, 8, 9, 5,
6, 12] }); 1
lcd.useChar('círculo'); 2
atualização de função () {
var display = formatDisplay({ título:
correctForDeclination(compass.heading, DECLINATION), 3
});
if (!lastDisplay || (lastDisplay.join('') != display.join(''))) { 4
lcd.clear();
lcd.cursor(0, 0).print(display[0]);
lcd.cursor(1, 0).print(display[1]);
últimaExibição = exibição; 5
}
}
board.loop(UPDATE_FREQ_MS, atualização);6 });
1 Instancia um LCD paralelo
2 Diz ao LCD para usar o caractere de círculo especial (para um marcador de grau)
3 Corrige a leitura da bússola para declinação e preenche as leituras.cabeçalho com

o resultado
4 O valor exibido mudou? Em caso afirmativo, atualiza o LCD.
5 Mantém o controle da última coisa exibida
6 Configura um loop para chamar a atualização a cada UPDATE_FREQ_MS

milissegundos (1000 ms, neste exemplo)
Verificando apenas os dados a cada segundo (frequência do loop da placa) e apenas reimprimindo
no LCD se os dados forem alterados, o desempenho é aprimorado e a oscilação excessiva do LCD é
UAU! e-book
www.wowebook.org
evitado.
Experimente:
$ node multisensor.js
Você deve ver uma bússola em seu LCD - ajustada para declinação magnética e arredondada para o grau completo
mais próximo. Ele deve ser atualizado a cada segundo conforme a bússola é reorientada.
7.5.2. Etapa 2: adicionar um multissensor ao dispositivo
A classe multicomponente do JohnnyFive destina-se a dispositivos como o BMP180, que combinam vários
sensores em um único pacote. A Figura 7.25 mostra a placa de breakout BMP180 da Adafruit , que contém
sensores de temperatura e pressão atmosférica.
Como o GPS e a bússola, a placa BMP180 precisa ser soldada nos pinos de cabeçalho
antes de usar em uma breadboard.
Figura 7.25. Placa de fuga BMP180 da Adafruit
Um objeto Multi se comporta como um contêiner para vários componentes do sensor e permite
que você interaja com eles de maneira coordenada. Cada sensor contido é mapeado para sua
própria classe de componente J5 apropriada. Por exemplo, o objeto instanciado como
const multi = new five.Multi({ controlador: 'BMP180' });
conterá as seguintes propriedades de instância:
UAU! e-book
www.wowebook.org
termômetro—Uma referência a uma instância do JohnnyFive Thermometer para o
sensor de temperatura
barometer—Uma referência a uma instância JohnnyFive Barometer para a pressão

sensor
2
O BMP180 usa IC para comunicação, ou seja, você pode conectá-lo à linha SDA e SCL
compartilhada já em uso pela bússola (figura 7.26).
Figura 7.26. Diagrama de fiação para adicionar o breakout BMP180 ao circuito
7.5.3. Passo 3: atualizar o display para mostrar temperatura e pressão

Exibir a temperatura, a pressão atmosférica e a direção da bússola ao mesmo tempo
sobrecarrega o espaço de caracteres limitado de 16x2 no LCD. Seria melhor
dividirmos a exibição em duas telas: uma para exibir temperatura e pressão e outra
para mostrar a direção da bússola. Em nossa primeira versão, não haverá como
alternar entre as duas telas - apenas mostrará temperatura e pressão - mas voltaremos
a isso em alguns momentos.
Primeiro, adicione mais uma variável perto do topo do arquivo:

UAU! e-book
www.wowebook.org
var AltDisplay = false;
Essa é uma maneira simplista de ajudar o programa a determinar qual tela - temperatura e pressão
ou rumo da bússola - exibir.
Agora, atualize a função de formatação de exibição, mostrada na listagem a seguir.
Listagem 7.10. multi-sensor.js: atualizando a formatação do display
função formatDisplay (leituras, altDisplay) { 1
var displayLine1, displayLine2;

if (altDisplay) { 2
displayLine1 = 'TÍTULO: ';
displayLine2 = Math.round(readings.heading) + ':círculo:';

} outro {
displayLine1 = 'TEMP/PRESSÃO:';
displayLine2 = leituras.temperatura.toFixed(1) + ':círculo:F'; displayLine2 += ' / ' + Math.round(10 * leituras.pressão) + 'mb'; 3
return [displayLine1, displayLine2];

}
1 Atualização para obter um parâmetro altDisplay (booleano).
2 Esta ramificação nunca será executada nesta versão do código (é sempre falsa).
3 A pressão está em kPa; multiplique por 10 e arredonde para obter milibares mais
familiares
Em seguida, atualize o callback pronto da placa: instancie um sensor Multi e passe mais
propriedades para a função displayformatting, conforme mostrado na listagem a seguir.
Listagem 7.11. multi-sensor.js: atualizando o callback pronto da placa
const compass = new five.Compass({ controller: 'HMC5883L' });
const lcd = new five.LCD({ controlador: 'JHD1313M1' });
const multi = new five.Multi({ controlador: 'BMP180' }); 1
lcd.useChar('círculo');
function update() { var display =
formatDisplay({
temperatura: multi.thermometer.F, 2
cabeçalho : correctForDeclination(compass.heading, DECLINATION),

pressão : multi.barometer.pressure 3 WOW! e-book www.wowebook.org
},
AltDisplay); 4
if (!lastDisplay || (lastDisplay.join('') != display.join(''))) {
lcd.clear();
lcd.cursor(0, 0).print(display[0]); lcd.cursor(1, 0).print(display[1]);
últimaExibição = exibição;
}
}
board.loop(UPDATE_FREQ_MS, atualização);
});
1 Instancia um objeto Multi para o BMP180
2 Adiciona uma propriedade de temperatura do valor de temperatura do BMP180,

em Fahrenheit
3 Adiciona uma propriedade de pressão do sensor de pressão do BMP180
4 Passa o valor altDisplay (atualmente sempre falso)
Agora tente algumas coisas:
Você deve ver a temperatura e pressão atuais na tela do LCD (mas não o rumo da bússola).
7.5.4. Passo 4: adicionando um recurso de exibição shake-to-swap com um acelerômetro
Acelerômetros medem mudanças de aceleração e orientação. Ao monitorar um

acelerômetro para aceleração - forças que excedem 1 G - você pode criar um tremor
para alterar o recurso de exibição.
A placa de breakout do acelerômetro de eixo triplo ADXL345 da Adafruit (figura 7.27) é um

2
componente de acelerômetro amigável de 5 V que fornece interfaces IC e SPI.
Embora as conexões da placa suportem ambos os protocolos seriais, o suporte do JohnnyFive
2
para ela usa a interface IC (somente).
Figura 7.27. A placa de acelerômetro

2 de eixo triplo ADXL345 da Adafruit.
Ele pode ser conectado a um barramento IC (através dos pinos SDA e SCL) ou, com alguns pinos fazendo
dupla função conforme observado na imagem, uma configuração SPI de quatro fios (através dos pinos CS,
SDO, SDA e SCL).
UAU! e-book
www.wowebook.org
Adicione o acelerômetro ao circuito (figura 7.28) depois de soldá-lo nos pinos de cabeçalho,
conectando-se às linhas SDA e SCL compartilhadas na breadboard.
Figura 7.28. Diagrama de fiação para adicionar o acelerômetro ao circuito
UAU! e-book
www.wowebook.org
A classe JohnnyFive Accelerometer fornece suporte para, você adivinhou, acelerômetros
(classes de componentes J5 provavelmente estão começando a parecer velhas).
Para implementar o recurso de exibição shaketoswap, vincularemos o evento de aceleração da
instância Accelerometer, que é disparado quando a leitura de aceleração do dispositivo é alterada, e
verificamos se ele excede um limite aproximado que sugere um movimento rápido e semelhante a um tremor.
movimento.
Edite o seguinte código.
Primeiro, adicione variáveis adicionais perto do topo do arquivo para definir um limite de vibração (em
Gs) e para acompanhar a última vibração detectada, para fins de debounce:
const SHAKE_THRESHOLD = 1,15; var

lastJiggleTime = nulo;
Detecção e eliminação de “tremores”
UAU! e-book
www.wowebook.org
O evento de aceleração de um objeto Accelerometer é acionado sempre que a leitura da
aceleração muda. Em experimentos grosseiros e não científicos, descobri que um limite
razoável para o que deve ser registrado como uma vibração é de cerca de 1,15 G. Se você achar
que isso é muito sensível ou requer uma vibração muito enérgica, você pode ajustar o limite no código.
Um movimento da vida real, como um tremor, gera valores de aceleração flutuantes durante
o período de várias leituras do dispositivo. Ou seja, vários eventos de aceleração sequencial
são disparados em um curto espaço de tempo, várias vezes, com leituras que excedem o limite.
Se implementássemos a troca para alternar exibições cada vez que o acelerômetro
relatasse aceleração acima do limite, a exibição piscaria descontroladamente para trás e
adiante.
Em vez disso, precisamos evitar a troca, evitando que ela ocorra com muita frequência. Podemos
fazer isso acompanhando a última vez que a exibição foi trocada e certificando-nos de não trocá-
la com mais frequência do que, digamos, uma vez por segundo.
Dentro do callback pronto, instancie o acelerômetro:
const accel = new five.Accelerometer({ controller: 'ADXL345' });
Também dentro da função de retorno de chamada pronto, adicione um manipulador para o evento de aceleração,
Listagem 7.12. multi-sensor.js: manipulador de aceleração
accel.on('aceleração', () => {
if (accel.acceleration > SHAKE_THRESHOLD) { 1 var jiggleTime = Date.now(); if (!lastJiggleTime ||
jiggleTime > (lastJiggleTime + 1000)) { 2
altDisplay = !altDisplay; 3
lastJiggleTime = Date.now(); 4
atualizar(); 5
}
}
});
1 Se o valor atual da propriedade de aceleração exceder o limite G...
2 Se o display não foi trocado nos últimos 1000 ms...

UAU! e-book
www.wowebook.org
3 Inverta o valor de altDisplay.
4 Acompanhe a hora em que a troca ocorreu.
5 Atualize a exibição.
Está feito! Correr.
Inicialmente, você deve ver as informações de temperatura e pressão exibidas no LCD. Pegue a
breadboard com os sensores e dê uma sacudida rápida: você deve ver o LCD mudar para a exibição
da bússola.
A essa altura, é provável que você tenha notado um elefante na sala. Você acabou de construir um
dispositivo parecido com orientação... que está conectado por um cabo ao seu laptop ou
computador. O Arduino e seus componentes anexados são inúteis sem o poder de computação na
máquina host – é onde o processo Node.js é executado. Esta é, obviamente, uma configuração
bastante ridícula para caminhar pela floresta. Da mesma forma, o robô que você construiu no capítulo
6 só pode se mover até onde o cabo USB permitir.
É hora de se libertar. No próximo capítulo, começaremos a desvincular nossos projetos e liberá-

los.
2
Trocando em um IC LCD: um estudo de caso
A fiação para o circuito do sensor combinado está lotada, exigindo duas placas de ensaio.
2
Na chance de você ter um display LCD habilitado para IC por aí (eu tinha), você pode usá-lo em vez do
2
paralelo. Usei um LCD IC compatível com Grove (número de peça, JHD1313M1). Grove é um
sistema de componentes feito pelo Seeed Studio que todos compartilham conectores comuns -
mas, infelizmente, esses conectores não são compatíveis com headers ou breadboards. Você
pode comprar adaptadores de conectores, mas, no meu caso, fiz algumas cirurgias caseiras:
cortei o conector na extremidade e soldei os quatro fios trançados (VCC, GND, SCL e SDA, como
2
qualquer outro dispositivo IC) à conexão solidcore fio que encaixava mais facilmente em uma placa
de ensaio.
2
O circuito resultante libera um monte de pinos Uno e é muito mais simples no geral. O IC é um protocolo
ideal para reduzir o número de pinos de E/S da placa de desenvolvimento física necessários para
suportar os componentes do seu projeto.
UAU! e-book
www.wowebook.org
2
Diagrama de fiação usando o componente Grove IC LCD. Ele pode compartilhar o mesmo SDA e
Linhas SCL como os outros sensores conectados.
A única alteração no código de orientação está na instanciação do LCD. Em vez disso,
const lcd = new five.LCD({ pinos: [7, 8, 9, 5, 6, 12] });
usa isto:
const lcd = new five.LCD({controlador: 'JHD1313M1'});
RESUMO
Embora sinais analógicos simples sejam suficientes para dados básicos do sensor, a leitura de
dados de componentes mais avançados exige uma forma mais estruturada de troca de
informações.
A comunicação paralela é rápida por natureza, mas pode ser complicada. A comunicação
serial - um bit de cada vez - é o método de escolha para troca de dados em
UAU! e-book
www.wowebook.org
eletrônica passatempo.
Serial assíncrono é comum, mas requer que ambos os dispositivos sejam configurados para especificações
de protocolo de antemão e é limitado a dois dispositivos.
TTL (transistortransistor logic) é o tipo de serial assíncrono usado em placas de desenvolvimento.
O hardware UART possibilita a serial TTL rápida nas placas, mas esse tipo de comunicação serial
também pode ser emulada em software (software serial).
Os protocolos seriais síncronos adicionam uma linha de relógio compartilhada ao barramento de comunicação.
SPI é um protocolo que requer três ou quatro fios (dados e relógio); o protocolo IC ainda mais
2
popular requer apenas dois fios.
Os componentes seriais podem ser combinados para criar projetos divertidos e mais poderosos.
Embora apenas dois dispositivos possam trocar dados em uma conexão serial assíncrona (TTL), muitos
2
dispositivos podem ser adicionados aos mesmos barramentos SPI ou IC, permitindo um uso mais eficiente
dos pinos de E/S da placa de desenvolvimento.

2
IC pode suportar até 1008 dispositivos em um único barramento (com endereços de 10 bits). Cada
dispositivo no barramento precisa ter um endereço exclusivo.
O suporte para troca de dados seriais geralmente é fornecido no nível do hardware (a emulação serial de
software é a exceção evidente). Em placas de desenvolvimento, isso geralmente depende do suporte serial
fornecido pelo microcontrolador ou processador.

2
Conexões seriais estão disponíveis apenas em determinados pinos. Para o Arduino Uno, IC é suportado
nos pinos A4 (SDA) e A5 (SCL), SPI nos pinos 10 (SS), 11 (MOSI), 12 (MISO) e 13 (SCK).
UAU! e-book
www.wowebook.org
História
Tópicos
Por que os projetos eletrônicos de hobby precisam de fios e como se livrar deles
Tutoriais
Usando JohnnyFive com diferentes plugins de I/O em diferentes plataformas
Configurando
Ofertas e promoções e trabalhando com a plataforma de desenvolvimento Tessel 2
Adaptação a níveis lógicos de 3,3 V e diferentes configurações de pinos Destaques

Implantação
de código sem fio no Tessel 2
Configurações Aproveitando o ecossistema Node.js e npm para criar um software mais complexo para o Tessel 2 Suporte
Usando baterias para ficar totalmente

sem fio
com o Tessel 2
Sair
1 placa de desenvolvimento Tessel 2
1 cabo USB A para micro USB
1 resistor de 100 V
Qualquer um dos seguintes:
3 pinos de cabeçalho fêmea
2 comprimentos de calibre 22, fio de núcleo sólido
UAU! e-book
www.wowebook.org
Bateria de 9 V e encaixes
Ferro de solda e suprimentos
1 carregador de parede USB 5 V ou similar, para alimentar o Tessel 2
1 bateria USB (às vezes chamada de banco de potência)
Fios de jumper
Robô itinerante (circuito de acionamento do motor e chassi) do capítulo 6
As coisas que estamos construindo estão se tornando mais complexas e poderosas, mas há um fator
limitante: elas estão fisicamente conectadas a um computador. Esses projetos JohnnyFive baseados em
Arduino Uno carecem de independência física - eles são totalmente dependentes de um computador host
para obter instruções lógicas e poder. Para alguns tipos de projetos, essa configuração de hostclient
conectado não é um problema. Mas, para avançar em sua jornada, para criar projetos controlados
por JavaScript, autônomos e autocontidos - para se livrar de fios - você precisará expandir seus horizontes
de hardware.
O microcontrolador ATmega328P usado no Arduino Uno é muito restrito para executar um

UAU! e-book
www.wowebook.org
sistema operacional completo ou executar JavaScript nativamente. Se você quiser controlar o Uno com
JavaScript, precisará usar algo externo e mais poderoso - um host - para executar o JavaScript em
nome da placa.
No host, a lógica do programa JavaScript precisa ser traduzida em instruções

o microcontrolador restrito pode entender. Essas instruções precisam ser
comunicado ao Uno, que atua como um thin client. Da mesma forma, os dados provenientes do Uno
— leituras de sensores e assim por diante — são comunicados de volta ao host para processamento
(figura 8.1).
Figura 8.1. Este esboço do capítulo 1 descreve as comunicações teóricas

host-cliente para um widget de ventilador automático. Em seus experimentos até
agora, o Arduino Uno atuou como um thin client e seu computador como o host.
Com o JohnnyFive, formatar e trocar essas instruções e dados entre o host e o cliente é tarefa da
camada de E/S.
Arduinos, incluindo o Uno, são um caso especial com JohnnyFive: Firmata fornece a camada de E/S e
está disponível por padrão em JohnnyFive. Ou seja, quando você instanciar um objeto Board, a
menos que você diga o contrário (com uma opção), o Firmata (por USB) será usado para E/S. Você
usou essa E/S padrão nos capítulos anteriores.
8.1. POR QUE VOCÊ ESTÁ AMARRADO ATÉ AGORA
Até agora, você usou o tethering USB físico para seus projetos porque a conexão USB
forneceu um meio de troca de E/S e um fornecimento de energia. Para
UAU! e-book
www.wowebook.org
desconecte, você precisa atender a esses requisitos — E/S e energia — de maneiras diferentes, então vamos
nos aprofundar para ver o que está acontecendo nos bastidores.
8.1.1. Troca de dados, camada de E/S e plug-ins de E/S
Embora JohnnyFive defina APIs e o comportamento lógico dos componentes, exatamente como os dados e
instruções são trocados entre um aplicativo JohnnyFive e o hardware é deixado para a camada de E/S. É assim
que o JohnnyFive se mantém agnóstico de plataforma: ele deixa esses detalhes para plug-ins de E/S
compatíveis.
Você não usou nenhum plug-in JohnnyFive I/O até este ponto porque Arduinos comuns, incluindo o Uno, são casos
especiais com JohnnyFive. Quando você instancia objetos Board sem especificar qual E/S usar, JohnnyFive usa
Firmata via USB por padrão – é por isso que “simplesmente funciona”. Ao contrário dos plugins I/O para outras
plataformas, que devem ser instalados individualmente, o Firmata vem com o JohnnyFive (tecnicamente: é uma
dependência). Isso pode fazer parecer que os detalhes de I/O da Firmata e nittygritty fazem parte do código do
JohnnyFive, o que não é realmente o caso. Ao experimentar o JohnnyFive em outras plataformas, você verá que
precisa instalar plug-ins de E/S apropriados. Mais sobre isso daqui a pouco.
Na configuração do seu hostclient JohnnyFive com um Arduino Uno até agora, o cabo USB serve como um
cordão umbilical para a troca de mensagens seriais com formato Firmata.
Essa é uma das razões pelas quais você foi fisicamente amarrado.
8.1.2. USB como fonte de alimentação
Algo tem que alimentar os circuitos em um projeto. A conexão USB que você está usando é uma fonte de alimentação
constante de 5 V. Com exceção de alguns circuitos indutivos - motores e servos, que requerem mais corrente ou
tensão do que a placa de desenvolvimento pode fornecer - você conta com o cabo USB para alimentação e
também para troca de dados.
Alimentação CC para placas de desenvolvimento
O Arduino Uno possui um conector DC interno que você pode usar para conectá-lo a um adaptador DC
alimentado na parede. Essas “verrugas de parede” são onipresentes, convertendo energia CA baseada na parede
em energia CC que tantos eletrônicos desejam.
As verrugas de parede de outrora têm conectores barriljack que podem se encaixar em qualquer coisa, desde
secretárias eletrônicas até suas próprias placas de desenvolvimento, como o Uno.
UAU! e-book
www.wowebook.org
O Uno tem um conector de barril DCin para energia
A maioria das placas de desenvolvimento (incluindo o Uno) possui reguladores de tensão integrados
para suas entradas de energia, o que significa que não há problema em fornecer de 9 V a mais de 20 V
para o Uno via DC, e ele se encarrega de regular isso até os 5 V necessários .
Os reguladores de tensão precisam ser fornecidos com uma tensão maior do que a tensão de saída
desejada. Como com os LEDs, há uma queda de tensão direta no próprio regulador - o circuito de ajuste
de energia na placa consome parte da tensão de entrada. No caso do Uno, para obter 5 V estáveis, são
necessários pelo menos 7 V de entrada.
Qualquer adaptador CC de 9 V–12 V com polaridade positiva central e um plugue de 5,5 mm x 2,5
mm (o tamanho mais comum) é ideal para alimentar o Uno.
Este símbolo indica que o adaptador de energia tem polaridade central positiva. Ou seja, a ponta do
conector tem polaridade positiva e a luva é negativa. A maioria das verrugas da parede DC são de
polaridade positiva central - esse é o tipo que você deseja para alimentar o Uno e, normalmente, outras
placas de desenvolvimento. UAU! e-book
www.wowebook.org
Nem todos os adaptadores têm um símbolo de polaridade impresso neles. É uma pena, porque você
não pode assumir que um determinado adaptador é de polaridade centro-positiva - não há padrão,
embora a polaridade centro-positiva seja mais comum.
Eu mantenho uma coleção de verrugas de parede DC, bem como carregadores USB de 5 V, à mão
para uso em projetos. Há muito órfãos de seus eletrônicos de consumo originais, eles são úteis em sua
segunda vida, fornecendo energia para vários protótipos e projetos.
8.1.3. Opções para comunicação de projeto sem fios

Como você viu, há dois motivos principais pelos quais os projetos têm fios: troca de dados e energia.
Abordaremos o poder momentaneamente, mas vamos primeiro olhar para diferentes maneiras de criar
projetos que não requerem conexões de dados conectadas fisicamente.
Configurações host-cliente sem fio
Certas placas de desenvolvimento com microcontroladores restritos fornecem recursos de
comunicação sem fio, como WiFi ou Bluetooth.
Um host ainda é necessário para executar a lógica do JavaScript, mas os dados e as instruções
podem ser trocados entre o host e o cliente sem fio, eliminando a necessidade de um cabo de dados
USB físico (figura 8.2).
Figura 8.2. Como o Uno, essas placas têm microcontroladores restritos, mas ambos podem se
comunicar sem fio.
A placa Blend Micro, por exemplo, pode ser usada sem fio com JohnnyFive por
UAU! e-book
www.wowebook.org
fazendo uso do plugin blendmicroio I/O e usando o firmware BLEFirmata na placa. Você conhecerá outra
pranchinha compatível com BLE, Espruino's Puck.js, no capítulo 12.
JavaScript incorporado
Outra classe de placas de desenvolvimento possui microcontroladores que variam de restritos a
moderadamente sofisticados e são otimizados para executar JavaScript, algum subconjunto de
JavaScript ou código semelhante a JavaScript nativamente. Os microcontroladores nessas placas não
foram feitos para executar sistemas operacionais completos, mas tendem a ser eficientes em termos de
energia, baratos e pequenos - todas características ideais para sistemas embarcados.
O fluxo de trabalho varia de plataforma para plataforma. Em alguns casos, o JavaScript que você
escreve pode ser compilado para outra coisa (código de nível mais baixo e eficiente) antes de ser atualizado
no dispositivo. Em outros casos, o microcontrolador da placa pode ser capaz de executar diretamente algum
subconjunto de JavaScript — o que significa que você escreve em JavaScript, mas pode não ter acesso a
todos os recursos da linguagem (figura 8.3). Revisitaremos plataformas JavaScript incorporadas e restritas
no capítulo 10.
Figura 8.3. Essa classe de dispositivos combina microcontroladores restritos com

variantes otimizadas de JavaScript e tempos de execução semelhantes a JavaScript.
Exploraremos tanto o Pico quanto o Elemento no capítulo 10.
Controlando um cliente com computadores minúsculos (SBCs)
Os computadores de placa única (SBCs) são capazes de executar uma operação real multitarefa
UAU! e-book
www.wowebook.org
sistema e fornecer uma gama de opções em termos de poder de processamento e suporte a
periféricos integrados. Eles podem fazer muito, incluindo a execução de Node.js, mas eles
consomem mais energia, são mais caros e fisicamente maiores do que outras placas de
desenvolvimento para projetos incorporados.
Com os SBCs, as linhas podem ser confusas entre o computador e a placa de desenvolvimento:
alguns, como a popular série Raspberry Pi, combinam funcionalidade de computação generalizada
com E/S semelhantes a placas de desenvolvimento em uma placa. Isso conta como execução de
lógica incorporada ou é uma variante miniaturizada da configuração do hostclient (com o processador do Pi
servindo como host para controlar a E/S)? As coisas ficam ainda mais complicadas porque você pode, por
exemplo, usar um Raspberry Pi para controlar um Arduino conectado a uma das próprias portas USB
do Pi - uma configuração de mini hostclient. Veremos mais SBCs no capítulo 11.
8.2. RUMO A PROJETOS SEM FIOS USANDO O TESSEL 2
O Tessel 2 (https://tessel.io/) é uma plataforma de desenvolvimento de código aberto (tanto o
hardware quanto o software são de código aberto) centrada no Node.js e no gerenciador de pacotes
npm (figura 8.4). Além dos tipos de E/S básicos nos quais você passou a confiar - digital, analógico,
2
PWM, IC e assim por diante - o Tessel 2 também possui alguns periféricos de alto nível, como
portas USB, Ethernet e - viva !-Wi-fi. (O Tessel 2 é o único modelo Tessel atualmente disponível, então
geralmente me referirei a ele apenas como Tessel.)
Figura 8.4. A placa de desenvolvimento de código aberto Tessel 2
UAU! e-book
www.wowebook.org
O Tessel é uma peça de hardware interessante e útil. Com base no critério “pode executar um sistema
operacional real”, ele cairia na categoria de dispositivos SBC – ele vem com OpenWrt, uma
distribuição Linux comumente encontrada em roteadores, pré-instalada.
Mas o fluxo de trabalho de desenvolvimento lembra mais as configurações do hostclient e

os dispositivos JavaScript incorporados: você escreve o código em seu computador e implanta no
Tessel, em vez de escrever o código nele. E embora o Tessel execute o OpenWrt e venha com
alguns softwares bacanas que veremos daqui a pouco, ele é mais restrito do que plataformas
SBC como o Raspberry Pis. Possui apenas 64 MB de RAM e 32 MB de espaço em Flash para
programas. Isso está muito além do que está disponível em placas baseadas em
ATmega328P como o Uno, mas não está no mesmo nível de um computador de mesa típico.
Depois de desenvolver projetos com JohnnyFive para o Uno, você encontrará muitas das
ergonomias com o Tessel familiar. De fato, a mecânica de trabalhar com o Tessel parecerá antiquada
se você estiver acostumado a desenvolver com ou para o Node.js em geral.
Há uma diferença entre o Tessel e o Arduino Uno que é essencial observar:
o Tessel opera em 3,3 V contra 5 V do Uno.
UAU! e-book
Tessel 2 é 3,3V www.wowebook.org
Tessel 2 é 3,3V
O Tessel 2 opera em 3,3 V. Você precisa projetar circuitos com isso em mente e certifique-se de usar
componentes compatíveis com 3,3 V. Conectar componentes de 5 V ou energia nos pinos do
Tessel 2 pode causar danos à placa. Não se preocupe: veremos os detalhes à medida que
avançamos.
8.3. CONFIGURANDO SEU TESSEL
1 Tesselação 2
1 cabo USB: USB A para USB micro
Para preparar o Tessel para a aventura, você precisa conectá-lo ao seu laptop com um cabo USB,
assim como no Uno. Mas existem algumas grandes diferenças. Por um lado, o código JavaScript que
você escreverá será carregado e executado no próprio Tessel - o Tessel não precisa de um host
para pensar por ele. Além disso, o Tessel tem Wi-Fi, então você não precisa mantê-lo conectado ao
USB depois de configurado - você pode implantá-lo sem fio.
Tessel e Node.js LTS
O Tessel oferece suporte à versão Long Term Support (LTS) do Node.js, que no momento da redação
deste artigo é a 6.11 (e quando você ler isso, provavelmente estará consideravelmente mais
avançada). Os exemplos de código neste livro assumirão pelo menos a versão 6.11 e os
scripts de exemplo farão uso dos recursos de linguagem disponíveis nessa versão. As versões do
Node.js mais recentes que o LTS atual podem não ser compatíveis com o Tessel.
Observe que a versão do Node.js em execução no próprio Tessel provavelmente é diferente (e

mais antiga) da versão do Node.js do seu sistema. Depois que seu Tessel estiver configurado, você
poderá ver qual versão do Node.js ele está executando a bordo, bem como sua versão de firmware,
usando o comando t2 version (mais sobre a ferramenta t2 em breve).
UAU! e-book
www.wowebook.org
8.3.1. Configurando o Tessel

As explicações a seguir podem tornar as etapas de configuração demoradas, mas o processo leva
apenas alguns minutos na maioria dos casos.
Etapa 1: instalar a CLI
Instale a interface de linha de comando (CLI) para controlar seu Tessel de seu computador.
Isso deve ser instalado como um pacote npm global inserindo o seguinte comando em seu terminal:
$ npm instalar g t2cli
Depois que o módulo estiver instalado, você poderá usar o comando t2 em um terminal para
controlar seu Tessel.
t2 vs. t2cli
O módulo npm é denominado t2cli, mas o comando que ele disponibiliza é t2.
Etapa 2: conecte, encontre e renomeie seu Tessel
Conecte um cabo USB da porta micro USB em seu Tessel a uma porta USB em seu computador.
Isso fornecerá energia ao Tessel e você deverá ver um LED piscando durante a inicialização (isso pode
levar cerca de 30 segundos).
Encontre o Tessel usando este comando no seu terminal:
$ t2 lista
Você deve ver algo assim.
Listagem 8.1. lista t2
$ t2 lista
INFORMAÇÕES Procurando Tessels próximos...

Tessel USB02A397D5D8A4
UAU! e-book
www.wowebook.org
Yay! Mas Tessel02A397D5D8A4 não é muito cativante. Felizmente, é muito fácil renomear seu Tessel com
este comando:
t2 renomear <nome>
Decidi chamar meu Tessel de Sweetbirch. Você pode escolher seu próprio nome.
Listagem 8.2. t2 renomear
$ t2 renomear sweetbirch
INFORMAÇÕES Procurando seu Tessel...

INFORMAÇÕES Conectado a Tessel02A397D5D8A4.
INFORMAÇÕES Renomeando Tessel02A397D5D8A4 para sweetbirch
INFORMAÇÃO Alterado o nome do dispositivo Tessel02A397D5D8A4 para sweetbirch
Etapa 3: obter Tessel em WiFi e provisionar
Obtenha seu Tessel em sua rede WiFi com o seguinte comando:
$ t2 wi-fi n <nome da rede> p <senha>
Compatibilidade WiFi de Tessel
Geralmente é fácil obter um Tessel em uma rede WiFi doméstica típica de 2,4 GHz com um único
comando. Mas atenção, os Tessels não são, neste momento, compatíveis com redes de 5 GHz.
Se você tiver problemas, vá para a página de configuração de conexão WiFi do Tessel
(http://tessel.github.io/t2start/wifi.html) para obter mais informações sobre conexão.
Por fim, provisione o Tessel para que você possa enviar código para ele do seu computador por
Wi-fi:
provisão de $ t2
A saída do comando t2 list após o provisionamento deve mostrar o Tessel como disponível tanto em
uma conexão USB quanto em WiFi (LAN), conforme mostrado na listagem a seguir.
Listagem 8.3. lista t2 após o provisionamento
$ t2 lista UAU! e-book

www.wowebook.org
INFORMAÇÕES Procurando Tessels próximos...
bétula USB
LAN Sweetbirch
Etapa 4: atualize seu Tessel
Atualizações são lançadas de vez em quando para o firmware do Tessel. Certifique-se de ter a versão mais
recente executando este comando:
$ t2 atualização
Se houver atualizações disponíveis, esse processo pode levar alguns minutos.
Certifique-se de que seu Tessel ainda esteja conectado ao USB e inicializado. Para obter o código de LED
piscando em seu Tessel, primeiro inicialize o projeto conforme mostrado na listagem a seguir.
Listagem 8.4. Inicialize o projeto Tessel de LED piscante
$ t2 calor
INFO Inicializando novo projeto Tessel para JavaScript...
INFORMAÇÕES Criado ".npmrc".

INFORMAÇÕES Criado ".tesselinclude".
INFORMAÇÕES Criado "package.json".
O comando t2 init
Versões mais recentes do pacote t2cli npm exigem que você execute o comando t2 init em um diretório de
projeto antes que o código desse projeto possa ser implantado em seu Tessel. Você só precisa fazer isso uma
vez (por projeto). Se você esquecer de executar o t2 init, obterá uma ajuda
mensagem:
$ t2 executar index.js

INFORMAÇÕES Conectado a sweetbirch.
AVISO Falta um arquivo ".npmrc" neste projeto!
WARN Para preparar seu projeto para implantação, use o comando:

AVISAR
WARN t2 init
AVISAR
WARN Uma vez concluído, tente novamente:

AVISAR
WARN t2 executar index.js
UAU! e-book
www.wowebook.org
8.3.2. LED “Hello World” piscando no Tessel

Você pode controlar o Tessel com JavaScript direto da caixa proverbial - é para isso que o Tessel
foi feito. Crie um arquivo chamado hellotessel.js e adicione o código LEDblinking na listagem a seguir.
Este script fará um dos builtin do Tessel, a bordo
LEDs piscam.
Listagem 8.5. olá-tessel.js
const tessel = require('tessel'); 1
tessel.led[2].on(); 2
setInterval(função () {
tessel.led[2].toggle();
tessel.led[3].toggle(); }, 100); 3
console.log("Estou piscando! (Pressione CTRL + C para parar)");
1 Importa a interface de hardware tessel
2 Começa ligando um dos LEDs integrados
3 Alterna LEDs a cada 100 ms
Agora você pode executar o código LEDblinking no Tessel usando o comando t2 run <file>, como
na listagem a seguir. Depois que o código for implantado e iniciado, você deverá ver dois dos
LEDs integrados do Tessel piscando rapidamente.
Listagem 8.6. corrida t2
$ t2 execute hellotessel.js lan

INFORMAÇÕES Projeto de construção.
INFO Escrevendo projeto para RAM em sweetbirch (89.088 kB)...

INFORMAÇÕES Implantadas.
INFORMAÇÕES Executando hellotessel.js...
Estou piscando! (Pressione CTRL + C para parar)
a bandeira da lan
Os scripts JohnnyFive que registram no REPL (com console .log()) funcionam melhor se o
UAU! e-book
www.wowebook.org
script é implantado em uma conexão LAN (WiFi). O sinalizador lan para o comando t2 run
especifica que a conexão WiFi deve ser usada (versus a conexão USB com fio).
Entendendo o exemplo “Hello Tessel”
Existem algumas coisas de aparência familiar no código hellotessel.js, mas alguns detalhes são
exclusivos do Tessel (em comparação com o controle do Uno com JohnnyFive).
A primeira coisa no código é o requisito de uma biblioteca chamada tessel:
var tessel = require('tessel');
Observadores atentos podem notar que isso é curioso: você nunca instalou nenhuma biblioteca
do tipo npm ou a disponibilizou de outra forma para o código em seu computador. A documentação
da API de hardware do Tessel 2 (http://mng.bz/Ror5) explica esta declaração de requisição:
Quando você requer ('tessel') dentro de um script que é executado no Tessel 2, ele carrega
uma biblioteca que faz interface com o hardware do Tessel 2, incluindo pinos, portas e LEDs...
Uma peça importante do quebra-cabeça aqui é a frase “executado no Tessel 2”. É verdade: se você
tentasse executar o script hellotessel.js com o Node.js em seu próprio computador, não iria
muito longe — encontraria um erro sobre o módulo ausente. Você também não encontrará o
pacote tessel no npm. Em vez disso, o tessel é uma biblioteca de API JavaScript pré-instalada
no próprio Tessel e, portanto, disponível para scripts executados no Tessel 2.
Ligar e alternar os LEDs integrados do Tessel por meio do objeto tessel parece como trabalhar com
objetos JohnnyFive Led, mas não exatamente:
tessel.led[2].on();
O objeto tessel fornece acesso às portas e pinos na placa Tessel, expondo uma API de hardware
para trabalhar com eles. É uma API de nível inferior ao JohnnyFive: você pode ler e gravar dados
digitais, analógicos e seriais, mas não há objetos de nível superior que envolvam, digamos, um
sensor de temperatura. A documentação da API de hardware do Tessel 2 fornece muito mais
informações (http://mng.bz/Ror5).
UAU! e-book
8.3.3. Piscando um LED externo com o Tessel www.wowebook.org
8.3.3. Piscando um LED externo com o Tessel
1 Tesselação 2
1 cabo USB para micro USB
1 LED padrão
1 resistor de 100 V
Fios de jumper
1 tábua de pão de tamanho normal
Honrando a tradição milenar do LED piscante “Hello World”, vamos mergulhar ainda mais no Tessel com
este primeiro circuito clássico. Em vez de piscar um LED onboard, este exemplo usa um LED
conectado externamente. Embora este experimento seja de escopo pedestre, ele apresentará o fluxo
de trabalho e a estrutura dos projetos Tessel.
Estrutura do projeto Tessel
Em vez de escrever scripts únicos e independentes como fez com o Uno, você estruturará cada
experimento Tessel como um projeto Node.js adequado:
Cada experimento terá seu próprio diretório de trabalho.
Você usará um arquivo package.json para gerenciar dependências.
O script principal (ponto de entrada) para experimentos será denominado index.js.
Se você tiver experiência em escrever software com Node.js, essa estrutura parecerá
familiar.
Configurando um projeto Johnny-Five Tessel
Antes de escrever qualquer código, configure

www.wowebook.org WOW!a área de trabalho para o projeto. Você precisará criar um
e-book
e configure um arquivo package.json usando o comando npm init. Abra um terminal e execute os seguintes
comandos:
mkdir t2blink
cd t2blink
npm init y
A execução do npm init normalmente o guiará por um conjunto interativo de perguntas para configurar seu projeto.
Adicionar o sinalizador y ignorará essas etapas e criará um arquivo package.json com as configurações padrão.
É uma maneira mais rápida de começar se você não estiver preocupado com os detalhes de configuração
específicos do seu projeto. Depois de executar npm init, você terá um arquivo package.json.
Fiação do circuito de LED de 3,3 V
Embora você tenha construído um circuito básico de LEDblink antes, um pouco de aritmética é necessário
para ajustar a tensão de alimentação de 3,3 V de Tessel. O circuito é semelhante ao circuito de LED básico para
o Uno que você construiu no capítulo 3 (figura 8.5), mas você precisará de um resistor limitador de corrente
diferente para levar em consideração a lógica de 3,3 V do Tessel.
Figura 8.5. O circuito de LED básico original para o Uno. O Uno opera em 5,5 V,
enquanto o Tessel é um dispositivo de 3,3 V. O circuito precisa ser ajustado
para a voltagem diferente do Tessel.
De volta ao capítulo 3, você fez um cálculo para o resistor limitador de corrente necessário para um único LED
em um circuito em série, levando em consideração a tensão operacional do Uno (5 V) e uma aproximação da
tensão direta de um LED (~1,8 V). Você veio com isso:
5,0 V (tensão de alimentação)

UAU! e-book
www.wowebook.org
– 1,8 V (tensão direta do LED vermelho)
= 3,2 V (tensão "restante" no circuito)
Visando 20 mA de corrente para o LED, você usou a lei de Ohm:
Resistência (R) = Tensão (V) / Corrente (I)

R = 3,2 V / 0,02 A
ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
= 160 V
160 V não é um valor de resistência comum, então você arredondou para 220 V (que é um valor comum).
Ajuste os valores para a alimentação de 3,3 V no Tessel:
3,3 V (tensão de alimentação)

– 1,8 V (tensão direta do LED vermelho)
= 1,5 V (tensão "restante" no circuito)
Resistência (R) = Tensão (V) / Corrente (I)

R = 1,5 V / 0,02 A
ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
= 75 V
75 V não é um valor de resistência comum, mas 100 V é - um resistor de 100 V serve bem aqui! Faz
sentido que um valor de resistência mais baixo seja necessário do que no circuito de 5 V: há menos
tensão restante depois que a queda de tensão do LED é considerada.
Conecte o circuito conforme mostrado no diagrama de fiação do LED Tessel (figura 8.6).
Figura 8.6. Conecte o ânodo do LED à porta A de Tessel, pino 5, e seu cátodo à
conexão GND na porta A.
UAU! eBook
Escrevendo o código de LED
piscando www.wowebook.org
Escrevendo o código de LED piscando
No capítulo 2, o experimento blinkingLED para o Arduino Uno usando JohnnyFive usou o seguinte
código.
Listagem 8.7. led.js
const five = require('johnnyfive'); const board = new five.Board();

1
board.on('pronto', () => { 2
led const = new five.Led('13'); 3
led.blink(500); 4
});
1 Instancia um objeto Board sem opções não padrão
2 Quando o tabuleiro estiver pronto...
3 Instancia um Led, conectado ao pino 13
4 pisca o LED
Não há muito que precise mudar para fazer isso funcionar com o Tessel. Você precisa levar em
conta duas coisas:
O Tessel precisa de suporte I/Olayer diferente para trabalhar com JohnnyFive. Você precisará
fazer com que seu objeto Board use tesselio para sua E/S (em vez da firmata padrão).
O número do pino ao qual o LED está conectado precisa ser atualizado.
Comece executando o seguinte comando em seu diretório de trabalho t2blink:
$ npm instalar salvar johnnyfive tesselio
Isso instalará os pacotes johnnyfive e tesselio localmente e salvará as dependências no

arquivo package.json. Você já conhece bem o pacote johnnyfive. tesselio é o plug-in
JohnnyFive I/O para o Tessel.
Crie um arquivo chamado index.js no mesmo diretório e adicione o seguinte código.
Listagem 8.8. index.js

const Tessel = require('tesselio'); 1 WOW! e-book www.wowebook.org
eu: novo Tessel() 2
});
led const = new five.Led('A5'); 3
led.blink(500);
});
1 Requer o pacote tesselio
2 Diz à placa para usar o tesselio para E/S
3 O LED está conectado à porta A, pino 5 no Tessel.
Este código é notavelmente semelhante ao código Unocompatível. As únicas diferenças são

o plug-in de E/S e o número do pino. Vá em frente e experimente usando a execução t2
comando:
Você deve ver uma saída semelhante à lista a seguir e o LED deve começar a piscar.
Listagem 8.9. Executando o código de piscada do LED no Tessel

INFORMAÇÕES Executando index.js...

1484926245789 Dispositivo(s) Tessel 2 (Tessel02A397D5D8A4)
1484926245946 Tessel Conectado 2 (Tessel02A397D5D8A4)
>>
8.3.4. Explorando os pinos e capacidades do Tessel

Como o Arduino Uno, pinos diferentes no Tessel fazem coisas diferentes. Existem 16 pinos de
E/S no Tessel, divididos entre duas portas (figura 8.7).
Figura 8.7. Os pinos do Tessel são divididos em duas “portas”, cada uma com 8 pinos de E/S.
UAU! e-book
www.wowebook.org
Os pinos são numerados de A0–A7 (na porta A) e B0–B7 (na porta B). Os dois pinos superiores em cada
2
porta física fornecem conexões de energia (GND e 3,3 V). Outros recursos, como IC, SPI e UART (serial
assíncrono/TTL) são suportados em pinos específicos (figura 8.8).
Figura 8.8. Tessel 2 pinos e suas características. Qualquer pino numerado pode ser usado
como E/S digital.
Embora todos os pinos possam ser usados como pinos de E/S digitais, a entrada analógica (ADC) está
disponível nos pinos A4 e A7 e em todos os pinos da porta B. Você também pode ver que alguns
pinos suportam interrupções (o que significa que eles seriam viáveis para “escutar” botões pressionados ou
para outros aplicativos que precisam detectar com precisão uma mudança de BAIXO para ALTO ou vice-versa).
Alguns pinos, mas não todos, suportam PWM.

UAU! e-book
www.wowebook.org
O pino B7 tem uma capacidade que ainda não encontramos: saída analógica. Esse pino pode fornecer conversão
digital para analógico (DAC). Não exploraremos esse recurso diretamente, mas ele está disponível
no Tessel.
8.4. PROJETOS SEM FIOS NO TESSEL
Ei, espere! O exemplo de LED ainda mantém você amarrado. Em seguida, você começará a remover alguns
fios.
Primeiro, você desconectará o Tessel do seu computador, mas usará uma tomada para fornecer
poder.
1 Tesselação 2
Carregador USB 5 V–12 V
1 LED
1 resistor de 100 V
Poder de parede para o Tessel
Se o seu Tessel não veio com um adaptador USB DC, você pode usar um carregador USB de 5 V, como um
tablet ou carregador de telefone, para alimentar o Tessel.
Como o conector de entrada CC do Arduino Uno, a microconexão USB do Tessel possui um regulador de
energia para regular a tensão de entrada para os 3,3 V necessários. O padrão de 5 V (tensão USB) é ideal
para a tensão de entrada.
UAU! e-book
www.wowebook.org
Os adaptadores de parede USB que fornecem alimentação de 5 V CC são amplamente difundidos. Eles são
especialmente populares como carregadores de telefones e tablets.
Só para provar que pode, você adaptará um pouco o código de piscada do LED para fazer o LED pulsar.
Você pode fazer isso porque o LED está conectado a um pino compatível com PWM no Tessel.
Para fazer essa alteração, localize a seguinte linha em index.js:
led.blink(500);
Substitua por isso:
led.pulse(500);
Agora, conecte seu Tessel à tomada em qualquer lugar que desejar, desde que esteja dentro do alcance
da mesma rede Wi-Fi em que seu computador está. Dê tempo para inicializar antes de tentar implantar
o código nele.
Agora, de volta ao seu computador, você pode tentar implantar de uma forma um pouco diferente.
Em seu diretório de trabalho, execute este comando:
t2 push index.js
O comando t2 push difere do comando t2 run. Com t2 run, o processo Node.js será executado no Tessel
somente até que o computador host elimine o processo (normalmente via CtrlC). Com t2 push,
o programa será enviado para o Tessel e será executado enquanto o Tessel tiver energia. Se você
desconectar o Tessel e conectá-lo novamente, UAU! e-book www.wowebook.org

ele retomará a execução do programa.
Agora você tem um LED pulsando em algum lugar ali, mas isso não é muito empolgante.
É hora de criar algo um pouco mais funcional que também possa se conectar ao ecossistema Node.js disponível
no Tessel. Você pode usar o Tessel como uma estação meteorológica independente: lendo dados de um ou
mais sensores e servindo esses dados executando um servidor web local (figura 8.9).
Figura 8.9. Um Tessel serve como centro nervoso para uma miniestação meteorológica. Um
aplicativo Node.js em execução no Tessel lerá os dados do multissensor BMP180 e executará
um servidor da Web para que outros computadores na mesma rede Wi-Fi possam visualizar as
informações meteorológicas em um navegador da Web.
8.4.1. Dados sem fio: uma estação meteorológica remota
1 Tesselação 2
1 cabo micro USB para USBA
1 carregador USB de 5 V–12 V

2
1 multissensor Adafruit BMP180 IC
Fios de jumper

UAU! e-book
www.wowebook.org
2
Há um recurso bacana dos sensores Adafruit I C usados no capítulo 7: eles funcionam tanto em 5
V quanto em 3,3 V. Cada uma de suas placas de fuga contém hardware regulador de tensão e pode
lidar com mudança de nível - ou seja, eles podem levar em conta os diferentes tensões de nível lógico
de microcontroladores de 3,3 V e 5 V. Você pode usar esses sensores tão facilmente com o Tessel quanto
com o Arduino Uno.
2
O circuito é direto: conecte o sensor BMP180 IC ao Tessel conforme mostrado na figura 8.10.
2
Figura 8.10. Conecte o sensor BMP180 IC à alimentação (pinos GND e 3,3 V da
porta A), SCL (A0) e SDA (A1).
Em seu aplicativo de terminal, configure um novo diretório de projeto de trabalho e instale as

dependências da mesma forma que no exemplo de LED:
mkdir t2weather
cd t2weather
npm init y
npm instalar salvar johnnyfive tesselio
Crie um arquivo chamado index.js e adicione o seguinte código.

const Tessel = require('tessel');

eu: novo Tessel() 1
});
UAU! e-book
www.wowebook.org
const weatherSensor = new five.Multi({
controlador: 'BMP180'
});
weatherSensor.thermometer.on('change', function () { 2 console.log(this.F); 3 });
});
1 Não se esqueça de especificar tesselio como a camada de E/S.
2 Quando o evento change dispara na instância termômetro do sensor...
3 ...desliga a leitura atual em Fahrenheit
Assim como no código LEDblinking anterior, a abstração de E/S dos componentes principais do
2
JohnnyFive faz com que esse código pareça quase idêntico a como você usaria um sensor IC
no Arduino Uno. Na verdade, a única diferença aqui é que você está passando uma opção de plug-
in de E/S diferente ao criar o objeto Board. Você não precisa mexer com os números dos
2
pinos porque a placa já sabe quais pinos suportam o IC no Tessel (e o padrão será a porta A).
O código anterior acessa a instância do termômetro via weatherSensor. Uma instância de

objeto Multi para o controlador BMP180 contém propriedades de termômetro e barômetro, que são
referências a instâncias de classe de componentes que representam os sensores de
temperatura e pressão do BMP180. Cada componente multisensor gera eventos de forma
independente, e os eventos também são agregados à instância Multi coletivamente:
weatherSensor.on('alterar', () => {
// Isso será invocado sempre que QUALQUER um dos sensores do multicomponente // tiver uma alteração
});
weatherSensor.barometer.on('change', () => { // Isso é invocado

somente quando a leitura do barômetro muda });
Outras classes de componentes de coleção em JohnnyFive (como Buttons e Leds)

comportar-se de maneira semelhante.
Com seu Tessel conectado via USB por enquanto, use t2 run para testar o script no
Tesselação:
UAU! e-book
www.wowebook.org
$ t2 executar index.js lan
Você deve ver algo assim:
$ t2 run index.js lan INFO Procurando

seu Tessel...


1487876926840 Dispositivo(s) Tessel 2 (sweetbirch)
1487876926995 Tessel conectado 2 (sweetbirch)

>> 72.14
72,32
72.14
72,32
Para fazer algo útil com as leituras do sensor — algo mais intuitivo e visual — você
aproveitará a capacidade do Tessel de oferecer suporte a pacotes npm e executar
códigos Node.js mais sofisticados — vamos ver como criar um aplicativo da web.
Construindo aplicativos mais sofisticados no Tessel
Para servir o conteúdo da web do Tessel, você precisará criar alguns arquivos adicionais. No
mínimo, você precisará começar com um documento HTML básico.
Crie um diretório chamado “app” dentro do diretório t2weather. Crie um arquivo index.html dentro
desse diretório, conforme mostrado na estrutura de diretório a seguir.
Listagem 8.11. Diretório do projeto e estrutura de arquivos, até agora
t2clima/
aplicativo
index.html
index.js
pacote node_modules.json
Abra index.html e adicione o seguinte conteúdo.
Listagem 8.12. index.html
<!DOCTYPE html>
<html lang="en"> UAU! e-book

www.wowebook.org
<cabeça>
<title>Condições Atuais</title>
</head>
<body>
<h1>Condições Atuais</h1>
<p>Dados em breve!</p> </body>
</html>
Quando você executa o código no Tessel, o Tessel sabe que deve copiar e usar o script que você está
executando, bem como os módulos Node.js instalados para o projeto. Mas você precisa dizer explicitamente
se ele precisa usar ativos fora desses itens. Você pode fazer isso colocando um arquivo .tesselinclude
no nível raiz do seu projeto.
Crie um arquivo .tesselinclude e adicione o seguinte a ele:
aplicativo/
Cada linha em um .tesselinclude é um glob, um padrão para arquivos correspondentes. Por exemplo, app/
corresponde a todos os arquivos no diretório app. Isso garantirá que o Tessel copie todos os arquivos no
diretório do aplicativo quando for implantado.
Depois de adicionar .tesselinclude, sua estrutura de arquivo deve ficar assim.
Listagem 8.13. Diretório do projeto e estrutura de arquivos com .tesselinclude
t2clima/
.tesselinclude
aplicativo
index.html
index.js
pacote
node_modules.json
Em seguida, você abordará a criação de um aplicativo da web para mostrar os dados da estação meteorológica em duas etapas:
1. Você configurará um servidor da Web básico e estático combinando o Express
(http://expressjs.com/) estrutura de aplicativo da Web com módulos Node.js integrados.
Isso servirá como uma página da web básica que será o recipiente para os dados da estação
meteorológica.
2. Você configurará um servidor socket.IO no Tessel (o servidor web) e se conectará a ele a partir do cliente
(a partir do JavaScript executado no navegador). Você também aprimorará o HTML com algum CSS
e marcação estruturada.
UAU! eBook
Configurando um servidor web
estático www.wowebook.org
Configurando um servidor web estático
Você começará de forma simples ativando um servidor da Web básico e estático no código do seu
aplicativo. Estático aqui significa que o servidor da Web fornecerá recursos (como HTML, imagens,
JavaScript e similares) sem executar nenhum processamento dinâmico do lado do servidor neles
- apenas fornecerá os arquivos solicitados de um diretório designado.
Comece instalando o express web framework. Verifique se você está no diretório t2weather e
execute o seguinte comando em um terminal:
$ npm instalar salvar expresso
Voltando agora ao script index.js, adicione o seguinte código ao início do arquivo.

const Tessel = require('tesselio'); const express =
require('express'); 1
const path = require('path'); 2 const http = require('http'); const os = require('os');
var app = express(); 3 app.use(express.static(path.join(__dirname, '/app'))); 4 var server = new

http.Server(app); 5

eu: novo Tessel()
});
}); 6
server.listen(3000, () => { 7
console.log(`http://${os.networkInterfaces().wlan0[0].address}:3000`); });
});
1 Requer Expresso
2 Requer alguns módulos Node.js embutidos
3 Instancia um novo aplicativo Express
UAU! e-book
www.wowebook.org
4 Diz ao aplicativo para fornecer ativos estáticos fora do diretório app/
5 Cria um servidor HTTP e o passa para o aplicativo
6 Omita ou comente as linhas console.log da versão anterior.
7 Faz com que o servidor escute as requisições na porta 3000
Não é necessário npm instalar os módulos os, path ou http porque eles estão embutidos no Node.js.
Experimente!
Você deve ver resultados como os seguintes.
Listagem 8.15. Executando index.js
$ t2 run index.js INFO

Procurando seu Tessel...
INFO Escrevendo projeto para RAM em sweetbirch (933.376 kB)... 1


1487884455497 Dispositivo(s) Tessel 2 (sweetbirch)
1487884455691 Repl inicializado >> http://
192.168.1.16:3000 2
1 O aplicativo fica maior à medida que você adiciona mais dependências.
2 Este é o endereço interno do Tessel e a porta HTTP de escuta ativa.
Agora você pode abrir um navegador da Web e visualizar a URL registrada no console (certifique-se
de usar a URL exibida em sua saída — não aquela mostrada na saída de exemplo anterior).
O endereço IP do Tessel
Seu Tessel precisa estar conectado à mesma rede que seu computador para que este experimento
funcione. Provavelmente será uma rede WiFi, conforme discutido na seção de configuração,
embora o Tessel também tenha uma porta Ethernet.
UAU! e-book
www.wowebook.org
Estar conectado à rede faz com que o Tessel receba seu próprio endereço IP, que você
precisará saber para acessar o servidor da Web em execução nele. A linha a seguir no código
index.js mostra isso para você:
console.log(`http://${os.networkInterfaces().wlan0[0].address}:3000`);
Você pode copiar e colar a saída disso de seu aplicativo de terminal na barra de URL de um
navegador. Visitar a URL de saída em um navegador renderizará o arquivo index.html atual
(figura 8.11).
Figura 8.11. Nada chique! Navegar até o endereço IP e a porta do Tessel em um

navegador exibe o arquivo index.html, que ainda não faz muita coisa.
Usando Socket.IO para exibir dados ao vivo
Uma opção para um aplicativo da Web simples seria incluir os valores do sensor atual na marcação do documento
HTML que é servido. Essa é uma abordagem perfeitamente válida e segue um modelo HTTP tradicional: o
navegador é responsável por solicitar mais dados ao servidor, na forma de solicitação de documento completo
(página da web). O efeito colateral é que o usuário teria que recarregar a página no navegador para ver novas
leituras.
Existe uma maneira melhor!
A API WebSocket é um padrão da Web que permite que um cliente (um navegador) e um servidor troquem
mensagens assíncronas em um único soquete TCP. Cada um pode enviar mensagens para o outro, permitindo a
troca de dados quase em tempo real.
WebSocket é suportado por muitos, mas não todos, navegadores. Para ajudar a preencher as lacunas, você
UAU! e-book
www.wowebook.org
use Socket.IO, uma API que usa WebSocket quando pode (quando o navegador oferece suporte), mas que
possui uma longa lista de outros transportes alternativos para emular o comportamento do WebSocket.
Resumindo, torna o uso dos recursos do WebSocket fácil e sem preocupações.
Com o Socket.IO, quando as leituras do sensor mudam, o servidor de soquete pode “enviar” os novos
dados para o cliente (supondo que o cliente esteja ouvindo e faça algo útil com os dados atualizados). O
efeito líquido é que você pode atualizar as leituras do sensor no navegador com frequência, sem recarregar
a página.
O primeiro passo é instalar o pacote socket.io npm:
npm instalar salvar socket.io
Em seguida, atualize o conteúdo de index.js com o seguinte código.

const Tessel = require('tesselium'); const express =
require('express'); const SocketIO = require('socket.io');
1
const caminho = require('caminho');

const http = require('http');
const os = require('os');
app const = new express();

const server = new http.Server(app); const socket = new
SocketIO(server); 2
app.use(express.static(path.join(__dirname, '/app')));
const board = new five.Board({ io: new Tessel() });
controlador: 'BMP180',
frequência: 5000 3
});
socket.on('conexão', cliente => { 4

cliente.emit('clima', {
temperatura: weatherSensor.thermometer.F,
pressão: (weatherSensor.barometer.pressure * 10)
});
});
});
UAU! e-book
www.wowebook.org
server.listen(3000, () => { console.log(`http://$
{os.networkInterfaces().wlan0[0].address}:3000`);
});
});
1 Requer a biblioteca socket.io
2 Cria o servidor socket.io
3 O JohnnyFive reduziu a frequência das leituras do sensor para cinco

segundos
4 Registra um retorno de chamada para quando um cliente solicita uma conexão
Diminuir a frequência do sensorread para cada cinco segundos mantém o desempenho dentro
limites e estabelece um limite razoável para a frequência com que o cliente receberá novos
dados pelo soquete. A cada cinco segundos é a frequência máxima com que o servidor de
soquete acionará atualizações, porque o evento climático só será acionado se as leituras do sensor
mudarem.
Vamos examinar a manipulação da conexão Socket.IO mais de perto na listagem a seguir.
// Registra um callback para quando um cliente (navegador) tenta se conectar.

// O retorno de chamada é passado uma referência ao `client`
socket.on('connection', client => { // Escuta eventos
de mudança no J5 Multi (representando o BMP180)
weatherSensor.on('change', () => { // Emite um evento
`weather` no cliente
// E passa um objeto que representa os valores atuais do sensor
// O cliente pode ouvir este evento e manipulá-lo de acordo
client.emit('weather', { // Esta é a temperatura
em Fahrenheit; // mude para `C` se preferir Celsius
temperature: weatherSensor.thermometer.F, // A multiplicação por 10

converte as leituras do sensor em kilopascals // para unidades milibares mais comumente usadas pressão:
(weatherSensor.barometer.pressure * 10)
});
});
});
Código não digno de produção WOW! e-

O código nesses exemplos é reduzido ao mínimo para maior clareza e brevidade. Isso é bom para
prototipagem caseira, mas o código em index.js não está pronto para produção. Em uma base de
código “real”, você gostaria de ter certeza de que o servidor de soquete não aceitaria involuntariamente
todas as conexões de entrada, de que um número máximo de conexões é imposto e assim por diante.
Além disso, embora a marcação index.html contenha HTML válido, ela carece de alguns
detalhes de acessibilidade e refinamento, e um cuidado maior deve ser tomado no CSS para
oferecer suporte a navegadores mais antigos e diversos ambientes de navegação (como
dispositivos móveis).
O servidor de soquete não será muito útil se não houver também um cliente que o aproveite. Primeiro,
você precisa preparar o HTML para exibir os valores do sensor adicionando alguma marcação
estruturada, conforme mostrado na listagem a seguir.
<!DOCTYPE html>
<html lang="en">
<cabeça>
<script src="/socket.io/socket.io.js"></script> 1
<link rel="stylesheet" href="style.css" type="text/css" /> 2 <title>Condições Atuais</title>
</head>
<corpo>
<main role="main"> 3
<h1>Condições Atuais</h1>
<div class="linha">
<div class="col">
<div class="dados">
<h2>Temperatura</h2> <span class="datavalue"
id="temperature">. 4 <small class="dataunit">F</small>
</div>
</div>
<div class="col">
<div class="dados">
<h2>Pressão</h2>
<span class="datavalue" id="pressure">. <small class="dataunit">mBar</small>
</div>
</div>
</div>
</main>
</body> </
html>
UAU! e-book
www.wowebook.org
1 Inclui o cliente socket.io JavaScript
2 Você criará esse arquivo CSS em breve.
3 Marca o conteúdo em alguns elementos de contêiner que serão renderizados como um

linha
4 Os intervalos de valor .data serão preenchidos com dados do sensor.
Esta linha pode estar fazendo você coçar a cabeça:
<script src="/socket.io/socket.io.js"></script>
De onde veio esse arquivo JavaScript “magicamente”?
No index.js, você iniciou o socket.io fornecendo a ele uma instância de servidor — ele disponibiliza o código
do lado do cliente automaticamente, por meio do servidor, em /socket.io/socket.io.js.
Quanto a esta linha:
<link rel="stylesheet" href="style.css" type="text/css" />
Você fará essa folha de estilo agora. Dentro do diretório t2weather, navegue até o subdiretório app e crie
um arquivo chamado style.css. Adicione o seguinte código a ele.
Listagem 8.19. estilo.css
html {
fontfamily : "Helvetica Neue", "Helvetica", "Arial", sem serifa;
}
.linha {
exibição: flexível;
justificar conteúdo : centro;
largura máxima: 48rem;
margem: automática;
}
.row .col {
margin : auto; padding : 2rem; }
h1, h2 {
margem: 0;
textalign : centro;
}
h2 {
tamanho da fonte: 1,5 rem;
}
UAU! e-book
www.wowebook.org
pequeno {
cor: #999;
tamanho da fonte: 0,65em;
}
.dados {
preenchimento: 1,5 rem;
cor de fundo: #eee;
raio da borda: 10px;
tamanho da fonte: 3rem;
}
.datavalue {
intensidade da fonte: Negrito; }
.connected { /* Torna a cor da fonte verde para mostrar que a atualização de websockets funciona
*/
cor: #093;
}
CSS flexbox
O CSS aqui faz uso do modo de layout “caixa flexível”, também conhecido como flexbox. O Flexbox
permite que você organize e posicione elementos sem a confusão de flutuações e margens
colapsadas. O Flexbox é cada vez mais bem suportado, mas se você estiver usando o Internet
Explorer, as coisas podem parecer um pouco estranhas (no entanto, os navegadores Edge suportam
o flexbox). Se tudo isso é bobagem, não se preocupe. O CSS aqui apenas estiliza a página da
Web e não é crítico para entender a funcionalidade do projeto.
Listagem 8.20. Estrutura completa de arquivos e diretórios do projeto
t2clima/
.tesselinclude
aplicativo
index.html
estilo.css index.js
pacote
node_modules.json
Agora, finalmente, o pivô. O cliente precisa se conectar ao servidor de soquete, ouvir eventos
relevantes (clima, neste caso) e responder a eles de alguma maneira útil.
Volte para index.html e adicione o seguinte código ao arquivo, logo antes da tag de fechamento do
corpo (</body>).
UAU! Listagem
de e-books 8.21. index.html www.wowebook.org
<script>
window.addEventListener('DOMContentLoaded', function () { 1
var socket = io(); 2
socket.on('clima', updateData); 3
});
função atualizarDados (dados) { 4
['temperatura', 'pressão'].forEach(function (dataPoint) { document.getElementById(dataPoint).innerHTML
=
dados[dataPoint].toFixed(2);
});
document.querySelectorAll('.datavalue').forEach(function (el) {
el.classList.add('conectado');
});
}
</script>
1 Quando o DOM da página estiver todo carregado...
2 Crie um cliente Socket.IO.
3 Registre um retorno de chamada para eventos climáticos.
4 Função do manipulador para o evento climático: analisa os dados atualizados e atualiza a
exibição da página
Vamos examinar mais de perto o código anterior.
Quando o DOM for carregado, você precisa criar um cliente Socket.IO e dizer a ele para invocar um retorno
de chamada (updateData) sempre que ocorrer um evento climático:
window.addEventListener('DOMContentLoaded', function () {
var soquete = io();
socket.on('clima', updateData); });
De onde veio io()?
A função io, para inicializar um cliente Socket.IO, é disponibilizada globalmente por meio da inclusão do
script /socket.io/socket.io.js.
A função updateData pega o objeto de dados atualizado e atualiza o DOM da página para incluir os novos
valores, como mostra a listagem a seguir. UAU! Listagem

de e-books 8.22. updateData () www.wowebook.org
detalhe
Listagem 8.22. detalhe updateData()
// `data` é um objeto contendo uma função de propriedades `temperature` e `pressure` updateData (data) { ['temperature',
'pressure'].forEach(function (dataPoint) {
document.getElementById(dataPoint).innerHTML = data[dataPoint].toFixed(2);
});
document.querySelectorAll('.datavalue').forEach(function (el) {
el.classList.add('conectado');
});
}
Primeiro, os elementos HTML com IDs de temperatura e pressão são atualizados - seus
O conteúdo HTML é definido para o valor dos sensores de temperatura e pressão, respectivamente:
['temperatura', 'pressão'].forEach(function (dataPoint) { document.getElementById(dataPoint).innerHTML

= data[dataPoint].toFixed(2); });
Os valores do sensor são formatados de forma que dois dígitos sejam exibidos após o decimal.
Em seguida, como uma sugestão visual, uma classe adicional – conectada – é
adicionada aos elementos #temperature e #pressure (o CSS estiliza isso como texto verde) para mostrar
que os dados estão sendo recebidos pelo soquete:
document.querySelectorAll('.datavalue').forEach(function (el) { el.classList.add('connected');
});
Código de manipulação de DOM, estilo jQuery
Para evitar dependências excessivas do cliente, o JavaScript em index.html usa a API DOM do
navegador diretamente, por exemplo, document.querySelectorAll(). Mas muitas pessoas estão mais
familiarizadas com a sintaxe jQuerystyle, que torna a travessia e a manipulação do DOM
mais legíveis e intuitivas.
Você pode usar jQuery se quiser. Para fazer isso, você precisa adicionar uma tag <script> para incluí -la.
O uso do código CDNhosted (https://code.jquery.com/) é recomendado para que você não precise
adicionar outro arquivo ao diretório do aplicativo.
UAU! e-book
www.wowebook.org
O script index.html atualizado ficaria mais ou menos assim:
$(função(){
var soquete = io();
socket.on('clima', updateData);
});
function updateData (data) { $
('#temperature').html(data.temperature.toFixed(2));
$('#pressure').html(data.pressure.toFixed(2));
$('.datavalue').addClass('conectado');
}
Está pronto! Você pode posicionar o Tessel, conectado à energia da parede, em qualquer lugar
dentro do alcance da sua rede sem fio. Então, mais uma vez, no seu computador, digite este comando:
t2 executar index.js lan
Abra um navegador para a URL indicada no console (figura 8.12).
Figura 8.12. Os valores de temperatura e pressão são atualizados em tempo real no

seu navegador, via websockets.
implantação push t2 para total independência
Lembre-se, ao implantar um projeto com execução t2, o Tessel ainda tem alguma
dependência do seu computador: o processo só é executado no Tessel desde que não seja
encerrado no seu computador. Com t2 push, o Tessel pode atingir autonomia total.
Anote o endereço IP atual do seu Tessel e a porta do servidor da web. Se você precisa ser
UAU! e-book
www.wowebook.org
lembrado, execute t2 run index.js novamente e copie o endereço IP registrado e a combinação de porta em
algum lugar que você possa acessar. Ao implantar via t2 push, você não poderá mais ver a saída do console.log.
Agora, execute este comando:
$ t2 push index.js
Você deve ver uma saída como a seguinte.
Listagem 8.23. saída push t2
$ t2 push index.js

INFO Escrevendo projeto para Flash em sweetbirch (1400.832 kB)...
INFORMAÇÕES Seu Tessel agora pode ser desamarrado.
INFORMAÇÕES O aplicativo será executado sempre que o Tessel inicializar.
INFORMAÇÕES Para remover este aplicativo, use "t2 erase".
Dê ao Tessel alguns segundos para terminar de ativar o servidor da web e começar e, em seguida, visualize a
página da web da estação meteorológica (no endereço IP do Tessel, porta 3000) em seu navegador.
Mesmo que seu Tessel perca energia, ele começará a executar o script da estação meteorológica assim que
recuperar energia e inicializar. O Tessel não precisa mais do seu computador.
Faça parar
Você pode usar t2 erase para fazer o Tessel parar de executar o programa da estação meteorológica.
8.5. ALIMENTANDO PROJETOS COM BATERIAS
Resta um fio: uma conexão de parede que fornece energia para o Tessel e seu
o circuito.
Existem inúmeras opções para projetos de energia, como energia de parede, alcalina ou
UAU! e-book
www.wowebook.org
baterias domésticas recarregáveis, muitas formas de baterias de íons de lítio ou painéis solares.
As opções podem parecer esmagadoras. Vamos decompô-lo um pouco.
Primeiro, o que exatamente precisa ser alimentado? Para um projeto como a estação
meteorológica, o próprio Tessel (placa de desenvolvimento, microcontrolador, processador)
precisa ser alimentado e, posteriormente, o Tessel fornece energia a 3,3 V para a placa de breakout
BMP180. Nesse caso, é natural pensar em fornecer energia para a placa dev e assumir que a placa dev
servirá como fonte de energia para o restante do circuito e seus componentes.
Esse é um bom conceito quando o circuito do projeto requer pouca energia, mas é diferente quando
os projetos contêm motores ou outros componentes que consomem muita corrente. De volta ao
capítulo 6, o circuito do robô rover continha dois motores CC e exigia mais corrente do que os
pinos do Arduino Uno podiam fornecer diretamente. Esse projeto incluía uma fonte de energia secundária
para acionar os motores: uma bateria alcalina de 9 V (figura 8.13).
Figura 8.13. A configuração de motores duplos para o robô no capítulo 6 usou uma fonte de
alimentação externa ao Uno para alimentar os motores CC: uma bateria de 9 V.
UAU! e-book
www.wowebook.org
Em qualquer caso, tudo o que você selecionar para fornecer energia ao seu projeto precisa alimentar todo
o projeto - às vezes toda a energia fluirá pela placa de desenvolvimento, às vezes não, dependendo do que
estiver no circuito.
Para sua primeira incursão na liberdade totalmente alimentada por bateria, usaremos um banco de
energia USB. Talvez você já tenha um em mãos: esses pequenos pacotes de energia costumam ser usados
para fornecer energia extra para celulares e tablets em movimento. Eles fornecem uma corrente constante
de 5 V via USB e são fáceis de carregar com carregadores de parede USB. Eles são ótimos como uma
bateria extra para o seu dispositivo móvel, mas também são ótimos para alimentar projetos que podem
funcionar com energia de 5 V.
Capacidade de carga
A quantidade de “suco” em uma determinada bateria é medida em termos de corrente ao longo do tempo.
A capacidade de uma bateria é medida em amperes-hora em sua tensão nominal ou, no contexto de
baterias domésticas, miliamperes-hora (mAh). Uma bateria de 1,5 V com capacidade de 500 mAh deve ser
capaz de fornecer, a 1,5 V, uma corrente constante de 100 mA por 5 horas. Ou uma corrente constante de
10 mAh por 50 horas.
Claro, não é tão simples assim. A capacidade real de uma bateria varia com base em muitas variáveis:
taxa de descarga (taxas de descarga mais altas resultam em capacidade total mais baixa), temperatura
ambiente (baterias não gostam de frio), tempo decorrido desde que a bateria foi carregada (baterias
naturalmente e normalmente lentas descarga), a química da bateria e muito mais.
As baterias de 1,5 AA do consumidor podem variar em capacidade de 400 a mais de 3000 mAh,
dependendo de sua química e de outros fatores. Essa é uma grande variedade!
O mais robusto da minha coleção atual de bancos de energia USB fornece 8000 mAh (8 Amp horas). No
extremo oposto, algumas das minhas baterias menores de polímero de lítio (LiPo) têm apenas algumas
centenas de mAh.
As necessidades de energia do Tessel (não é uma placa particularmente de baixa potência) e os motores
exigem uma bateria de maior capacidade como aquele tijolo USB, enquanto um projeto que combina um
Arduino Nano (uma pequena e eficiente placa Arduino) e um sensor de temperatura de baixa potência
funcionaria bem em um LiPo de menor capacidade.
8.5.1. Um robô movido a bateria com o Tessel
UAU! e-book
O que você precisará www.wowebook.org
1 Tesselação 2
1 robô itinerante construído e chassi do capítulo 6
1 bateria “power bank” USB com conexão micro USB
3 pinos de cabeçalho fêmea ou um comprimento de fio de núcleo sólido (núcleo sólido de calibre 22 é ideal)
(opcional)
Pistola de solda e suprimentos
Fazendo algumas pequenas alterações, o robô que você construiu com o Arduino Uno no capítulo 6 pode ser liberado
(dos fios). Isso não parecerá mais com um robô real?
Para liberar o bot, você precisará fazer o seguinte:
1. Solde algumas conexões ao Tessel para disponibilizar uma fonte de alimentação de 5 V para os motores
(opcional)
2. Substitua o Uno no circuito por um Tessel 3. Inicialize um
diretório de trabalho do projeto, copie o código do rover para o novo projeto e
ajuste os números dos pinos para os pinos do driver do motor
Alimentando os motores
No capítulo 6, os motores do robô itinerante foram alimentados por uma bateria de 9 V. A tensão operacional de 3,3 V
do Tessel é muito baixa para alimentar os motores e, além disso, as restrições de corrente nos pinos
seriam problemáticas. Mas as placas Tessel fornecem acesso à alimentação de 5 V com corrente suficiente para
fazer o trabalho (figura 8.14). O truque é acessá-lo - você precisará soldar um pouco.
Figura 8.14. O Tessel pode fornecer energia de 5 V dos pinos de alimentação destacados aqui.
UAU! e-book
www.wowebook.org
A opção mais flexível é soldar conectores fêmeas aos três pinos de alimentação no Tessel,
resultando em “soquetes” reutilizáveis nos quais você pode conectar cabos de jumper (8.15).
Soldar pinos de cabeçalho fêmea (figura 8.16) é um pouco diferente de soldar em cabeçalhos
de separação macho: você vira a placa de cabeça para baixo e solda os pinos na parte inferior.
Use um pedaço de fita para manter os pinos no lugar na parte superior, para que não caiam da
placa ao invertê-la.
Figura 8.15. A soldagem de pinos de cabeçalho fêmea aos pinos de alimentação de 5 V fornece
slots reutilizáveis úteis para fios de jumper.
UAU! e-book
www.wowebook.org
Figura 8.16. Para soldar conectores fêmea na placa, vire a placa e solde na parte
inferior. Você precisará de um pedaço de fita para prender os pinos no lugar
enquanto solda.
Como alternativa, você pode soldar comprimentos de fio aos pinos +5 V e GND (figura 8.17).
No entanto, isso resulta em fios permanentemente conectados.
Figura 8.17. Soldar fios de núcleo sólido aos pinos de alimentação também é uma opção.
UAU! e-book
www.wowebook.org
Se isso parecer muito incômodo, você pode optar por usar duas fontes de alimentação para este
projeto: a bateria de 9 V existente para o trilho de alimentação do motor e a bateria USB para alimentar
o Tessel - um diagrama de fiação para cada um é fornecido no próximo seção.
Não alimente os motores de 3,3 V
Os pinos de alimentação de 3,3 V do Tessel não fornecem nem a tensão nem a corrente exigida
pelos motores. Não tente alimentar os motores diretamente dos pinos de 3,3 V do Tessel.
(Re-)construindo o circuito do robô
Retire a parte superior do chassi do robô Unopowered (figura 8.18) para que você possa acessar o
interior e altere o circuito para usar o Tessel em vez do Uno. Se você soldou as conexões à
alimentação de 5 V do Tessel, monte o circuito conforme mostrado na figura 8.19. Se você optou
por continuar usando a bateria de 9 V, conecte o circuito conforme a figura 8.20.
Figura 8.18. Substituindo o Uno no capítulo 6 do bot itinerante por um Tessel, fazendo alguns
ajustes de fiação e conectando uma bateria USB ao Tessel, você pode criar um bot itinerante
sem fios.
UAU! e-book
www.wowebook.org
Figura 8.19. O circuito do robô rover usando o Tessel e a potência de 5 V do Tessel.

A alimentação de 5 V do Tessel precisa alimentar ambos os trilhos de alimentação - certifique-se
de conectar as colunas positivas dos trilhos de alimentação usando um fio de jumper adicional
(vermelho) (próximo ao topo).
UAU! e-book
www.wowebook.org
Figura 8.20. O circuito rover usando duas fontes de energia: 3,3 V do Tessel e uma bateria
de 9 V para os motores.
UAU! e-book
www.wowebook.org
Atualizando o código do rover
Crie um diretório de trabalho e instale algumas dependências. Em um terminal (certificando-se de que

você não está dentro do t2weather ou qualquer outro diretório de projeto pré-existente), digite estes
comandos:
mkdir t2rover
cd t2rover
npm init e npm
install salvar johnnyfive tesselio keypress
O pacote keypress é usado para capturar a entrada do teclado, para que o bot possa ser direcionado
com as teclas de seta.
Copie os dois scripts de robô para o diretório t2rover — index.js e Rover.js (ou volte ao capítulo 6
para encontrar a fonte). Abra o arquivo index.js em um editor de texto e faça o
UAU! e-book
www.wowebook.org
seguintes alterações:
1. Adicione um require for tesselio próximo ao topo do arquivo:
2. Atualize a instanciação da placa para especificar o plug-in de E/S:
3. Atualize os pinos do motor:

{ pinos: { dir: 'A4', pwm: 'A5' }, invertPWM: verdadeiro }, { pinos: { dir: 'B4', pwm: 'B5' },
invertPWM: verdadeiro }
]);
É isso! Seu bot está pronto para funcionar, sem fio. Posicione a placa Tessel no lugar do bot itinerante
onde o Uno estava anteriormente. Conecte a fonte de alimentação USB (e bateria de 9 V, se estiver
usando uma) e use fita adesiva ou velcro para prendê-la ao chassi do robô.
Certifique-se de que o Tessel esteja totalmente inicializado e visível na LAN (use a lista t2 para garantir).
Em seguida, execute este comando:
Você deve ser capaz de controlar seu robô a partir do seu computador usando as teclas de seta, e o rover
deve ser capaz de se movimentar muito mais amplamente do que quando estava conectado a um
Cabo USB.
Por meio dos experimentos deste capítulo, você viu como pode começar a libertar seus projetos de
amarras físicas. Você já passou do básico. É hora de dar a você mais ferramentas para inventar seus
próprios experimentos e criar coisas que não foram criadas

antes.
Tensões e o driver do motor
O rover baseado em Arduino Uno usava níveis lógicos de 5 V e os motores recebiam 9 V de energia de
uma bateria. Lembre-se, há duas fontes de energia aqui - uma para a lógica do driver do motor e outra
para alimentar os próprios motores.
Na configuração baseada em Tessel, o driver do motor é conectado a níveis lógicos de 3,3 V e o

UAU! e-book
www.wowebook.org
os motores recebem apenas 5 V (a menos que você esteja usando uma bateria de 9 V). O driver do motor funciona
na lógica de 3,3 V porque 3,3 V HIGH é suficiente para registrar como um nível ALTO lógico para o dispositivo
do driver do motor de 5 V - muitas vezes você pode usar a lógica de 5 V com 3,3 V porque a faixa de tensões
ALTAS válidas para um dispositivo de 5 V geralmente inclui 3,3 V.
A lógica de 3,3 V às vezes é compatível com componentes que possuem níveis lógicos de 5 V. A faixa de
tensão que é interpretada como ALTA para dispositivos de nível lógico de 5 V geralmente abrange 3,3 V. Ou seja,
um sinal de +3,3 V (ALTO do dispositivo de 3,3 V) será interpretado como ALTO no dispositivo de 5 V
porque está dentro de sua tensão ALTA faixa.
Você notará que os motores não são tão rápidos com 5 V quanto com 9 V. Isso era de se esperar.
Mas eles ainda são bons o suficiente para vagar.
RESUMO
Existem dois motivos principais pelos quais os projetos exigem conexões com fio: troca de dados e
comunicação e energia.
Usar JohnnyFive com Arduino Uno é um exemplo de configuração de hostclient. Um cabo deve existir entre
um computador host e o Uno o tempo todo. Alguns hardwares restritos, como o Photon Particle, podem
se comunicar sem fio com o JohnnyFive, mas um computador host ainda é necessário para pensar.
Tessel 2 é uma plataforma de código aberto que executa Linux e Node.js incorporados diretamente na própria
placa. O Tessel pode executar código independentemente de um computador host.
O Tessel 2 opera em 3,3 V. Ele tem duas portas de 8 pinos cada e suporta diferentes recursos em diferentes
pinos.
Na maioria das vezes, as únicas adaptações necessárias para escrever roteiros de JohnnyFive para o
Tessel versus o Uno (ou portar entre as plataformas) é usar o tesselio

UAU! e-book
www.wowebook.org
plug-in de E/S para JohnnyFive e altere a numeração dos pinos dos componentes.
Como o Tessel pode executar o Node.js nativamente e oferece suporte a pacotes

npm, é possível criar aplicativos sofisticados de alto nível e executá-los diretamente no
Tessel.
Existem muitas opções para alimentar projetos. Até agora você usou energia de
parede, pilhas alcalinas e um banco de energia USB. As baterias USB são úteis porque
têm várias aplicações, incluindo carregar dispositivos móveis, e são fáceis de carregar.
usar.
UAU! e-book
www.wowebook.org

história
Este capítulo cobre tópicos
As possibilidades infinitas de criar seus próprios mashups usando eletrônicos de consumo de baixa
tutoriaistensão pré-existentes
Etapas para criar suas próprias invenções: prototipagem, iteração e depuração

ofertas e ofertas
Isolando circuitos uns dos outros usando fotoacopladores

luzes
Analisando folhas de dados e outras implementações de software e firmware para criar seu próprio suporte de
software para configurações de componentes
Encapsulando o comportamento do componente com plug-ins JohnnyFive personalizados e o J5

Apoiar Mixagem de coleção
Disputando sensores sofisticados: processando dados complexos e gerenciando
Configuração de saída
1 Tesselação 2
1 conjunto de tomadas de parede com controle remoto
1 placa breakout SparkFun 3.3 V APDS9960
Ferro de solda e suprimentos
Botões de pressão e/ou LEDs para circuitos de depuração (opcional)
6 fotoacopladores (optoisoladores), como o 4N25
UAU! e-book
www.wowebook.org
Fios de jumper
1 multímetro
Cabeçotes separatistas masculinos de 0,1ÿ
Fio sólido 22AWG (opcional, para soldar ao circuito de controle remoto)
Kit de ferramentas de hardware para o capítulo 9 (fio sólido 22AWG opcional não mostrado)
Você já foi muito além do mundo lightupanLED e pode estar ansioso para começar a
construir coisas com eletrônicos que não foram construídos antes, para traçar seu próprio
curso. Vamos fazer um tour pelo arco de um projeto de exemplo inteiro - remixar um
conjunto de interruptores de tomada controlados remotamente - desde o início,
passando pela prototipagem, solução de problemas, iteração e melhoria. Em vez de
confiar em esquemas, instruções e software pré-existentes, você abrirá seu próprio caminho
em algumas partes do projeto.
Os projetos neste capítulo irão expor você a mais complexidade de software do que
experimentos anteriores. Dependendo do seu nível de conhecimento em JavaScript, isso
pode atingir um ponto ideal ou pode parecer mais do que você deseja morder agora. Se for demais,
UAU! e-book
www.wowebook.org
tudo bem: é sempre válido juntar projetos de componentes preexistentes
apoiar.
Projetos do mundo real têm altos e baixos. É preciso um toque de coragem para se lançar em
projetos mais elaborados com incógnitas. Fazer funcionar no final é docemente recompensador, e
espero que você aprenda a saborear o mergulho.
9.1. HACKING DE ELETRÔNICOS DE CONSUMO
Um dos momentos mais eletrizantes (com o perdão do trocadilho miserável) durante o crescimento
de minha experiência em eletrônica foi quando percebi que tinha conhecimento básico suficiente
para mexer com os eletrônicos de consumo existentes: para torná-los melhores ou para inventar
mashups criativos - coçando qualquer coceira do inventor que possa surgir. Por que projetar, comprar
peças e construir laboriosamente um circuito se você tem uma bugiganga eletrônica sem uso
espalhada pela casa que já executa a mesma função?
9.1.1. Modificando interruptores de saída controlados por RF
Perambular por uma sala para ligar (ou desligar) várias lâmpadas individuais pode ser cansativo, especialmente
se seus interruptores estiverem localizados de forma inconveniente. Os interruptores de plug-in
controlados sem fio para tomadas elétricas podem ser úteis. Por cerca de US$ 20, você pode comprar um
conjunto de três com controle remoto (figura 9.1).
Figura 9.1. Conjuntos de tomadas com controle remoto são baratos e amplamente disponíveis
em lojas de ferragens e home centers. A unidade de controle remoto é alimentada por uma
bateria de baixa voltagem.
UAU! e-book
www.wowebook.org
Com o controle remoto operado por bateria em mãos, você pode ligar ou desligar cada um dos
interruptores plugados (e, por sua vez, as lâmpadas plugadas neles), individualmente. Este é
um passo à frente de ter que dar uma volta física ao redor da sala. Mas há algumas coisas que
poderiam ser melhoradas.
Não é possível - pelo menos com o modelo que tenho - ligar ou desligar todos os interruptores
(e, portanto, suas luzes) ao mesmo tempo. Cada um deve ser trocado individualmente.
Mais interessante, não seria bom poder acionar as luzes de outras maneiras, possivelmente
automatizadas? Talvez você queira que as luzes se acendam quando escurece, ou de outro
cômodo da sua casa, ou usando alguma outra forma de entrada que você sonhou.
Boas notícias! O circuito dentro desses pequenos controles remotos é de baixa complexidade e
potência - baixa voltagem, baixa corrente. Eles são fáceis de entender e provavelmente não
vão te machucar terrivelmente se você estragar alguma coisa. Vamos hackear. Usando a coragem
do controle remoto, você montará seu próprio dispositivo personalizado.
Sempre seja cuidadoso!
Embora o circuito em muitos produtos eletrônicos de consumo alimentados por bateria e de baixa
tensão seja benigno, cada dispositivo é diferente e você precisa usar o bom senso.
UAU! e-book
www.wowebook.org
A menos que você seja um eletricista qualificado, não abra ou altere os componentes de saída do
sistema de controle remoto - mantenha seus hackers confinados à unidade de controle remoto. As
tomadas são conectadas à parede e tenho como política nunca chegar perto da rede elétrica em
minhas explorações eletrônicas - isso me mantém fora do hospital.
Remova as baterias dos eletrônicos quando estiver trabalhando com eles. E sempre, sempre dê aos
capacitores um amplo espaço. Eles podem manter a carga por muito tempo, mesmo quando não
estão conectados à energia.
Desmontagem da unidade de controle remoto
Você precisará desmontar o conjunto do controle remoto. Sua unidade de controle remoto pode ser um
pouco diferente, mas para desmontar o controle remoto que tenho, removi dois pequenos
parafusos. Dentro do estojo, encontrei apenas algumas coisas (figura 9.2):
Uma bateria coincell de 3 V (lítio CR2032 neste controle remoto)
Os botões físicos que podem ser pressionados, todos juntos em uma cama flexível de plástico
Uma pequena placa de circuito contendo os contatos dos botões, contatos da bateria e um LED
de status (entre outras coisas, como o transmissor de rádio)
Uma antena telescópica, anexada à placa de circuito
Figura 9.2. O controle remoto desconstruído
UAU! e-book
www.wowebook.org
Cada botão tem um pad correspondente abaixo dele na placa de circuito, que se parece com um
padrão em zigue-zague. Quando o botão sobreposto é pressionado, ele faz uma conexão entre
os dois lados diferentes do zigue-zague, completando o circuito. Você mesmo pode conectar o
circuito, agindo como um único botão pressionado, usando um fio jumper e tocando uma
extremidade em cada lado do zigue-zague (figura 9.3).
Figura 9.3. Quando um botão é pressionado, ele faz contato com ambos os lados dos
contatos em zigue-zague abaixo dele. Você pode reproduzir esse efeito conectando os
dois lados com um jumper.
UAU! e-book
www.wowebook.org
Adicionando ao circuito do controle remoto
Um lado do ziguezague é conectado ao terra. Você precisa determinar qual é o lado para
poder conectar seus próprios “botões” corretamente (ou seja, não ao contrário). A
melhor maneira de fazer isso é com um multímetro, mas se você não quiser comprar um
multímetro agora, pode tentar tocar os fios do LED em cada lado dos contatos do
botão e ver quando ele acende - seja qual for o lado do cátodo do LED está tocando
nesse ponto é o lado do terra (figura 9.4). Lembre-se de que você corre o risco de
sacrificar o LED se ele receber muita corrente ou se recusar a ser conectado ao contrário.
Figura 9.4. Sem multímetro? Você pode usar um LED para descobrir qual lado dos contatos do
botão é o lado do terra. Um LED é um diodo - ele só permitirá que a corrente flua se estiver
alinhado corretamente no circuito. Quando acende, significa que seu cátodo está no lado terra do
botão.
UAU! e-book
www.wowebook.org
Masterização de multímetros
Um multímetro, que pode medir tensão, corrente e resistência, é uma ferramenta essencial para a caixa
de ferramentas de um mecânico eletrônico. Eles são baratos - qualidade de passatempo tolerável

pode ser obtido por menos de $ 20.
UAU! e-book
www.wowebook.org
Um multímetro permite medir resistência, corrente e tensão.
Em nosso experimento atual, você pode determinar qual lado dos contatos do botão está conectado
ao terra observando a diferença de potencial de tensão entre os dois lados do zigue-zague. Para
fazer isso, defina o multímetro para uma configuração de tensão CC. Escolhi 20 V - o dispositivo
deve operar em torno de 3 V com base em sua bateria. A configuração de 20 V pode exibir
leituras de tensão de até 20 V; a tensão do dispositivo é um pouco alta demais para usar minha
configuração de 2 V.
UAU! e-book
www.wowebook.org
Com o multímetro definido para uma configuração de tensão CC apropriada, a leitura será positiva
quando a ponta de prova de aterramento estiver no lado do aterramento dos contatos do botão.
Ao tocar as pontas de prova do multímetro em cada lado dos contatos do botão, você verá uma leitura de
tensão no dispositivo. Se o número for negativo, troque as sondas. Depois de ver uma leitura positiva -
a minha era de cerca de 2,5 V - você encontrou o lado positivo (conexão da ponta de prova vermelha) e o
lado negativo (conexão da ponta de prova preta). Tome nota destes

para cada conexão de botão.
Os controles podem parecer intimidadores no início, mas os multímetros são ótimos amigos para
verificação de sanidade e depuração de circuitos. O tutorial “Como usar um multímetro” do SparkFun
é bom: http://mng.bz/9f03.
A próxima etapa pode exigir alguma engenhosidade, dependendo das especificidades da placa de circuito
do seu dispositivo: você precisa conectar fios a cada lado dos ziguezagues do botão (dois fios por botão).
Subseqüentemente, você poderá ligar e desligar os interruptores remotos controlando — fazendo e
desfazendo — as conexões entre esses fios.
UAU! e-book
www.wowebook.org
Se tiver sorte, você pode soldar fios diretamente nos botões de contato (figura 9.5). No
meu caso, a placa de circuito impresso (PCB) do controle remoto - uma placa fabricada
especificamente para este produto com conexões serigrafadas e traços conectando
diferentes elementos - tornou isso desafiador. Embora os contatos do botão
fossem eletricamente condutivos, a solda não aderiria a eles. Por mais que eu tentasse,
tudo o que consegui foi espalhar solda em meus fios e fazer uma bagunça. Prender os
fios às almofadas usando fita isolante era frustrante e meticuloso e ficava desmoronando em mim.
Figura 9.5. Uma configuração ideal seria soldar os fios diretamente em cada lado de
cada botão de contato.
Finalmente, vasculhando com meu multímetro, consegui encontrar furos na placa de circuito
que correspondiam aos contatos dos botões. Esses orifícios ainda não continham solda, mas
serviam como pontos de ancoragem através dos quais eu poderia inserir fios em uma placa
de ensaio subjacente (figura 9.6).
Figura 9.6. Minha solução de fiação caseira, aproveitando a estrutura da placa

de circuito específica
UAU! e-book
www.wowebook.org
Descobriu-se que cada botão na placa de circuito tinha sua própria conexão separada com o terra (fios
azuis — os seis primeiros na figura 9.6). Mas todos os botões foram conectados por meio de rastros a
uma única fonte de alimentação positiva compartilhada (fio amarelo — na parte inferior da figura 9.6).
Para ativar qualquer um dos botões, era necessário completar o circuito conectando a conexão de
aterramento específica do botão à fonte positiva compartilhada.
Aprendendo a ter paciência na hora de inventar
Quando você está desbravando novas trilhas e inventando suas próprias coisas, é provável que você tenha
pelo menos um ponto em cada projeto em que as coisas não saiam como o esperado (provavelmente
mais, para ser honesto). Pode ser uma decepção. Seja um problema ao soldar um fio a uma conexão ou um
componente que não se encaixa em uma placa de ensaio, você precisará ser engenhoso e atencioso
para resolvê-lo.
Tente não se apressar ou ficar confuso - é mais fácil aconselhar do que fazer, é claro! É tudo parte da
experiência. Tente usar a ferramenta certa para o trabalho, mesmo que isso signifique deixar seu projeto
de lado por alguns dias enquanto espera que a ferramenta ou peça certa encomendada on-line chegue
pelo correio. Mesmo que você tenha os materiais necessários à mão, às vezes é uma boa ideia fazer
uma pausa.
Fica melhor! À medida que avança, você aprenderá a prever certas pegadinhas. Você também estará
construindo seu conjunto de ferramentas, então terá mais opções para recorrer quando precisar corrigir uma
falha ou solucionar problemas. E você aprenderá quanto tempo realmente leva para construir um projeto de
UAU! e-book
www.wowebook.org
zero: pode demorar mais do que você pensa!
Se quiser experimentar, você pode conectar alguns interruptores momentâneos (botões de

pressão) aos fios do botão e usá-los para fazer conexões, ligando ou desligando os
interruptores remotos (figura 9.7).
Figura 9.7. Se desejar, você pode conectar um ou mais de seus botões com fio a um
botão de pressão para testá-lo.
Até agora, este foi um exercício interessante para entender como as coisas funcionam, mas você deve
ter percebido que não realiza nada de útil. Ainda requer toques de dedos humanos para operar os
controles. Em vez disso, vamos projetá-lo para que você possa controlar o dispositivo com base em
qualquer entrada ou lógica que desejar.
Usando fotoacopladores para manter os circuitos isolados
Ao fazer interface com circuitos em outros eletrônicos, é melhor manter as fontes de alimentação e os
componentes do circuito do dispositivo de destino isolados de sua placa de desenvolvimento e circuito.
Você não gostaria que caprichos de corrente ou tensão no controle remoto danificassem os
componentes eletrônicos no circuito da placa de desenvolvimento ou vice-versa. Você deseja que
sua placa de desenvolvimento e os dispositivos conectados a ela sejam capazes de controlar o fluxo
de corrente através do controle remoto (fazendo e desconectando conexões para diferentes botões),
mas não deseja realmente conectar-se ao circuito do controle remoto (figura 9.8). .
Figura 9.8. Para cada botão no controle remoto, você deseja pressionar e soltar o botão usando
o Tessel como um controlador semelhante a um interruptor. Você deseja que a aplicação de corrente
nos pontos 1 e 2 (o lado de entrada) faça com que a corrente flua entre os pontos 3 e 4 (a saída,
lado remoto), mas você não deseja que os dois circuitos sejam conectados fisicamente.
UAU! e-book
www.wowebook.org
É aqui que os componentes do fotoacoplador brilham (literalmente). Quando a corrente está

fluindo entre dois pinos no lado de entrada de um componente fotoacoplador, a corrente pode fluir
entre dois pinos no lado de saída. Ou seja, a chave do lado de saída está fechada (figura 9.9).
Se essa noção lhe parece um tanto reminiscente de como os transistores funcionam - uma pequena
corrente de entrada que permite que a corrente flua entre dois outros pinos - você está certo.
Mas neste caso, a corrente de entrada ativa o transistor de saída sem “tocá-lo” com sua corrente.
Em vez disso, um LED interno é alimentado pela corrente que flui pelos pinos de entrada. O
transistor de saída é fotossensível e ativa (fecha o interruptor) quando a luz o atinge.
Figura 9.9. A corrente aplicada ao lado de entrada de um fotoacoplador ativa

um LED infravermelho interno. O LED brilha em um transistor fotossensível, ativando-
o e permitindo que a corrente flua no lado da saída.
UAU! e-book
www.wowebook.org
Como você viu com alguns outros componentes, um fotoacoplador tem muitos nomes alternativos: você
pode vê-los chamados de optoacopladores ou optoisoladores.
9.2. CONTROLANDO OS INTERRUPTORES REMOTOS COM UM JOHNNY-FIVE

PLUGIN DE COMPONENTE
Seu primeiro experimento com o controle remoto do controle remoto (oh, está ficando meta!)
novos caminhos.
Nesta primeira iteração, você fará com que possa controlar cada botão liga/desliga — pressionando botões
virtualmente — usando a lógica do aplicativo em execução no Tessel.
9.2.1. Prototipando o projeto do switch

Em vez de ligar e conectar todos os fotoacopladores e interruptores de uma vez - seis fotoacopladores e
componentes relacionados no meu caso - pode ser útil começar com um pedaço do circuito e garantir que
funcione. Em seguida, você pode criar um código menos polido para verificar se as coisas estão se
comportando conforme o esperado antes de fazer qualquer ajuste fino.
Esse processo de prototipagem pode ajudá-lo a validar sua abordagem e solucionar problemas em
uma escala menor antes de mergulhar fundo demais.
Protótipo do hardware
Conecte o primeiro conjunto de botões liga e desliga conforme mostrado na figura 9.10. Fios amarelos
devem UAU!
conecte-se às conexões de botão positivo, preto ao negativo (no meu caso, todos os fios amarelos se
conectam à mesma fonte positiva compartilhada). Certifique-se de que o ponto indicador do pino 1 nos
fotoacopladores esteja orientado corretamente. Conecte o pino 2 de ambos os fotoacopladores ao terra.
Figura 9.10. Diagrama de fiação para o primeiro conjunto de botões liga/desliga
Conecte o pino 1 do primeiro fotoacoplador ao pino A0 no Tessel através de um resistor de 100 V e o pino
2 ao GND. O resistor limitador de corrente é necessário aqui porque há um LED dentro do fotoacoplador.
Conecte o pino 5 do fotoacoplador ao fio positivo do botão liga/desliga do primeiro interruptor e o pino 4
ao fio terra desse botão.
Conecte o segundo fotoacoplador de maneira semelhante, mas conecte-o ao pino A1 no lado Tessel
(fonte) e aos fios positivo e terra do botão de desligar do primeiro interruptor.
Prototipando o software
Aqui está algo a considerar. O que significa “pressionar um botão” no controle remoto?
A conexão que o pressionamento do botão faz não permanece conectada para sempre, nem é um sinal
instantâneo - pense em um dedo humano pressionando e soltando o botão. Sobre
UAU! e-book
www.wowebook.org
meu controle remoto, na verdade, eu notei no passado que se eu pressionasse um botão muito rápido -
liberando-o muito rapidamente - o interruptor nem sempre respondia. Há um pouco de pressandhold envolvido.
Você pode imitar isso com software ativando a conexão de um botão por meio do
fotoacoplador e mantendo-o ligado por um período de tempo, digamos meio segundo, antes de desligá-lo
novamente. Isso provavelmente é mais fácil de conceituar observando o código real. Vamos.
Primeiro, configure o projeto:
interruptores remotos mkdir
cd remoteswitches
npm init y
Em seguida, instale as dependências padrão e crie um arquivo index.js:
npm instalar salvar johnnyfive tesselio touch index.js
Em vez de usar uma classe de componente JohnnyFive de nível superior, como Led, você escreverá
valores digitais - HIGH (1) ou LOW (0) - nos pinos A0 e A1 diretamente. Um pino pode ser
configurado como um pino de saída digital, assim:
board.pinMode('A0', five.Pin.OUTPUT);
Uma vez configurado, pode ser escrito assim:
board.digitalWrite('A0', 1); // define HIGH (3,3V no Tessel) board.digitalWrite('A0', 0); // define LOW (0V)
Para “pressionar” o botão que liga o primeiro interruptor, você deve definir o pino A0 HIGH – “ligar” o
fotoacoplador e permitir que a corrente flua pelo primeiro botão.
Após 500 milissegundos, você definirá A0 LOW novamente, interrompendo a conexão do circuito e
“soltando” o botão.
Adicione o seguinte código de alternância de protótipo a index.js.
Listagem 9.1. Protótipo de código para pressionar o botão
UAU! e-book
www.wowebook.org
const switchPins = { 1
em: 'A0',
desligado: 'A1'
};
duração do pressionamento constante = 500; 2
board.pinMode(switchPins.on, five.Pin.OUTPUT); 3
board.pinMode(switchPins.off, five.Pin.OUTPUT);
const pressButton = function (pin) { board.digitalWrite(pin, 1); 4
setTimeout(() => {
placa.digitalWrite(pino, 0);
}, pressioneDuração); 5
};
const ligar = function () {
pressButton(switchPins.on);
};
const desligar = function () {
pressButton(switchPins.off);
};
board.repl.inject({ 6
ligar: ligar,
desligar: desligar
});
});
1 Esses dois pinos são conectados ao lado da fonte dos dois fotoacopladores.
2 botões “pressiona e segura” por 500 milissegundos para garantir a ativação do interruptor
3 Configura A0 e A1 como pinos de saída digital
4 Para pressionar um botão, primeiro defina o pino do fotoacoplador associado em ALTO.
5 Em seguida, defina um tempo limite para pressDuration (500 ms) antes de definir o pino
BAIXO novamente.
6 Para a fase de prototipagem, disponibilize o turnOn e o turnOff para o

REPL.
Experimente. Implante o código no Tessel pela LAN (você precisa implantar pela LAN para que o
REPL funcione):
UAU! e-book
www.wowebook.org
Tente invocar as funções turnOn() e turnOff() do REPL. Observe que ambos

as funções retornam indefinido - isso é bom e não é um erro.
1492612088185 Disponível Tessel 2 (sweetbirch)

1492612088415 Repl inicializado >> turnOn()
indefinido
>> desligar()
indefinido
Ao fazer isso, você deve “pressionar” os botões liga e desliga no controle remoto e ligar e desligar a
tomada de parede associada.
Construindo o resto do circuito
Quando estiver mais confiante de que seu primeiro circuito está fazendo o que você espera,
expanda-o conforme mostrado na figura 9.11. Certifique-se de prestar atenção à orientação de cada
fotoacoplador.
Figura 9.11. A fiação do interruptor/fotoacoplador concluída. As saídas dos

fotoacopladores devem ser conectadas aos fios de contato do botão.
UAU! e-book
www.wowebook.org
9.2.2. Escrevendo o plug-in RemoteSwitch
Agora que você poliu o circuito, é hora de polir o código. Em vez de ter uma coleção heterogênea de
código no módulo principal do aplicativo (index.js), você pode encapsular o comportamento de
cada uma das três combinações de chave liga/desliga em um componente personalizado chamado
RemoteSwitch. Remover o código específico do componente permitirá, de volta ao index.js, simplesmente
instanciar um objeto RemoteSwitch para cada um dos três pares liga/desliga (ou quantos pares de
interruptores seu controle remoto tiver) e transformá-los

ligar ou desligar à vontade.
Vamos percorrer as etapas de criação de um plug-in de componente JohnnyFive reutilizável.
Plug-ins de componentes Johnny-Five vs. classes de componentes
Classes de componentes integrados como Led e Motor fazem parte do núcleo do JohnnyFive. A criação de
uma nova classe de componente requer alterações na própria base de código do JohnnyFive. Por
outro lado, os plug-ins de componentes podem ser criados sem fazer nenhuma modificação no
JohnnyFive - portanto, o plug-in de terminologia. A estrutura de um plug-in de componente tem muitas
semelhanças com a estrutura do código de classe de componente, mas as duas coisas—

UAU! e-book
www.wowebook.org
classe de componente versus plug-in de componente - são animais diferentes, então não se confunda
(você está fazendo um plug-in)!
Princípios básicos da estrutura do plug-in de componentes
Crie um novo arquivo no diretório remoteswitches chamado RemoteSwitch.js para conter o módulo de
plug-in. A estrutura do módulo começará conforme mostrado na listagem a seguir. Esta estrutura
de esqueleto segue algum plug-in do componente JohnnyFive
convenções para torná-lo modular e flexível.
Listagem 9.2. RemoteSwitch.js: ponto de partida
module.exports = function (cinco) { 1

return (function () { function RemoteSwitch
(opts) { /* ... */ } 2 RemoteSwitch.prototype.toggle = function (turnOn) {}; 3 RemoteSwitch.prototype.on = function () {};
RemoteSwitch.prototype .off = função () {}, return RemoteSwitch;
}());
};
1 O módulo de consumo fornece uma referência a JohnnyFive (cinco).
2 Isso inicializará um novo objeto RemoteSwitch (este é seu construtor).
3 Você adicionará três métodos de protótipo para controlar o componente switch.
O módulo RemoteSwitch não tem uma dependência direta do JohnnyFive.
Em vez disso, ele usa uma referência de objeto JohnnyFive como um argumento para sua
função exportada. Dessa forma, o plug-in pode funcionar em cima de qualquer objeto JohnnyFive
que esteja em jogo quando for incluído. O objeto JohnnyFive passado pode conter uma placa
configurada com o plug-in Tessel I/O, ou pode ter um Arduino com uma camada Firmata I/O, ou talvez
outra coisa - dessa forma, o plug-in não precisa se preocupar com logística ou validação
números de pinos ou qualquer coisa. O objeto JohnnyFive passado cuidará disso, deixando você livre
para lidar com a lógica em questão.
O plug-in precisa ter um construtor que possa ter algumas opções, executar qualquer configuração
necessária e se registrar no JohnnyFive. A instanciação de um RemoteSwitch ficará assim quando
terminar:
const switch1 = new RemoteSwitch({ pins: { on: 'A0', off: 'A1' } });
UAU! e-book
www.wowebook.org
Você trabalhará nesse construtor a seguir.
Codificando o plug-in
Adicione o seguinte código a RemoteSwitch.js.
Listagem 9.3. RemoteSwitch.js: construtor
module.exports = function (cinco) {

return (função () {
function RemoteSwitch (opts) { if (!(esta instância de
RemoteSwitch)) { 1
retornar novo RemoteSwitch(opções);
}
five.Board.Component.call(this, opts = five.Board.Options(opts)); 2
// opts.pins deve conter duas propriedades, òn` e òff`, // definindo seus números de pin,
respectivamente
this.pins = opts.pins;
this.duration = 500;
this.isOn = indefinido; 3
this.isActive = false; 4
this.io.pinMode(this.pins.on, this.io.MODES.OUTPUT); 5
this.io.pinMode(this.pins.off, this.io.MODES.OUTPUT);
} // ...
}());
};
1 Este padrão (padrão) garante que a função seja chamada com a palavra-chave “new”.
2 Registra o componente
3 Você não sabe, tecnicamente, se o interruptor está ligado ou desligado no

início.
4 isActive é verdadeiro quando um dos botões do switch é ativado (sendo pressionado).
5 Configura os pinos liga e desliga do switch para serem pinos de saída digital.
Agora é hora de adicionar os métodos que ligam e desligam o switch.
Listagem 9.4. RemoteSwitch.js: métodos de protótipo
module.exports = function (cinco) { return (function () {
UAU! e-book
www.wowebook.org
function RemoteSwitch (opts) { /* já escrevemos isso */ };
RemoteSwitch.prototype.toggle = function (turnOn) {

if (this.isActive) { return false; } 1
this.isActive = verdadeiro; 2
if ( typeof turnOn === ' undefined ' ) { turnOn = ! this .isOn ; 3
}
pino const = (turnOn) ? este.pins.on : este.pins.off; 4
this.io.digitalWrite(pin, 1);
setTimeout(() => {
this.io.digitalWrite(pino, 0);
this.isActive = false; 5
this.isOn = !!turnOn; 6
}, this.duration);
};
RemoteSwitch.prototype.on = function () {
this.toggle(true);
};
RemoteSwitch.prototype.off = function () { this.toggle(false); };
}());
};
1 Não aciona o switch se já estiver ativo (ocupado)
2 Indica que o switch está ativo no momento
3 Determina o comportamento de alternância se o turnOn estiver ausente
4 Determina qual dos pinos do switch (ligado ou desligado) ativar
5 O interruptor não está mais ativo; isActive deve ser falso novamente
6 Mantém o controle do estado atual do switch
Você notará que tudo gira em torno do método de alternância. O único argumento de alternância,
turnOn, define o que acontece. Se for verdadeiro, o interruptor será ligado. Se for falso, o interruptor
será desligado. Se estiver ausente (indefinido), o switch mudará de qualquer estado em que esteja
atualmente. Para oferecer suporte a essa funcionalidade, o estado atual do switch é armazenado na
propriedade isOn.
Para evitar que o controle remoto tente enviar dois sinais ao mesmo tempo, a propriedade isActive é
usada como sinalizador. toggle não gravará em nenhum pino se isActive for verdadeiro.
Refatorando index.js para usar RemoteSwitch
Agora você pode atualizar index.js para conter o seguinte código.
UAU! Listagem
de e-books 9.5. index.js refatorado www.wowebook.org
Listagem 9.5. index.js refatorado
const five = require('johnnyfive'); const Tessel = require('tesselio');

const RemoteSwitch = require('./RemoteSwitch')(five); 1
const switch1 = new RemoteSwitch({
pinos: { on: 'A0', off: 'A1' }
});
});
});
board.repl.inject({ switch1: switch1,
interruptor2: interruptor2,
interruptor3: interruptor3
});
});
1 Importa o módulo RemoteSwitch e passa a ele as cinco referências
Experimente:
t2 executar index.js lan
Uma vez em execução, você pode interagir com os objetos switch no REPL:
1492618175517 Disponível Tessel 2 (sweetbirch)

>> switch1.on()
indefinido
>> switch1.off()
indefinido
>> switch2.on()
indefinido
Iteração: filas e callbacks
No momento, o método toggle nas instâncias RemoteSwitch não fará nada se isActive
for true — ou seja, não permitirá várias ativações de switch simultâneas. O
UAU! e-book
www.wowebook.org
a desvantagem é que, como está escrito atualmente, os comandos para alternar serão efetivamente
descartados e ignorados se acontecerem enquanto a opção já estiver ativa. Digamos que, por algum motivo,
você queira piscar o interruptor várias vezes e tenha o seguinte código em index.js para tentar fazer isso:
for (var i = 0; i < 10; i++) {

switch1.toggle();
}
O interruptor alternaria uma vez conforme o esperado, com certeza. Mas as nove chamadas
subseqüentes para alternar aconteceriam imediatamente depois - enquanto o switch ainda está ativado
desde a primeira chamada (e, portanto, enquanto isActive é verdadeiro). Eles seriam ignorados.
Como resultado, o interruptor alternaria apenas uma vez, não 10 vezes.
Você pode corrigir isso lançando um enfileiramento FIFO simples (primeiro a entrar, primeiro a sair —
análogo a “as chamadas são atendidas na ordem em que são recebidas”) para alternar comandos que
chegam enquanto o switch está ativo. Isso requer apenas algumas linhas de código.
Enquanto estiver lá, você também pode adicionar algum suporte de retorno de chamada aos métodos
do RemoteSwitch, conforme mostrado na listagem a seguir. Isso é consistente com outros componentes do
J5 e possibilita o registro de uma função a ser chamada quando o comando switch (on/off/toggle)
for concluído. No momento, isso é molho, mas será útil mais tarde.
Listagem 9.6. O plugin RemoteSwitch completo

function RemoteSwitch (opts) { if (!(esta instância de
RemoteSwitch)) {
return new RemoteSwitch(opções); }
five.Board.Component.call(this, opts = five.Board.Options(opts));
this.pins = opts.pins;
this.duration = opts.duration || 500;
this.isOn = indefinido;
this.isActive = false;
esta.fila = []; 1
this.io.pinMode(this.pins.on, this.io.MODES.OUTPUT);
this.io.pinMode(this.pins.off, this.io.MODES.OUTPUT);
}
RemoteSwitch.prototype.toggle = function (turnOn, callback) { 2 if (this.isActive) { 3
this.queue.push([turnOn, callback]); UAU! e-book

www.wowebook.org
retornar;
}
this.isActive = verdadeiro;
if (typeof turnOn === 'indefinido') { turnOn =!this.isOn;
}
pino const = (turnOn) ? este.pins.on : este.pins.off;
this.io.digitalWrite(pin, 1);
setTimeout(() => {
this.io.digitalWrite(pino, 0);
this.isActive = false;
this.isOn = !!turnOn;
if (typeof callback === 'function') { 4 callback();
}
if (this.queue.length) { 5
this.toggle.apply(this, this.queue.shift());
}
}, this.duration);
};
RemoteSwitch.prototype.on = function (callback) { 6 this.toggle(true, callback);
};
RemoteSwitch.prototype.off = function (callback) {
this.toggle(falso, retorno de chamada);
};
retornar RemoteSwitch;
}());
};
1 Instancia um array vazio para conter “comandos” enfileirados
2 Agora aceita um retorno de chamada
3 Coloca coisas na fila se o interruptor estiver ocupado
4 A ação de alternância está concluída: invoca o retorno de chamada, se houver
5 As chamadas alternam para o próximo item da fila, se houver
6 funções de manipulador liga e desliga recebem um argumento de retorno de chamada e o passam para
alternar.
Agora, se você adicionar o seguinte código ao index.js, ele deve funcionar conforme o esperado:
for (var i = 0; i < 10; i++) { switch1.toggle(); //

Isso fará com que o switch alterne 10 vezes
}
UAU! e-book
www.wowebook.org
Seu hardware pode variar
A chave deve alternar 10 vezes, com base no software que escrevemos. Vale a pena notar, no
entanto, que pode haver limitações de hardware que impedem que isso realmente aconteça. Por
exemplo, os componentes eletrônicos do seu controle remoto podem não permitir que um interruptor
seja alternado com tanta frequência.
Até agora, você invadiu a eletrônica de consumo, construiu um pequeno protótipo e o expandiu
para um circuito mais polido com um plug-in de componente JohnnyFive personalizado para saída
(interruptores).
Você pode acionar seus componentes do RemoteSwitch com alguns dos dispositivos de entrada
que você já viu. Você pode usar um fotoresistor e acionar os interruptores quando escurecer na sala.
Você pode usar um sensor de movimento ou proximidade para ativá-los quando seu gato passar (e
desligá-los automaticamente após um determinado período de tempo). Mas o que acontece quando
você deseja controlar os interruptores com um tipo de entrada que não é suportada pelo JohnnyFive? O
que então?
9.3. SOFTWARE DE ESCRITA PARA HARDWARE SOFISTICADO

2
Há um dispositivo IC bacana que chamou minha atenção. O dispositivo Avago APDS9960 (figura
9.12) contém vários sensores: um sensor de luz ambiente RGB, um sensor de proximidade e um
sofisticado sensor de gestos. A SparkFun vende uma placa de fuga barata (cerca de US$ 15) baseada
no chip. Organizado! Um sensor de gestos! Que maneira divertida de controlar suas lâmpadas
comutadas remotamente. Por que apertar botões quando você pode deslizar pelo ar como um mágico?
Figura 9.12. O APDS-9960 reúne três sensores em um pacote, incluindo um

sensor de gestos. O SparkFun oferece um breakout board que facilita o trabalho
com o chip.
UAU! e-book
www.wowebook.org
O problema é que, na época em que me deparei com o APDS9960, não havia suporte
JohnnyFive preexistente para ele. Não há classe de componente para sensores de gesto.
Isso significa que você precisa criar esse suporte! Quando o software preexistente não
existe para algo que você deseja usar, você tem duas opções: substituir outra peça de
hardware que tenha suporte ou criar esse suporte você mesmo.
9.3.1. Projeto: suporte Johnny-Five para sensor de gestos APDS-9660
O APDS9960 testará sua coragem (é um dispositivo sofisticado), mas a estrutura de alto

nível do plug-in que você criará para ele espelhará a do RemoteSwitch. O processo de
projeto a seguir é baseado em uma experiência real e destaca algumas fases comuns,
contratempos e resultados encontrados ao criar um novo suporte para um pedaço de
hardware.
Para criar o suporte, você fará o seguinte:
1. Defina os objetivos e o
escopo 2. Reúna informações e faça pesquisas sobre o
APDS9960 3. Crie um protótipo rápido de prova
de conceito 4. Defina a superfície da API e o
ciclo de vida do plug-in 5. Escreva
o código do plug-in 6. Teste se
o plug-in funciona 7 . Termine o projeto, integrando o plugin APDS9960 com seu RemoteSwitch
do início do capítulo
Objetivos para o plug-in do sensor de gestos
UAU! e-book
www.wowebook.org
Antes de conectar fios, soldar ou inserir código, a primeira coisa a fazer é perguntar a si mesmo o que você
está tentando realizar.
Você deseja criar um plug-in de componente JohnnyFive para o sensor de gestos no APDS9960.
Uma API razoável consistente com outros componentes do JohnnyFive incluiria a exposição de eventos
de gestos que poderiam ser ouvidos e respondidos pelo código do aplicativo.
O que não está no escopo? Dada a complexidade do sensor de gestos do APDS9960 sozinho, não
tente lidar com o suporte para seus outros sensores. Da mesma forma, para economizar tempo de
desenvolvimento e dores de cabeça, você irá em frente e codificará muitas das configurações padrão e
suporte a recursos que poderiam ser gerenciados posteriormente de outra maneira, como por meio de
opções passadas para o plug-in.
Projetar o código para ser usado em várias plataformas de hardware é uma boa meta, assim como
manter a flexibilidade para o futuro em mente. Escrever um módulo que esteja em conformidade com as
convenções de plug-in do componente JohnnyFive - como RemoteSwitch - ajudará no objetivo da
plataforma cruzada. Estar atento sobre como as constantes são gerenciadas, prestar atenção à
consistência da superfície da API e manter os métodos modulares ajudará a tornar o software mais fácil de
modificar e expandir posteriormente.
Você escreverá este suporte de sensor de gestos com base no Tessel. Não há razão para pensar que não
funcionaria em outras plataformas compatíveis com JohnnyFive (3,3 V), mas você não gastará tempo
neste projeto para fazer testes além do Tessel.
Coletando informações sobre o APDS-9960
Com seus objetivos e escopo definidos, é hora de coletar informações. Há muitas perguntas para
responder:
Hardware físico e protocolos— Qual é a voltagem operacional do dispositivo? Quais são os
pinos e conexões? Qual protocolo de comunicação faz

usar?
Comunicação— Quais são os detalhes para ler dados e gravá-los no dispositivo?
Configuração e configuração— Quais etapas precisam ser executadas para inicializar o dispositivo,
definir padrões e habilitar os recursos necessários?
Dados— Que tipo de dados são produzidos pelo dispositivo? Como você interpreta e processa os
dados?
UAU! e-book
www.wowebook.org
Sua primeira parada na jornada de descoberta é ler o guia e a documentação de conexão
APDS9960 do SparkFun (http://mng.bz/MapU). A placa de breakout do SparkFun para o
APDS9960 cuida de algumas das tarefas de nível de hardware para você - jumpers e conexões de
2
energia. A placa resultante pode ser conectada como outros componentes IC que você
encontrou. Mas há uma adição: uma conexão com um pino com capacidade de interrupção.
Voltaremos a isso. Outro detalhe muito importante é que este dispositivo opera em 3,3 V — tudo
bem para o Tessel, mas não tente conectá-lo a um Arduino de 5 V.
Em seguida, pegue a folha de dados do APDS9960 e dê uma olhada (http://mng.bz/

by50). A grande notícia é que a folha de dados do APDS9960 é excelente, como folhas de dados.
Mas ainda é uma folha de dados para um dispositivo não trivial: não entre em pânico se uma
espiada inicial fizer seus olhos se cruzarem um pouco. Leia a página 1 na íntegra — é um bom resumo.
2
Na folha de dados, você pode obter detalhes vitais, como o endereço IC codificado do dispositivo (é
0x39; consulte a p. 8).
Ao revisar o suporte de software e firmware existente para o APDS9960, você pode obter uma
grande vantagem. Shawn Hymel, da SparkFun, criou uma biblioteca Arduino de código aberto
completa e excelente (somente para Arduinos de 3,3 V!) que oferece suporte a todos os recursos
do dispositivo (http://mng.bz/8gE7). É excelente: legível e exaustivamente comentado. A
referência cruzada entre a biblioteca do Arduino e a folha de dados fornece alguns outros
detalhes sobre como trabalhar com o dispositivo.
Como trabalhar com o APDS-9960
Antes que os dados de gesto possam ser gerados, o hardware APDS9960 precisa ser inicializado e
ter seu modo de gesto ativado. Este é, conceitualmente, um processo de duas etapas.
Primeiro, há uma fase de configuração na qual os padrões e configurações são gravados em

vários registros individuais diferentes no APDS9960. Subseqüentemente, há uma fase de habilitação
na qual o modo de gesto é ativado (em oposição a um modo para um dos outros sensores do
dispositivo) e algumas configurações específicas de gesto são gravadas em mais alguns registros
(figura 9.13) .
Figura 9.13. Nesta representação de máquina de estado parcial simplificada de seu plug-in,
uma instância de objeto de plug-in começa em um novo estado. Por meio de um método
de configuração, ele se move para um estado inicializado, no qual o dispositivo APDS-9960
é inicializado, mas não detecta ativamente os gestos. Um método enable ativa o modo de
gesto no dispositivo.
UAU! e-book
www.wowebook.org
Para usar uma metáfora muito desleixada e imprecisa: configurar é como ligar o chip e inicializá-lo, enquanto
habilitar é como iniciar um aplicativo específico de gesto no dispositivo. Embora sua implementação
suporte apenas a detecção de gestos, o que significa que a habilitação sempre ocorrerá logo após a
configuração sem a intervenção do usuário, manter essas duas fases distintas facilitará a adição posterior
de suporte a sensores adicionais.
Quais registradores e quais valores precisam ser escritos durante a configuração e habilitação? Todas essas
informações estão na folha de dados; requer tempo, paciência e atenção aos detalhes para organizar tudo.
Com a configuração e habilitação concluídas, o APDS9960 estará detectando ativamente o movimento
do gesto. Quando o dispositivo detecta movimento e começa a produzir dados, ele puxa o pino de
interrupção para BAIXO, sinalizando que um gesto foi detectado. Ou seja, a voltagem no pino Tessel
conectado ao pino de interrupção da placa de breakout mudará de 3,3 V para 0 V. A chamada borda
descendente de HIGH para LOW é o sinal de que seu software deve ler os dados de gesto do
dispositivo.
Os dados que representam um gesto são compostos por uma coleção de conjuntos de dados de 4
bytes, cada um contendo 1 byte (um valor de 0 a 255) para cada direção (para cima, para baixo,
esquerda, direita). Ao analisar a maneira como esses valores mudam para cada direção no
conjunto de amostras do conjunto de dados, é possível derivar uma direção geral do gesto.
Quando o dispositivo detecta movimentos de gestos, ele puxa a interrupção LOW e começa a armazenar
conjuntos de dados em registros de memória. Existem 128 bytes de espaço no dispositivo para isso – até
32 leituras de 4 bytes cada – e os dados são colocados nesses registradores de maneira FIFO (firstin,
firstout) (figura 9.14).
Figura 9.14. Existem 128 bytes de FIFO RAM, começando no endereço de memória 0xFC, disponíveis
para armazenar dados de gestos. Neste exemplo, há três conjuntos de dados disponíveis na fila FIFO.
Um conjunto de dados é composto de quatro bytes, cada um representando dados para uma direção
diferente — para cima, para baixo, para a esquerda e para a direita.
UAU! e-book
www.wowebook.org
Quando o dispositivo de controle - seu Tessel - lê os bytes de dados desses registradores, ele
libera espaço e mais dados podem ser inseridos na FIFO RAM. Este ciclo continua - o controlador lê, o
dispositivo coloca mais dados no FIFO - até que não haja mais dados de gesto entrando e o FIFO seja
esvaziado. Então os dados podem ser processados pelo dispositivo de controle (figura 9.15).
Tecnicamente falando: interrupções
Tecnicamente, o dispositivo acionará uma interrupção ao detectar dados de gesto porque você o
configurará para fazer isso como parte da etapa de habilitação. O APDS9960 é altamente configurável
e a interrupção por gesto é um recurso opcional. Ainda mais tecnicamente, ele disparará uma
interrupção após quatro conjuntos de dados (amostras) terem sido colocados na FIFO RAM.
Precisamente quando essa interrupção dispara é, sim, também configurável.
Figura 9.15. A máquina de estado do plug-in ganha mais detalhes à medida que a pesquisa continua.
Quando uma interrupção é detectada, a instância do plug-in entra em uma fase de ciclo de leitura e,
em seguida, em uma fase de processamento antes de retornar ao estado ativado de escuta ativa.
UAU! e-book
www.wowebook.org
Prototipando uma prova de conceito
Antes de abordar a implementação do plug-in, uma verificação de sanidade é necessária. Você vai
2
estabelecer uma área de trabalho, conectar o chip e certificar-se de que pode estabelecer
comunicação IC com ele. Isso fará com que você se sinta mais confiante ao entrar nas fases de
desenvolvimento mais detalhadas.
A fiação da placa de conexão APDS9960 é fácil, embora você precise soldar os pinos de cabeçalho
nela primeiro. Conecte-o como mostrado na figura 9.16. O pino de interrupção está conectado ao
pino A2 no Tessel, que é um pino com capacidade de interrupção.
Figura 9.16. Diagrama de fiação para placa de breakout APDS-9960
UAU! e-book
www.wowebook.org
Crie uma nova área de trabalho do projeto e instale estas dependências:
gesto mkdir
cd gesto npm
init e npm install
johnnyfive tesselio
Copie também o arquivo RemoteSwitch.js para o diretório de gestos. Você vai usá-lo novamente
mais tarde.
Criação e compartilhamento de diagramas de circuitos e fiação
Para criar os diagramas de fiação usados neste livro, usei o software Fritzing de código aberto
(http://fritzing.org/home/), que está disponível nas plataformas Mac, Windows e Linux. Ele vem
com uma variedade de peças, incluindo placas e componentes com os quais você pode construir
diagramas. Além disso, fabricantes de peças como SparkFun e AdaFruit geralmente fornecem peças
Fritzing para seus produtos. Consegui encontrar uma peça para o APDS 9960 no repositório
Fritzing_Parts do SparkFun, por exemplo (http://mng.bz/Hsa2).
É possível criar esquemas e diagramas com Fritzing, embora eu ache complicado.

Consideravelmente mais pesado no mundo do software de design esquemático e PCB é o EAGLE
da Autodesk. Tem, sem surpresa, uma curva de aprendizado, mas é amplamente UAU! e-book
www.wowebook.org
usado e há uma versão gratuita de plataforma cruzada se você quiser dar uma volta
(www.autodesk.com/products/eagle/freedownload).
KiCad EDA é outra opção para plataforma cruzada, esquema de código aberto e software de design
de PCB (http://kicadpcb.org/).
Se você está interessado em experimentar a simulação de circuitos eletrônicos - não placas de alto nível
e microcontroladores, mas fundamentos como capacitores, portas lógicas, transistores e transformadores
- você pode tentar o iCircuit App ($ 9,99), disponível para iOS, Android e Windows (desktop e telefone). Este
não é um aplicativo de desenho ou desenho estático.
Em vez disso, é um mecanismo de simulação ao vivo que permite ver o que realmente acontece conforme
você faz alterações nos circuitos.
Um dos muitos registradores no APDS9960 é um registrador DEVICE_ID somente leitura, com endereço
0x92 (p. 25 do datasheet). Ao ler um byte desse endereço, você deve sempre obter o valor 0xAB (figura
9.17). Isso não é útil para a operação posterior do chip, mas é uma maneira conveniente de garantir
2
que a comunicação do IC esteja funcionando e que você esteja, de fato, conectado a um APDS9960.
Figura 9.17. O valor no registro DEVICE_ID no endereço 0x92 no APDS

9960 deve ser sempre 0xAB (10101011 em binário).
UAU! e-book
www.wowebook.org
Crie um arquivo chamado i2ctest.js e adicione o seguinte código a ele.
Listagem 9.7. Testando a conexão com o APDS-9960
const five = require('johnnyfive'); const Tessel =

require('tesselio'); const board = new five.Board({ io: new
Tessel() });
board.i2cConfig({ endereço: 0x39 });
board.i2cReadOnce(0x39, 0x92, 1, data => { if (data[0] !== 0xAB) { // O registro DEVICE_ID deve retornar 0xAB
throw new Error('Não é possível estabelecer conexão com APDS9960');

} outro {
console.log('Conectado ao APDS9960!'); }
});
});
2
1 Inicia as comunicações IC com endereço escravo 0x39. Este é o APDS
2
Endereço IC codificado do 9960.
UAU! e-book
www.wowebook.org
2 Lê 1 byte do registrador 0x92 do dispositivo no endereço 0x39
3 Se esse registrador não contém o dado 0xAB, algo deu errado.
2
Interface IC padrão
2
Tessel tem duas interfaces IC. JohnnyFive, via tesselio, usará automaticamente o da porta A se
não for informado nas opções passadas para board.i2cConfig().
2
Recursos de IC no JohnnyFive
O método i2cReadOnce(address, register, bytesToRead,

handler(arrayOfBytes)) lê o número fornecido de bytesToRead a partir do registrador
indicado. O retorno de chamada é chamado e passado uma matriz de bytes quando a leitura é
concluída.
i2cReadOnce é diferente de um método relacionado, i2cRead. Como o nome indica,

i2cReadOnce lê uma vez, enquanto i2cRead lerá continuamente a partir da combinação
de endereço/registro indicada. i2cRead é útil se você quiser ler o(s) mesmo(s) registrador(es)
repetidamente para observar as alterações. No seu caso, você usará o recurso de interrupção do
APDS9960 para avisá-lo quando houver novos dados de gesto, não pesquisando usando
i2cRead.
2
A implementação subjacente real desses métodos utilitários de IC - que também, sem
2
surpresa, incluem a capacidade de gravar em um dispositivo IC - depende do plug-in de E/S
ativo. No caso do Tessel, isso é tratado pelo tesselio; para o Arduino, seria a Firmata fazendo
o trabalho pesado aqui.
Experimente este código de teste em seu circuito Tessel e APDS9960 conectado:
$ t2 execute i2ctest.js lan
Depois de ver com sucesso a mensagem registrada “Connected to APDS9960!” é hora de seguir
em frente e construir o próprio plug-in do componente.
Escrevendo o plugin APDS9960

WOW! e-book
www.wowebook.org
Crie um arquivo chamado APDS9960.js e comece com o código mostrado na listagem a seguir.
Para completar o código do plug-in, você preencherá essas seções.
Listagem 9.8. ponto de partida APDS9960.js
// Dependências
const Emitter = require('events').EventEmitter;const util = require('util');
/** CONSTANTES AQUI **/

return (função() { /**
* @param {Object} opts Opções: pin, endereço * pin denota conexão de pino de
interrupção
*
* Exemplo de inicialização: * var gesto = new

APDS9960('A2');
* var gesto = new APDS9960({ pin: 'A2'});
* gesto.on('para cima', () => { ...faça alguma coisa ...}); */
função APDS9960 (opta) {

// Construtor: configura as propriedades da instância e inicia a inicialização
}
// Estende a classe EventEmitter do Node.js para que nosso objeto possa emitir eventos
util.inherits(APDS9960, Emissor);
/* Redefine os dados de gesto atuais desta instância */

APDS9960.prototype.resetGesture = function () { };
/* `setup` e ènable` são chamados a partir do construtor */ APDS9960.prototype.setup =

function (callback) { };APDS9960.prototype.enable = function () { };
/* Quando a interrupção é baixada, `readGesture` lê os dados do

* FIFO até que os dados se esgotem, então invoca `processGesture` * e `decodeGesture` para processar os
dados resultantes */
APDS9960.prototype.readGesture = função () { };
/* `processGesture` realiza alguns cálculos sobre os dados lidos e

* determina algumas proporções e deltas nas amostras direcionais. */
APDS9960.prototype.processGesture = function () { };
/* Usando `deltas` calculado por `processGesture`, "decodifica" a * informação em um gesto (para

cima, para baixo, esquerda, direita) quando possível
* e emite eventos.
*/
APDS9960.prototype.decodeGesture = function () { };
UAU! e-book
www.wowebook.org
retornar APDS9960;
}());
};
Os métodos na superfície da API de alto nível representam a máquina de estado completa

(figura 9.18). Agora você precisa implementar esses métodos.
Figura 9.18. A máquina de estado do plug-in agora está completa. O próximo passo
é implementá-lo.
Constantes e definições de configuração
Você obterá algumas constantes definidas primeiro, pois existem muitas delas. Mas não entre em pânico. As
constantes em APDS9960.js definem endereços de registro, máscaras de bits, valores padrão e alguns outros
bits e bobs de configuração.
Descobrir quais registradores precisam ser escritos para configurar e habilitar o dispositivo é um
exercício detalhado de referência de folha de dados (e espiar outras implementações de software
quando disponíveis).
A Figura 9.19 mostra alguns dos registradores nos quais as definições de configuração são gravadas
durante a configuração e habilitação. Alguns valores de registradores são definidos como um valor
padrão simples e sensível, como GPENTH, que é definido como a representação binária de 40. Outros
são desativados — GOFFSET_U é definido como 0x00. E alguns são bitmasks, definindo vários
sinalizadores — valores de configuração — de uma só vez (GCONF1, GCONF2).

UAU! e-book
Figura 9.19. Uma amostra dos registradores APDS-9960 que são gravados durante
www.wowebook.org
Figura 9.19. Uma amostra dos registros APDS-9960 que são gravados durante a configuração
e permitem
Usando bitmasking para gerenciar a configuração de recursos
O plug-in APDS9960 usa bitmasking para gerenciar definições de configuração no

APDS9960 — vários valores de configuração geralmente estão contidos em um único byte,
com diferentes posições de bits correspondentes aos valores de diferentes recursos. Vários
sinalizadores de máscara são bitwiseOR'ed juntos para compor o byte multifuncional.
Por exemplo, o registrador no endereço 0xA3 (GCONF2), contém configuração para três
features (figura 9.20).
Figura 9.20. Diferentes faixas de bits dentro do registro GCONF correspondem a diferentes
configurações. Os dois bits nas posições 6 e 5 definem o ganho do gesto, por exemplo. O bit 7
não é usado.
UAU! e-book
www.wowebook.org
Mais uma vez, indico o excelente artigo do MDN sobre operadores bitwise e bitmasking (http://mng.bz/
CLvy).
Preencha as constantes conforme mostrado na listagem a seguir.
Listagem 9.9. Constantes APDS9960
const REGISTROS = {
ENABLE: 0x80, // Habilita diferentes sensores/recursos (p.20)
WTIME : 0x83, // Valor de configuração do tempo de espera (p.21)
PPULSE: 0x8E, // Contagem e duração do pulso de proximidade (p.23)
CONFIG2 : 0x90, // Segundo registro de configuração (p.24), para aumento de LED DEVICE_ID: 0x92, // Contém ID do
dispositivo (0xAB) (p.25)
GPENTH : 0xA0, // Limiar de proximidade de entrada para gestos (p.27)
GEXTH : 0xA1, // Sair do limite de proximidade para gestos (p.28)
GCONF1 : 0xA2, // Gesture config 1: mascaramento de detecção de gesto (p.28)
GCONF2 : 0xA3, // G config 2: ganho, drive de LED, tempo de espera por gesto (p.29)
GOFFSET_U: 0xA4, // Deslocamento do gesto (para cima) (p.30)
GOFFSET_D: 0xA5, // Deslocamento do gesto (para baixo) (p.30)
GULSE: 0xA6, // Contagem e duração do pulso do gesto (p.31)
GOFFSET_L: 0xA7, // Deslocamento do gesto (esquerda) (p.30)
GOFFSET_R: 0xA9, // Deslocamento do gesto (direita) (p.31)
GCONF4 : 0xAB, // Gesture config 4: interrupções, habilitação do modo (p.32)
GFLVL : 0xAE, // Gesture FIFO level: # of datasets in FIFO (p.32)
UAU! e-book
www.wowebook.org
GSTATUS : 0xAF, // Status do gesto; bit 0 indica dados disponíveis (p.33)
GFIFO_U : 0xFC, // 1º registrador FIFO em (RAM)—leia os dados daqui (p.33)
};
const SINALIZADORES = {
GFIFOTH : 0b10000000, /* Limiar FIFO: acionar interrupção após 4 conjuntos de dados em FIFO (GCONF1 <7:6>
p.28) */ GGAIN : 0b01000000, /* Controle de ganho de gesto: 4x (GCONF2 <6:5> p.29 ) */ GLDRIVE : 0b00000000, /*
Intensidade do LED do gesto: * 100mA (GCONF2 <4:3> p.29) */ GWTIME :
0b00000001, /* Tempo de espera do gesto:
2,8 ms (GCONF2 <2:0> p.29) */ GPLEN : 0b11000000, /* Comprimento do pulso do gesto: 32ÿs
(GPULSE <7 :6> p.31) */ GPLEN : 0b00001001, /* Contagem de pulso do gesto: 10
(9 + 1) (GPULSE <5:0> p.31) */ GVALID : 0b00000001, /* O valor do registro GSTATUS indica
dados válidos se o bit 0 for 1 */
PPLEN : 0b10000000, /* Comprimento do pulso de proximidade: 16ÿs (PPULSE <7 :6>

p.23) */ PPULSE : 0b10001001, /* Contagem de pulso de proximidade: 10 (9 + 1) (PPULSE
<5:0> p.23 ) */ LED_BOOST: 0b00110000, /* Aumento da unidade de LED: 300%
(CONFIG2 <5:4> p.24) */ GIEN : 0b00000010, /* Ativação de interrupção por gesto: sim (GCONF4 <1>
p.32) */ GMODE: 0b00000001, /* Modo de gesto:
sim! (GCONF4 <0> p.32) */ ENABLE : 0b01001101, /* Ativar recursos:
Gesto, Espera, Proximidade, Ligar (ENABLE, p.20) */
};
// Durante a configuração, (valor) é escrito em cada registrador (chave) const SETUP_DEFAULTS

= { ENABLE : 0x00, /* Desativa todas as
coisas, desligando efetivamente o chip (p. 20) */ GPENTH : 40, // Proximidade de
entrada limiar GEXTH : 30, // Limite de proximidade de saída GCONF1 : FLAGS.GFIFOTH, // Limite de interrupção FIFO
GCONF2 : FLAGS.GGAIN | FLAGS.GLDRIVE | FLAGS.GWTIME, // Ganho de gesto,
Unidade de LED, tempo de espera

GOFFSET_U: 0x00, // sem deslocamento GOFFSET_D: 0x00, //
sem deslocamento GOFFSET_L: 0x00, // sem deslocamento
GOFFSET_R: 0x00, // sem deslocamento GULSE : FLAGS.GPLEN
| FLAGS.GPULSE // contagem e duração do pulso,
};
// Durante a habilitação, cada (valor) é escrito no registrador (chave)

const ENABLE_VALUES = { WTIME :
0xFF, /* Tempo de espera entre os ciclos no modo de baixa potência: 2,78ms (p. 21) */ WOW! e-book
www.wowebook.org
PPULSE : FLAGS.PPLEN | FLAGS.PPULSE, // Comprimento do pulso de proximidade e contagem CONFIG2:
FLAGS.LED_BOOST,
GCONF4 : FLAGS.GIEN | FLAGS.GMODE,
ATIVAR: FLAGS.ENABLE
};
// Para processamento de dados lidos

const GESTURE_THRESHOLD_OUT = 30;
const GESTURE_SENSITIVITY = 10;
Tecnicamente falando: como realmente funciona
O APDS9960 detecta “gestos” detectando mudanças na quantidade de energia refletida de volta
para ele por um LED infravermelho embutido. Os detalhes da configuração desse LED – quanta energia é
usada para acioná-lo, quantas vezes ele pulsa e quanto tempo cada pulso dura por ciclo de detecção –
aparecem frequentemente nos valores de configuração definidos.
9.3.2. Implementando construtor e métodos de inicialização

Em seguida, você detalhará o construtor, bem como os métodos para inicializar e ativar o dispositivo no modo
de gestos.
A estrutura básica do construtor é a mesma do construtor RemoteSwitch.
O construtor também inicia a configuração e ativação, conforme mostrado na listagem a seguir.
Listagem 9.10. APDS9960: redefinição de dados do construtor e do gesto
função APDS9960 (opta) { if (!(esta

instância de APDS9960)) {
return new APDS9960(opções); }
five.Board.Component.call(this, opts = five.Board.Options(opts));

this.interruptState = 1; // A interrupção está ativa LOW
opts.address = opts.address || I2C_ADDR; this.address = opts.address; this.io.i2cConfig(opts); // Inicia as comunicações I2C para o
dispositivo
this.io.i2cReadOnce(this.address, REGISTERS.DEVICE_ID, 1, data => { if (data[0] !==

DEVICE_ID) { // O registro DEVICE_ID deve retornar 0xAB throw new Error('Não é possível estabelecer
conexão com APDS9960 ');
}
});
this.resetGesture();
this.setup(this.enable); UAU! e-book www.wowebook.org
}
util.inherits(APDS9960, Emissor);
APDS9960.prototype.resetGesture = function () {
this.gestureData = {
cru: [],
deltas: {}, moves: { // Um
gesto pode ter movimentos em mais de um eixo vertical : false,
horizontal: falso,
para cima: falso,
para baixo: falso,
esquerda: falso,
certo: falso
}, valid:
false, // A decodificação do gesto foi bem-sucedida?
direção: indefinida
};
};
1 Registra o componente com a placa ativa
2 A interrupção passará de ALTO para BAIXO para ativar; começa com um valor ALTO (1)
2
3 Prepara o endereço IC para passar para i2cConfig
2
4 Também retém o endereço IC no objeto do componente
5 this.io é uma referência à instância de placa ativa.
6 Redefine (inicializa) o objeto de dados de retenção de gestos
7 Inicia a configuração (seguida de ativação)
A seguir, os métodos de inicialização: setup e enable.
Listagem 9.11. APDS9960: preenchendo a configuração e habilitando
APDS9960.prototype.setup = function (callback) {

for (var rKey in SETUP_DEFAULTS) { this.io.i2cWrite(this.address,
REGISTERS[rKey], [SETUP_DEFAULTS[rKey]]);
}
if (typeof callback === 'function') { callback.call(this);
}
};
APDS9960.prototype.enable = função () {
UAU! e-book
www.wowebook.org
// Configure o tratamento de interrupção
this.io.pinMode(this.pin, this.io.MODES.INPUT); // As interrupções do dispositivo estão ativas em nível BAIXO—
quando o pino for BAIXO, devemos agir
this.io.digitalRead(this.pin, dados => {
if (dados !== this.interruptState && dados === 0) {
this.readGesture();
}
this.interruptState = dados;
});
for (var rKey in ENABLE_VALUES) { this.io.i2cWrite(this.address,
REGISTERS[rKey], [ENABLE_VALUES[rKey]]); }
};
1 Grava valores padrão (SETUP_DEFAULTS) para configuração do dispositivo em vários registradores
2 Chama o retorno de chamada (habilitar, neste caso)
3 Configura a interrupção conectada como um pino de entrada digital
4 Lê valores continuamente do pino de interrupção
5 Quando a interrupção vai de HIGH para LOW, invoca readGesture
6 Assim como a configuração, escreve a configuração para recursos específicos do modo de gesto
Lendo dados do sensor
Com esse código de inicialização e configuração definido, vamos atacar a verdadeira essência do plug-
in: ler e processar dados de gestos. Quando o pino de interrupção fica BAIXO, readGesture é invocado,
lendo dados do APDS9960.
Listagem 9.12. Lendo dados de gesto
APDS9960.prototype.readGesture = function () { // O valor GSTATUS

determina se dados válidos estão disponíveis (p.33)
this.io.i2cReadOnce(this.address, REGISTERS.GSTATUS, 1, status => {
if (status & FLAGS.GVALID === FLAGS.GVALID) {
// Deve haver dados válidos no FIFO
// GFLVL reportará quantos conjuntos de dados estão no FIFO (p.32)
this.io.i2cReadOnce(this.address, REGISTERS.GFLVL, 1, fifoLevel => { // Lê o número de amostras de 4 bytes
indicadas por sampleCount // E as divide em seus componentes direcionais
this.io.i2cReadOnce(this.address,
REGISTERS.GFIFO_U, (fifoLevel * 4), rawData => { for (var i = 0; i < rawData.length; i += 4)
{ this.gestureData.raw.push({ up : rawData[i],
UAU! e-book
www.wowebook.org
para baixo : rawData[i + 1],
esquerda: rawData[i + 2],
direita: rawData[i + 3]
});
}
return this.readGesture(); // Continue lendo os dados...
});
});
} else { // Não há (mais) dados para coletar sobre este gesto this.processGesture();
this.decodeGesture();
this.resetGesture();
}
});
};
Primeiro, readGesture lê um byte do registrador GSTATUS. Se o valor nesse registro tiver

seu bit menos significativo (0º) definido como 1, você está no negócio: há dados válidos para serem
lidos do FIFO. Mas quantos dados? O valor do registrador GFLVL (nível FIFO de gesto) informará
quantas amostras do conjunto de dados estão disponíveis no FIFO no momento. Em
seguida, ele segue em frente e lê muitas amostras dos registradores FIFO, que começam em
GFIFO_U (endereço 0xFC).
Lembre-se de que cada conjunto de dados tem quatro bytes (um byte para cada direção),
portanto, o número total de bytes a serem lidos do FIFO é fifoLevel * 4. readGestures usa o
método i2cReadOnce mais uma vez, desta vez lendo fifoLevel * 4 bytes de um único byte. Em
seguida, itera sobre cada conjunto de dados completo e insere bytes individuais
correspondentes a cada direção na estrutura de dados brutos para processamento posterior. Em
seguida, chama a si mesmo (recursivamente) novamente para ver se há mais dados disponíveis para leitur
Figura 9.21. O ciclo de leitura começa verificando se o bit 0 no registrador

GSTATUS é 1. Se sim, GFLVL é lido para ver quantas amostras estão
disponíveis (0101, ou seja, 5), e então o número indicado é lido do FIFO.
O ciclo continua até que GSTATUS<0> seja 0.
UAU! e-book
www.wowebook.org
Este ciclo se repete até que o valor do registro GSTATUS indique que nenhum dado válido foi deixado para
read — a primeira condicional falha e a execução continua na cláusula else. Quando o
ciclo de leitura de dados estiver completo, o processamento desses dados começa.
Processamento e decodificação de dados de gestos
Os métodos em seu plug-in APDS9960 distinguem entre processamento e decodificação de dados de gestos
(figura 9.22).
Figura 9.22. processData executa aritmética em dados; decodeData deriva a direção do gesto dos resultados
calculados e dispara eventos. Por fim, o objeto de dados do gesto é redefinido na instância para que esteja
pronto para coletar dados do próximo gesto.
Na etapa de processamento, a matemática acontece. A coleção bruta completa de amostras é

filtrada para incluir apenas leituras nas quais o valor de cada direção excede um limite definido
UAU! e-book
www.wowebook.org
constante. Em seguida, a alteração (delta) nas taxas de leituras ao longo do tempo é calculada em cada
eixo (para cima/para baixo e esquerda/direita).
Listagem 9.13. Processando dados de gesto
APDS9960.prototype.processGesture = função () {
const raw = this.gestureData.raw;
const direçãoDelta = função (el1, el2, dir1, dir2) {
var el2r = ((el2[dir1] el2[dir2]) * 100) / (el2[dir1] + el2[dir2]);
var el1r = ((el1[dir1] el1[dir2]) * 100) / (el1[dir1] + el1[dir2]);
retornar el2r el1r;
};
const excedeThreshold = raw.filter(amostra => {
return (sample.up > GESTURE_THRESHOLD_OUT && sample.down
> GESTURE_THRESHOLD_OUT && sample.left >
GESTURE_THRESHOLD_OUT && sample.right >
GESTURE_THRESHOLD_OUT); });
if (!exceedsThreshold.length || raw.length < 4) {

// Se não houver dados suficientes ou nenhum exceder o limite, nada a fazer
// Isso resultará em dados de gesto sendo ignorados e descartados
retorna falso;
}
const primeiro = excedeThreshold[0];

const last = excedeThreshold[exceedsThreshold.length 1]; const deltas = {
upDown: direçãoDelta(primeiro, último, 'cima', 'baixo'),

leftRight: direçãoDelta(primeiro, último, 'esquerda', 'direita')
};
this.gestureData.deltas = deltas;
};
1 Calcula deltas comparando proporções de leituras de direções diferentes
2 Filtra as amostras para incluir apenas aquelas com leituras que excedem o
limite
3 Certifica-se de que há dados válidos para processar
4 Em última análise, cozinha alguns deltas
Por fim, a etapa de decodificação na listagem a seguir converte os deltas calculados pelo método
processGesture em direções derivadas para o gesto geral. Em seguida, ele dispara um evento
correspondente — para cima, para baixo, para a esquerda ou para a direita — ou, se não puder
determinar uma direção de gesto simples e clara, disparará um evento de gesto genérico, conforme
UAU! Listagem
de e-books 9.14. Decodificando dados
de gestos www.wowebook.org
Listagem 9.14. Decodificação de dados de gesto
APDS9960.prototype.decodeGesture = function () { const deltas =

this.gestureData.deltas;
const verticalMotion = Math.abs(deltas.upDown);
const horizontalMotion = Math.abs(deltas.leftRight); if (verticalMotion >
GESTURE_SENSITIVITY) { // Determina significado
movimento no eixo vertical
this.gestureData.valid =
verdadeiro;this.gestureData.movements.vertical =
verdadeiro;this.gestureData.movements.up = (deltas.upDown >= 0);
this.gestureData.movements.down = (deltas.upDown < 0);
} if
(horizontalMotion > GESTURE_SENSITIVITY) { // Determina significado
movimento no eixo horizontal
this.gestureData.valid =
verdadeiro;this.gestureData.movements.horizontal = verdadeiro;
this.gestureData.movements.left = (deltas.leftRight >= 0);
this.gestureData.movements.right = (deltas.leftRight < 0);
}
if (this.gestureData.valid) { if (verticalMotion >
horizontalMotion) {
this.gestureData.direction = (this.gestureData.movements.up) ? 'para cima' : 'para baixo'; } else {
this.gestureData.direction = (this.gestureData.movements.left) ?
'esquerda direita';
}
}
// Emite um evento direcional se houver uma direção
if (this.gestureData.direction)
{ this.emit(this.gestureData.direction, this.gestureData); }
// Sempre emite um evento de gesto genérico, mesmo se a decodificação falhar

this.emit('gesto', this.gestureData);
};
Com isso, o código do plugin está completo!
9.3.3. Integrando o sensor de gestos e os interruptores remotos
Agora você pode editar index.js para adicionar algum código de teste rápido, conforme mostrado
na listagem a seguir. Antes de chegar à grande etapa de combinação - conectar os interruptores
remotos - você pode testar diferentes eventos de furto de direção e registrá-los no console.
Listagem 9.15. Test drive APDS9960

const Tessel = require('tesselio'); const Gesture
= require('./APDS9960')(cinco); UAU! e-book
www.wowebook.org
gesto const = new gesto ({ pin: 'A2'});
gesto.on('direita', () => console.log('direita'));
gesto.on('esquerda', () => console.log('esquerda'));
gesto.on('para cima', () => console.log('para cima'));
gesto.on('para baixo', () => console.log('para baixo'));
});
Execute index.js no Tessel (t2 run index.js lan) e tente mover sua mão sobre a parte superior
do sensor de gestos — a melhor distância é de cerca de 20 cm (oito polegadas).
Combinando APDS9960 e RemoteSwitch
Você já tem os ingredientes para controlar combinações individuais de chave liga/desliga

usando o sensor de gestos e o RemoteSwitch. Por exemplo, você pode fazer algo como o que
é mostrado na listagem a seguir.
Listagem 9.16. APDS9960 controlando um único interruptor com o sensor de gesto

const Tessel = require('tesselio'); const Gesture = require('./
APDS9960')(cinco); const RemoteSwitch = require('./RemoteSwitch')(cinco);
const switch1 = new RemoteSwitch({ pins : { on: 'A3', off: 'A4' } });
gesto.on('direita', () => switch1.on());
gesto.on('esquerda', () => switch2.on());
});
Até agora tudo bem. Mas um dos objetivos declarados no início não era a capacidade de ligar ou
desligar todos os interruptores de uma só vez? A boa notícia é que você está prestes a fazer isso
acontecer. A outra notícia é que você precisa dar mais um passo para que isso aconteça.
Os desafios de orquestrar vários switches
O design do RemoteSwitch leva em conta a necessidade de escalonar as ativações do switch:

enfileira os “comandos” que chegam quando um dos botões já está ativo, coloca-os em uma
fila FIFO e executa o próximo comando na fila quando não está mais ativo. Além disso, ele
invocará um retorno de chamada fornecido quando terminar com um comando.
Assim, você pode executar o código na listagem a seguir sem medo da troca
UAU! e-book
www.wowebook.org
pisando em si.
Listagem 9.17. Um par de botões gerenciados por uma instância RemoteSwitch tem
uma fila
switch1.on(); // Acontece imediatamente switch1.off(); //

Fica na fila switch1.on(); // Entra na fila
switch1.off(() => console.log('hi!')); // Fica na
fila; registra 'hi!' para o
console quando terminar
Mas, infelizmente, há uma falha: o enfileiramento é gerenciado individualmente para cada par de
switches. Diferentes instâncias de RemoteSwitch não têm ideia umas das outras; consulte a listagem
a seguir.
Listagem 9.18. Cada RemoteSwitch tem sua própria fila
switch1.on(); // Acontece imediatamente switch1.off(); //

Fica na fila do `switch1` switch2.on(); // A fila do `switch2` está vazia...acontece
imediatamente (uh oh) switch3.on(); // a fila do `switch3` está vazia...acontece imediatamente (oh querido)
É bastante provável que o switch2 e o switch3 tentem ativar enquanto o switch1 ainda está
ocupado - o equivalente a apertar vários botões no controle remoto ao mesmo tempo.
Isso provavelmente não é bom. O RemoteSwitch foi projetado de forma que cada par de switches
não se conheça. Isso é um bom aceno para a abstração de hardware, mas nossa realidade é que
vários pares de switches estão compartilhando o mesmo transmissor em um único controle remoto.
dispositivo.
Controlando vários switches com Collection
Hooboy, outro ponto de inflexão do projeto. Você poderia separar RemoteSwitch e reescrevê-lo
para lidar com vários conjuntos de switches e suas filas misturadas. Ou você pode escrever algum
código para gerenciar vários pares de switches dentro da lógica específica do aplicativo.
Ambas as opções têm desvantagens. Seria tedioso adaptar o RemoteSwitch sem quebrar sua
API existente ou complicá-la demais (essa opção pareceria mais atraente se você estivesse
começando do zero). Despejar a lógica relacionada em seu código de aplicativo principal seria
feio e perturbador. Depois de refletir um pouco, optei por uma terceira opção pragmática -
embora ligeiramente remendada - que tira vantagem de um Johnny
Cinco mixins chamados Collection.
UAU! e-book
www.wowebook.org
Classes de coleção incorporadas como Motors (que você viu no capítulo 6) usam o mixin Collection no JohnnyFive,
que fornece recursos para gerenciar vários componentes em um único objeto semelhante a um contêiner. Você
pode usar alguns dos recursos oferecidos por este mixin para criar um componente que pode gerenciar vários
objetos RemoteSwitch. Depois de concluído, você poderá escrever um código como o da lista a seguir de dentro do
módulo principal do aplicativo.
Listagem 9.19. Usando RemoteSwitches
interruptores const = new RemoteSwitches([

new RemoteSwitch({ pins : { on: 'A3', off: 'A4' } }), new RemoteSwitch({ pins: { on: 'A5',
off: 'A6' } }), new RemoteSwitch({ pins: { on: 'A7', off: 'B0' } }) ]);
// Você pode agir em todos os interruptores de uma vez...

switches.on(); // Liga todos os interruptores // Ou um único
interruptor... switches.off(1); //
Desliga o segundo interruptor
Crie um arquivo chamado RemoteSwitches.js em seu diretório de trabalho e adicione o seguinte

código.
Listagem 9.20. RemoteSwitches
const util = require('util');
module.exports = function (cinco, RemoteSwitch) {

função RemoteSwitches (opções) {
if (!(esta instância de RemoteSwitches)) {
retornar novos RemoteSwitches(opções);
}
// RemoteSwitch é o "tipo" de cada objeto componente individual
// que será gerenciado por esta instância RemoteSwitches
Object.defineProperty(this, 'type', { value: RemoteSwitch }); // Faça funcionar: registrar e inicializar os
objetos do componente da coleção
five.Collection.call(this, opts);
this.isActive = false; 1((CO111))
esta.fila = [];
}
// Use o mixin Collection
util.inherits(RemoteSwitches, five.Collection);
// A lógica prática para (des)ativar um determinado switch

// Observe que isso não está no protótipo (inacessível externamente)
const write = function (whichSwitch, turnOn) {
if (this.isActive) {
this.queue.push([whichSwitch, turnOn]);
retornar; UAU! e-book
www.wowebook.org
}
this.isActive = verdadeiro;
// O método "toggle" de um objeto RemoteSwitch individual // é invocado
whichSwitch.toggle.call(whichSwitch, turnOn, () => { this.isActive = false;
if (this.queue.length) { write.apply(this,
this.queue.shift());
}
});
};
// Os métodos de protótipo aceitam o argumento ìdx` opcional para designar qual // switch ativar. Se não for
fornecido, todos os interruptores serão afetados.
RemoteSwitches.prototype.toggle = function (idx, turnOn) { if (typeof idx !== 'undefined' && this[idx])
{
write.call(this, this[idx], turnOn);
} outro {
this.each(whatSwitch => write.call(this, whichSwitch, turnOn));
}
};
RemoteSwitches.prototype.on = function (idx) { this.toggle(idx, true); }; RemoteSwitches.prototype.off = function (idx)

{ this.toggle(idx, false); };
retornar RemoteSwitches;
}());
};
9.3.4. Juntando todo o projeto

Todas as peças já estão prontas para fazer um projeto combinado, reunindo software e
módulos de circuitos em um controle remoto controlado por gestos.
Combine os dois circuitos — controle remoto e gesto — conforme mostrado na figura 9.23.
Os lados de saída dos fotoacopladores devem ser conectados aos contatos do botão do
controle remoto. Observe que os fotoacopladores agora estão conectados a pinos diferentes no
Tessel para abrir espaço para o APDS9960.
Figura 9.23. Diagrama de fiação mostrando a combinação da placa breakout

APDS-9960 e os circuitos de botão/fotoacoplador.
UAU! e-book
www.wowebook.org
Usando breadboards de tamanho normal
Se você usar uma breadboard de tamanho normal, conforme mostrado na figura 9.23, certifique-se de conectar
os trilhos de alimentação conforme mostrado no meio do comprimento da placa: as conexões do trilho de alimentação
têm uma interrupção no meio.
Você pode pensar em uma breadboard de tamanho normal como duas breadboards de meio tamanho juntas.
Finalizando o software
Seu diretório de gestos agora deve conter o seguinte:
APDS9960.js_— Plug-in do sensor de gestos
RemoteSwitch.js— (Individual) plug-in de comutação remota
RemoteSwitches.js— Coleta de switches remotos
index.js— Lógica do aplicativo
UAU! e-book
www.wowebook.org
Para abrir espaço para as conexões APDS9960, as conexões para os fotoacopladores precisam diminuir
alguns pinos (consulte a figura 9.23) — esses números de pinos atualizados são contabilizados na
versão final do index.js, conforme mostrado na listagem a seguir.
Listagem 9.21. Juntando tudo em index.js

const Tessel = require('tesselio'); const Gesture = require('./
APDS9960')(five); const RemoteSwitch = require('./RemoteSwitch')(five);
const RemoteSwitches = require('./RemoteSwitches' )(cinco, RemoteSwitch);
interruptores const = new RemoteSwitches([
new RemoteSwitch({ pins : { on: 'A3', off: 'A4' } }), new RemoteSwitch({ pins: { on: 'A5', off: 'A6' } }),
new RemoteSwitch({ pins: { on: 'A7', off: 'B0' } }) ]);
gesto.on('para cima', () => switches.on());

gesto.on('para baixo', () => interruptores.desligar());
gesto.on('direita', () => switches.on(1));
gesto.on('esquerda', () => interruptores.desligar(1));
});
1 Requer o módulo RemoteSwitches
2 Você pode, é claro, alterar quais gestos correspondem a qual comportamento do switch.
Isso foi muito trabalho! Mas há alguns resultados sólidos aqui. Você definitivamente esculpiu mais alguns
entalhes triunfantes em seu pólo de experiência em hackers eletrônicos. É claro que ainda há fios
indo para todos os lugares, algo que você abordará daqui a pouco quando examinarmos diferentes tipos
de gabinetes de projeto para diferentes fatores de forma.
Falando em fatores de forma, você tem dado muita atenção ao Arduino Uno e ao Tessel, usando ambos
com o JohnnyFive. Mas há muito mais opções de hardware controlado por JavaScript por aí. É
hora de conhecer alguns dos outros jogadores.
RESUMO
Eletrônicos de consumo de baixa voltagem operados por bateria podem muitas vezes ser
reaproveitados em peças e componentes para seus próprios projetos (desde que você tenha cuidado!).
UAU! e-book
www.wowebook.org
Os componentes do fotoacoplador podem ajudar a isolar os circuitos desses componentes
eletrônicos dos circuitos do microcontrolador.
A invenção requer engenhosidade, mas também persistência e paciência. Muitas vezes requer
pensamento criativo para resolver problemas inesperados.
Folhas de dados podem ser extremamente densas em dados, mas são vitais e, com o tempo, você
aprenderá os truques e poderá encontrar informações importantes dentro deles – como endereços
de registro de memória e etapas de configuração – mais rapidamente.
Mesmo projetos pessoais de hobby podem se beneficiar de uma abordagem de desenvolvimento
organizada: identificação de metas e escopo, pesquisa, prototipagem e iteração.
Encapsular o comportamento em blocos modulares em nível de componente é uma boa
prática de desenvolvimento, especialmente para abstração e suporte de plataforma cruzada. Com o
JohnnyFive, você pode criar plugins de componentes e também aproveitou o

Coleção mixin.
UAU! e-book
www.wowebook.org
Parte 4. Usando JavaScript com hardware em outros ambientes

História
Esta parte do livro explora alguns outros ambientes nos quais você pode usar JavaScript para
controlar o hardware e olha para o futuro.
Tutoriais
Você começará no capítulo 10 examinando ambientes JavaScript e semelhantes a JavaScript em dispositivos
altamente restritos, prototipando alguns experimentos com o Espruino Pico e

Ofertas e
promoções Dispositivos Kinoma Element.
Os capítulos 10 e 11 percorrem um conjunto de etapas reutilizáveis para conhecer rapidamente as novas
plataformas Highlights . No capítulo 11, voltaremos nossa atenção para hardwares mais robustos:
as computadores de placa única de uso geral (SBCs) que possuem recursos de E/S integrados. Você colocará
configurações em funcionamento com o Raspberry Pi 3 e o BeagleBone Black e adaptará alguns experimentos

do
Johnny Support Five para serem executados em ambas as plataformas.
Sair O
Capítulo 12 fornece uma amostra de algumas outras partes do ecossistema IoT e examina o que é possível em um
navegador da web. Você usará um serviço de nuvem para empacotar e implantar um aplicativo JohnnyFive em um
BeagleBone Black e explorará a vanguarda da Web Bluetooth e da Web física com o dispositivo Espruino Puck.js.
Quando terminar esta parte do livro, seu kit de ferramentas JavaScript on Things estará bem abastecido e
você estará pronto para partir por conta própria no mundo corajoso e inspirador do JavaScript e dos sistemas
embarcados.
UAU! e-book
www.wowebook.org

História

Tópicos
Como as plataformas de hardware embarcadas compatíveis com JavaScript se comparam às

Tutoriais plataformas hostclient e singleboardcomputer (SBC)
Etapas para se familiarizar com uma nova plataforma de desenvolvimento

Examinando duas plataformas JavaScript incorporadas representativas: Espruino Pico e
DestaquesElemento Kinoma
Desenvolvendo projetos com o Espruino Pico

Configurações
Criando texto e formas com os visores LCD do Nokia 5110 e o Espruino Graphics
Biblioteca de suporte
Reutilizando componentes confiáveis: usando o multissensor BMP180 e o HMC5883L

Bússola
de saída de novas maneiras em diferentes plataformas
Uma visão de estudo de caso do Elemento Kinoma
Na primeira metade deste livro, os fundamentos da eletrônica foram demonstrados usando um Arduino
Uno conectado — uma configuração de hostclient. Nos últimos capítulos, no entanto, você conheceu o
Tessel 2, que tem a capacidade de executar o Node.js nativamente em seu sistema operacional OpenWrt
— que é uma configuração de computador de placa única (SBC).
Agora vamos dar uma olhada em uma terceira classe de plataformas controladas por JavaScript:
hardware embarcado restrito com suporte nativo para JavaScript (ou, geralmente, algo parecido
com JavaScript). Para realizar essa façanha com recursos de hardware tão limitados, essas plataformas
tendem a contar com mecanismos JavaScript personalizados altamente otimizados.
Esses dispositivos estão evoluindo rapidamente, entrando (e saindo) do mercado mais rapidamente do
que pode ser capturado na impressão. Neste exato momento, a plataforma Espruino – veremos em
breve o Espruino Pico – parece estar mantendo um impulso robusto (figura 10.1). O Elemento
,
Kinoma - também no convés para nossas investigações - está em pré-lançamento há algum tempo.
Embora o tempo de execução incorporado do Kinoma tenha sido considerado um pioneiro no suporte à
maioria dos recursos do ECMAScript 6, o produto Element

UAU! e-book
www.wowebook.org
pode acabar não decolando. É difícil dizer com as coisas acontecendo tão rapidamente.
Figura 10.1. Duas plataformas JavaScript incorporadas: Espruino Pico e Kinoma

Element
A obsolescência é praticamente garantida para informações de hardware e software IoT comprometidas para
impressão, e é por isso que este capítulo se concentra mais em tarefas e quebra-cabeças comuns em
plataformas JavaScript incorporadas. Produtos e plataformas específicos vêm e vão, mas há várias etapas de
pesquisa comuns que podem ajudá-lo a se atualizar rapidamente em qualquer produto que você escolher.
1 bico espruim
1 Elemento Kinoma
1 micro cabo USB
18 (duas tiras de 9 cada) pinos de cabeçalho de separação macho de 0,1 ÿ
1 cabo USB 2.0 A para USB A fêmea (também conhecido como cabo de extensão USB)
2
1 placa multissensor Adafruit BMP180 IC
1 módulo de display LCD Nokia 5110 84x48
1 resistor de 100 V
UAU! e-book
www.wowebook.org
1 placa de magnetômetro Adafruit HMC5883L (bússola)
Fios de jumper
10.1. A PLATAFORMA ESPRUINO PICO
O Espruino Pico tem menos memória e menos poder computacional que o Tessel 2.
Não há WiFi nem suporte para periféricos USB, então por que usá-lo? Porque ele se destaca em outras
coisas: é mais barato, é minúsculo, é confiável e tem baixo consumo de energia - marcas registradas de
plataformas incorporadas de baixo consumo de energia.
O Espruino descreve a própria família de hardware e o interpretador de tempo de execução do
firmware que vem pré-flash nos dispositivos Espruino. Espruinotheinterpreter suporta a maioria dos
recursos JavaScript, mas não todos eles. Você não pode omitir ponto e vírgula, por exemplo, e expressões regulares
não são suportadas.
É importante diferenciar JavaScript e JavaScriptesque de Node.js: isso não é Node.js, então você não pode usar
JohnnyFive ou quaisquer módulos npm.
UAU! e-book
www.wowebook.org
Em vez disso, o Espruino fornece sua própria API JavaScript para interagir com a E/S do
hardware (www.espruino.com/Reference#software). Você tem experiência suficiente agora que
os aspectos da API provavelmente soam familiares - há uma função analogRead, por exemplo,
que usa um número de pino como argumento. Existem também módulos Espruinoespecíficos que
encapsulam o comportamento de componentes eletrônicos específicos, como você verá.
Antes de examinar o Pico com mais profundidade, você vai configurá-lo e dar uma olhada em
um script Hello World LED piscando.
10.1.1. Configurando o pico

O Pico precisa ser soldado nas tiras de cabeçalho (figura 10.2). Seu Pico pode ter vindo com tiras
de cabeçalho, mas se não, você precisará de duas tiras de nove pinos cada.
Figura 10.2. O Pico tem 18 pinos (duas fileiras de 9 cada) em um passo de 0,1 polegada
- compatível com breadboard. Eles precisarão ser soldados nos pinos de cabeçalho. Uma
extremidade da placa Pico é moldada para que possa ser conectada diretamente a uma porta USB.
O Pico se conecta diretamente a uma porta USB. Algumas versões do Pico têm uma conexão micro
USB adicional, mas você pode ficar preso apenas com a conexão USB A. Isso pode ser conveniente,
porque você pode conectar seu Pico diretamente ao seu computador, mas se quiser usar o Pico em
uma breadboard - o que é necessário quando você deseja experimentar qualquer um dos pinos de E/
S - fica um pouco complicado. . O Pico foi projetado para se conectar a um conector USB A
fêmea. Você pode usar o tipo de cabo comercializado como um cabo de extensão USB para obter
as conexões USB A para USB A fêmea de que o Pico precisa (figura 10.3).
Figura 10.3. Você pode usar um cabo de extensão USB para conectar seu Pico ao seu
computador, permitindo que o Pico seja colocado em uma breadboard. A extremidade USB do
Pico se encaixa em uma conexão USB A fêmea.
UAU! e-book
www.wowebook.org
As coisas estão evoluindo rápido o suficiente na família Espruino que incluir instruções exaustivas de configuração
aqui seria uma tolice. Em vez disso, vá para https://espruino.com para obter
iniciado.
Estas são as etapas básicas, depois de conectar seu Pico ao USB:
1. Prepare o Pico para sua plataforma:
1. Os usuários de Mac provavelmente não precisam fazer mais nada.
2. Os usuários do Windows provavelmente precisarão de um driver.
3. Os usuários do Linux podem precisar ajustar as permissões.
2. Instale o aplicativo Espruino IDE Chrome (e o navegador Chrome se você não o tiver
instalado).
3. Inicie o aplicativo Chrome, conecte-se e atualize o firmware do Pico.
Para experimentar o Pico, você usará o IDE baseado na web do Espruino (aplicativo do Chrome) - isso significa que
você se conectará, se comunicará e implantará o código no Pico a partir do aplicativo do Chrome.
Figura 10.4. O aplicativo Espruino Chrome IDE
UAU! e-book
www.wowebook.org
No lado esquerdo da interface do aplicativo, você verá uma área de console semelhante a
um terminal. Uma vez conectado a um Pico, você pode digitar expressões aqui diretamente, como
um interpretador Node.js ou JohnnyFive REPL. No lado direito está uma área onde você
pode compor scripts.
10.1.2. Hello World LED piscando
Vamos tentar com o piscar obrigatório de um LED. Para esta experiência, você usará um
dos LEDs integrados do Pico, para poder conectar o Pico diretamente à sua porta USB ou
colocá-lo em uma breadboard com um cabo de extensão USB: a escolha é sua.
Uma variedade de variáveis está disponível em nível global nos scripts Espruino, pertencentes
aos recursos e pinos da plataforma. Isso inclui as variáveis LED1 e LED2 para os LEDs vermelho
e verde embutidos no Pico, respectivamente (figura 10.5).
Figura 10.5. Este experimento fará com que os LEDs internos do Pico - um vermelho,
um verde - pisquem alternadamente. O acesso aos LEDs é feito através das variáveis
globais LED1 e LED2.
UAU! e-book
www.wowebook.org
Abra o aplicativo Espruino IDE Chrome e conecte-se ao Pico. Digite o código mostrado
na listagem a seguir na área de composição de código da tela (lado direito) e clique
no ícone Send to Espruino no centro (figura 10.6).
Listagem 10.1. Piscando os LEDs do Pico
var ledStatus = false;

função alternar LED () {
if (!ledStatus) {
digitalWrite(LED1, 1); 1 digitalWrite(LED2, 0);
} outro {
digitalWrite(LED1, 0);
digitalWrite(LED2, 1);
}
ledStatus = !ledStatus;
setTimeout(toggleLED, 500); 2
}
alternarLED(); 3
1 LED1 (o LED integrado vermelho) e LED2 (verde) estão disponíveis em scripts

Pico.
2 Usa setTimeout para fazer a função chamar a si mesma a cada 500 ms
UAU! e-book
www.wowebook.org
3 Inicia a alternância
Figura 10.6. Inserindo o código de piscada do LED no Espruino IDE (tamanho da fonte aumentado
para visibilidade)
Este exemplo usa a função digitalWrite do Espruino para alternar entre os LEDs HIGH e LOW. Depois
de implantar o código no Pico, você deve ver os LEDs vermelho e verde do Pico piscando, um de cada
vez. Você também verá alguma saída no lado esquerdo do IDE
janela.
10.2. APRENDER SOBRE NOVAS PLATAFORMAS
Agora que você começou a trabalhar, vamos voltar um pouco. Como você sabe que o Pico tem dois
LEDs embutidos (vermelho e verde), e como você sabe que existem variáveis LED1 e LED2? Até
agora, convenções como digitalWrite sendo um nome para uma função que escreve níveis lógicos em
saídas digitais provavelmente parece sensata. Mas ainda pode parecer um tanto mágico ou aleatório.
Por onde começar?
Há uma série de etapas de investigação que você pode aplicar ao enfrentar uma nova plataforma
para avançar rapidamente. Você os abordará para aprender especificamente sobre o Pico agora, mas
poderá reutilizá-los para avaliar diferentes plataformas incorporadas no futuro:
1. Descubra os principais recursos da plataforma

2. Encontre uma pinagem ou um diagrama de
hardware 3. Aprenda sobre o fluxo de trabalho de configuração e
desenvolvimento 4. Encontre exemplos eexperimente
tutoriais simples e
WOW! e-book www.wowebook.org
5. Use a documentação da API de referência
Vejamos cada um deles.
10.2.1. Descobrindo os principais recursos de uma plataforma
Antes mesmo de colocar as mãos em uma nova placa ou plataforma de desenvolvimento, você provavelmente
desejará ter uma noção geral do que ela pode fazer.
Muitas vezes, os principais detalhes são resumidos no site do fabricante ou do fornecedor. No caso do Pico, uma
lista de recursos que a página do Pico nos dá: é um dispositivo de 3,3 V, pequeno em formato (33 mm x 15 mm),
alimentado por um microcontrolador STM32F401CDU6 (não, meu gato não basta caminhar sobre o meu teclado;
ST — o fabricante — tem convenções de nomenclatura pouco românticas, mas bastante precisas) e usa um
processador ARM Cortex M4 (www.espruino.com/Pico).
Também na lista de recursos principais estão pontos sobre o consumo de energia (figura 10.7).
Mesmo que os números específicos citados aqui não atinjam o alvo, você pode ver que eles estão fazendo barulho por
serem eficientes no consumo de energia.
Figura 10.7. As principais características do Espruino Pico, listadas no site do Espruino
UAU! e-book
www.wowebook.org
2
Existem 22 pinos GPIO no dispositivo, incluindo 3 interfaces IC e 3 interfaces SPI
(hardware) - nada mal para algo tão pequeno. Se você clicar no
datasheet do microcontrolador (http://mng.bz/i7r8), verá que tem que
agradecer à família STM32F401D/E (há uma seção sobre interfaces de
comunicação na página inicial).
Um par de outros recursos saltam para fora. Um deles é um bom aceno para a onipresença da lógica de
5 V - "Todo GPIO é tolerante a 5 volts (compatível com Arduino)" - uma gentileza para aqueles de nós
que precisam alternar muito entre os dois. A saída sempre será de 3,3 V, mas a entrada de 5 V não dará o
Pico azia.
Outro detalhe digno de nota: embora 18 pinos (duas fileiras de 9) estejam em uma protoboard padrão
de 0,1ÿ de pino, 8 pinos em uma extremidade curta estão separados por apenas 0,05ÿ (figura 10.8). Você
não usará esses pinos em suas explorações, pois eles não se encaixam facilmente em uma
placa de ensaio, mas existem calços físicos que você pode obter para tornar isso possível.
Figura 10.8. Oito dos pinos de E/S do Pico estão em um passo de 0,05 polegada: muito estreito para
encaixar em breadboards.
UAU! e-book
www.wowebook.org
Concedido, esta lista particular de recursos não menciona que este é um dispositivo com JavaScript,
o que é uma espécie de chave, mas você certamente pode obter isso na página inicial do Espruino
(www.espruino.com ).
MCUs ARM Cortex M e JavaScript incorporado
Tanto o Espruino Pico quanto o Kinoma Element são baseados em microcontroladores da família
ARM Cortex M. Assim como os MCUs ATmega são encontrados em todos os tipos de placas
hostclientclass compatíveis com Arduino (como o Arduino Uno e seus irmãos), os MCUs ARM
Cortex M são muito populares para a classe de plataformas embarcadas que incluem o
Elemento e o Pico. O site da ARM afirma que dezenas de bilhões de dispositivos foram
produzidos com produtos da família Cortex M.
Os microcontroladores de 32 bits da família Cortex M superam os ATmegas de 8 bits enquanto ainda operam com
baixo consumo de energia (a maioria não é previsivelmente tão barata). Os tempos de execução de JavaScript
incorporado (ou semelhante a JavaScript) precisam de mais poder de processamento do que um ATmega de 8
bits pode fornecer.
UAU! e-book
www.wowebook.org
À medida que você continua a experimentar novas plataformas, é provável que continue a
encontrar variantes do Cortex M.
Outra coisa que é útil entender é o modelo financeiro e de licenciamento da plataforma. O hardware
ou software (ou ambos) é de código aberto ou são proprietários? Isso pode ser relevante se você estiver
pensando em usar uma plataforma comercialmente, estender hardware ou software ou fazer
contribuições para uma plataforma. (As plataformas Espruino são totalmente de código aberto.)
10.2.2. Encontrar um diagrama de pinagem
Talvez seja porque eu adoro mapas, mas encontrar e analisar o diagrama de pinagem de uma placa
geralmente é quando as coisas realmente se encaixam. Esses diagramas mostram quais pinos podem
fazer o quê: interfaces de comunicação, PWM, pinos de alimentação e assim por diante.
A partir do diagrama do Pico (figura 10.9), podemos notar algumas coisas (veja em tamanho maior e
com mais detalhes na página de documentação do Pico do Espruino: www.espruino.com/Pico). Por um
lado, os números dos pinos não são sequenciais; eles saltam um pouco e você encontrará os pinos A e
B em ambos os lados que usará. Você também pode ver que há suporte para PWM em quase
todos os pinos GPIO. Por fim, você pode ver quais pinos têm suporte de hardware para IC e SPI
2
e quais podem suportar ADC (conversão analógico-digital).
Figura 10.9. Detalhe do diagrama de pinagem para o Espruino Pico
UAU! e-book
www.wowebook.org
Uma combinação de layout de pino geral sensato (design de hardware) e diagramas de pinagem de alta
qualidade pode proporcionar uma melhor experiência de desenvolvimento.
10.2.3. Aprendendo sobre configuração e fluxo de trabalho
Como o código é escrito? Implantado? Como o dispositivo é gerenciado, configurado e atualizado?
É compatível com o seu sistema operacional? O processo de configuração é opressor e tedioso? Isso
pode ser um sinal de uma dor de cabeça contínua.
No caso do Pico, seguimos o caminho recomendado de usar o aplicativo Chrome IDE.
Isso pode ser conveniente – autoria de código, gerenciamento de dispositivos e implantação em um só
lugar – mas se você for o tipo de pessoa que tem um anexo ao seu próprio editor ou IDE para escrever
JavaScript, isso pode deixá-lo maluco.
Tenha uma noção das construções de software de alto nível: existem plugins ou outros
UAU! e-book
www.wowebook.org
componentes modularizados? Existe uma API geral orientada para hardware? Espruino tem
ambos estes.
10.2.4. Encontrar exemplos e tutoriais
Percorrer alguns exemplos do Hello World é o próximo passo, e você já fez isso com o Pico. Ao
experimentar uma nova plataforma, descubra como realizar algumas tarefas comuns, como piscar
LEDs, ler dados de um sensor analógico, trabalhar com monitores e controlar dispositivos IC.
2
Idealmente, você terá experiência prática nesta etapa, obtendo uma noção de como realmente é
interagir com a plataforma durante o desenvolvimento.
Depois de entender o quadro geral e ver (e experimentar) alguns exemplos aplicados, acessar a
documentação de referência pode ajudar a preencher os detalhes.
10.2.5. Usando a documentação da API de referência
Se você olhar a documentação da API do Espruino (10.10), verá classes JavaScript familiares —
String, Math, Boolean, JSON — junto com classes específicas do Espruino relevantes
para coisas de hardware: I2C, SPI, WLAN. A seção Globals lista funções de hardware como
digitalWrite() disponível para scripts Espruino, e também alguns recursos globais padrão de JavaScript
como setTimeout() e eval().
Há também uma página que lista os módulos disponíveis para Espruino e como usá-los
(www.espruino.com/Modules). Mais sobre isso à medida que exploramos o Pico mais profundamente.
À medida que aprende mais sobre uma plataforma e ganha experiência com ela, você passará de
uma fase de aprendizado, em que procura exemplos, conceitos e tutoriais pré-configurados, para uma
fase de referência, em que busca detalhes sobre como realizar tarefas específicas.
Figura 10.10. A documentação da API do Espruino em www.espruino.com/Reference
UAU! e-book
www.wowebook.org
10.3. EXPERIMENTANDO O PICO
Em seguida, você dará uma volta no Pico e fará alguns experimentos. Primeiro, você revisitará o
multissensor meteorológico BMP180, mas o combinará com um componente de tela LCD Nokia
5110 para construir uma miniestação meteorológica independente e de boa aparência.
10.3.1. O multissensor Pico e o BMP180
1 bico espruim
1 cabo de extensão USB
1 placa de fuga BMP180
Fios de jumper UAU! e-book

www.wowebook.org
Como você está usando o Web IDE, trabalhar com módulos Espruino é tão fácil quanto usar uma
instrução require() no código Espruino com o nome do módulo que você procura.
Esses módulos fornecem suporte encapsulado para diferentes tipos de componentes. E, huzzah,
existe um módulo existente para o seu confiável multissensor de temperatura e pressão BMP180. O
módulo é chamado de BMP085 porque também é compatível com o sensor BMP085 similar. Depois
que o módulo for importado, você pode usar a API fornecida para
interagir com o sensor BMP180. Vamos ver o que isso parece.
O módulo BMP085 Espruino
Este experimento registrará a temperatura atual (em Celsius) e a pressão (em pascal)
2
conforme obtido do sensor IC BMP180.
O código necessário para registrar as leituras de um BMP180 não é muito denso, como você verá na
2
Listagem 10.2. Ele faz uso do I2C1 global exposto para configurar uma interface IC que passa para o
método connect do módulo BMP085.
Como você viu, JohnnyFive fornece várias construções para executar ações contínuas e periódicas,
como leituras de sensores - board.loop, por exemplo. Mas você não está usando JohnnyFive aqui.
Em vez disso, você seguirá a convenção Espruino, que usa setInterval para E/S repetida.
Listagem 10.2. Usando o módulo BMP085 Espruino
I2C1.setup({ scl: B6, sda: B7}); 1

var bmp = require('BMP085').connect(I2C1); 2
bmp.getPressure(função (leituras) { 3
console.log('Pressão: ' + leituras.pressão + 'Pa');
console.log('Temperatura: ' + leituras.temperatura + ' C');
});
}, 1000); 4
2 2
1 Configura a primeira interface IC do Pico (I C1), usando os pinos B6 para SCL e
B7 para SDA
2 Requer o módulo BMP085 e invoca sua função de conexão, usando

2
a interface I C1
3 O método getPressure do objeto bmp instanciado é assíncrono; registra um retorno de

chamada...
4 Realiza leituras do sensor a cada segundo (1000 ms)

UAU! e-book
2
www.wowebook.org
Como você sabe que os pinos B6 e B7 suportam IC SCL e SDA, respectivamente? Da pinagem (figura
10.11).
Figura 10.11. Diagrama de fiação para o sensor Espruino Pico e BMP180
Construindo o circuito BMP180
Para construir isso, você vai querer colocar o Pico em uma placa de ensaio de tamanho normal e usar
um cabo de extensão USB. Construa o circuito mostrado na figura 10.11.
A configuração pode parecer um pouco absurda no momento. “Por que colocar o sensor BMP180 tão longe
do Pico?” você pode estar se perguntando. Há um método para essa loucura: a lacuna resultante permitirá
a expansão desse circuito para acomodar o componente Nokia 5110 LCD em experimentos futuros.
Conexões breadboard de tamanho normal
Se esta é a primeira vez que você usa uma protoboard de tamanho normal, observe que na verdade são
duas protoboards de meio tamanho unidas de ponta a ponta, em termos de conexões elétricas. Uma
pegadinha com breadboards de tamanho normal é que os trilhos de alimentação têm uma interrupção
em suas conexões na metade da placa (figura 10.12).
Figura 10.12. Não se esqueça! Os trilhos de alimentação em uma breadboard de tamanho normal têm
uma quebra no meio da placa.
UAU! e-book
www.wowebook.org
Implantando o código
Insira o código da listagem 10.2 no lado direito do IDE e clique no ícone de seta para
cima Enviar para Espruino para executar o código no Pico. A pressão e a
temperatura registradas aparecerão no lado do console/terminal (esquerdo) da janela
IDE (figura 10.13).
Figura 10.13. Depois que o script BMP180 for carregado no Pico, você deverá ver o
log de saída no lado esquerdo da tela uma vez por segundo.
UAU! e-livro
10.3.2. O Pico e o Nokia 5110 LCD www.wowebook.org
10.3.2. O Pico e o Nokia 5110 LCD
1 bico espruim
1 Nokia 5110 48x84 LCD breakout board
1 resistor de 100 V
Fios de jumper
A tela de 48x84 pixels do Nokia 5110 (figura 10.14) foi originalmente usada na popular família de
telefones Nokia 51xx, que data do final da década de 1990 (ótimos telefones, a propósito — eles eram
conhecidos por sua durabilidade, excelente duração da bateria e facilidade de uso). usar). As unidades
Nokia 5110 LCD podem ser encontradas online por apenas US$ 6, mas são mais fáceis de
encontrar por cerca de US$ 10 cada. Eles são pequenos componentes excelentes: 48x84 pixels não é
um espaço infinito, mas é muito mais do que o 16x2 que vimos até agora. Há espaço para desenhar, animar e
fazer coisas divertidas.
Figura 10.14. O Nokia 5110 LCD tem resolução de 48x84 pixels e uma interface SPI fornecida por seu
driver Phillips Semiconductor PCD8544. O visor é mostrado aqui com o lado direito para cima.
UAU! e-book
www.wowebook.org
A exibição é controlada por um driver Philips Semiconductor chamado, dessa maneira nada
memorável que esses componentes costumam ter, o PCD8544. O PCD8544 fornece uma
interface SPI para o display e (yay!) há um módulo Espruino para isso

controlador.
Você começará criando um cronômetro visual de contagem regressiva usando o Nokia 5110 sozinho e,
em seguida, o combinará com o BMP180 para criar uma pequena estação meteorológica.
Pinagem do Nokia 5110/PCD8544
Diferentes módulos PCD8544/Nokia 5110 possuem diferentes pinagens! Verifique a rotulagem dos pinos
de sua placa antes de tentar seguir o diagrama de fiação na figura 10.15. as conexões
deve ser serigrafado no quadro.
O layout usado no diagrama de fiação é baseado na variante 5110 disponível na página do
produto SparkFun (http://mng.bz/IId1), com conexões conforme mostrado na figura a seguir.
Vale notar que a pinagem do módulo SparkFun é diferente da assumida no tutorial “Pico LCD Display
Hello World” no site do Espruino (http://mng.bz/604s), mas o layout documentado pelo SparkFun
parece ser mais

comum.
O diagrama de fiação neste capítulo é baseado na versão SparkFun do Nokia 5110 e assume uma
pinagem conforme mostrado aqui. Verifique a pinagem do seu 5110 e ajuste o

UAU! e-book
www.wowebook.org
conexões no circuito se forem diferentes.
Consulte a tabela 10.1 para obter informações específicas sobre quais pinos dos módulos LCD se conectam no Pico.
Conectando o LCD ao Pico
Deixe o BMP180 conectado do experimento anterior - você o usará novamente em um minuto - e conecte o Nokia
5110 a uma seção livre da breadboard de tamanho normal, conforme mostrado na figura 10.15 (e resumido na
tabela 10.1).
Figura 10.15. Diagrama de fiação para a adição de um componente Nokia 5110 LCD
ao circuito
Tabela 10.1. Conexões Nokia 5110 LCD
pino do módulo LCD Função de pino do LCD Conectar ao pino Pico Cor do fio no diagrama
VCC ou Vin Fonte de alimentação 3,3 V 3,3 V Vermelho
GND Chão GND Preto
CE ou SCE Seleção de chip SPI B14 Azul
RST Reiniciar B15 Branco
CC ou D/C dados/comando B13 Laranja
Saída mestre SPI, escravo

MOSI ou DN B10 Verde
em
SCK ou SCLK Relógio SPI B1 Amarelo
Fonte de 3,3 V para LED 3,3 V, até 100 V Luz de fundo

LIDERADO vermelha
resistor
Diagramas de fiação e estética
UAU! e-book
www.wowebook.org
Se você estudar a figura 10.15, notará alguns detalhes que indicam clareza e estética, tanto no próprio
diagrama quanto no circuito resultante.
Por exemplo, observe as conexões de energia (fios vermelhos). O LED de luz de fundo do BMP180 e do
Nokia 5110 agora compartilha uma das conexões de alimentação positiva. A energia do LED da luz
de fundo do LCD é conectada por meio de um resistor de 100 V - é um LED, portanto, esse valor de resistor
de 100 V é bom para um circuito de 3,3 V.
Lembre-se de que os trilhos de energia da placa de ensaio de tamanho normal têm uma
interrupção em suas conexões no meio do lado mais comprido da placa de ensaio (uma placa de ensaio de
tamanho normal é realmente equivalente a duas placas de meio tamanho coladas uma na outra). Daí o
pequeno fio terra extra neste diagrama: ele conecta a energia do terra à outra metade do trilho de
aterramento da placa, preenchendo a lacuna de conectividade.
Ao trabalhar com diagramas de circuitos, muitas vezes você verá recursos feitos para manter a aparência
do circuito “organizado”, como aquela conexão de aterramento dividida. Ainda outro exemplo na figura
10.15 é o fio laranja para o D/C do Nokia 5110 (modo de dados/comando); a conexão é dividida em
dois segmentos para que não tenha que se sobrepor visualmente a outros componentes ou
fios. Outras conexões são interligadas através do entalhe central da breadboard antes de usar fios
separados para completar as conexões.
Existem muitas maneiras de obter o mesmo circuito resultante. Cada uma das conexões multifio
pode ser feita com um único fio, se você quiser economizar tempo ou fios necessários.
O mesmo circuito, sem fazer affordances para arrumação
Fazendo uma contagem regressiva visual com o Nokia 5110
UAU! e-book
www.wowebook.org
Para conhecer o Nokia 5110 e as capacidades gráficas do Espruino, este experimento
cria um cronômetro de 10 segundos que mostra seu progresso usando uma barra de
progresso animada no LCD (figura 10.16). Você pode, é claro, ajustar a duração do cronômetro
no código. O cronômetro é iniciado pressionando o botão integrado ittybitty do Pico.
Figura 10.16. O visor do temporizador. O retângulo preenchido é “animado” e cresce para a

direita conforme o tempo passa.
O módulo Espruino PCD8544
Para escrever um programa para o timer, você usará o módulo Espruino PCD8544. O código
primeiro configura algumas variáveis e cria uma função de inicialização para configurar o timer
(10.3), conforme mostrado na listagem a seguir.
Listagem 10.3. Configurando o temporizador
var lcd;
var progress = 0; // Progresso atual do timer var frameDuration = 200; //
ms (5fps) var timerSeconds = 10;
var timerLength = timerSeconds * 1000 / frameDuration; 1

var timerAtivo = falso; 2
function onInit () { SPI1.setup({ sck:

B3, mosi: B5 }); 3
lcd = require('PCD8544').connect(SPI1, B13, B14, B15); 4
}
onInit(); 5
1 Determina quantos “tiques” (quadros) dura o temporizador
2 Monitora se o timer está funcionando no momento

UAU! e-book
www.wowebook.org
3 Configura uma interface SPI para o LCD
4 Utiliza o módulo PCD8544 Espruino para instanciar um objeto representando o LCD
5 Invoca a função onInit() para fazer as coisas acontecerem
Em seguida, você precisa encontrar uma maneira de um usuário ativar o cronômetro. Você pode
usar o botão onboard do Pico como um gatilho para iniciar o cronômetro fazendo uso de alguns
recursos globais do Espruino: a função setWatch(função, pino, opções) e o pino BTN virtual.
A função setWatch() fornece um comportamento semelhante a uma interrupção, permitindo que você
registre um retorno de chamada que é invocado quando o valor do pino observado muda.
Na listagem 10.4, setWatch() é usado para monitorar o BTN continuamente. Antes de iniciar o
cronômetro, o código garante que não haja outro cronômetro em execução e, em seguida, redefine
o progresso do cronômetro e dá o pontapé inicial.
Comportamento tipo interrupção?
A função setWatch fornece um comportamento semelhante a uma interrupção. A tecnicalidade é
explicada na documentação da API de Espruino em setWatch (http://mng.bz/EE71): “Internamente,

uma interrupção escreve o tempo da mudança de estado do pino em uma fila, e a função
fornecida para setWatch é executada apenas a partir do loop de mensagem principal.”
Listagem 10.4. Iniciando o cronômetro
// variáveis
function onInit() { /* ... */ }
setWatch (função (e) {
if (!timerAtivo) {
progresso = 0;
setInterval(desenho, frameDuration); 1
timerAtivo = verdadeiro;
}
},
BTN, 2
{ repetir: verdadeiro }); 3
1 Chama a função de desenho a cada frameDuration (200 ms)
2 O segundo argumento para setWatch especifica o pino a ser observado - o

UAU! e-book
www.wowebook.org
Botão onboard do Pico.
3 O terceiro argumento é opções, aqui especificando que a observação deve continuar
indefinidamente (repetição: verdadeiro).
O cronômetro é executado invocando repetidamente uma função chamada draw em um intervalo calculado.
Mas o que é a função desenhar? Você precisará escrevê-lo! As tarefas da sua função de desenho serão
incluem incrementar o progresso do temporizador e renderizar seu progresso proporcional na tela LCD.
O objeto retornado pelo método connect do módulo PCD8544—atribuído em seu código à variável lcd—
fornece alguns métodos específicos do LCD como flip(), que pega o conteúdo atual de um buffer e os
exibe na tela, e setContrast()—que método faz o que parece que faria. Além disso, o
O objeto herda da biblioteca Graphics do Espruino (www.espruino.com/Graphics), fornecendo ferramentas
para renderizar strings de texto, bem como desenhar linhas e formas.
A função draw na Listagem 10.5 usa o método drawRect(x1, y1, x2, y2) para desenhar o contorno de uma
caixa que representa a duração total do cronômetro. Em seguida, fillRect(x1, y1, x2, y2) é usado para
desenhar uma barra de progresso preenchida em uma largura representativa do tempo decorrido até o
momento. A única matemática real que a função de desenho precisa fazer é determinar a largura desse
retângulo preenchido — quantos dos 84 pixels horizontais disponíveis do LCD representam a proporção
do tempo decorrido. Isso é calculado e atribuído à variável rightEdge. Para resumir: um retângulo vazio - o
contorno da barra de progresso - é desenhado, centralizado verticalmente na tela e, em seguida, um
retângulo preenchido com a largura calculada é desenhado dentro dele.
Listagem 10.5. Desenhando o cronômetro
// ...
função desenhar () {
progresso++;
if (progresso > timerLength) { 1
clearInterval();
timerAtivo = false;
}
var rightEdge = Math.floor((progress / timerLength) * 84) 1; 2

lcd.clear();
lcd.drawRect(0, 19, 83, 27); 3
lcd.fillRect(0, 19, bordadireita, 27); 4 lcd.flip(); 5
UAU! e-book
www.wowebook.org
1 Se o cronômetro terminar, desligue-o e pare
2 Calcula a posição do eixo x do lado direito do retângulo de progresso preenchido
3 Usa drawRect(x1, y1, x2, y2) para desenhar uma caixa vazia centralizada verticalmente, oito px
de altura
4 Usa fillRect(x1, y1, x2, y2) para desenhar uma caixa preenchida representando o progresso
até agora
5 Desenha tudo para a tela LCD
Cole o código do timer no lado direito do Espruino IDE, conecte-se ao Pico e carregue o código.
Pressione o botão do Pico para iniciar o cronômetro.
Você pode fazer ajustes no código, se desejar. Você pode alterar a duração do cronômetro ou
fazer com que o LCD exiba uma mensagem quando o cronômetro estiver completo, por exemplo.
10.3.3. Construindo um dispositivo meteorológico com baixo consumo de energia com o Pico
Você está se tornando um especialista em construir miniaparelhos meteorológicos, e aqui está

outro para adicionar ao arsenal. Ao combinar seu velho amigo, o sensor BMP180 com a tela do
Nokia 5110, você pode montar um dispositivo meteorológico independente, bem formatado e de
baixa potência (figura 10.17).
Figura 10.17. A saída do gadget meteorológico mostrará a temperatura e a

pressão do ar, bem formatadas.
Se você acompanhou os dois experimentos anteriores, já tem o circuito de

que precisa: o BMP180 e o Nokia 5110 conectados ao Pico em um tamanho normal
UAU! e-book
www.wowebook.org
placa de ensaio (figura 10.18). Você contará com mais alguns recursos da biblioteca Espruino
Graphics para permitir que você desenhe fontes vetoriais e mais formas para formatar a
exibição dos dados e implantará o código resultante na memória flash do Pico para que
o Pico execute o programa sempre que for alimentado.
Figura 10.18. Usando o suporte gráfico do Espruino para criar formas e desenhar strings
de texto
Assim como com o timer, você começará configurando algumas variáveis e uma
função de inicialização, mostrada na Listagem 10.6. As leituras de pressão no BMP180 são
consideravelmente mais precisas se você ajustá-las para a altitude local (em metros).
O método getSeaLevel, disponível em objetos retornados pela função connect() do módulo
BMP085, fornece uma maneira prática de executar essa correção de altitude. Observe que
o método getPressure é usado aqui para ler a pressão e a temperatura ao mesmo
tempo. Certifique-se de ajustar o valor da variável de altitude na próxima listagem
para sua altitude local (em metros).
Listagem 10.6. Configurando o gadget de clima
var altitude = 300; // Altitude local em metros: MUDE-ME!

var lcd;
function onInit () {
clearInterval();
I2C1.setup({ scl: B6, sda: B7});
var bmp180 = require('BMP085').connect(I2C1); SPI1.setup({ sck: B3, mosi: B5 });
lcd = require('PCD8544').connect(SPI1, B13, B14, B15, função
() { 1
bmp180.getPressure(função (leituras) {
draw(readings.temperature, WOW! eBook
www.wowebook.org
bmp180.getSeaLevel(leituras.pressão, altitude)); 2
});
}, 1000);
});
}
onInit(); 3
1 Assim que o LCD estiver configurado, inicie o setInterval.
2 Invoca o desenho com a temperatura atual e a pressão ajustada para altitude
3 Não se esqueça de invocar a função onInit!
Linhas, círculos e texto com Espruino Graphics
Assim como no timer, você precisa escrever a função draw. O código na Listagem 10.7 faz uso de
mais métodos de desenho de formas da biblioteca Graphics: drawLine(x1, y1, x2, y2) e drawCircle(x,
y, radius) (figura 10.18). Ele também se vale de alguns métodos para derivação de dimensões:
getWidth() e getHeight(), por exemplo, que retornam a área utilizável do display, em pixels, para os
eixos x e y, respectivamente.
Por fim, stringWidth(str) calcula a largura em pixels da string fornecida, usando as configurações
de fonte atuais.
Vamos falar de fontes. Há uma pequena fonte de bitmap disponível cujos caracteres têm 4 x 6 pixels
de tamanho. Para usar a fonte bitmap, use o método setFontBitmap() para tornar essa fonte ativa.
Neste exemplo, no entanto, você usará uma fonte vetorial. A fonte vetorial pode ser usada em vários
tamanhos - ela é dimensionada. O método setFontVector(size) definirá a fonte ativa para
uma fonte vetorial em escala com uma altura de pixels de tamanho.
Há muitos números na seguinte função de desenho. É um pouco meticuloso, mas tudo aqui é
aritmética de pixel não sofisticada para posicionar elementos de texto e formas. Observe que a
string “mb” na função de desenho (a abreviação de milibares) é “handkerned”, porque
descobri que desenhar a string de uma só vez naquele tamanho de fonte juntava as letras de
maneira ilegível.
Listagem 10.7. Renderizando a exibição do clima
desenho de função (temperatura, pressão) {

lcd.clear();
// Converte temperatura para Fahrenheit e formata para uma casa decimal var tempString = (temperature *
(9 / 5) + 32).toFixed(1); // Converte pressão de pascal para milibares e formata para um
decimal
UAU! e-book
www.wowebook.org
coloque var
pressString = (pressão / 100).toFixed(1);
// Desenha uma linha centralizada verticalmente na tela lcd.drawLine(0, (lcd.getHeight() / 2),

lcd.getWidth(),
(lcd.getHeight() / 2));
// Define a fonte ativa para 18 pixels de altura lcd.setFontVector(18);
// Calcula a largura em pixels do valor da temperatura na fonte de 18px var tempWidth = lcd.stringWidth(tempString);
// Calcula a largura do pixel do valor da pressão na fonte 18px

var pressWidth = lcd.stringWidth(pressString); // A temperatura será centralizada
horizontalmente // Determina a coordenada x para onde o valor deve ser exibido var
xTemp = ((lcd.getWidth() tempWidth) / 2);
// Renderiza a temperatura no ponto (xTemp, 2) lcd.drawString(tempString,

xTemp, 2);
// Renderiza um símbolo de grau (círculo) de raio 2px // no ponto (xTemp + tempWidth
+ 4, 5)
// O centro do círculo será 4px à direita do // final da string de valor de temperatura
lcd.drawCircle(xTemp + tempWidth + 4, 5, 2); // Renderiza o valor da pressão

alinhado à esquerda, 2px abaixo do centro vertical lcd.drawString(pressString, 0, (lcd.getHeight() / 2 + 2));
// Define uma fonte menor para os caracteres da unidade

lcd.setFontVector(8); // Desenha um
"F" para denotar Fahrenheit
lcd.drawString('F', xTemp + tempWidth + 2, 12); // Desenha "mb" (milibar) string.
lcd.drawString('m', pressWidth + 3, (lcd.getHeight() / 2 +
12)); lcd.drawString('b', pressWidth + 12, (lcd.getHeight() / 2 + 12)); lcd.flip();
Coloque todo o código do gadget de previsão do tempo no lado do código do Espruino IDE e use
o ícone Send to Espruino para executar o código no Pico. Ele mostrará a temperatura e a
pressão até que seja desconectado da porta USB do seu computador.
Mas você pode fazer um pouco melhor! No lado esquerdo do IDE, digite o comando save() e
pressione Enter. Isso piscará o código para o Pico. Agora, sempre que o Pico tiver energia, ele
retomará a execução desse código. Experimente conectando o Pico a uma fonte de energia
USB, como um carregador de telefone.
Eficiência energética e retroiluminação do

LCD WOW! e-
Para tornar o dispositivo meteorológico mais eficiente em termos de energia, você pode considerar
desconectar a conexão da luz de fundo de LED do LCD da energia. Você não conseguirá ler o LCD em
uma sala escura, mas consumirá menos energia.
10.4. EXPERIMENTANDO A PLATAFORMA KINOMA ELEMENT
Para enxaguar e repetir o processo de exploração da plataforma, daremos uma breve olhada
em outra plataforma JavaScript incorporada: o Kinoma Element.
O Element é uma pequena plataforma IoT movida a JavaScript com 16 pinos programáveis (figura
10.19). Como o Espruino Pico, é barato - um Element custará cerca de US $ 20 ou talvez um pouco
mais. Também como o Pico, ele não possui os sinos e assobios de seus irmãos mais robustos (e caros)
- você não encontrará USB, Ethernet, SDCard ou outros periféricos integrados - mas possui os bits
básicos necessários para produtos IoT em um pequeno pacote eficiente. Além disso, possui
suporte Wi-Fi integrado.
Figura 10.19. O Elemento Kinoma
10.4.1. Os principais recursos do elemento
A fabricante de chips Marvell produz o Element (http://mng.bz/w1lR), que apresenta seu

Marvell MW302 SystemonaChip (SoC), que por sua vez usa um ARM Cortex M4 de 200 MHz. A
placa, o gabinete, o tempo de execução do JavaScript e o software da estrutura estão abertos
fonte.
Para rodar JavaScript nativamente com apenas 512 KB de RAM, o Element utiliza uma tecnologia
chamada XIP (execute in place). O Element executa o FreeRTOS, um sistema operacional de
código aberto simplificado e mínimo. A tensão de operação da placa é de 3,3 V.
UAU! e-book
www.wowebook.org
O Element vem embalado em um gabinete, o que o torna menos parecido com uma placa e mais com um
dispositivo acabado (o design do gabinete também é de código aberto). Em vez de ter pinos de alimentação
dedicados, você configura qualquer um dos 16 pinos do elemento (8 em cada lado da placa) como 3,3 V ou terra
conforme necessário.
Kinoma usa seu próprio mecanismo JavaScript (licenciado pela Apache), XS6, que, com pequenas
exceções, afirma ser compatível com ES6. Observe que o software IDE do Element está disponível para Mac e
Windows (beta), mas não possui suporte para Linux.
10.4.2. Diagrama de pinagem e hardware
O layout dos pinos do elemento é bastante simples (figura 10.20). É um dispositivo mais simples que o Pico
2
em termos de suporte a recursos de E/S; por exemplo, existem duas interfaces IC, mas não há suporte para
SPI. Por outro lado, é menos complexo descobrir quais pinos fazem o quê, e a numeração é fácil de seguir.
Figura 10.20. Diagrama de pinagem para o Elemento Kinoma
10.4.3. Configuração, gerenciamento, fluxo de trabalho
O Element é um pacote organizado e independente que não requer solda ou preparação.
Os fios jumper podem ser conectados diretamente a ele.
A configuração e o fluxo de trabalho são semelhantes aos do Pico, pois há um IDE para configurar,
criar e implantar. Se você tiver um elemento em mãos, pode acessar o guia de início rápido para obter detalhes
(http://mng.bz/84cS), mas esses são os UAU ! e-book www.wowebook.org

passos:
1. Baixe e instale o Kinoma Code IDE.
2. Configure o Element em sua rede WiFi.

3. Aplique a atualização do firmware.
Projetos de código para o Element, desenvolvidos no Kinoma Code IDE (figura 10.21), podem ser
implementados via USB ou WiFi b/g/n. A configuração envolve obter o Elemento em sua rede Wi-Fi
local. Ele receberá seu próprio endereço IP.
Figura 10.21. Software Kinoma Code IDE
Os projetos de aplicativos para o Elemento têm alguma estrutura para eles. Por exemplo, cada
um deve conter um arquivo project.json, que define um ponto de entrada — o script que será
executado no dispositivo. O ponto de entrada padrão é main.js.
Assim como o Espruino, o Kinoma fornece alguns objetos globais para ajudá-lo a interagir
com o hardware, e há a noção de módulos para o encapsulamento do comportamento do
componente. Os módulos Kinoma para controlar componentes de hardware são
conhecidos como BlinkingLight Libraries (BLLs) e envolvem a interação com o hardware
por meio de um módulo de pinos (embutido). Você pode usar instruções de estilo CommonJS para
obter outros arquivos JS em seus projetos e quaisquer módulos BLL integrados ou
personalizados (mas lembre-se, isso não é Node.js: você não pode usar módulos npm).
UAU! e-book
10.4.4. Exemplos e tutoriais www.wowebook.org
O site da Kinoma tem alguns exemplos de código para o elemento: http://mng.bz/1BaB.
Observando o código de exemplo blinkingLED (http://mng.bz/5t61), fica imediatamente
evidente que a estrutura dos projetos Kinoma é mais formal do que a de algumas outras
plataformas (figura 10.22). Piscar um LED envolve um arquivo project.json para definir o
projeto, um main.js (ponto de entrada) para inicializar a placa e configurar o pino para o LED e
um módulo led.js BLL que fornece o suporte lógico para piscar por meio de um método
de alternância. (O arquivo .project e o arquivo XML no projeto parecem ser para construção
específica do Kinomasite e suporte de metadados.)
Figura 10.22. A fonte para um projeto de exemplo de Kinoma com LED piscando. A
estrutura de um projeto Kinoma é mais envolvente do que a de um projeto Espruino.
Você também precisará trazer seu próprio LED e resistor para a festa, pois não há nenhum LED
onboard evidente que você possa usar. O código dentro do arquivo main.js deste projeto assume que
você está usando os pinos 9 e 10 (terra), mas não há nenhum diagrama de fiação fornecido.
Você aprenderá mais sobre a aparência do código em um script Kinoma main.js daqui a pouco.
10.4.5. Referência da API
Os módulos Kinoma fornecem a API para interação de hardware. O módulo mais imediatamente
relevante é o Pins, que fornece suporte básico de E/S para os tipos de coisas que você esperaria: entrada
e saída digital e analógica; modulação por largura de pulso (PWM); serial (IC, por exemplo). Você
2
pode encontrar um guia do programador no site Kinoma WOW! e-book
www.wowebook.org
(http://mng.bz/w1lR).
10.4.6. Projeto de estudo de caso: atualização ao vivo das leituras da bússola
1 Elemento Kinoma
1 cabo USB A para micro USB
1 tábua de pão
1 placa de magnetômetro HMC5883L
Fios de jumper
O Element, com seu Wi-Fi integrado e bibliotecas de utilitários da web, se presta a atuar como um
servidor da web de maneira um pouco mais óbvia do que o Pico.
Neste experimento, você dará uma olhada no processo de alto nível de criação de um projeto com o
2
Element, criando um BLL personalizado para suportar o magnetômetro HMC5883L IC (bússola).
você usará o módulo WebSocket disponível da Kinoma para executar um servidor WebSocket no elemento
que pode emitir alterações quando a direção da bússola muda. Por fim, você construirá um
documento HTML que se conectará ao servidor WebSocket do Element e será atualizado conforme
a direção da bússola mudar (figura 10.23).
Figura 10.23. Detalhe da exibição do navegador, mostrando a direção da bússola. A direção da

bússola será atualizada, ao vivo, sem a necessidade de recarregar o navegador. Nesse caso, a
direção atual era de 190,62 graus – um pouco a oeste do sul.
O módulo HMC5883L será conectado a uma breadboard. Ao girar a protoboard, você pode alterar a
orientação do magnetômetro e ver a direção atualizada no navegador — em tempo real.
Suporte ao navegador WebSocket

UAU! e-book
www.wowebook.org
Você já conheceu o protocolo WebSocket antes. No capítulo 8, você usou socket.IO no aplicativo da estação
meteorológica Tessel 2 para mostrar temperatura e pressão atualizadas ao vivo.
Socket.IO usa WebSockets para navegadores com suporte a WebSockets e recorre a outros métodos para
navegadores que não oferecem suporte a WebSockets.
Neste exemplo, você usará WebSockets propriamente dito: o aplicativo não funcionará em navegadores que não
oferecem suporte a WebSockets. A falta de suporte a WebSockets é extremamente rara nos navegadores
atualmente, então é improvável que você tenha problemas.
Coloque o HMC5883L em uma breadboard e conecte-o ao Element conforme a figura 10.24. Os pinos SDA e SCL da
placa breakout conectam-se aos pinos 13 e 14 do Elemento, que, conforme mostrado na pinagem da figura 10.20,
2
possuem suporte para I C. Qualquer pino do Elemento pode ser configurado como alimentação ou terra; pinos 11 e
12 são usados aqui por causa de sua proximidade com os pinos do IC.
2
Figura 10.24. Elemento Kinoma e HMC5883L
Estruturando o projeto
O projeto Element livecompass consiste em quatro arquivos (figura 10.25):
Um arquivo package.json com metadados do projeto Kinoma
Um arquivo main.js servindo como módulo principal do aplicativo (ponto de entrada)
UAU! e-book
www.wowebook.org
Um arquivo HMC5883L.js, que é o módulo Kinoma BLL personalizado para a bússola
Um arquivo index.html, que é o código do lado do cliente — você o visualiza em um navegador da web
Figura 10.25. A estrutura para o projeto Element live-compass. O arquivo main.js fornece
lógica de aplicativo e um servidor WebSocket, contando com o suporte do BLL em
HMC5883L.js para interagir com o magnetômetro. O arquivo project.json define o
projeto, usando convenções Kinoma. Index.html é executado em um navegador da Web
em seu computador e mostra cabeçalhos de bússola atualizados ao vivo.
Primeiro, crie o arquivo package.json e insira alguns metadados, conforme mostrado na listagem a seguir.
Listagem 10.8. projeto.json
{
"id": "compass.websockets.lyza.com", 1 "título": "hmc5883L",
"Elemento": {
"principal": "principal" 2
1 As strings de ID devem estar no “estilo de nome de domínio pontilhado” de acordo com a

documentação.
2 O ponto de entrada do aplicativo será main.js.
Criando a estrutura do aplicativo
UAU! e-book
www.wowebook.org
Os módulos de aplicativo do projeto Kinoma - main.js neste caso - têm uma estrutura geral.
Eles precisam exportar uma função padrão que implemente alguns manipuladores de eventos, como onLaunch()
e onQuit(). O manipulador de inicialização configura os pinos da placa e dá o pontapé inicial.
A estrutura básica do módulo é a seguinte.
Listagem 10.9. Estrutura de main.js
importar Pins de 'pins';

importar { WebSocketServer } de 'websocket';
var formatMsg = título => JSON.stringify({ título: título.toFixed(2) });

var principal = {
aoLaunch () {
Pins.configure({ // Configure o
HMC5883L por meio de um módulo BLL personalizado que ainda precisa
para ser escrito
}, sucesso => {
se (sucesso) {
// Configure um servidor WebSocket // leia os cabeçalhos
da bússola e emita as alterações } else {
// Lida com a falha com a função interna `trace`

trace('Falha ao configurar\n');
}
});
}
};
principal padrão de exportação;
1 Este é o módulo interno de Pins, do qual depende muito dos aplicativos Kinoma.
2 O Kinoma possui um módulo websocket integrado; você precisará usar o WebSocketServer a

partir dele.
3 Esta é uma função conveniente para formatar cabeçalhos de bússola (ainda não utilizada).
4 onLaunch() será invocado automaticamente na inicialização.
5 Pins.configure recebe uma função de retorno de chamada, invocada quando é concluída.
Depois que o módulo HMC5883L personalizado estiver pronto, você voltará e preencherá os espaços em branco
em main.js.
UAU! eBook
Um BLL personalizado paraHMC5883L
o www.wowebook.org
Um BLL personalizado para o HMC5883L
Uma BLL, ou biblioteca blinkinglight, encapsula o comportamento do componente compatível com

Kinoma em um módulo. Um módulo BLL precisa fazer certas coisas. De acordo com a
documentação do Kinoma, um BLL deve exportar no mínimo um objeto de pinos definindo o tipo de
pinos que ele usa, uma função de configuração e uma função de fechamento.
A listagem a seguir mostra um trecho do módulo HMC5883L BLL concluído.
Listagem 10.10. Detalhe do código BLL
// Da folha de dados: vários endereços de registro para o dispositivo

var registros = {
CRA: 0x00,
CRB: 0x01,
MODO: 0x02,
LEIA: 0x03,
};
/* ... */
// Objeto de exportação necessário //

Configure os pinos envolvidos como I2C no endereço 0x1E (da folha de dados) exports.pins = {
bússola: {tipo: 'I2C', endereço: 0x1E }

};
// Função de exportação necessária

exports.configure = function () { this.compass.init(); //
Inicia o I2C // Derivado do suporte de classe JohnnyFive Compass
para HMC5883Ls this.compass.writeByteDataSMB(registers.CRA, 0x70); 1
this.compass.writeByteDataSMB(registers.CRB, 0x40);
this.compass.writeByteDataSMB(registers.MODE, 0x00);
};
// Função de exportação necessária

exports.close = function () { this.compass.close(); //
Limpeza; clichê };
// Pode ser invocado repetidamente para ler dados do sensor

exports.read = function () { // Derivado da classe
JohnnyFive Compass, novamente var bytes =
this.compass.readBlockDataSMB(registers.READ, 6, 'Array'); 2 var data = { 3
x: int16(bytes[0], bytes[1]), 4 y: int16(bytes[4], bytes[5]),
z: int16(bytes[2], bytes[3])
};
return toHeading(data.x, data.y); 5
UAU! e-book
www.wowebook.org
};
2
1 writeByteDataSMB() é fornecido pela API Kinoma IC; ele lê de um endereço de registro
específico.
2 readBlockDataSMB(), novamente da API, é usado para obter seis bytes do registrador READ
como uma matriz.
3 Os dados HMC5883L consistem em dois bytes para cada um dos três eixos.
4 int16() é uma função utilitária para criar um inteiro de 16 bits a partir de dois bytes (a
implementação não é mostrada).
5 toHeading() usa matemática para derivar um cabeçalho dos dados

(implementação não mostrada).
Créditos para o módulo HMC5883L Kinoma BLL

2
Eu mesmo montei este BLL como uma exploração de como os módulos BLL e o IC funcionam
no Element, mas o código se baseia fortemente no trabalho preexistente. É efetivamente uma porta
da lógica de suporte do JohnnyFive para o sensor (http://mng.bz/TxHV), escrita pelo inventor do
JohnnyFive, Rick Waldron. O código JohnnyFive, por sua vez, depende de uma implementação
anterior para Arduino (http://mng.bz/nB4V), que por sua vez depende da folha de dados do
dispositivo (http://mng.bz/j67k).
Esse tipo de pedigree complexo é normal no software de código aberto, mas, como lembrete,
sempre verifique suas licenças e certifique-se de honrá-las. Além disso, dê gritos de inspiração
para o seu trabalho.
A Listagem 10.10 mostra apenas uma parte do BLL concluído. A versão completa do 5883L BLL
pode ser encontrada no repositório de códigos do livro. Você precisará dele se quiser construir
este experimento: coloque-o no mesmo diretório que os outros arquivos do projeto.
Finalizando o código do aplicativo
Com o BLL configurado, os bits em main.js que dependem do BLL podem ser preenchidos.
Conforme mostrado na listagem a seguir, o manipulador onLaunch configura o sensor de bússola
no elemento passando um objeto de configurações para Pins.configure ().
Listagem 10.11. Configurando pinos
UAU! e-book
www.wowebook.org
/* ... */
var principal = {
aoLaunch () {
Pins.configure({ bússola: {
requer: 'HMC5883L', 1
pinos: {
bússola: {sda: 13, relógio: 14},
aterramento: { pino: 12, tipo: 'Ground' }, potência: { pino: 11, tipo:
'Potência' }
}
},
}, sucesso => { } ); 2
}
};
1 O módulo BLL personalizado, por nome de arquivo, sem extensão
2 função de retorno de chamada
Você também passa uma função de retorno de chamada como um segundo argumento para Pins.configure().
Nesse retorno de chamada, primeiro você precisa ativar um servidor WebSocket, conforme mostrado na listagem a
seguir. Este código usa a API do Kinoma WebSocketServer integrado (o WebSocketServer era necessário na
listagem 10.9).
Listagem 10.12. Configuração do servidor WebSocket
/* ... */
var principal = {
aoLaunch () {
Pins.configure({ /* ... */
}, sucesso => {
se (sucesso) {
clientes const = new Set(); 1
const wss = new WebSocketServer(80); 2
deixe últimoResultado = 0; 3
wss.onStart = client => { // Quando um cliente (navegador) se conecta

clientes.add(cliente);
// Envia imediatamente o cabeçalho da bússola mais recente
client.send(formatMsg(lastResult)); // Limpa ao fechar mais tarde
cliente.onclose = () => clientes.remove(cliente);

};
}
});
}
};
UAU! e-book
www.wowebook.org
1 suporte ao recurso ES6, então Set pode ser usado
2 Inicia um servidor WebSocket na porta 80 do elemento
3 Mantém a última leitura da direção da bússola
O código na Listagem 10.12 emite uma leitura inicial da bússola quando um cliente se conecta,
mas como as leituras da bússola são obtidas em primeiro lugar e como o cliente recebe
atualizações quando as leituras mudam? Os últimos bits de código para main.js, mostrados
na listagem a seguir, cuidam dessas coisas.
Listagem 10.13. Lendo e atualizando as direções da bússola
/* ... */
var principal = {
aoLaunch () {
Pins.configure({ /* ... */
}, sucesso => {
if (sucesso) { /* ... */
Pins.repeat('/compass/read', 500, resultado => { 1

if (Math.abs(result lastResult) >= 0.5) { 2
clientes.forEach(destinatário => { 3 destinatário.send(formatMsg(resultado)); });
}
últimoResultado = resultado;
});
}
});
}
};
1 leitura a cada 500
2 Se o novo resultado (a direção, em graus) diferir do último resultado em algum limite...
3 ... mudou significativamente. Envie o novo valor para cada um dos

clientes conectados.
Funciona como caminhos em BLLs
Funções em BLLs são referenciadas externamente pelo caminho:
UAU! e-book
www.wowebook.org
Pins.repeat('/compass/read', 500, resultado => { });
Aqui, /compass/read é um “caminho” para a função de leitura no módulo BLL. A linha de código aqui invoca
repetidamente a leitura a cada 500 ms e uma função de retorno de chamada recebe o resultado da última
operação de leitura. Veja-o em jogo na Listagem 10.13.
Código do cliente (HTML)
Por fim, você precisará de uma página HTML para servir como um cliente WebSocket e mostrar os
rumos da bússola em tempo real. Esta página pode ser visualizada em um navegador.
Listagem 10.14. Código do cliente (página HTML) para mostrar a direção da bússola
<!doctype html>
<html lang="en">
<cabeça>
<meta charset="utf8">
<title>Direção da bússola ao vivo</title>
<estilo> #bússola
{1
textalign: center; fontsize: 2em;
fontfamily: "Helvetica", sansserif; margem: 2em; } </style>
<script>
window.addEventListener('load', function () { 2 var ws = new WebSocket('ws://10.0.0.17:80'); 3
ws.onmessage = função (mensagem) { 4

var data = JSON.parse(message.data);
document.getElementById('direction').innerHTML = data.heading; };
}); </script> </

head>
<body> <div
id="compass"> <label
for="direction">Direção da bússola</label><div id="direction">...
</div>
</div>
</body> </
html>
1 Estilo para a exibição do título
UAU! e-book
www.wowebook.org
2 Ao carregar, conecta-se ao servidor WebSocket
3 Importante! Você precisa alterar isso para o endereço IP do seu próprio elemento.
4 Quando novos dados chegam, atualiza o HTML no elemento #direction para exibir o novo título
Implantando o código da bússola
O código é implantado no elemento por meio do Kinoma Code IDE. Observe que o arquivo index.html
não é fornecido pelo elemento neste exemplo. Em vez disso, você abre esse arquivo em um navegador
assim que o elemento estiver executando o aplicativo de bússola. Consulte o guia de início rápido
do Element (http://mng.bz/84cS) para obter instruções passo a passo sobre como se conectar e
implantar código em seu Element a partir do Kinoma Code IDE, caso ainda não o tenha feito.
Depois que o código for implantado e executado, você poderá abrir o arquivo index.html em um
navegador e girar a placa de ensaio com a bússola anexada para ver a atualização da exibição em
tempo real.
RESUMO
As plataformas JavaScript incorporadas usam hardware e firmware otimizados para executar

subconjuntos de JavaScript nativamente. Tanto Kinoma quanto Espruino mantêm seus próprios
mecanismos JavaScript de código aberto (KinomaJS e Espruino JavaScript, respectivamente)
para tornar isso possível.
As plataformas JS incorporadas tendem a ter processadores mais sofisticados - geralmente de 32

bits - mas ainda têm restrições significativas de memória e espaço de programa.
A família de produtos de código aberto da Espruino inclui o Pico, uma placa de desenvolvimento
de tamanho diminuto. Os projetos Espruino podem fazer uso de módulos específicos do Espruino
para trabalhar com diferentes tipos de componentes.
O Elemento Kinoma é outro dispositivo JavaScript de código aberto. A criação de projetos para o
Element envolve o uso de módulos de componentes chamados BLLs (bibliotecas de luz
piscante).
Embora existam muitas opções de plataforma por aí, você pode acelerar seu processo de
aprendizado com novas plataformas seguindo algumas etapas: aprendendo sobre os detalhes
principais, encontrando hardware e informações de pinagem, entendendo o fluxo de trabalho,
experimentando exemplos e buscando a documentação da API.
UAU! e-book
www.wowebook.org

História

Tópicos
Introdução ao desenvolvimento de hardware Node.js em plataformas de computador de

Tutoriais placa única (SBC)
Encurralando componentes e configurando um sistema Raspberry Pi 3 Modelo B

Como o GPIO funciona no Raspberry Pi e algumas opções diferentes para controlá-lo com
JavaScript
Destaques
Adaptando um aplicativo da estação meteorológica JohnnyFive para funcionar em várias plataformas diferentes
Configurações
—Tessel 2, Raspberry Pi, Arduino e BeagleBone Black
Apoiar Trabalhando com o SBC de código aberto GPIOrich BeagleBone Black
Os computadores
computação Sign Outde
deplaca únicageral
propósito (SBCs)
comsão minúsculas usinas
as características dos de força que
sistemas combinam(figura
embarcados a
11.1). Esses computadores ittybitty reúnem uma série de periféricos e itens em um pequeno
pacote: várias portas USB, Bluetooth, WiFi, Ethernet - os recursos que você esperaria de um
computador desktop.
Mas eles têm vários recursos que se prestam bem a aplicativos incorporados: seu tamanho
reduzido, preço mais baixo, suporte a GPIO e eficiência relativa de energia (embora não
sejam tão miseráveis quanto as plataformas incorporadas mais simples, eles certamente exigem
menos suco do que seus irmãos de desktop).
Figura 11.1. Computadores de placa única (SBCs), da esquerda para a direita: módulo Intel
Edison com Arduino breakout, Raspberry Pi 2 Modelo B e BeagleBone Black
UAU! e-book
www.wowebook.org
Esta não é a primeira vez que você vê SBCs neste livro, mas vamos revisitar o que é um SBC, em termos gerais.
Não há uma definição formal do termo, mas as plataformas SBC tendem a fazer o seguinte:
Execute sistemas operacionais de alto nível; na maioria dos casos, você pode instalar um sistema operacional
diferente, se desejar (normalmente, mas nem sempre, Linux)
Ofereça recursos de desktop de uso geral, como suporte para periféricos USB, monitores, som e assim por diante
Forneça opções de GPIO, embora às vezes sejam secundárias em relação a outros recursos da plataforma
O rolo compressor nesta categoria é a plataforma Raspberry Pi, uma família de SBCs que está desfrutando de
popularidade épica. Da mesma forma, passaremos a maior parte deste capítulo mergulhando no Node.js e no
Raspberry Pi 3 Modelo B. Mas também faremos um breve tour pela placa BeagleBone Black como um
segundo exemplo de plataforma nesta classe SBC.
1 fonte de alimentação Raspberry Pi 3 Modelo B e 5 V
UAU! e-book
www.wowebook.org
1 cartão microSD e adaptador
1 Adafruit TCobbler, SparkFun Pi Wedge ou similar, ou uma variedade de fios de jumper macho
para fêmea
1 resistor de 100 V
Fios de jumper
1 BeagleBone Black
1 Arduino Uno
O Tessel 2 e a definição de computadores de placa única
O Tessel 2 é quase uma categoria de dispositivo em si. Seus periféricos USB, recursos de rede e
sistema operacional de alto nível (OpenWrt Linux) parecem sugerir território SBC. No entanto, sua RAM
limitada e armazenamento em Flash, bem como sua falta de suporte a periféricos semelhantes a
desktops (como um monitor) são sinais de que ele foi projetado para aplicativos incorporados.
UAU! e-book
www.wowebook.org
Então é um SBC? Eu tenderia a inclinar-me para um sim qualificado, mas se sua própria definição de SBC envolve
enfaticamente a capacidade de conectar um monitor e usá-lo como um computador de mesa, então não!
11.1. TRABALHANDO COM PEQUENOS COMPUTADORES
Os SBCs são certamente mais sofisticados do que seus irmãos devboard mais simples. Eles também podem ser,
correspondentemente, mais envolvidos para configurar e configurar fora da caixa. Em muitos casos, você estará
lidando com muitas opções de escolha nos reinos de software e hardware. Mas não entre em pânico: ir do zero
ao zoom em um Raspberry Pi 3 usando um cartão SD pré-flash com NOOBS (New OutofBox Software) para
Raspberry Pis pode ser incrivelmente simples. Mas você precisará arregaçar as mangas do Linux e passar
algum tempo em um terminal para obter um fluxo de trabalho confortável e centrado no Node.js.
Não fique nervoso. Se algo der errado ao seguir as etapas de configuração para qualquer um dos SBCs que
examinaremos - o Raspberry Pi 3 e o BeagleBone Black - você sempre poderá começar do zero sem causar danos
irreparáveis.
SBCs, sistemas embarcados e (Debian) Linux
Houve um Big Bang de projetos e distribuições do Linux voltados para dispositivos embarcados e móveis nos
últimos anos. Por exemplo, o Tessel executa um Linux simplificado originalmente desenvolvido para roteadores:
OpenWrt.
À medida que nos aprofundarmos nos SBCs de alto desempenho, você verá que há decisões a serem tomadas
— a maioria das plataformas executará com prazer várias distribuições Linux diferentes.
Com o Raspberry Pi, ficaremos com a escolha padrão e mais comum: Rasp bian, um Linux baseado em
Debian. Para consistência, a exploração do BeagleBone Black no final do capítulo atualiza a placa com o Debian
Linux em vez de usar o padrão (Ångström) que acompanha.
Os lançamentos do Debian são nomeados em homenagem aos personagens de Toy Story. No momento em
que escrevo, o Debian estável está na versão 9 (Stretch), mas a maioria das plataformas embarcadas e SBC
ainda estão usando compilações da versão 8 (Jessie). Às vezes, vemos compilações da versão 7 (Wheezy),
embora estejam se tornando menos comuns.
UAU! e-book
www.wowebook.org
O Raspberry Pi (figura 11.2) está em todos os lugares que você olha. O que a plataforma Arduino é para placas
de desenvolvimento mais simples, a plataforma Pi é para SBCs: onipresente.
Figura 11.2. Raspberry Pi 2 Modelo B (esquerda), Raspberry Pi Zero (primeiro plano

central) e Raspberry Pi 3 Modelo B (em um estojo, com SparkFun Pi Wedge anexado)
Com cada geração Pi numerada sequencial (1, 2 e 3 até agora), a plataforma tornou-se mais
poderosa, eficiente, estável e repleta de recursos. A exceção é a família Pi Zero, que é ainda menor e
mais barata, mas custa alguns recursos e desempenho.
Apesar de seu poder e flexibilidade, a plataforma Raspberry Pi nem sempre é a escolha ideal para
iniciantes em eletrônica. O grande número de coisas que você pode fazer com um Pi pode ser
uma distração, assim como a tarefa de lidar com a administração do Linux e outros detalhes de
configuração. É fácil sair pela tangente da pesquisa do Google, chafurdando por horas entre
fóruns e ideias e opções de projetos.
Além disso, as pinagens do Pi são bastante complexas e possuem sistemas de numeração e

nomenclatura múltiplos e confusos. Apesar do grande número de pinos, algum suporte GPIO está
completamente ausente. Não há conversão analógica para digital (ADC) integrada, por exemplo.
Outros recursos importantes do GPIO são limitados. Dos 40 pinos GPIO em um Raspberry Pi 3 Modelo
B (figura 11.3), apenas dois são compatíveis com PWM.
Figura 11.3. O Raspberry Pi 3 Modelo B UAU!

Por outro lado, você aprendeu o suficiente sobre o básico para que algumas dessas armadilhas em potencial não
pareçam mais tão assustadoras. Raspbian - o sistema operacional padrão baseado em Debian do Pi - é
amplamente usado, sensato e confiável. Como tantas pessoas usam o Pis, existem muitos recursos projetados
para ajudar até mesmo os iniciantes, e há uma vasta coleção de fóruns, wikis, Stack Overflow e postagens de blog,
e assim por diante, para ajudá-lo com cada último

detalhe.
Colocando seu kit em ordem
As seções a seguir fornecem duas opções diferentes para configurar um Raspberry Pi 3
Sistema baseado no Modelo B:
Configuração tradicional - A maneira tradicional e mais amigável para iniciantes de configurar um
Raspberry Pi é tratá-lo como um computador de mesa - conecte um mouse USB, um teclado USB e
um monitor HDMI e trabalhe nele diretamente.
Configuração sem cabeça - Se você não deseja dedicar tantos periféricos ao seu Pi, pode optar por tratá-lo
mais como um sistema integrado. Se essa noção agrada, a seção de configuração sem cabeça é para você!
Para uma configuração inicial, os kits iniciais do Pi, disponíveis em todos os principais varejistas de eletrônicos on-
line, são um ótimo, embora mais caro, caminho a percorrer (em vez de comprar a placa Pi e os
componentes de suporte separadamente). Aqui estão algumas coisas para procurar em um kit:
Um cartão microSD pré-flash com NOOBs ou Raspbian - de preferência também com um SD
UAU! e-book
www.wowebook.org
adaptador de cartão para que você possa usar um leitor/gravador de cartão de tamanho padrão para atualizar
o conteúdo do cartão
Um invólucro (estojo) - Isso dá ao seu Pi estabilidade física, proteção e, em alguns
casos, uma aparência suave.
Fonte de alimentação—A conexão de energia do Pi é micro USB, então você pode usar um
carregador de dispositivo USB de 5 V. Tenha em mente, no entanto, que as necessidades atuais
do Pi podem não ser atendidas por todos os carregadores de telefone: o site do Pi recomenda um
adaptador que pode fornecer 2,5 A ou mais.
Hardware para fornecer acesso mais fácil aos pinos GPIO do Pi — Eles vêm na forma de Adafruit
Cobbler, SparkFun Wedge e outras opções semelhantes (figura 11.4).
Figura 11.4. Kit Raspberry Pi 3 Modelo B SparkFun construído com Pi Wedge, mostrado
aqui conectado a uma placa de ensaio. Também é mostrado um Adafruit T-Cobbler (à
direita), que fornece o mesmo tipo de funcionalidade que o Wedge.
Os kits podem oferecer outras vantagens úteis - o SparkFun inclui um leitor de cartão USB microSD,
por exemplo - mas eles têm a desvantagem de incluir coisas que você provavelmente já possui: breadboards,
jumpers, LEDs e similares.
Uma placa Raspberry Pi 3 Modelo B sozinha custa cerca de US$ 40, enquanto os kits completos
custam cerca de US$ 90. Os atuais kits iniciais do Pi 3 da Adafruit e SparkFun contêm todas as peças
necessárias para esta seção.
Fazendo conexões GPIO no Pi
Os pinos do Pis são machos - se você se conectar diretamente a eles, precisará de fios de jumper
macho para fêmea e poderá acabar com um ninho de rato e frustração, porque não há
informações serigrafadas no próprio Pi.
UAU! e-book
www.wowebook.org
Existem componentes de hardware de terceiros destinados a tornar o GPIO do Pi mais fácil
de trabalhar. O Pi Wedge da SparkFun e o TCobbler da Adafruit são dois exemplos: esses
breakouts organizam os pinos em agrupamentos mais intuitivos (com dicas serigrafadas) e
fornecem um fator de forma compatível com breadboard. Seu kit Pi pode vir com eles ou podem
ser adquiridos separadamente.
Adafruit TCobbler montado e SparkFun Pi Wedge (mostrado com cabo de 40 pinos conectado)
FTDI (Future Technology Devices International)
A FTDI fabrica chips que permitem comunicação serial assíncrona entre dispositivos
embarcados e computadores. Os chips FTDI traduzem os sinais TTL ou RS232 (RS 232 é outro
protocolo serial assíncrono) provenientes de um dispositivo em sinais USB que um
computador pode entender e vice-versa. As conexões FTDI podem ser usadas para
monitorar a saída serial de um dispositivo. Em alguns casos, eles também podem ser usados
para programar ou controlar o dispositivo.
O Pi Wedge da SparkFun inclui uma interface FTDI. Você também precisa de um cabo ou uma
placa breakout para conectar aos pinos FTDI (uma placa breakout SparkFun FTDI com
conector miniUSB é visível conectada ao Pi Wedge na figura 11.4).
UAU! e-book
www.wowebook.org
Seguem-se as etapas para uma configuração Pi tradicional estilo desktop e uma configuração sem
cabeça. Você desejará escolher apenas uma dessas opções, mas não importa qual caminho seguir,
você precisará do seguinte:
1 Raspberry Pi 3 Modelo B
1 micro fonte de alimentação USB de 5 V
1 gabinete (opcional, mas recomendado)
1 Adafruit TCobbler, SparkFun Pi Wedge ou similar; ou um conjunto de cabos jumper macho

para fêmea
11.1.2. Opção de configuração 1: a forma tradicional
Além das peças listadas na seção anterior, você também precisará do seguinte:
1 cartão microSD, pré-flash com NOOBS ou Raspbian OS (com desktop)
1 teclado USB
1 mouse USB
1 monitor
1 cabo HDMI para o monitor
Esta opção de configuração envolve conectar periféricos e energia e seguir as instruções na tela.
Coloque um cartão microSD pré-flash com NOOBS e ligue-o.
O NOOBS oferece a opção de instalar um dos vários sistemas operacionais. Vá em frente e selecione
a primeira opção - Raspbian. O processo UAU!
de instalação
e-book leva alguns minutos.
www.wowebook.org
Depois que o sistema operacional estiver instalado e configurado, você poderá inicializar no
ambiente PIXEL (Pi Improved Xwindows Environment, Lightweight). Configurar o WiFi é simples:
comece clicando no ícone WiFi na barra de menu superior direita (figura 11.5).
Figura 11.5. A área de trabalho PIXEL. Observe o ícone WiFi no canto superior direito.
Se você quiser fazer shell no seu Pi mais tarde, sem ter que trabalhar diretamente no Pi,
você precisa habilitar o SSH. Para fazer isso, use a opção de menu Preferências >
Configuração do Raspberry Pi. Navegue até a guia Interfaces e clique na opção Enabled ao lado de
SSH. Clique em OK para aplicar a alteração.
Por enquanto é isso! Se você tiver alguma dificuldade, acesse o Raspberry Pi Software Guide
(http://mng.bz/P8Hu), que é ilustrado e fácil de usar.
11.1.3. Opção de configuração 2: sem cabeça
Essa abordagem mais simples e direta ao essencial elimina a necessidade de periféricos e

cabos. Por outro lado, é uma abordagem menos comum e requer mais tempo em um terminal.
O Raspbian está em constante evolução, mas as etapas a seguir funcionaram de maneira
confiável em meados de 2017.
Se você já configurou seu Pi usando a abordagem de área de trabalho, pode pular este
conjunto de etapas. Você pode pular para a seção 11.8.
UAU! e-book
www.wowebook.org
Além das peças listadas no final da seção 11.1, você precisará do seguinte:
1 cartão microSD
1 adaptador de cartão SD
1 leitor/gravador de cartão SD (ou um computador com leitor integrado)
1 cabo Ethernet
Como você está sem cabeça, precisará configurar o Pi para poder se comunicar com ele de
alguma forma, pois não terá teclado e monitor.
Primeiro, você precisará criar um cartão SD inicializável que permitirá o ssh para o Pi por meio de uma
conexão Ethernet com fio. Em seguida, você fará o shell e configurará o WiFi no comando
linha.
Criando uma imagem de disco Raspbian inicializável
Você precisará colocar um sistema operacional em um cartão microSD para que o Pi possa inicializar:
1. Baixe o Raspbian (não o NOOBS) na página de download do Raspbian
(www.raspberrypi.org/downloads/raspbian/) (figura 11.6).
Figura 11.6. Baixe a versão completa do Raspbian na página de download do Raspberry

Pi's Raspbian.
UAU! e-book
www.wowebook.org
Quando o download grande estiver concluído, descompacte o arquivo zip resultante. Se tudo der certo,
você deve terminar com um arquivo IMG (uma imagem de disco inicializável).
Grande arquivo zip Raspbian buzinando
Conforme observado na página de download do Raspbian (figura 11.6), o arquivo compactado
resultante é grande e seu utilitário de descompactação padrão pode não estar à altura da tarefa
de descompactá-lo (o meu não estava). Conforme sugerido lá, tente o Unarchiver para Mac ou 7Zip para
Windows se tiver problemas.
2. Crie um cartão microSD inicializável:
1. Instale o aplicativo gratuito Etcher (https://etcher.io/), disponível para Windows, Mac ou Linux. Isso
permitirá que você pegue o arquivo Raspbian IMG e grave-o no cartão microSD.
2. Insira o cartão microSD no adaptador de cartão SD e, em seguida, insira todo
kaboodle em seu computador ou leitor/gravador de cartão SD.
3. Inicie o Etcher e siga as etapas para colocar o arquivo IMG no cartão microSD
(figura 11.7).
Figura 11.7. O Etcher é um utilitário direto: selecione o arquivo de imagem do disco, selecione a unidade
(muitas vezes ele seleciona automaticamente para você) e pronto.
UAU! e-book
www.wowebook.org
3. Adicione um arquivo ao cartão microSD para ativar o SSH:
1. Quando o Etcher terminar - leva vários minutos para criar a imagem do disco - o
O cartão microSD será ejetado (desmontado) do seu computador. Desconecte-o, conecte-o
novamente e abra a partição de inicialização (essa pode ser a única partição que você pode ver).
2. Crie um arquivo vazio chamado “ssh” – sem extensão – e coloque-o no nível superior da inicialização.
Isso ativará o SSH no Pi, que é desativado por padrão no Raspbian.
4. Instale o SO:
1. Ejete o adaptador de cartão SD de seu computador, remova o cartão microSD de
o adaptador e insira o cartão microSD no Pi 3.

2. Inicialize o Pi.
5. Estabeleça comunicação com seu Pi via Ethernet:
1. Conecte a interface Ethernet do Pi 3 diretamente ao seu roteador sem fio com um

Cabo Ethernet.
2. Encontre o endereço IP do seu Pi. Seu Pi 3 deve receber automaticamente um IP
endereço (via DHCP), mas você precisará descobrir qual é esse endereço IP. Existem muitas
maneiras de esfolar este gato. Google “scanner IP” ou “scanner LAN” e você encontrará uma
infinidade de utilitários gratuitos para várias plataformas, ou você pode usar uma ferramenta de
linha de comando. Eu uso o LanScan para Mac (figura 11.8). A ideia é determinar qual IP foi
atribuído ao seu Pi.
Figura 11.8. Usando LanScan para Mac, posso ver que a interface Ethernet
do Raspberry Pi recebeu o endereço IP 192.168.1.13.
UAU! e-book
www.wowebook.org
6. Depois de obter o endereço IP do Pi, abra um terminal e digite este comando:
$ ssh pi@<IP do seu Pi>
Nome de usuário e senha padrão do Pi
O nome de usuário padrão no Raspberry Pi é pi e a senha é framboesa. É uma boa ideia alterar
a senha do usuário pi. Você pode fazer isso (quando conectado como o usuário pi) digitando
passwd no prompt de comando e seguindo as instruções na tela
instruções. Faça isso. Faça isso agora.
Configurando WiFi no Pi
A última etapa é configurar o WiFi para o seu Pi para que você não precise usar uma conexão
Ethernet com fio. Isso envolve mexer com a configuração wpa_supplicant do Pi.
Às vezes, isso pode ser complicado e frustrante se você tentar editar o arquivo de configuração
diretamente. Descobri que a maneira mais segura é usar o utilitário de linha de comando
wpa_cli:
Suporte Wi-Fi do Raspberry Pi 3
O Pi 3, como o Tessel 2, não suporta redes WiFi de 5 GHz.
1. SSH em seu Pi, se ainda não o fez.

2. Inicie uma sessão wpa_cli interativa digitando este comando:
UAU! e-book
www.wowebook.org
$ sudo wpa_cli
Isso o colocará em um modo interativo. Você pode digitar comandos subseqüentes no

> prompt.
3. Procure redes sem fio disponíveis para garantir que seu Pi possa ver o WiFi desejado
rede. Para fazer isso, digite isto:
> digitalizar
Então, para ver os resultados da verificação:
> resultados_scan
Sua rede aparece? Caso contrário, verifique as configurações do seu roteador e certifique-se de que
é uma rede Wi-Fi compatível (não 5 GHz). Se isso acontecer, sim! Continuar.
4. Execute cada um dos seguintes comandos para adicionar, configurar e ativar o desejado
Conexão de rede WiFi na configuração wpa_supplicant do Pi:
> add_network 0 >

set_network 0 ssid "<SSID da sua rede>" > set_network 0 pwk "<senha
da sua rede>"
> ativar rede 0
> salvar_config
5. Pressione CtrlC para sair do wpa_cli.

6. Para verificar se funcionou, digite isto:
$ ifconfig wlan0
Se estiver tudo bem, você deverá ver um endereço IP atribuído (figura 11.9).
Figura 11.9. Depois de configurar o WiFi, o Pi agora tem dois endereços IP - um

para a interface Ethernet e outro para a interface WLAN (WiFi).
UAU! e-book
www.wowebook.org
Você pode desconectar a conexão Ethernet, se quiser. O Pi agora se conectará automaticamente à rede
WiFi configurada aqui toda vez que inicializar. Prático!
Se você precisa de um recomeço
Não é muito difícil recomeçar se o seu Pi estiver se comportando mal ou se você se sentir confuso ou preso.
Desligue o Pi, ejete o microSD e atualize-o novamente com o sistema operacional desejado: NOOBS para uma
configuração visual amigável; Raspbian; ou qualquer outro sistema operacional compatível de sua escolha.
Inicializar a partir desse cartão SD atualizado lhe dará uma ardósia limpa.
11.2. APRENDENDO SOBRE O RASPBERRY PI 3
Agora que você configurou um Pi com conectividade Wi-Fi, vamos aplicar as etapas de aprendizado da
plataforma descritas no capítulo 10 para entender melhor a plataforma Raspberry Pi 3 em geral.
Os SBCs realmente aumentam a aposta no poder de processamento, compatível com seus sinos e assobios
adicionais. Os microcontroladores da família Cortex M de 32 bits da ARM estão no centro de uma série de
plataformas que podem executar JavaScript incorporado. Com os SBCs completos, você estará dando mais
um passo à frente no desempenho do processador. Esses processadores de 32 e 64 bits geralmente apresentam
vários núcleos, aceleração de gráficos 3D, velocidades de clock mais altas e subsistemas complexos.
O Pi 3 possui uma CPU quadcore ARM (A8) de 64 bits rodando a 1,2 GHz. Isso está muito longe do ATmega de
8 bits do Uno a 20 MHz (correndo o risco de comparar maçãs com laranjas).
Outras especificações observadas na página de informações do produto (figura 11.10) incluem 1 GB de RAM,
UAU! e-book
www.wowebook.org
Wi-Fi e Bluetooth integrados, 4 portas USB, saídas de vídeo e estéreo, interface HDMI
e muito mais (www.raspberrypi.org/products/raspberrypi3modelb/).
Figura 11.10. Destaques das especificações do Raspberry Pi 3 Modelo B no site do

Raspberry Pi
2
GPIOwise, é um saco misturado. Existem várias interfaces SPI e IC e muitos pinos em geral. Como
mencionado anteriormente, não há suporte para ADC e o PWM é limitado. Acessórios adicionais
e certos periféricos podem exigir conexões a alguns dos pinos, o que significa que você
pode não ter acesso de E/S a todos os 40 pinos, dependendo da sua configuração.
Por causa do mercado de uso geral do Pi 3, a lista de recursos principais em sua página de
produto não menciona que sua tensão de nível lógico GPIO é de 3,3 V, mas você deve saber que:
o Raspberry Pi 3 é um dispositivo de 3,3 V.
Sério, o Pi é um dispositivo de3,3 V WOW!

Não aplique energia de 5 V a nenhum dos pinos do Pi ou você pode acabar com um Pi morto.
As pinagens Pi são complicadas. Para começar, há muitos pinos (40), muitos esquemas de
nomenclatura e numeração de pinos diferentes, e um determinado pino pode já estar
2
monopolizado por um componente, processo ou periférico. Grupos de conexões relacionadas,
como pinos SPI ou IC, também não são necessariamente adjacentes fisicamente. O site
pinout.xyz é um bom recurso para os detalhes minuciosos sobre as pinagens do Pi.
Como um exemplo das muitas faces de um único pino Raspberry Pi GPIO, o pino físico 33
(figura 11.11) é também conhecido como BCM 13 (número do pino Broadcom), por seu nome
funcional primário de PWM1 (é um dos pinos compatíveis com PWM), e como WiringPi pino 23.
Ele também possui vários aliases nomeados funcionalmente, como AVEOUT VID 9. E estará
disponível para uso GPIO? Não será se você tiver um monitor externo paralelo conectado ao Pi
- é um dos pinos necessários para isso. E pode não ser se você quiser usar uma interface de
depuração JTAG ou dispositivo SMI (Secondary Memory Interface); é um dos pinos usados
nesses tipos de conexões também.
Figura 11.11. pinout.xyz é um site inteiramente dedicado às informações de

pinagem do Raspberry Pi. Este detalhe de pinout.xyz mostra os muitos aliases do
pino físico 33.
SBCs e terminologia de hardware específica da plataforma

UAU! e-book
www.wowebook.org
Parece que cada plataforma SBC adiciona mais termos de jargão ao vocabulário IoT. Assim como as placas de
expansão compatíveis com Arduino são chamadas de shields, as placas que se encaixam no Raspberry
Pi são normalmente chamadas de hats, e aquelas que se encaixam no BeagleBone Black são chamadas de
capes.
As possibilidades do que você pode fazer e como fazer são virtualmente ilimitadas na plataforma Pi - afinal, é um
computador completo. Vamos restringir isso um pouco, concentrando-nos nas opções de configuração e
fluxo de trabalho para um hacking eletrônico centrado no Node.js
configurar.
Neste ponto, você deve ter um Pi funcionando - seja configurado como um computador autônomo ou
um dispositivo sem cabeça. Você tem mais três etapas a seguir para obter a configuração e o fluxo
de trabalho sólidos:
1. Certifique-se de que o software do Pi está atualizado.
2. Obtenha uma versão toleravelmente recente do Node.js instalada no Pi.
3. Descubra uma maneira de criar código e colocá-lo no sistema de arquivos do Pi.
Atualizando o software do Pi
Certifique-se de que o Pi tenha as atualizações de software mais recentes:
1. ssh no Pi (sem cabeça) ou use um terminal (desktop). Certifique-se de que o Pi é

Conectado a internet.
2. Execute o seguinte comando:
$ sudo apt update
Isso pode levar alguns minutos para ser concluído.
3. Execute este comando:
$ sudo apt fullupgrade
Isso também pode levar vários minutos para fazer seu trabalho.
Atualizando o Node.js no Pi
Ainda conectado ao Pi ou em uma janela de terminal, tente executar este comando:
$ versão do nó UAU! e-book

www.wowebook.org
Isso produzirá a versão atual do Node.js no Pi. No momento da escrita, a versão pré-instalada
do Node.js era v0.10.29, que é arcaica. Traga isso para LTS (LongTerm Support), para que não
tenhamos problemas de compatibilidade ou segurança em seus projetos:
1. Se você não acabou de executar uma atualização completa do sistema (como mostrado na seção anterior), primeiro
execute este comando:
$ sudo apt update
2. Baixe e execute um script de configuração Node.js para a versão de destino executando este
comando:
$ curl sL https://deb.nodesource.com/setup_6.x | sudo E bash
No momento da escrita, o LTS era v6.x. Isso terá mudado quando você ler isso, então você pode
substituir a parte setup_6.x da URL pelo número da versão principal apropriada. Consulte
o repositório NodeSource Binary Distributions para obter mais informações (https://github.com/

nodesource/distributions).
3. Instale o Node.js:
$ sudo apt install e nodejs
4. Verifique se funcionou executando este comando:
$ versão do nó
Gerenciando arquivos no Pi
Os arquivos e recursos JavaScript para seus projetos Pi serão executados no Pi e precisam existir no
sistema de arquivos do Pi. Existem, sem surpresa, muitas maneiras de colocar seus arquivos no Pi. Aqui
estão algumas opções:
Crie os arquivos no próprio Pi. Você pode usar um editor baseado em terminal, como vi ou nano.
Ou, se você tiver uma configuração de desktop para o seu Pi, poderá usar um editor GUI como o
aplicativo Leafpad pré-instalado. Ou você pode instalar qualquer número de aplicativos adicionais
de edição de texto.
Use um utilitário para copiar arquivos do seu computador para o Pi. Você pode usar a
ferramenta de linha de comando do Unix scp (cópia segura) para mover arquivos ou um
aplicativo GUI compatível, por exemplo.
UAU! e-book
www.wowebook.org
Configure um servidor de arquivos no Pi para que você possa acessá-lo como um compartilhamento
remoto de outros computadores em sua rede. Um dos muitos métodos possíveis para fazer isso é usar um
servidor Samba (SMB).
Configurando um servidor Samba (SMB) no Pi
Uma maneira de facilitar o acesso aos arquivos do seu Pi é configurar um servidor de arquivos no próprio Pi.
As etapas a seguir configuram um compartilhamento Samba (SMB) chamado de projetos que podem ser lidos
e acessados pelo usuário pi. Depois de configurado, esse compartilhamento deve aparecer no Finder ou no
File Explorer do seu sistema como uma unidade de rede. Observe que estas instruções pressupõem uma
familiaridade geral com a linha de comando do Linux:
1. ssh no Pi como o usuário pi (headless) ou use um aplicativo de terminal (desktop).
2. Certifique-se de estar no diretório inicial do usuário pi digitando este comando:
$pwd
Você deve ver a seguinte saída:
/home/pi
3. Crie um diretório para manter os arquivos do projeto em:
$ mkdir projetos
4. Instale o Samba:
$ sudo apt instalar samba
5. Configure uma senha do Samba para o usuário pi digitando o seguinte comando e
seguindo as indicações:
$sudo smbpasswd para pi
6. O Samba não usa senhas do sistema, ele mantém as suas próprias.
7. Edite o arquivo de configuração do Samba. Primeiro faça um backup para o seu diretório pessoal, apenas
em caso:
$ sudo cp /etc/samba/smb.conf ~/
8. Agora edite a configuração:
UAU! e-book
www.wowebook.org
$ sudo you /etc/samba/smb.conf
9. (Você pode usar um editor diferente, como o nano, se preferir, no lugar do vi.) Role
até o final do arquivo e adicione estas linhas, incluindo os espaços ao redor dos caracteres =:
[projetos]
caminho = /home/pi/projetos
usuários válidos = pi
somente leitura = Não
10. Salve o arquivo e saia.
11. Reinicie o serviço Samba:
$ sudo serviço smbd reiniciar
12. Verifique sua configuração se desejar:
$ testparm
Agora você deve conseguir se conectar ao compartilhamento SMB de outros computadores na mesma rede
(usando Map Network Drive no Windows File Explorer ou Connect to Server ou CmdK em um Mac). A string
de conexão assume este formato:
smb://user@host/sharename
Você deve acabar com algo assim:
smb://pi@<IP do seu Pi>/projetos
Às vezes, os compartilhamentos do Samba podem ser imperfeitos e é possível que você precise
ajustar as permissões ou os metadados do usuário para que funcionem corretamente. Existem muitos fóruns
de usuários e artigos de ajuda na web, se você precisar de suporte.
Crie uma área de “projetos”
Criar um diretório chamado “projetos” dentro do diretório pessoal do usuário pi é uma das etapas na barra
lateral para configurar um servidor Samba. Mesmo se você não configurar um compartilhamento em
UAU! e-book
www.wowebook.org
o Pi, vá em frente e crie um diretório para encurralar seus próximos experimentos de código. O restante
do capítulo assumirá a existência de um diretório ~/projects (um diretório chamado “projects” dentro
do seu diretório pessoal).

Não há uma maneira única de piscar um LED em um Raspberry Pi - as opções são quase
incontáveis. Você tentará algumas maneiras aqui, enfatizando as opções de JavaScript.
1 Raspberry Pi 3 configurado
1 SparkFun Pi Wedge, Adafruit TCobbler ou similar; ou jumper masculino

fios
1 resistor de 100 V
1 tábua de pão
Fios de jumper
O jeito certo de sudo
Devido às permissões conservadoras para interagir com GPIO no Raspbian, você provavelmente
precisará executar os exemplos de código a seguir usando sudo. Por exemplo,
$ sudo ./blink.sh
ou
$ sudo nó index.js
UAU! e-book
www.wowebook.org
Sem sudo, você pode obter erros de permissão como estes:
./blink.sh: linha 4: /sys/class/gpio/gpio4/direction: Permissão negada ./blink.sh: linha 5: /sys/class/gpio/gpio4/

value: Permissão negada ./blink.sh: linha 7: eco: erro de gravação: operação não permitida
Tente usar o sudo apenas com comandos que o exijam, como ao executar esses scripts.
Não use o sudo para instalar módulos npm ou criar arquivos ou coisas do tipo. Você pode
acabar criando coisas com permissões instáveis se fizer isso. Em caso de dúvida, tente fazer
algo primeiro sem sudo e veja se funciona.
Construindo um circuito de LED
Cada um dos exemplos a seguir usa a mesma configuração de circuito físico: o ânodo do
LED deve ser conectado ao pino físico 7 do Pi (pino 7 do WiringPi, pino 4 do BCM). O
cátodo deve ser conectado a um pino GND.
Os diagramas de fiação são mostrados para conexões directtoPi (figura 11.12), T Cobbler
da Adafruit (figura 11.13) e Pi Wedge da SparkFun (figura 11.14).
Figura 11.12. Diagrama de fiação para conectar o LED diretamente aos pinos do Pi,
usando fios jumper macho-fêmea
UAU! e-book
www.wowebook.org
Figura 11.13. Diagrama de fiação, usando o T-Cobbler da Adafruit
UAU! e-book
www.wowebook.org
Figura 11.14. Diagrama de fiação, usando o Pi Wedge do SparkFun
UAU! e-book
www.wowebook.org
Piscando um LED com sysfs
Sysfs é um pseudosistema de arquivos Linux que organiza a configuração de dispositivos e sistemas

conectados em uma hierarquia de sistema de arquivos. Cada entidade exportada pelo sysfs para
o espaço do usuário é representada por um diretório. O Sysfs é montado em /sys e,
de dentro de /sys/class/gpio, é possível controlar os pinos GPIO do Pi.
Para cada pino que você deseja usar, você precisa fazer o seguinte:
UAU! e-book
www.wowebook.org
1. Exporte o pino. Isso é feito escrevendo o número PIN no arquivo em /sys/class/
gpio/export usando o esquema numérico BCM. Isso criará um diretório para o pino
(<pin_directory>).
2. Configure o pino, como escrevendo o valor 'in' ou 'out' para /sys/class/gpio/<pin_directory>/
direction.
3. Interaja com o pino, como lendo o arquivo /sys/class/gpio/
<pin_directory>/value ou gravando um valor nele.
4. Limpe. Cancele a exportação do pin escrevendo o número do pin no arquivo em /sys/class/
gpio/unexport.
Isso provavelmente é mais fácil de entender por exemplo. Piscar um LED conectado ao pino físico
7, BCM GPIO 4, uma única vez - ligando-o e desligando-o novamente - pode ser feito usando um
script de shell, conforme mostrado na listagem a seguir.
Para experimentar o sysfs, crie um diretório “blinksysfs” dentro do diretório ~/projects.
Listagem 11.1. Um script bash para piscar um LED anexado uma vez
#! /bin/bash
# Exporte o pino para que possamos trabalhar com ele echo
"4" > /sys/class/gpio/export
# Defina o pino como um pino de saída
echo "out" > /sys/class/gpio/gpio4/direction
# Ligue o LED definindo o pino como HIGH ("1") echo "1" > /sys/class/gpio/
gpio4/value
# Não faça nada por um segundo
dormir 1
# Desligue o pino definindo-o como LOW ("0") echo "0" > /sys/class/
gpio/gpio4/value sleep 1
# Unexport o pino para limpar depois de nós mesmos echo "4" > /sys/
class/gpio/unexport
Para executar o script blink.sh, você precisa tornar o arquivo executável. Você deve ser capaz de
fazer isso executando este comando dentro do diretório ~/projects/blinksysfs:
$ chmod +x ./blink.sh
Agora experimente digitando o seguinte:
$ sudo ./blink.sh
Piscando um LED com sysfs e Node.js

UAU! e-book
www.wowebook.org
No final das contas, essas são apenas ações do sistema de arquivos, portanto, você também pode fazer
isso com o Node.js usando o módulo interno fs, conforme mostrado na listagem a seguir.
Listagem 11.2. Piscando um LED com sysfs e Node.js
const fs = require('fs'); const sysfsPath = '/

sys/class/gpio'; const ledPin = '4'; 1
const piscaTotal = 10;
var piscaCont = 0;
var ledStatus = false;
// Exporta e configura o pino como saída fs.writeFileSync(`${sysfsPath}/

export`, ledPin); fs.writeFileSync(`${sysfsPath}/gpio${ledPin}/direction`, 'out');
var piscando = setInterval(() => {

if (ledStatus) { // O LED está
aceso. Desligue isso.
fs.writeFileSync(`${sysfsPath}/gpio${ledPin}/value`, '0'); blinkCount++; // Isso completa um ciclo de
piscada if (blinkCount >= blinkTotal) {
console.log('All done blinking'); // Limpamos depois de nós

mesmos
fs.writeFileSync(`${sysfsPath}/unexport`, '4');
clearInterval(pisca);
}
} outro {
// O LED está desligado. Ligue-o.
fs.writeFileSync(`${sysfsPath}/gpio${ledPin}/value`, '1');
}
ledStatus = !ledStatus; // O LED mudou de estado
}, 1000);
1 Observe que o número do pino e todos os valores escritos neste exemplo são strings.
Experimente usando este comando:
$ sudo nó index.js
Não se esqueça de desexportar
Você realmente precisa desexportar objetos no diretório gpio quando terminar ou será problemático para você
na próxima vez que quiser usar esse pino. Se você vir um erro como este
UAU! e-book
www.wowebook.org
ao tentar executar o script intermitente do Node.js, é provável que o pino não tenha sido exportado
corretamente:
Erro: EBUSY: recurso
ocupado ou bloqueado, escreva
Você pode executar o seguinte comando em um terminal para limpar manualmente:
$ echo "4" > /sys/class/gpio/unexport
Você poderia preencher um tomo enciclopédico com todas as coisas que pode fazer com o sysfs,
mas vamos seguir em frente. É bom saber sobre o sysfs, mas trabalhar diretamente com ele
requer paciência e envolve uma curva de aprendizado.
WiringPi
WiringPi é um wrapper de abstração que tenta tornar a numeração de pinos mais sensata e expõe
uma API que é mais familiar ao estilo Arduino. Está escrito em C, mas as bibliotecas Ruby e Python
são populares. Há um pacote npm que fornece ligações Node.js: wirepi.
Se você quiser experimentar, crie um diretório em sua área ~/projects chamado blinkwiringpi.
Dentro desse diretório, execute este comando:
$ npm instalar fiaçãopi
Em seguida, crie um arquivo index.js com o conteúdo mostrado na listagem a seguir. Nesse script,
o valor do status alterna entre 0 e 1, desligando e ligando o LED, respectivamente.
const wpi = require('wiringpi');

const ledPin = 7; 1
const piscaTotal = 10;
var piscaCont = 0;
onde estado = 1; 2
wpi.setup('wpi');
wpi.pinMode(ledPin, wpi.OUTPUT); 3
UAU! e-book
www.wowebook.org
var piscando = setInterval(() => {
wpi.digitalWrite(ledPin, status); 4
if (!estado) {
piscarContagem++;
if (contagem de piscadas >= total de piscadas) {
console.log('Todo piscando!'); clearInterval(blinker);
}
}
estado = +!estado; 5
}, 1000);
1 Mesmo pino físico de antes, mas usando números WiringPi, que na verdade são números
JavaScript (não Strings)
2 O status da nota é um número (0 ou 1), não booleano como antes.
3 pinMode() e a constante OUTPUT ecoam a API de linguagem do Arduino.
4 aqui é 1 (ALTO) ou 0 (BAIXO).
5 Inverte o equivalente booleano de status e o torna um número novamente (+ operador)
Para executar o script, use este comando:
$ sudo nó index.js`
Johnny-Five com o plugin raspi-io I/O
Para completar a extravagância piscante, voltaremos ao nosso velho amigo JohnnyFive. Assim como
o plugin tesselio JohnnyFive I/O torna possível usar JohnnyFive com o Tessel, o pacote npm raspiio
permite usar J5 no Raspberry Pi.
Vá em frente e crie mais um diretório no diretório ~/projects chamado blinkj5.
Dentro do diretório blinkj5, execute este comando para instalar os pacotes JohnnyFive e
raspiio:
$ npm install johnnyfive raspiio
Para seu próximo truque, você pegará um dos primeiros scripts de LED que já experimentou -
desde o capítulo 2 - e o adaptará para funcionar no Pi, conforme mostrado na listagem a seguir.
As únicas alterações necessárias são incluir e usar o plug-in raspiio para fornecer E/S e alterar o
número do pino do LED. É isso!
UAU! Listagem de
e-books 11.4. Piscando o LED com Johnny-Five www.wowebook.org
Listagem 11.4. Piscando o LED com Johnny-Five
const five = require('johnnyfive'); const Raspi = require('raspiio');

1
const board = new five.Board({io: new Raspi() 2

});

five.Led(7); 3
var piscaCont = 0;
const blinkMax = 10;
led.blink(500, () => {
piscarContagem++;
console.log(`Mudei de estado ${blinkCount} vezes`);

if (blinkCount >= blinkMax) {
console.log('Vou parar de piscar agora');
led.stop(); }
});
});
1 Requer o módulo de plug-in raspiio I/O
2 Usa um objeto Raspi para io
3 Usa o esquema de numeração WiringPi
O Raspiio oferece suporte a vários esquemas de numeração de pinos Pi. Os pinos passados como
valores numéricos JavaScript são automaticamente assumidos como números WiringPi. Mas você
também pode usar números de pinos físicos e nomes funcionais (como GPIO4). Veja a
documentação do plugin para mais detalhes (https://github.com/nebrius/raspiio).
11.2.5. Documentação da API
Dado que existem inúmeras maneiras de controlar o hardware com um Pi, não há uma única
fonte de documentação da API. Em vez disso, usaremos JohnnyFive, Node.js e o plug-in raspiio I/
O, então você vai querer manter os sites de documentação para essas APIs ao seu alcance enquanto
exploramos.
11.3. ESCREVENDO APLICATIVOS DO JOHNNY-FIVE PARA DIFERENTES

PLATAFORMAS
Conforme visto na Listagem 11.4, adaptar os aplicativos JohnnyFive para funcionar em diferentes
plataformas (como migrar do Arduino Uno para o Raspberry Pi) pode ser bastante fácil.
Freqüentemente, é uma questão de selecionar o plug-in de E/S correto e atualizar alguns números de pinos no c
UAU! e-book
www.wowebook.org
Nos próximos experimentos desta seção, você adaptará o aplicativo meteorológico de atualização ao
vivo BMP180 criado originalmente para o Tessel no capítulo 8 (figura 11.15). De acordo com sua
exploração de SBCs e do Raspberry Pi 3 especificamente, você implementará a estação
meteorológica primeiro no Pi 3 e, posteriormente, fará com que funcione em
um Arduino Uno.
Figura 11.15. O mini aplicativo meteorológico fornece dados de temperatura e pressão atualizados
ao vivo que podem ser visualizados em um navegador em qualquer computador na mesma rede.
Você pode encontrar o código-fonte da versão Tessel do aplicativo da estação meteorológica no

repositório de código-fonte do livro no GitHub.
11.3.1. Adaptação da mini estação meteorológica para o Pi 3
1 SparkFun Pi Wedge, Adafruit TCobbler ou similar; ou jumper masculino

fios
1 placa multissensor BMP180
1 tábua de pão
Fios de jumper
Como atualização, o aplicativo de previsão do tempo tem dois componentes principais:
Código do servidor—Isto inclui o código JohnnyFive para lidar com E/S e sensor de leitura
UAU! e-book
www.wowebook.org
data, um servidor web estático (usando express) e um servidor socket.IO que emite eventos que
representam atualizações de dados meteorológicos (os clientes socket.IO podem escutar esses eventos).
Código do cliente—Isso está na forma de uma única página HTML—index.html—que será atendida
pelo servidor da Web estático expresso. Depois de carregado em um navegador, o index.html se
conecta ao servidor socket.IO como um cliente, para que possa receber e exibir dados
meteorológicos sem que o usuário precise atualizar a página.
Esse padrão – manipulação de E/S e servidor da Web combinado com um front-end baseado em navegador
– pode ser reutilizado para criar muitos tipos diferentes de aplicativos de IoT. É um padrão útil para se ter
no bolso de trás.
Primeiro, você precisa construir o circuito conectando o breakout BMP180 ao seu Pi. Assim como o LED
piscando, os detalhes dependerão da sua configuração. Diagramas de fiação são fornecidos para
conexões diretas ao Pi (figura 11.16), SparkFun Pi Wedge (figura 11.17) e TCobbler da Adafruit
(figura 11.18).
Figura 11.16. Diagrama de fiação para o BMP180, mostrando conexões diretas com o Pi
Figura 11.17. Diagrama de fiação para o BMP180 e o SparkFun Pi Wedge
UAU! e-book
www.wowebook.org
Figura 11.18. Diagrama de fiação para o BMP180 e o Adafruit T-Cobbler
UAU! e-book
www.wowebook.org
2
Raspiio e IC
UAU! e-book
2 2
www.wowebook.org
Machine Translated by Google 2 2
O BMP180 é I C. Raspiio suporta IC muito bem, mas para habilitá-lo você precisará reiniciar
(se ainda não o fez) após instalar o raspiio. (Dica: sudo reboot é um recurso útil
comando.)
Testando o BMP180
Antes de adaptar o software da estação meteorológica do Tessel, você criará um script básico
para registrar os dados de temperatura e pressão do BMP180 no console. Isso confirmará que
2
a combinação de Raspbian, raspiio, IC e BMP180 está trabalhando em harmonia:
1. Estabeleça uma área de trabalho. Crie um diretório chamado “clima” dentro do seu Pi's
diretório de projetos:
$ mkdir tempo
2. Dentro do diretório weather, execute este comando:
$ npm install johnnyfive raspiio
3. Crie um arquivo index.js e preencha-o com o código mostrado na listagem a seguir.
Listagem 11.5. Testando o Pi, Johnny-Five, raspiio e BMP180
const five = require('johnnyfive'); const Raspi = require('raspiio');

eu: novo Raspi() 1
});
const bmp180 = novo cinco.Multi({
});
bmp180.on('alterar', () => {
var temperatura = bmp180.thermometer.fahrenheit.toFixed(2);
var pressão = bmp180.barometer.pressure.toFixed(2); console.log(`${temperatura}°F | ${pressão}kPa`);
});
});
1 Mais uma vez, usa o plugin raspiio para I/O
Na listagem anterior, observe que você não precisa designar quais pinos o BMP180 é WOW! e-
book
www.wowebook.org
conectado na instanciação do componente Multi sensor (atribuído à variável bmp180). O
2
Raspiio “sabe” onde estão os pinos compatíveis com IC no Raspberry Pi e cuida da configuração
da interface para você! Isso é útil.
Experimente. Ainda dentro do diretório weather, execute este comando:
$ sudo nó index.js
Você deve ver o registro de dados de temperatura e pressão no console, algo como o seguinte.
Listagem 11.6. Exemplo de saída para o script BMP180 de teste
>> 77,54°F | 98,05kPa

77,54 °F | 98,05kPa 77,54°F
| 98,05kPa 77,54°F |
98,05kPa 77,54°F | 98,06kPa
77,54°F | 98,05kPa 77,72°F
| 98,06kPa 77,72°F |
98,06kPa
77,54 °F | 98,05kPa
Fazendo alterações específicas do Pi
Agora você fará algumas alterações específicas do Pi. Crie uma nova área de trabalho, um
diretório chamado “piweather”. Copie os arquivos de origem do aplicativo meteorológico original
do repositório GitHub do livro para esse diretório, mas omita .tesselinclude. Você deve terminar
com uma estrutura semelhante à seguinte.
Listagem 11.7. Diretório do projeto e estrutura de arquivos
piweather/
aplicativo
index.html
estilo.css
index.js
pacote.json
Não copie o diretório node_modules
Se você inadvertidamente acabar com um diretório node_modules dentro do piweather (copiado

de experimentos anteriores com o Tessel), elimine-o antes de prosseguir:
UAU! e-book
www.wowebook.org
$ rm rf node_modules
Existem dois locais no código que precisam de alterações:
package.json — Você precisará atualizar as dependências.
index.js — Você precisará usar o raspiio para E/S.
Atualizando as dependências do package.json
Comece editando package.json. Ele deve conter, em parte, um objeto de dependências, que deve
ser semelhante ao mostrado na listagem a seguir, embora os números de sua versão possam ser
diferentes. Remova a dependência tesselio, pois você não precisará dela para a versão Raspberry Pi.
Listagem 11.8. Dependências Package.json do projeto Tessel
"dependências": {
"expresso": "^4.14.1",
"johnnyfive": "^0.10.4",
"socket.io": "^1.7.3", 1
"tesselio": "^0.9.0" 2
}
1 Não se esqueça de excluir a vírgula final se a entrada tesselio for a última.
2 Exclua esta linha.
Agora instale as dependências restantes:
instalação de $npm
Em seguida, adicione uma nova dependência—raspiio—usando o sinalizador save para gravar a alteração
nas dependências em package.json:
$ npm instalar salvar raspiio
Atualizando index.js
As alterações necessárias em index.js são simples.
UAU! e-book
www.wowebook.org
1. Substitua esta linha,
com este:
const Raspi = require('raspiio');
2. Atualize a instanciação da placa para usar raspiio ao invés de tesselio, alterando

está linha,
para ficar assim:
const board = new five.Board({ io: new Raspi() });
O conteúdo index.js resultante deve ser semelhante ao seguinte.
Listagem 11.9. Uma versão compatível com Pi do index.js

const Raspi = require('raspiio'); const express =
require('express'); const SocketIO = require('socket.io');
const caminho = require('caminho');

const http = require('http');
const os = require('os');

servidor const = new http.Server(aplicativo);
const socket = new SocketIO(servidor);
app.use(express.static(path.join(__dirname, '/app')));
const board = new five.Board({ io: new Raspi() });
controlador: 'BMP180',
frequência: 5000 });
socket.on('conexão', cliente => {

cliente.emit('clima', {
temperatura: weatherSensor.thermometer.F,
pressão: (weatherSensor.barometer.pressure * 10)
});
UAU! e-book
www.wowebook.org
});
});
server.listen(3000, () => {
console.log(`http://${os.networkInterfaces().wlan0[0].address}:3000`);
});
});
Nenhuma alteração é necessária em app/index.html porque é um código do lado do cliente — ele é executado
no navegador do usuário e não é afetado por alterações na plataforma.
Execute o aplicativo usando este comando no diretório weather:
$ sudo nó index.js
Depois que o código do servidor for inicializado, ele desconectará a URL onde você pode acessar a
exibição do tempo de outros computadores na mesma rede que o Pi (conforme mostrado na listagem a
seguir). Aponte o navegador do seu computador para o URL registrado para ver o tempo
estação em ação.
Listagem 11.10. Exemplo de saída ao iniciar o aplicativo da estação meteorológica
pi@raspberrypi:~/projects/weather $ sudo node index.js

1499532864338 Disponível RaspberryPiIO 1499532864960
Conectado RaspberryPiIO 1499532864984 Repl
inicializado >> http://192.168.1.16:3000
11.3.2. Adaptando a mini estação meteorológica para o Arduino Uno
Fazer o aplicativo de clima funcionar em outras plataformas com suporte do JohnnyFive é igualmente
simples. É um trabalho rápido fazer o aplicativo meteorológico funcionar em um Arduino Uno conectado ao
seu próprio computador, em vez de no Pi.
1 Arduino Uno
1 tábua de pão
UAU! e-book
www.wowebook.org
Fios de jumper
1. Copie a versão Pi do aplicativo - o diretório meteorológico e seu conteúdo,

menos o diretório node_modules, para o seu computador.
2. Edite package.json. Remova a dependência do raspiio; o suporte de E/S para plataformas
Arduino está embutido no JohnnyFive e não requer um plug-in de E/S.
3. Instale as dependências:
4. Edite o arquivo index.js:
1. Remova a instrução exigida para raspiio.
2. Altere a instanciação da placa. Remova a referência a Raspi de forma que

tem a seguinte redação:
5. Conecte o BMP180 ao Arduino Uno conforme a figura 11.19.
Figura 11.19. Diagrama de fiação para o BMP180 e o Arduino Uno
Conecte o Uno ao seu computador e execute o aplicativo. Você não precisará sudo aqui: WOW! e-
book
www.wowebook.org
$ node index.js
11.4. USANDO O RASPBERRY PI COMO HOST
Lembre-se, o Raspberry Pi 3 é um computador “real”, então não há motivo para você não usá-lo como
host em uma configuração hostclient, com seu próprio Arduino conectado, assim como você faz com
seu próprio computador.
1 Arduino Uno
1 tábua de pão
Fios de jumper
1. Copie a versão Arduino Uno do código do aplicativo meteorológico - novamente, sem o diretório
node_modules - para o Pi.
2. Instale as dependências:
3. Conecte o Arduino Uno—conectado ao BMP180 como na figura 11.23—em um dos

As quatro portas USB do Pi.
4. Execute o aplicativo:
$ node index.js
(Você não precisa usar o sudo aqui, pois não está usando o GPIO do Pi.)
Estação meteorológica com Raspberry Pi 3 e Tessel 2
UAU! e-book
www.wowebook.org
Não há nenhuma razão técnica para que você não possa implantar a versão Tessel 2 do aplicativo
de clima no Tessel a partir do Pi (em vez de seu próprio computador). Primeiro, no entanto, você
precisará instalar o t2cli no Pi e provisionar o Tessel a partir dele, conforme detalhado na
página “Instalar o Tessel 2” do Tessel (http://tessel.github.io/t2start/).
No final das contas, a plataforma Raspberry Pi é um vasto mundo de opções e escolhas. Um

verdadeiro computador por si só, o Pi 3 tem o poder de atuar como um host em uma configuração
de hostclient, o que é especialmente bom se você não quiser se preocupar com o GPIO um
tanto complicado do Pi. Mas se você quiser mergulhar no GPIO integrado do Pi, certamente
há uma infinidade de maneiras de fazer o trabalho.
11.5. ESTUDO DE CASO: BEAGLEBONE BLACK
O Pi não é o único jogo na cidade - há uma série de outras plataformas SBC. Para ter uma noção
das semelhanças e diferenças entre eles, vamos fazer um breve tour pelo BeagleBone Black (figura
11.20), um dos SBCs da família BeagleBoard.
Figura 11.20. O BeagleBone Black SBC
11.5.1. Conhecendo o BeagleBone Black

A comparação de quaisquer dois SBCs geralmente é um caso de maçãs e laranjas; plataformas
diferentes são direcionadas a aplicativos diferentes. O Pi 3 vence o concurso de CPU e periféricos
UAU! e-book
www.wowebook.org
(CPU multicore, maior velocidade de clock, mais portas USB e assim por diante), mas o BeagleBone
Black supera o Pi em termos de recursos GPIO e é mais eficiente em termos de energia em modo inativo.
Rev C do BeagleBone Black também aumenta a RAM: tem 4 GB.
Outra distinção importante é que, embora as várias distribuições Linux que você pode executar no
Raspberry Pi sejam de código aberto, seu hardware não é. Os Pis são fabricados exclusivamente
pela Raspberry Pi Foundation e contêm alguns componentes de código fechado. BeagleBoards,
em contraste, são hardware de código aberto.
Um rev C BeagleBone Black custará cerca de US $ 55.
Recursos principais
Como mencionado momentos atrás, a CPU do BeagleBone Black é singlecore e roda a 1,0 GHz, que é
mais lenta que os 1,2 GHz do Pi 3. Ambos são chips ARM v8, portanto, não são muito diferentes
no geral. Se você obtiver a rev C, obterá 4 GB de RAM (as versões mais antigas têm 512 MB). Como o
Pi, o BeagleBone Black possui um slot microSD, mas também possui 4 GB de armazenamento flash eMMC
integrado. Ele tem uma única porta USB, uma interface miniHDMI e uma interface Ethernet (figura
11.21).
Figura 11.21. A página de informações do BeagleBone Black no site da BeagleBoard
UAU! Recursos
e pinagens do eBook GPIO www.wowebook.org
Recursos e pinagens do GPIO
O BeagleBone Black possui uma miscelânea de GPIO. São 92 (noventa e dois!) pinos.
Há suporte de hardware para 4 UARTs, 65 pinos de E/S digitais com capacidade de interrupção, 8 pinos
PWM e 7 entradas analógicas. Enquanto o Pi é um computador que também faz GPIO, o BeagleBone
é mais como um campeão de GPIO que também faz computação.
As opções de conectividade BeagleBone Black e não Ethernet
O BeagleBone Black básico não possui WiFi integrado, mas você pode adicionar suporte usando um adaptador
de terceiros. Você pode encontrar uma lista de adaptadores WiFi suportados na página BeagleBone Black do
Embedded Linux Wiki (http://mng.bz/Uj9d).
Outra abordagem de rede permite que você envie ssh para seu BeagleBone Black por meio de uma conexão
USB. Isso pode exigir que você instale alguns drivers ou ajuste alguma outra configuração; consulte
a página “Getting Started” no site da BeagleBoard para obter mais detalhes (http://beagleboard.org/
gettingstarted).
Os pinos do BeagleBone Black são dispostos em dois conjuntos de cabeçalhos de expansão com 46 pinos em
cada. Com a conexão de alimentação CC da placa na parte superior, o cabeçalho de expansão P9 está à
esquerda, P8 à direita (e quanto ao que aconteceu com P1–P7: não faço ideia). Tal como acontece com o
Pi, muitos dos pinos do BeagleBone Black podem desempenhar várias funções.
Você usará outro plug-in JohnnyFive I/O para controlar o GPIO do BeagleBone Black. A Figura 11.22 mostra
os pinos suportados pelo plug-in beagleboneio JohnnyFive I/O e seus recursos. Para fazer referência a um
pino com beagleboneio, você prefixa o número físico do pino com o número do cabeçalho, como P9_11 para o
pino 11 em P9. Você usará apenas a interface IC, portanto não precisará fornecer nenhum número de pino
2
— o beagleboneio saberá automaticamente usar os pinos P9_19 (SCL) e P9_20 (SDA).
Voltagem BeagleBone Black
Os pinos de entrada analógica no BeagleBone Black aceitam apenas tensões de entrada de até 1,8 V.
É importante observar que os recursos dos pinos mostrados na figura 11.22 não são indicativos de todos
UAU! e-book
www.wowebook.org
do suporte de hardware que o BeagleBone Black fornece nesses pinos, mas o
suporte que o plug-in beagleboneio fornece (para scripts JohnnyFive).
Figura 11.22. Recursos de pino BeagleBone Black disponíveis através do plug-in

beagleboneio Johnny-Five I/O
Por exemplo, não há suporte serial UART/TTL mostrado aqui, mas o BeagleBone Black tem
vários UARTs. Às vezes, a busca por um diagrama de pinagem relevante pode ser complicada
pela realidade de que o que os pinos realmente fazem depende de como você os está usando.
BBB GPIO além de Johnny-Five
Você planeja usar seu BeagleBone Black em outros contextos, não JohnnyFive?
Você vai querer procurar um diagrama de pinagem mais completo. Existem muitos outros
diagramas de pinagem do BeagleBone Black disponíveis na web. O BeagleBone Black tem uma
colheita abundante de 96 pinos, cada um capaz de desempenhar mais de cinco ou seis papéis
diferentes e referenciados por diferentes convenções de nomenclatura. Isso pode
levar a alguns diagramas bastante esmagadores. Não se apresse e seja paciente: não é você - é
realmente muita informação para assimilar visualmente.
Configuração e fluxo de trabalho
UAU! e-book
www.wowebook.org
Uma maneira de configurar o BeagleBone Black espelha de perto a configuração do Raspberry Pi 3 anterior
no capítulo, menos a configuração de WiFi (não há WiFi para configurar).
A placa vem com o Ångström, uma distribuição Linux embarcada, mas este processo de configuração
o substitui pelo Debian. Para obter mais detalhes sobre como criar um microSD inicializável (as etapas são
abreviadas aqui), consulte a configuração anterior do Raspberry Pi 3 na seção 11.4:
1. Baixe a imagem Debian mais recente para BeagleBone em http://beagleboard.org/latest
imagens.
2. Grave a imagem em um cartão SD usando o aplicativo Etcher.
3. Em vez de inicializar repetidamente a partir do cartão SD, o que você deseja fazer é atualizar a imagem do
sistema operacional para o armazenamento flash eMMC integrado. Isso requer uma etapa adicional,
um pouco meticulosa, aqui: um arquivo de configuração precisa de uma edição simples. Depois de
atualizar o cartão SD com a imagem do Debian, pode não ser legível pelo seu computador (não foi com o
meu). Em vez disso, você pode inicializar o BeagleBone Black diretamente do cartão SD, uma vez, para
poder editar o arquivo de configuração:
1. Insira o cartão microSD com a imagem Debian nele no BeagleBone Black.
2. Conecte o BeagleBone Black diretamente ao seu roteador com um cabo Ethernet e, em seguida,
conecte o BeagleBone Black à energia. Levará um ou dois minutos para o BeagleBone Black
inicializar e obter um endereço IP em sua rede.
3. Acione seu utilitário LAN ou IPscanning para descobrir o IP do BeagleBone Black

endereço.
4. Do seu computador, em um terminal, ssh no BBB com o usuário debian (ssh é ativado por padrão
na imagem Debian que você está usando aqui):
$ ssh debian@<BBB IP>
Há uma senha padrão para esse usuário, que será exibida para você no primeiro login.
5. Edite o arquivo de configuração em questão:
$ sudo you /boot/uEnv.txt
(ou use seu editor preferido se não gostar do vi). Na parte inferior do arquivo, localize a seguinte linha
e descomente-a (remova o #):
#cmdline=init=/opt/scripts/tools/eMMC/initeMMCflasherv3.sh
Salve e saia do arquivo. Descomentar essa linha permitirá que o BeagleBone Black execute um script
na inicialização que copiará (flash) o conteúdo do cartão SD para o

UAU! e-book
www.wowebook.org
eMMC embutido.
4. Agora desligue o BeagleBone Black. Com o cartão SD ainda inserido, mantenha pressionado o
botão BOOT/USER (figura 11.23) e reconecte a energia. Continue segurando o botão por mais
alguns segundos até que todos os LEDs integrados fiquem acesos por um momento. Então você
pode soltar o botão.
Figura 11.23. O botão BOOT/USER no BeagleBone Black
5. O processo de eMMCflashing demora um pouco - o site da BeagleBoard diz de 30 a 45 minutos.

Você pode saber quando está pronto porque todos os LEDs azuis do BeagleBone Black serão
desligados (francamente, uma pausa bem-vinda de todas as piscadas padrão!).
6. Desligue o BeagleBone Black e ejete o cartão SD. Ligue-o novamente.
7. Do seu computador, ssh no BeagleBone Black como o usuário debian.
8. Execute este comando:
$ lsb_release a
Você deve ver uma saída semelhante à seguinte:
Nenhum módulo LSB está disponível.
ID do Distribuidor: Debian
Descrição: Debian GNU/Linux 8.7 (jessie)
Lançamento: 8.7
Codinome: jessie
UAU! e-book
www.wowebook.org
9. Para ver qual versão do Node.js você possui, execute este comando:
$ versão do nó
Eu tenho v4.8.0.
10. Você pode atualizar a versão do Node.js se quiser, mas a v4.8.x é boa o suficiente para oferecer
suporte ao restante dos exemplos de código nesta seção.
Exemplos e tutoriais
Em seguida, você levará o BeagleBone Black para um giro Hello World, estilo LED, usando Johnny Five e o
plug-in beagleboneio. Há um LED integrado que você pode acessar, portanto, este é um esforço rápido (sem
necessidade de circuitos).
Conecte-se ao seu BeagleBone Black via SSH e crie uma área de trabalho (um diretório de projetos ou
similar). Dentro deste diretório, instale o JohnnyFive e o plugin beagleboneio I/O:
$npm install johnnyfive beagleboneio
Crie um arquivo index.js e adicione o conteúdo da listagem a seguir.
Listagem 11.11. LED piscando no BeagleBone Black

var BeagleBone = require('beagleboneio');
var board = new five.Board({

io: new BeagleBone() 1 });
board.on('pronto', function () {
var led = new five.Led(); 2
led.blink(500);
});
1 Usando o plug-in beagleboneio
2 Nenhum número de pino é fornecido aqui: o beagleboneio usará automaticamente o LED integrado.
Agora execute! Assim como no Pi, você precisará do sudo aqui:
$ sudo nó index.js
UAU! e-book
www.wowebook.org
Agora você deve ver um dos LEDs azuis do BeagleBone Black piscando a cada
500 ms.
Documentação da API
Mais uma vez, você está seguindo a rota JohnnyFive aqui. A documentação do plug-in
beagleboneio contém informações vitais sobre suporte a pinos e detalhes de uso do plug-in (https://
github.com/julianduque/beagleboneio).
11.5.2. Adaptação da estação meteorológica para o BeagleBone
1 BeagleBone Black configurado em rede e fonte de alimentação
1 tábua de pão
Fios de jumper
Até agora, o padrão geral de adaptação para o aplicativo de clima está se tornando familiar:
1. Conecte o BMP180 ao BeagleBone Black, conforme a figura 11.24.
Figura 11.24. Diagrama de fiação para o BMP180 e o BeagleBone Black
UAU! e-book
www.wowebook.org
2. Crie um diretório meteorológico no BeagleBone Black e copie o código-fonte da estação

meteorológica original (variante Tessel) para ele, sem node_modules.
3. Edite package.json para remover a dependência tesselio.
4. Execute $ npm install para instalar as dependências.
5. Execute $npm install save beagleboneio para instalar o beagleboneio
plugin e salve-o em package.json.
6. Edite index.js:
1. Remova a dependência tesselio e substitua-a por beagleboneio:
const BeagleBone = require('beagleboneio');
2. Altere a instanciação da placa para usar o plugin beagleboneio:

io: new BeagleBone() });
O BeagleBone Black vai exigir apenas mais alguns truques rápidos de você.
Acontece que o BeagleBone Black, por padrão, já tem um servidor rodando na porta 3000. E
não tem WiFi, então não tem interface de rede wlan0. Para contabilizar isso, edite o código
para server.listen() da seguinte maneira.
Listagem 11.12. server.listen() atualizado
server.listen(4000, () => { 1
console.log(`http://${os.networkInterfaces().eth0[0].address}:4000`); 2 UAU! e-book www.wowebook.org
});
1 Altere o número da porta para outra coisa; 4000 funciona bem.
2 Use eth0 em vez de wlan0 aqui e também atualize o número da porta.
Tudo feito! Faça assim:
$ sudo nó index.js
Agora abra a URL registrada em um navegador no seu computador.
Manter os detalhes de I/O sequestrados para plug-ins de I/O torna os aplicativos JohnnyFive relativamente
portáveis entre plataformas. Detalhes aparecem, como a indisponibilidade da porta 3000 no BeagleBone Black,
mas no geral não é tão ruim mover coisas entre plataformas. Se desejar, você também pode executar a
variante compatível com Arduino do aplicativo de clima, usando o BeagleBone Black como host. Os SBCs oferecem
toda uma constelação de opções.
RESUMO
Os computadores de placa única (SBCs) adicionam vários recursos e itens de uso geral, mas usam mais
energia e são mais complicados de configurar e administrar do que plataformas mais restritas.
O Raspberry Pi 3 é a plataforma Raspberry Pi de terceira geração e pode ser usado para computação de uso
geral, bem como para aplicativos incorporados. Raspbian é um sistema operacional Linux baseado em Debian
otimizado especificamente para a família Pi.
Etapas comuns de configuração para desenvolvimento de SBCs e Node.js incluem atualização (ou
instalação ou atualização) de um sistema operacional, configuração de rede, atualização de versões do Node.js
e estabelecimento de um fluxo de trabalho do sistema de arquivos.
Sysfs é um pseudosistema de arquivos Linux que permite a interação com componentes e hardware
conectados por meio de diretórios e arquivos virtuais.
Existem inúmeras maneiras de hackear hardware em um Raspberry Pi, com estruturas e bibliotecas para
praticamente qualquer linguagem de programação que você possa imaginar.
WiringPi é uma abstração popular para Raspberry Pi GPIO. Está escrito em C, mas existem bibliotecas para
ele em várias outras linguagens. Outros frameworks não baseados em WiringPi (incluindo o plugin
raspiio) suportam pinnumbering de WiringPi
UAU! e-book
www.wowebook.org
porque sua clareza de emulação do Arduino pode ser menos confusa do que outros esquemas de
numeração.
Os plug-ins de E/S raspiio e beagleboneio oferecem suporte à compatibilidade JohnnyFive
nas plataformas Raspberry Pi e BeagleBone Black, respectivamente.
Adaptar os aplicativos JohnnyFive para funcionar em plataforma cruzada geralmente envolve a
troca de plug-ins de E/S e a atualização dos números dos pinos. Muitas vezes, essas são as
únicas mudanças necessárias.
O Raspberry Pi também pode ser usado em uma configuração de hostclient, atuando como o host.
Ele pode controlar um Arduino Uno (cliente) conectado, por exemplo.
O BeagleBone Black é um SBC de código aberto com recursos no mesmo estádio, em geral, como
um Raspberry Pi 3, mas é mais direcionado para aplicativos incorporados e GPIO.
UAU! e-book
www.wowebook.org

História

Tópicos
Usando um serviço baseado em nuvem (resin.io) para implantar e gerenciar um aplicativo em uma frota de
dispositivos Tutoriais
Tecnologias de plataforma web de ponta para interagir com hardware, incluindo

Web Bluetooth e a API de Sensor Genérico
Destaques
Construindo a Web física com o protocolo Eddystone aberto e Bluetooth Low
Sinalizadores de energia (BLE)
Configurações Controle de hardware de uma página da web usando Web Bluetooth e Puck.js
Apoiar Lendo dados e escrevendo comandos para um dispositivo BLE
Sair
1 BeagleBone Black e fonte de alimentação de 5 V
1 Espruino Puck.js
Fios de jumper
UAU! e-book
www.wowebook.org
Este capítulo abre algumas grandes perspectivas. No entanto, essa grandeza de escala esbarra em um
espaço limitado. Os tópicos apenas abordados aqui são especialidades inteiras; há o suficiente para
aprender sobre cada um para encher livros, prateleiras ou até mesmo bibliotecas inteiras:
segurança; o processo de padrões da web; as complexidades da arquitetura Bluetooth e Bluetooth LE
(BLE); provisionamento e gerenciamento de frotas de Dispositivos IoT em escala.
Como tal, este capítulo não marca o fim de uma jornada de aprendizado, mas sim um trampolim
para as aventuras subsequentes. Sua primeira metade abre as cortinas do mundo das ofertas de
serviços IoT baseados em nuvem. A segunda metade usa o chapéu de um futurista, avançando
nos limites do que podemos fazer na web e em um navegador hoje e no que pode estar por vir amanhã.
O código não está pronto para produção
O código neste capítulo não está pronto para um ambiente de produção. Segurança,
desempenho, degradação elegante e diligência de acessibilidade são sacrificados aqui em busca de
clareza e brevidade.
UAU! e-book
12.1. IOT E A NUVEM www.wowebook.org
12.1. IOT E A NUVEM
Este livro se preocupa principalmente em ilustrar os princípios básicos da eletrônica e disputar

hardware com JavaScript. Mas a nuvem é uma parte indispensável da IoT – você não pode ter
a internet das coisas sem a internet. Os serviços comerciais de nuvem IoT fornecem aos
inventores e empreendedores maneiras de dar vida às suas visões IoT, oferecendo
serviços de suporte como armazenamento de dados, ferramentas de implantação, APIs RESTful,
análise, segurança, teste, benchmarking, depuração, monitoramento, estruturas de
desenvolvimento — uau! Acontece que a IoT é complexa. E, cara, tem muito jargão envolvido!
A noção já vaga de serviços de nuvem IoT é ainda mais confusa pelo fato de que alguns
produtos de empresas de IoT não se limitam a software. De fato, algumas empresas combinam
plataformas físicas de hardware com seus serviços em nuvem, criando um pacote de
cima para baixo (figura 12.1).
Figura 12.1. Tanto o Particle (https://www.particle.io) quanto os serviços ARTIK da

Samsung (https://www.artik.io) são chamados de ofertas “end-to-end” para IoT.
A Particle, por exemplo, fabrica a placa Electron, que possui conectividade 2G/3G integrada.
Você implanta seu código e lê dados de um determinado Electron usando redes celulares
— dependendo dos serviços de nuvem proprietários da Particle para essa implantação
e I/O, naturalmente. Nesse caso, a empresa - Particle - está fornecendo o hardware (o
dispositivo Electron), o software (você programa suas placas de partículas usando sua API) e
a infraestrutura de nuvem (você implanta em sua frota de dispositivos Particle usando suas
ferramentas centralizadas baseadas na web) .
UAU! e-book
www.wowebook.org
Outro exemplo dessa chamada oferta de produto end-to-end é a plataforma ARTIK da Samsung. Você pode usar
um dos “módulos” de hardware ARTIK autônomos - suas placas das séries 5, 7 e 10 são todas SBCs compatíveis que
acompanham o Fedora Linux - mas o hardware em si é apenas uma parte de seu ecossistema integrado.
Eles esperam que você opte por usar seus serviços de nuvem também.
Este é um oceano profundo para mergulhar. Pode ser opressor se você não tiver pontos de referência
familiares para traçar sua viagem, e há uma quantidade dolorosa de jargões e jargões de negócios. Em uma tentativa
de moderar esse novo ataque, não iniciaremos um projeto do zero, mas adaptaremos nossa velha amiga, a mini
estação meteorológica com a interface do navegador, para funcionar no BeagleBone Black.
Usaremos o mesmo código de aplicativo da estação meteorológica, com alguns pequenos ajustes, mas, em vez de
trabalhar diretamente no dispositivo para gerenciar o sistema operacional e executar o código do aplicativo, usaremos
deixe o resin.io fazer esse trabalho para nós.
12.2. IMPLANTAÇÃO CONTÊINERIZADA COM RESIN.IO
1 BeagleBone Black e fonte de alimentação
1 cabo Ethernet
1 cartão microSD e adaptador
1 tábua de pão
Fios de jumper
Resin.io (https://resin.io/) é um serviço que oferece implantação em contêiner e gerenciamento de dispositivos
Linux IoT provisionados e conectados à Internet. Isso é um bocado - há um pouco daquele jargão sobre o qual eu avisei
- então vamos descompactá-lo abordando-o do ponto de vista dos problemas que serviços como o resin.io estão
realmente tentando resolver.
Lembre-se do capítulo 11 que os SBCs (como o BeagleBone Black) são tipicamente capazes de
UAU! e-book
www.wowebook.org
executando vários tipos de Linux, mas que a compensação por essa flexibilidade é que a instalação
e a administração do Linux podem adicionar alguma sobrecarga (e dor de cabeça) a um fluxo de trabalho
baseado em SBC. Transferir arquivos de código para um dispositivo de seu ambiente de
desenvolvimento preferido (como seu laptop) pode ser uma tarefa árdua. Gerenciar configurações e
configurações do ambiente pode ser uma dor de cabeça. Você pode ter vontade de trabalhar de
forma iterativa, usando metodologias e ferramentas de desenvolvimento de software familiares
(como Git para controle de versão) e colaborando com outros desenvolvedores. Conseguir tudo isso
aos poucos pode levar tempo e energia, ou pode até atrapalhar você completamente.
Agora imagine que seu aplicativo de IoT precisa ser executado não apenas em um BeagleBone (ou Pi ou
outro SBC), mas em uma frota inteira deles, possivelmente espalhados geograficamente por estados,
províncias e países. Acompanhar os dispositivos, manter as coisas sincronizadas, enviar a versão
correta do código para cada dispositivo, monitorar dispositivos quanto a falhas, enviar SO ou
atualizações de segurança — fazer tudo isso manualmente não vai funcionar bem.
Depois, há todos os requisitos para produtos de software e hardware usados por pessoas reais: análise
(quanto uso um determinado dispositivo está recebendo?), segurança (vamos garantir que estamos
carregando a frequência cardíaca desse usuário por meio de uma conexão segura !), e
assim por diante.
Há muita coisa acontecendo aqui. Para realizar muito disso, o resin.io (e alguns outros serviços
semelhantes) emprega várias estratégias-chave:
Conteinerização — A ideia-chave aqui é que você deseja que o mesmo aplicativo seja executado
da mesma maneira em cada um de seus dispositivos. O Resin.io usa contêineres do Docker para
empacotar aplicativos e suas dependências de maneira limpa e confiável. O contêiner do seu
aplicativo é implantado em cada um dos seus dispositivos provisionados.
Provisionamento — Um determinado dispositivo precisa ser capaz de obter o resin.io, identificar-se
e receber atualizações de aplicativos. Para fazer isso, baixe uma imagem de disco personalizada de
resin.io e inicialize cada dispositivo a partir dela. Assim que um dispositivo for provisionado
com sucesso, ele aparecerá no painel da web para o aplicativo resin.io associado, como você
verá em breve.
Integração de controle de versão— Enviar código para um controle remoto específico de um
repositório Git especificado aciona automaticamente a reimplantação do aplicativo para todos os
dispositivos provisionados conectados. Parte da configuração de um projeto resin.io é definir
qual repositório Git usar como fonte do aplicativo.
Recipientes, recipientes, recipientes!
Você não pode balançar um gato na internet hoje em dia sem encontrar alguém que está
UAU! e-book
www.wowebook.org
dizendo algo (geralmente vago, mas quase sempre elogioso) sobre contêineres. Você lerá que os contêineres são a melhor
solução para implantação de aplicativos, para segurança, para desempenho, para garantir a paz mundial e assim por
diante, mas o que é mais difícil de rastrear é uma explicação do que diabos é um contêiner e o que é, em termos reais,
sim.
Um contêiner serve para encapsular e isolar um aplicativo e os bits e bobs necessários para funcionar corretamente
(dependências, configurações e afins). Um único servidor ou dispositivo de computação pode executar vários contêineres
separados ao mesmo tempo sem que eles interfiram entre si. Da mesma forma, o mesmo contêiner pode ser
implantado em vários computadores diferentes e, como o contêiner contém todas as coisas necessárias para definir o
ambiente do aplicativo, bem como todas as suas dependências, você pode ter certeza de que o aplicativo se comportará
da maneira mesma maneira em cada um dos diferentes dispositivos.
O Resin.io usa contêineres do Docker. Docker é o nome de uma plataforma de tecnologia de
conteinerização específica e da empresa que a criou. O Docker é, de longe, a tecnologia de contêiner mais popular do setor.
Depois que um projeto resin.io e seus dispositivos são configurados, você pode desenvolver seu aplicativo iterativamente.
Quando você envia alterações para seu Git remoto resin.io, o resin.io reconstrói o contêiner do seu aplicativo com o código
atualizado e implanta esse contêiner em todos os dispositivos conectados e provisionados para esse aplicativo, onde
quer que estejam (figura 12.2).
Figura 12.2. Os dispositivos que executarão o aplicativo são provisionados com a instalação e
inicialização de uma imagem personalizada do sistema operacional resin.io em cada um. O push do
código do aplicativo para um controle remoto resin.io Git específico do projeto aciona a reconstrução do
contêiner do aplicativo e sua reimplantação em dispositivos provisionados conectados.
UAU! e-book
www.wowebook.org
Atualizando a velocidade
O código para seu aplicativo resin.io será gerenciado em um repositório Git — você precisará ter o Git
instalado em seu computador. A seção “Instalando o Git” no site do gitscm documenta como fazer
isso em várias plataformas diferentes (https://git scm.com/book/en/v2/
GettingStartedInstallingGit).
Embora as instruções para criar um aplicativo resin.io incluam todos os comandos do Git necessários
para colocar um aplicativo em funcionamento em um BeagleBone Black, um conhecimento prático do
Git deve fazer parte da caixa de ferramentas mental de todo desenvolvedor. Leva alguns minutos
para aprender o básico do Git (embora, honestamente, uma vida inteira para dominar). O GitHub
tem um tutorial interativo (https://try.github.io/levels/1/challenges/1) e há vários outros recursos
educacionais on-line sobre o Git, muitos deles gratuitos.
12.2.1. Criando um aplicativo resin.io

Você criará um aplicativo resin.io para seu software de estação meteorológica, para implantação em seu
BeagleBone Black. O Resin.io oferece um nível gratuito que permite a implantação e o
gerenciamento de até cinco dispositivos. Acesse https://resin.io/ e crie uma conta (figura 12.3).
Figura 12.3. Crie uma conta em resin.io.
Em seguida, crie um aplicativo. Você será solicitado a fornecer um nome e um tipo de dispositivo
para seu aplicativo. Você pode nomeá-lo como quiser - eu chamei o meu de beagleweather. Para
UAU! e-book
www.wowebook.org
No campo Device Type, selecione BeagleBone Black na longa lista de opções (figura
12.4).
Não BeagleBone Black?
Nenhum BeagleBone Black disponível? Você pode usar um Raspberry Pi, se quiser.
Você precisará usar a versão Pi do código do aplicativo meteorológico (encontre-o na
pasta do capítulo 11 do repositório GitHub do livro) - com o plug-in raspiio I/O - mas, caso
contrário, as etapas devem ser as mesmas. Ah, e, claro, certifique-se de selecionar
Raspberry Pi 3 em vez de BeagleBone Black como o tipo de dispositivo para seu aplicativo resin.io.
Figura 12.4. Detalhe da etapa de criação do aplicativo mostrando a lista de tipos de

dispositivos suportados
UAU! e-book
www.wowebook.org
12.2.2. Provisionando o BeagleBone Black

O Resin.io gera uma imagem personalizada do sistema operacional para cada projeto. O sistema operacional
resin.io é um Linux leve. Ele pode executar o contêiner Docker do seu aplicativo e também cuidar de
tarefas de manutenção, como provisionar o dispositivo e ficar de olho nas atualizações implantadas.
UAU! e-book
www.wowebook.org
Depois de definir seu aplicativo resin.io, você pode fazer o download da imagem do sistema
operacional gerada (há um link fornecido, conforme mostrado na figura 12.5) e instalá-la em seus
dispositivos (ou, no nosso caso, em um único dispositivo) . Consulte a seção 11.2.3 no capítulo 11
para obter mais detalhes sobre as etapas aqui:
1. Baixe a imagem do sistema operacional.
2. Usando o aplicativo Etcher, grave o arquivo IMG no cartão microSD.
3. Insira o cartão microSD no BeagleBone Black e conecte o BeagleBone
Interface Ethernet de Black para o seu roteador.
4. Mantenha pressionado o botão USER/BOOT (figura 12.6) e conecte a energia na
BeagleBone Black. Continue segurando o botão até que os LEDs comecem a piscar loucamente.
Solte o botão.
Figura 12.5. Detalhe do painel do projeto resin.io durante o processo de provisionamento de um

dispositivo BeagleBone Black. O dispositivo, chamado automaticamente de “noite vermelha” pelo
resin.io, está no meio da instalação da imagem do sistema operacional resin.io específico do aplicativo.
Figura 12.6. Mantenha pressionado o botão BOOT/USER do BeagleBone Black para inicializar a
partir do cartão SD.
UAU! e-book
www.wowebook.org
De volta ao seu próprio computador, você deve ver o dispositivo aparecer no painel do seu
aplicativo resin.io após alguns instantes. No painel, você poderá acompanhar o progresso do dispositivo
durante o processo de provisionamento.
12.2.3. Adaptar o software de aplicação meteorológica

Para obter o software do aplicativo meteorológico em execução no BeagleBone Black provisionado,
existem mais algumas etapas:
1. Instale e configure um repositório Git para o aplicativo.
2. Configure o contêiner do Docker para o aplicativo.
3. Defina um script para iniciar o aplicativo (em package.json).
4. Faça alguns ajustes no próprio software.
5. Confirme e envie para o GitHub.
6. Dê ao aplicativo um URL público.
Inicializando um repositório Git
Primeiro você precisa estabelecer uma área de trabalho. Crie um diretório para conter o projeto
(beagleweather, talvez?) em seu computador.
Dentro desse diretório, inicialize um repositório Git executando este comando:
$ git calor
UAU! e-book
www.wowebook.org
Para implantar seu aplicativo, você precisa ser capaz de enviar o branch master do seu repositório para
resin.io. Você precisará adicionar um controle remoto Git específico do resin.io para poder enviar para
o resin.io mais tarde. O Resin.io mostra convenientemente o comando exato que você precisa executar
para configurar esse controle remoto: localize-o no canto superior direito do painel do seu aplicativo.
Execute o comando exibido em seu repositório local (figura 12.7).
Figura 12.7. Detalhe do painel do aplicativo resin.io mostrando onde encontrar o

comando para adicionar o controle remoto Git resin.io do seu aplicativo
Você pode ver todos os controles remotos do seu repositório executando este comando:
$ git remoto v
Você deve ver a saída algo como isto:
resina <seu nome de usuário de resina>@git.resin.io:<seu nome de usuário de resina>/

beagleweather.git (obter)
resina <seu nome de usuário de resina>@git.resin.io:<seu nome de usuário de resina>/
beagleweather.git (push)
Em seguida, copie os arquivos de origem do aplicativo de clima BeagleBone original para o novo diretório
de trabalho do projeto Git — index.js, package.json e o diretório do aplicativo e seu

conteúdo.
Definindo o contêiner do aplicativo Docker
O sistema operacional resin.io básico para seu aplicativo que agora está sendo executado em seu
BeagleBone Black consiste em um Linux simplificado e também contém algumas ferramentas úteis de
suporte. Mas você ainda precisa criar o contêiner do Docker que será executado no(s) dispositivo(s) do seu aplicativo
diga-lhe como se comportar e o que fazer.
Crie um arquivo chamado Dockerfile.template no diretório do seu projeto (a extensão “template”
permite o uso de certas variáveis úteis dentro do arquivo) e adicione o conteúdo mostrado na listagem a
seguir. A maior parte da listagem é clichê, proveniente diretamente de

UAU! e-book
www.wowebook.org
documentação do resin.io.
Listagem 12.1. Dockerfile.template
# baseimage para nó em qualquer máquina usando uma variável de modelo

DE resina/%%RESIN_MACHINE_NAME%%nó:6
# Define nosso diretório de trabalho no container

WORKDIR /usr/src/app
# Copia o package.json primeiro para melhor cache em pushes posteriores

COPY pacote.json pacote.json
# Isso instala as dependências do npm no servidor de compilação resin.io, # certificando-se de

limpar os artefatos que ele cria para reduzir o
tamanho da imagem.
RUN JOBS=MAX npm install produção unsafeperm && npm cache clean &&
rm rf /tmp/*
# Isso copiará todos os arquivos em nossa raiz para o diretório de trabalho no

recipiente
CÓPIA DE . ./
# Habilita o sistema init systemd no container

ENV INITSYSTEM ligado
# server.js será executado quando o contêiner for inicializado no dispositivo CMD ["npm", "start"]
1 Usa uma imagem base com Node.js, versão 6
2 Você precisará definir um script npm start que inicia seu aplicativo.
Mais sobre nomes de máquinas resin.io, imagens de base e tags
Dentro dos Dockerfiles resin.io, você pode especificar muitos detalhes sobre dispositivos, recursos
e distribuições e versões do Linux. Há muito o que abordar aqui, mas se você estiver curioso sobre
essas coisas, a documentação do resin.io é completa (https://docs.resin.io/
raspberrypi/nodejs/gettingstarted/).
Adicionando um script de início npm
Esta linha aparece no final da configuração do Dockerfile.template:
UAU! e-book
www.wowebook.org
CMD ["npm", "iniciar"]
Isso informa ao construtor para executar o comando npm start assim que o contêiner for iniciado.
Você ainda não tem um script de início, mas pode facilmente adicionar um editando package.json.
Edite o campo scripts em package.json para que fique parecido com a listagem a seguir.
Listagem 12.2. Scripts Package.json
"scripts": {
"start": "node index.js", "test": "echo \"Erro:
nenhum teste especificado\" && exit 1"
},
Agora, quando o processo de compilação executar o comando npm start, ele terá o mesmo efeito que a
execução do node index.js — ele iniciará seu aplicativo de previsão do tempo.
Ajustando o código do aplicativo
Há duas pequenas alterações a serem feitas no index.js antes de terminar.
O REPL do JohnnyFive e o resin.io não se dão bem. Você pode desabilitar o REPL facilmente, adicionando
uma propriedade ao objeto boardinstantiation options (repl: false).
Listagem 12.3. Desativar Johnny-Five REPL

io: new BeagleBone(),
repl: falso });
A porta existente definida para o servidor web (4000) em server.listen() funcionaria bem, mas há um truque muito
bacana que você vai fazer momentaneamente, então mude o
porta para 80.
Listagem 12.4. Mude a porta do servidor web para 80
server.listen(80, () => { console.log(`http://$

{os.networkInterfaces().eth0[0].address}:80`);
});
Comprometendo-se e empurrando
Adicione e confirme os arquivos do projeto no Git (certifique-se de estar no nível superior do projeto
UAU! e-book
www.wowebook.org
diretório):
$ git add index.js package.json Dockerfile.template app/

$ git commit m "primeiro commit"
Agora pressione para acionar a implantação em seu BeagleBone Black:
$ git push mestre de resina
A primeira vez que você fizer isso, levará vários minutos (depois é mais rápido). Você pode
acompanhar o progresso em seu painel resin.io (figura 12.8). Você poderá visualizar o aplicativo
em um navegador em seu computador em seu endereço IP local.
Figura 12.8. Painel do aplicativo Resin.io durante a implantação
Para iterar em seu aplicativo, você pode fazer alterações em seu repositório local, confirmar e
enviar com a frequência necessária.
Dar ao seu aplicativo um URL público
Você tem construído muitas interfaces baseadas na Web para seus gadgets, mas até agora só
conseguiu visitar seus aplicativos da Web na mesma rede. O Resin.io tem um recurso
interessante que gera uma URL pública para um dispositivo, permitindo acesso externo à porta
80 desse dispositivo (agora você sabe por que mudou o número da porta!).
Para habilitar URLs públicos para o aplicativo como um todo, vá para a seção Ações do WOW! e-
book
www.wowebook.org
painel do seu aplicativo (figura 12.9).
Figura 12.9. Habilite URLs públicos para seu aplicativo na guia Ações do aplicativo.
Em seguida, acesse uma visualização específica do dispositivo navegando até a seção Devices e
clicando no nome do dispositivo que deseja gerenciar — rednight no meu caso (figura 12.10).
Figura 12.10. Consulte a URL pública de um dispositivo navegando até a guia Ações específica
do dispositivo.
UAU! e-book
www.wowebook.org
Vá para a seção Ações novamente - essas são ações apenas para este dispositivo, em
vez de todo o aplicativo. Você deve ser capaz de ver — e, para ajudar, clicar — na URL
pública de seu aplicativo em execução no BeagleBone Black (figura 12.11).
Figura 12.11. O aplicativo da estação meteorológica, executado em um BeagleBone Black,

acessado por um URL público gerado por resina .io
12.3. HARDWARE E O NAVEGADOR DA WEB
O aplicativo da estação meteorológica aproveita uma API da web relativamente moderna,

WebSockets (mais precisamente, ele usa socket.IO, que usa a API WebSockets em navegadores
que a suportam). Esta API é utilizada para manter a conexão entre o cliente (browser) e o servidor
(rodando no BeagleBone Black, neste caso). O servidor é capaz de emitir dados do sensor
atualizados que o cliente pode “ouvir” e processar de acordo. Mas isso ainda é indireto - o
navegador depende do servidor para lidar com a interação real
com a E/S do BeagleBone Black e o sensor conectado. É possível interagir com hardware,
diretamente, de dentro do próprio navegador?
A resposta é complexa – uma combinação de “depende” e “em alguns navegadores”, com uma boa
dose de “espere e veja só mais um pouco”.
A web é, sem dúvida, uma plataforma com muito mais capacidade física do que há alguns anos.
Não faz muito tempo que você tinha que criar um aplicativo nativo para poder acessar os serviços de
localização de um dispositivo móvel ou sua câmera, ou enviar notificações push. Agora
tudo isso pode ser feito no navegador.
A plataforma web é uma (vasta) coleção de tecnologias e APIs. Claro, existem as estrelas
principais - HTML, ECMAScript e CSS (embora, tecnicamente, CSS não seja uma coisa, mas
uma coleção de módulos) - mas também há dezenas e dezenas de outras peças: Web
Workers, WebGL, XMLHttpRequest, Web Audio, WebSocket, WebRTC (eu poderia continuar o dia
todo). Diferentes tecnologias e APIs estão em diferentes estágios no
UAU! e-book
www.wowebook.org
processo de padronização, e alguns ainda não estão tecnicamente no caminho dos padrões.
12.3.1. A API Web Bluetooth
A Web Bluetooth API permite a interação com dispositivos Bluetooth Low Energy (BLE) por
meio do Generic Attribute Profile (GATT). Há um grupo comunitário ativo para Web Bluetooth no
W3C (o World Wide Web Consortium, o principal órgão que desenvolve padrões da Web) e é
implementado em algumas versões do Chrome, Opera e do navegador Android. Mas ainda não é um
padrão nem está na trilha dos padrões (embora esteja indo nessa direção geral). É complicado.
Web Bluetooth também encontrou um problema típico de APIs de webhardware: questões de

segurança. Não é preciso ser um gênio para evocar algumas visões de como os dispositivos físicos
expostos à web podem representar um pesadelo de segurança. Neste ponto, a Mozilla (Firefox) não
está buscando a implementação do Web Bluetooth porque está insatisfeita com o (atual) modelo de segurança.
Mas, para que isso não pareça sombrio, essas lutas não são atípicas dos padrões propostos. É difícil
prever onde o Web Bluetooth estará em seis meses ou dois anos. E você pode — e vai — usá-lo hoje
no Chrome.
12.3.2. A API do Sensor Genérico
O Web Bluetooth não é a única API da Web relacionada a hardware na cidade (embora tenha as
implementações de navegador mais completas neste momento). O Grupo de Trabalho de Dispositivos
e Sensores do W3C (https://www.w3.org/2009/dap/) tem a tarefa de criar APIs que “interagem com o
hardware do dispositivo, sensores, serviços e aplicativos, como câmera, microfone, sensores de
proximidade, catálogos de endereços nativos, calendários e aplicativos de mensagens nativos.”
A API Generic Sensor do grupo (https://www.w3.org/TR/genericsensor/), atualmente em fase de

rascunho, define uma classe base Sensor abstrata, que não faz nada por conta própria, mas deve ser
estendida por APIs específicas de componentes. Um exemplo disso é a API Ambient Light Sensor
(também um rascunho, https://www.w3.org/TR/ambientlight/), que define uma interface — baseada
em Sensor — para interagir com sensores de luz ambiente. Se você analisar os detalhes das
especificações, não será nenhuma surpresa que um dos editores das APIs genéricas e de outros
sensores seja Rick Waldron, o inventor do JohnnyFive. Certamente há aspectos do encapsulamento
de comportamento de componente da API que estão em harmonia com a forma como JohnnyFive
abstrai o comportamento.
Essas APIs não se preocupam com detalhes de como o hardware é detectado e
conectado tanto quanto definir uma API de nível superior para interagir com componentes.
UAU! e-book
www.wowebook.org
Como tal, as primeiras implementações do Sensor de luz ambiente dependem da presença de
hardware integrado (normalmente a câmera de um dispositivo) e do navegador expondo esse
hardware de acordo. O sensor de luz ambiente está disponível (atrás de uma bandeira - você
deve ativá-lo explicitamente nas configurações do navegador) no Chrome e no Microsoft Edge.
12.3.3. A Web física

A Physical Web é um serviço de descoberta que simplifica muito a interação com objetos por meio
de simples beacons Bluetooth LE, aproveitando um dos maiores presentes que a web nos oferece:
a URL.
Examinamos a Web física brevemente no capítulo 1. O cenário imaginado ali era de um ponto de
ônibus ativado por um sinalizador. O beacon transmite constantemente uma URL que corresponde
a uma página onde as próximas chegadas de ônibus podem ser rastreadas (figura 12.12).
Figura 12.12. Com a Web física, os beacons Bluetooth Low Energy (BLE) anexados
ou incorporados a um objeto físico transmitem uma URL pertinente à interação com
esse dispositivo. Os usuários próximos podem detectar e interagir com dispositivos,
abrindo suas páginas da Web associadas em um navegador.
Ou diga que você está caminhando por um jardim de esculturas. Algumas das obras têm um
farol próximo ou sobre elas, transmitindo uma URL para uma página da web com informações
sobre aquela peça e seu artista. Ao passear, você pode ver os beacons perto de você e optar por
interagir com um deles, visitando a URL que está anunciando.
O Google está defendendo a Web física e o protocolo BLE aberto relacionado,

Eddystone. Como as demandas técnicas são tão diretas - um dispositivo BLE precisa apenas
anunciar uma URL usando um determinado protocolo - as necessidades de hardware são
UAU! e-book
www.wowebook.org
as baterias mínimas e de farol podem durar muito, muito, muito tempo. Os aplicativos, disponíveis agora para
Android e iOS, permitem que você encontre qualquer beacon perto de você.
12.4. EXPLORANDO BLUETOOTH LE COM PUCK.JS
Espruino fabrica um dispositivo que permite que você experimente - hoje! agora mesmo!—com o Web Bluetooth
e a Web física. O Puck.js é um dispositivo em forma de botão que executa o interpretador Espruino e se
comunica usando BLE (figura 12.13). Você aproveitará isso para colocar em prática o Web Bluetooth e a Web
física.
Figura 12.13. Puck.js é um dispositivo beacon BLE que, como o Pico, executa o
interpretador Espruino JavaScript.
O Puck.js é construído em torno de um Nordic Semiconductor SoC (sistema em um

chip) de ultrabaixa potência que inclui suporte a Bluetooth LE e NFC, bem como uma CPU
ARM Cortex M4 que não é muito diferente da do Pico. Embora o Pico e o Puck.js
executem o mesmo software Espruino subjacente, o Puck.js difere do Pico na maneira como você
UAU! e-book
www.wowebook.org
comunique-se com ele: por BLE versus conexão USB direta do Pico.
Os componentes integrados do Puck.js incluem um magnetômetro embutido, termômetro e três LEDs
(vermelho, verde, azul). O LED vermelho também pode ser usado como um sensor de luz ambiente.
O Puck.js é um dispositivo de 3,3 V alimentado por uma bateria coincell. É aproximadamente comparável
a um Pico, embora um pouco mais restrito: velocidade de clock mais lenta, um pouco menos de memória
e menos pinos de E/S (figura 12.14).
Figura 12.14. Algumas das funcionalidades do Puck.js, listadas no site do Espruino
Puck.js tem uma capa de silicone flexível. A coisa toda pode funcionar como um botão grande,
fazendo um clique tátil quando você o pressiona (e ativa o botão embutido).

UAU! e-book
2
www.wowebook.org
Puck.js tem vários recursos GPIO, incluindo IC, PWM, SPI e ADC (figura 12.15).
Você fará uso de seu hardware integrado (somente) nesses experimentos.
Figura 12.15. Um detalhe da pinagem Puck.js de Espruino.com. O pino D11 pode detectar
2 entradas capacitivas. O suporte IC, SPI e USART está disponível em qualquer pino (há
2
suporte para uma interface de hardware cada, mas suporte de software ilimitado para IC e
SPI).
Acesse o Guia de primeiros passos do Espruino's Puck.js: http://www.espruino.com/
Puck.js+Quick+Start. Você precisará desmontar o dispositivo para remover uma aba protetora da bateria.
O que acontece depois disso depende do sistema operacional da sua plataforma de desenvolvimento e do estado de
UAU! e-book
www.wowebook.org
Web Bluetooth no momento. O Chrome no Mac OS é compatível com isso — é fácil. Os usuários do
Linux podem ter uma etapa extra e podem precisar habilitar um sinalizador ou dois no Chrome. O suporte
Web Bluetooth no Windows (no Chrome) é potencialmente iminente (meados de 2017). Consulte
o Guia de primeiros passos para obter informações atualizadas.
Se você acompanhou os experimentos do Pico no capítulo 11, talvez já tenha instalado o IDE do
aplicativo Espruino Chrome. Se não, não se preocupe, porque você pode realmente trabalhar com
Puck.js usando o IDE baseado na web em https://www.espruino.com/ide (não requer
instalação). O Web IDE (figura 12.16) é uma imagem cuspida do aplicativo Chrome
VAI.
Figura 12.16. IDE baseado na web do Espruino
Se você não conseguir obter suporte Web Bluetooth...
Um navegador compatível com Web Bluetooth é necessário para os experimentos de LED e

campainha remota controlados pela Web posteriormente neste capítulo. Você não precisa de
suporte Web Bluetooth para o LED Hello World básico piscando, nem para o exemplo da Web física
— Puck.js pode ser controlado de dentro do IDE para eles.
Você não poderá usar o IDE baseado na Web em https://www.espruino.com/ide se não tiver suporte
Web Bluetooth. Em vez disso, você precisará instalar o Web IDE (consulte o Guia de introdução do
Puck.js para obter detalhes: http://www.espruino.com/Puck.js+Quick+Start).
UAU! e-book
www.wowebook.org
Lembre-se também do capítulo 11 que a autoria do código Espruino envolve o uso de módulos
Espruino - comportamento encapsulado e suporte que podem ser importados para scripts Espruino.
Existem três maneiras principais de fazer o Puck.js fazer algo:
Uma vez conectado, o Puck.js executará qualquer comando digitado no lado esquerdo da interface
IDE, semelhante a um REPL ou console.
O código escrito no lado direito do IDE pode ser carregado usando o ícone sendto Espruino.
Dados e comandos podem ser enviados e recebidos do Puck.js via Web Bluetooth.
Isso é feito no contexto de execução do navegador, contando com uma pequena biblioteca
JavaScript do lado do cliente fornecida pelo Espruino. (Este método é exclusivo do Puck.js, ao
contrário de outras placas Espruino.)
12.4.4. Exemplos, tutoriais e documentação da API
Inicie o IDE e conecte-se ao seu Puck.js para que você possa experimentar um piscar de LED Hello
World e cutucar alguns dos recursos do Puck.js.
Tente digitar alguns dos seguintes comandos no lado esquerdo do IDE. Depois de pressionar Enter, o
comando será enviado por BLE para Puck.js e será executado lá:
Ligue o LED vermelho integrado com LED1.set().
Desligue o LED vermelho integrado com LED1.reset().
Tente os comandos anteriores com os outros dois LEDs: LED2 (verde) e LED3 (azul).
O LED vermelho também serve como um sensor de luz ambiente. Certifique-se de que todos os
LEDs estejam desligados (LEDx.reset()) e tente Puck.light() para retornar uma leitura de luz
ambiente. Tente encobrir Puck.js com a mão e enviar o Puck.light()

comando uma segunda vez para ver a diferença.
Tente E.getTemperature() para obter uma leitura de temperatura. E é a classe utilitária de
Espruino. A temperatura deve ser precisa de cerca de +/1 grau (Celsius).
A documentação da API do Espruino (http://www.espruino.com/Reference) abrange a API

disponível para todos os dispositivos Espruino, bem como os recursos específicos do Puck expostos no
objeto global Puck.
12.4.5. Controlando o LED a partir de uma página

UAU! da web
e-book
www.wowebook.org
1 Puck.js
1 Web Navegador da Web habilitado para Bluetooth
Como você viu, você pode controlar o Puck.js usando o IDE: enviando comandos ou escrevendo um script
e implantando-o no dispositivo. Este é um fluxo de trabalho semelhante ao Espruino Pico.
Mas há outra maneira: você pode controlar o Puck.js a partir do seu próprio código no navegador. Neste
experimento, você construirá uma página da Web que permite ao usuário ligar e desligar o LED vermelho do
Puck.js clicando nos botões do navegador (figura 12.17).
Figura 12.17. O LED do Puck.js pode ser controlado por meio de uma página da Web em um navegador
compatível com Bluetooth.
O JavaScript da página precisará emparelhar com Puck.js e se comunicar com ele (enviar
comandos) usando Web Bluetooth.
UAU! e-book
www.wowebook.org
O Espruino facilita essa parte para você, fornecendo uma pequena biblioteca do lado do cliente (um
arquivo JavaScript) que você pode usar em nossa página. A biblioteca abstrai os detalhes da Web Bluetooth
API, oferecendo uma interface simples que você pode usar para emparelhar e interagir com o Puck.js.
Essa biblioteca do lado do cliente pode ser encontrada em https://www.puckjs.com/puck.js. Você o incluirá
na página index.html do projeto.
Web Bluetooth: ainda curioso?
Se você está curioso sobre como o Web Bluetooth funciona nos bastidores, você pode ler a fonte do
arquivo JavaScript puck.js, que é bem comentado: https://www.puck
js.com/puck.js.
A biblioteca JavaScript de puckjs.com fornece utilitários para conectar e se comunicar com Puck.js,
mas você ainda precisará escrever sua própria lógica específica para lidar com cliques de botão e enviar
comandos para Puck.js para ligar e desligar o LED .
Definindo a estrutura do projeto
Primeiro você precisa estabelecer uma área de trabalho - crie um diretório chamado ledtoggle. Em
seguida, dentro desse diretório, execute este comando:
$ npm instalação expressa
Essa é a única dependência do projeto.
Em seguida, crie um ponto de entrada de aplicativo em index.js, que ativa um servidor da Web estático
superbásico para recursos em app/, conforme mostrado na listagem a seguir.
const express = require('express'); const path =

require('path'); const http = require('http');

servidor const = new http.Server(aplicativo);
app.use(express.static(path.join(__dirname, '/app'))); server.listen(3000);
UAU! e-book
www.wowebook.org
Agora é hora de criar a página HTML do aplicativo. Para isso, crie um diretório app no
projeto e adicione index.html com o conteúdo mostrado na listagem a seguir.
<html>
<cabeça>
<title>Alternar LED do Puck.js</title>

<estilo>
h1 {
fontfamily: "Helvetica";
}
botão {
exibição: bloco, largura: 6em;
altura: 4em;
margem: 2em;
cor de fundo: #eee; borda: 1px sólida #ccc;
tamanho da fonte: 1,75em;

}
</estilo>
</head>
<body>
<h1>Alternar Web Bluetooth Puck.js</h1> <div
id="message"></div> 1 <button id="onButton">ON</button>
<button id="offButton">DESATIVADO</button>
<script src="https://www.puckjs.com/puck.js"></script> 2 <script> 3
// ... TBD
</script> </
body> </html>
1 contêiner para armazenar mensagens se Web Bluetooth não for compatível
2 Fornece um objeto Puck para comunicação com Puck.js usando Web

Bluetooth
3 A lógica do cliente do aplicativo: você precisa escrevê-la!
A página HTML não faz nada sozinha: ela tem algum CSS e inclui o script do site
puckjs.com que permite que você se comunique com o Puck.js usando Web Bluetooth.
Ele também tem a marcação para os botões ON e OFF, mas eles ainda não fazem nada.
Criando a lógica de alternância de LED
UAU! e-book
www.wowebook.org
Vamos falar sobre manipuladores de cliques para os botões ON e OFF. Quando um botão é clicado,
você precisa enviar um comando para o Puck para ligar ou desligar o LED vermelho. Como você
viu na seção 12.4.4, este é o comando que o Puck.js precisa executar para ligar o LED vermelho:
LED1.set();
Esse é o comando que você precisa enviar para o Puck.js a partir do navegador, usando a
biblioteca do cliente puck.js como um mensageiro. O comando precisa ser enviado para Puck.js como
uma string, incluindo o caractere \n (quebra de linha). Esta é a string de comando resultante:
'LED1.set();\n'
Para enviar isso para Puck.js, você usará o método write() no objeto Puck, que está disponível
globalmente no JavaScript da sua página porque você incluiu a biblioteca puck.js do lado do
cliente (figura 12.18).
Puck.write('LED1.set();\n');
Figura 12.18. O JavaScript executado pelo navegador chama o método write() no

objeto Puck fornecido pela biblioteca puck.js. Essa biblioteca usa Web
Bluetooth para enviar a string para o Puck.js físico, que a avalia. O \n no final do
comando string permite que Puck.js saiba que o comando está completo; é
quase como digitar em um REPL virtual e apertar Enter.
UAU! e-book
www.wowebook.org
O que significa Puck.js?
Há um objeto Puck no navegador, um objeto Puck diferente para o qual você pode enviar comandos no
IDE Puck.js, e Puck.js e puck.js são coisas totalmente diferentes. Caramba!
As convenções de nomenclatura são reconhecidamente um pouco confusas. Aqui está um resumo:
Puck.js—O próprio dispositivo físico Puck.js
puck.js — Uma biblioteca JavaScript do lado do cliente, fornecida pela Espruino, usada no
navegador para comunicação com um dispositivo Puck.js via Web Bluetooth (BLE)
Objeto Puck—Confusamente, esta é uma das duas coisas (totalmente diferentes) dependendo de onde
o código está sendo executado:
No IDE ou scripts executados diretamente no Puck.js—É a classe global Espruino Puck (http://
www.espruino.com/Reference#Puck), que adiciona alguma funcionalidade de interação de
hardware específica para Puck.js—ou seja, funcionalidade que não está disponível em outras
placas Espruino (como usar Puck.light() para obter uma leitura do sensor de luz ambiente do
Puck.js)
Em um navegador, assumindo a inclusão da biblioteca do lado do cliente puck.js— Fornece
acesso a alguns métodos de comunicação com Puck.js via Web Bluetooth (como Puck.write()
e Puck.connect()). Lembrando que todos os comandos enviados são avaliados no próprio Puck.js,
no interpretador Espruino.
Isso significa que em um script de navegador — supondo que a biblioteca cliente puck.js esteja incluída — a
seguinte instrução é válida:
Puck.write('Puck.light();\n');
Puck.write() é executado no contexto do navegador, o que significa que se refere ao objeto fornecido
pela biblioteca incluída puck.js. Mas o comando que ele envia via write() é avaliado no próprio
Puck.js: o objeto Puck em Puck.light() é uma referência ao objeto Espruino Puck global. Ufa!
A listagem a seguir define o que acontece entre as tags <script> em index.html: os ouvintes de evento de
clique e os comandos enviados para Puck.js.
Listagem 12.7. Ouvintes de evento para alternar LEDs
UAU! e-book
www.wowebook.org
window.addEventListener('load', () => {
if ('bluetooth' em window.navigator) {
const onButton = window.document.getElementById('onButton'); const offButton =
window.document.getElementById('offButton'); onButton.addEventListener('click', () => Puck.write('LED1.set() ;
\n'));
offButton.addEventListener('click', () => Puck.write('LED1.reset();\n'));
} outro {
const mEl = window.document.getElementById('mensagem');
mEl.innerHTML = "Parece que seu navegador não suporta Bluetooth!";
}
});
A detecção de recurso substituta na listagem 12.7 — if ('bluetooth' em window.navigator)
— é reconhecidamente desajeitada e ingênua. Só porque um navegador expõe navigator.bluetooth não
significa que implementa corretamente o que é necessário para Puck.js. Há uma verificação mais correta e
completa do suporte do navegador em uma função chamada checkIfSupported(), dentro do código
JavaScript que fornece o objeto Puck. Infelizmente, essa função não está exposta ao objeto Puck - não está
em nenhum escopo ao qual você tenha acesso - portanto, você não pode invocá-la diretamente.
Experimente! Inicie o servidor da Web usando o node index.js e abra um navegador da Web compatível
com Bluetooth em localhost:3000.
Ao clicar pela primeira vez em um botão, você verá um pop-up de solicitação de emparelhamento,
semelhante à figura 12.19. Assim que o emparelhamento estiver concluído, você poderá clicar em ON e
OFF e ver o LED vermelho do Puck.js ligar e desligar.
Figura 12.19. Você será solicitado a emparelhar com Puck.js quando clicar em um botão pela primeira vez.
UAU! e-book
www.wowebook.org
12.4.6. A Web física e o Puck.js
1 Puck.js
1 dispositivo móvel rodando Android ou iOS
A Web física é composta de beacons usando um formato específico — Eddystone — para transmitir uma
URL associada, e essas transmissões podem ser captadas por aplicativos em execução
em dispositivos móveis.
O Puck.js pode servir como um sinalizador compatível com a Web física com bastante facilidade. Para fazer isso
funcionar, você precisará fazer o seguinte:
Instale um aplicativo utilitário de descoberta da Web física ou habilite esse recurso no Chrome, em
um dispositivo móvel.
Determine qual URL você gostaria que o Puck.js transmitisse.
UAU! e-book
www.wowebook.org
Faça o Puck.js começar a se anunciar como um beacon compatível.
O protocolo de Eddystone
Eddystone é um protocolo de beacon BLE aberto criado pelo Google. Os Web beacons físicos usam
esse formato para transmitir sua URL associada e os aplicativos clientes detectam esses beacons
Eddystone.
Eddystone é direto. Existem apenas alguns tipos de informações - tipos de quadros - que um sinalizador
Eddystone falante pode enviar, sendo o mais pertinente
EddystoneURL.
Restrições de comprimento de EddystoneURL
O comprimento máximo de um URL EddystoneURL é 17. Isso é apertado. Mas não é tão restritivo
quanto parece. Um byte separado também é usado para manter uma representação do prefixo do
esquema da URL (https://www., http:// e assim por diante) — esses caracteres não contam para os 17.
Além disso, domínios de nível superior comuns ( .com, .org e similares) podem ser representados
com um único caractere, deixando 16 caracteres livres. Supõe-se que os desenvolvedores
usarão encurtadores de URL (como https://goo.gl) para minimizar os tamanhos de URL.
A URL https://www.lyza.com tem 20 caracteres em seu formato normal, mas requer apenas 5 dos
17 bytes disponíveis.
Configurando o Puck.js como um beacon
Configurar o Puck.js como um Web beacon físico compatível com Eddystone é incrivelmente
fácil. Tem um módulo ble_eddystone Espruino esperando por você!

Inicie o Web IDE, conecte-se ao seu Puck.js e insira o seguinte comando no
lado esquerdo do IDE:
require("ble_eddystone").advertise("https://www.lyza.com");
(Sinta-se à vontade, é claro, para substituir a URL do meu domínio por qualquer outra que desejar.)
Desconecte o IDE do seu Puck.js para que ele possa começar a transmitir em Eddystone
formatar.
Ativando a descoberta da Web física em seu dispositivo móvel
UAU! e-book
www.wowebook.org
Você pode detectar seu beacon da Web física Puck.js com dispositivos que executam Android
ou iOS (figura 12.20); as instruções podem ser encontradas no site da Web
física (https://google.github.io/physicalweb/tryphysicalweb). Uma vez configurado, seu
dispositivo móvel deve ser capaz de ver seu beacon Puck.js.
Figura 12.20. Suporte físico da Web por meio do widget do Chrome no iOS. Puck.js
está configurado para transmitir a URL https://www.lyza.com usando o protocolo
Eddystone.
UAU! e-book
www.wowebook.org
É hora de sair com um estrondo (bem, um ding, pelo menos). Nosso último experimento combinará
Web Bluetooth, Web Audio e dados enviados de Puck.js.
12.4.7. Uma campainha Bluetooth baseada na web

WOW! e-
1 Puck.js
1 Web Navegador da Web habilitado para Bluetooth
Este experimento reproduz um som (de alta qualidade) e exibe um alerta visual em um navegador sempre que
o botão Puck.js emparelhado é pressionado. Pense nisso como uma campainha baseada na web. Ele aproveita
a API de áudio da Web - mais uma bela API da Web - para carregar e reproduzir um som de carrilhão (domínio
público).
A lógica do aplicativo usa a biblioteca puck.js do lado do cliente para se conectar ao Puck.js via Web Bluetooth,
configura o Puck.js para monitorar seu botão onboard e analisa os dados — saída de string que significará o
pressionamento do botão — emitido pelo Puck.js.
Definindo a estrutura do projeto
Comece estabelecendo uma área de trabalho. Crie um diretório (“campainha”) e instale express como uma
dependência nesse diretório:
$ npm instalação expressa
Crie index.js, o servidor web estático. Você pode reutilizar o código da listagem 12.5, que executará um servidor
web estático na porta 3000.
Criando o HTML e os ouvintes de eventos
Crie um diretório de aplicativos dentro da campainha. Adicione um arquivo index.html com o seguinte
contente.
<html>
<cabeça>
<title>Puck.js Remote Chime</title>

<estilo>
corpo { largura
máxima: 90%;
UAU! e-book
www.wowebook.org
fontfamily: "Times New Roman";
margem: 1em automático; cor: #111;
cor de fundo: transparente; transição: cor de fundo 0,5s

easeinout; }
.ding {
cor de fundo: #e60a62;
transição: todos os 0,1s de saída fácil;
}
botão {
largura: 100%;
altura: 100%; borda: 5px
sólido #e60a62;
fontfamily: "Times New Roman";
texttransform: letras minúsculas;
fontvariant: smallcaps;
cor de fundo: transparente;
tamanho da fonte: 3em;
peso da fonte: 600; cursor: ponteiro; }
botão: passe o mouse {

cor: #fff;
cor da borda: #b5084d;
cor de fundo: #f62c7d;
}
.ativo {
opacidade: 0; transição:
todos os 1s;
} </
estilo> </head>
<body>
<button id="goButton">Ligue</button> <script src="https://
www.puckjs.com/puck.js"></script> <script src="PuckChime.js "></script> <script>
// ... adiciona ouvintes de evento

</script> </body> </
html>
Se você visualizasse index.html em um navegador agora, veria o que é mostrado na Figura

12.21, mas ainda não faria nada.
Figura 12.21. No momento, index.html mostra um botão muito grande, mas não tem
nenhuma funcionalidade.
UAU! e-book
www.wowebook.org
O botão (#goButton) terá um manipulador de evento de clique que ativará a campainha. Você pode estar
se perguntando por que essa etapa de clique extra é necessária - por que não ativar a campainha
no carregamento da página? Por motivos de privacidade e permissões, é necessário que haja uma ação
explícita na interface do usuário antes que o emparelhamento Bluetooth seja permitido pelo navegador
— se você tentar fazer isso sem a entrada ativa do usuário, receberá um erro.
O arquivo index.html contém um pedaço de CSS. Parte do estilo é formatar o grande botão Turn It
On, mas também há estilos para fazer a tela piscar quando a campainha toca e para desativar o botão
Turn It On (a classe .active) quando a campainha é tocada
ativado.
Agora você pode preencher o conteúdo <script> com o código na listagem a seguir. Este código
assume a existência de uma classe PuckChime, cuja criação veremos a seguir.
Listagem 12.9. Manipulador de cliques para o botão Ativar
window.addEventListener('load', () => {
const onButton = window.document.getElementById('goButton');
onButton.addEventListener('click', function () {
var carrilhão = new PuckChime();
chime.init().then(() => { 1
onButton.classList.add('ativo'); 2
});
});
});
1 Assim que a promessa chime.init() for resolvida, você saberá que o BLE Puck.js
UAU! e-book
www.wowebook.org
carrilhão foi configurado com sucesso.
2 Você não precisa mais do botão, então você pode adicionar a classe ativa para fazê-la
desaparecer.
Codificando a classe PuckChime
A lógica da campainha BLE é mais complicada do que enviar comandos de uma linha para Puck.js em
manipuladores de eventos de clique, como na página da web de controle de LED anterior.
Faz sentido encapsular o código em uma classe, PuckChime, dentro de um novo arquivo,
app/PuckChime.js. A superfície da API para PuckChime é mostrada na listagem a seguir.
Você o preencherá nas próximas etapas.
Listagem 12.10. A superfície da API para PuckChime
classe PuckChime {
construtor () {
aquecer () {
/**
* estabelecer conexão com Puck.js
* redefinir Puck.js
* envie o comando para Puck.js: observe o botão embutido para pressionamentos * invoque `chime()` como
confirmação auditiva/visual quando for bem-sucedido
*/
}
conectar () {
/**
* conecte-se ao Puck.js com BLE
* adicione um manipulador de eventos para eventos `data` do Puck.js */
enviar (cmd) {
// formata e envia `cmd` para Puck.js
}
reiniciar () {
// envia um comando `reset` para Puck.js e espera 1,5 segundos para que ele "pegue"
}
watchButton () {
/**
* envie um comando para Puck.js para observar o pressionamento de seu botão
* e registra (por Bluetooth) uma string quando o botão é pressionado */
}
UAU! e-book
www.wowebook.org
parseData (dados) { /**
* Manipulador de eventos `data` para blocos de dados recebidos de Puck.js * anexar `data` ao
buffer * analisar o buffer em linhas (dividido em
`\n`)
* envie cada linha (`cmd`) para `parseCommand()` */
parseCommand (cmd) { // se `cmd`

for `CHIME`, chame `chime()`
}
chime () { // toca
um som de carrilhão e faz um carrilhão visual
}
}
Vejamos como os métodos constructor e init() podem ser implementados na próxima

listagem.
Listagem 12.11. PuckChime: construtor e métodos de inicialização
construtor () {
this.connection = null; 1
this.dataBuffer = ''; 2
this.sound = new Sound('/chime.mp3'); 3
}
aquecer () {
return this.connect().then(() => {
return new Promessa((resolver, rejeitar) => { this.reset()
.then(this.watchButton.bind(this))
.then(() => {
this.chime(); 4
resolver();
});
});
});
}
1 Mantém a conexão com Puck.js; é inicialmente nulo até ser conectado
2 Um buffer para armazenar e analisar os dados recebidos do Puck.js
3 Sound é uma classe de conveniência para carregar e reproduzir um som com a

Web Audio API.
UAU! e-book
www.wowebook.org
4 Após a conclusão do trabalho do init, invoca chime() uma vez
O construtor prepara um som — chime.mp3 — instanciando um objeto Sound. Se Sound parece uma aula
mágica que surgiu do nada, e chime.mp3 um arquivo de origem misteriosa, você está certo! Aguarde; mais
detalhes sobre eles daqui a pouco.
O método init retorna uma promessa que resolve quando as seguintes etapas são concluídas:
1. Uma conexão é estabelecida com Puck.js 2. Puck.js
é redefinido 3. Puck.js
é instruído a observar o pressionamento de seu botão
Somente quando todas essas coisas estiverem concluídas, a Promessa retornada por init() é resolvida;
chime() também é invocado como uma confirmação (a campainha tocará uma vez quando estiver pronta para
funcionar).
Continuando, os métodos connect(), send(cmd), reset() e watchButton() se comunicam com Puck.js, cada um
retornando uma promessa. Esses métodos dependem do código de comunicação puck.js do lado do
cliente fornecido por Espruino:
connect() — conecta-se ao Puck.js e adiciona um manipulador de eventos (parseData) para eventos
de dados do Puck.js
send(cmd) — Formata a string cmd apropriadamente e a envia para Puck.js, agrupando o
método connection.write() orientado a callback com uma Promise para consistência
reset()—Envia um comando reset para Puck.js e também espera 1,5 s para que Puck.js esteja pronto
novamente antes de resolver a promessa que ele retorna
watchButton()—Envia um comando mais complexo para Puck.js para configurar um relógio em

seu botão embutido
Esses métodos são detalhados na listagem a seguir.
Listagem 12.12. Métodos de comunicação com Puck.js
conectar () {
return new Promise ((resolver, rejeitar) => {
Puck.connect(conexão => {
this.connection = conexão;
this.connection.on('data', this.parseData.bind(this)); resolve(this.connection);
});
UAU! e-book
www.wowebook.org
});
}
enviar (cmd) {
cmd = `\x10${cmd}\n`;
return new Promise ((resolver, rejeitar) => {
this.connection.write(cmd, () => { resolve(cmd); });
});
}
reiniciar () {
return new Promise((resolver, rejeitar) => { this.send('reset()').then(() =>
{ setTimeout(resolver, 1500); });
});
}
watchButton () {
const cb = "function() { Bluetooth.println('CHIME'); LED1.set();
setTimeout(() => LED1.reset(), 250);}";
const opts = "{repeat:true,debounce:250,edge:'rising'}";
const cmd = `setWatch(${cb},BTN,${opts});`;
return this.send(cmd);
}
Vamos dar um zoom no comando enviado por watchButton()—é um pouco confuso como
formatado—e entender melhor o que está acontecendo com o envio e recebimento de
dados e comandos do Puck.js.
Como você viu no exemplo de LED controlado pela web na seção 12.4.5, os comandos precisam
ser formatados como strings antes de enviá-los ao Puck.js a partir do navegador. No experimento
de LED mais simples, isso foi feito com chamadas individuais para Puck.write() (veja a figura
12.18).
Nesse caso mais complexo, em que os dados estão indo em ambas as direções, você está
estabelecendo uma conexão persistente (no método connect()). Depois que a conexão é
estabelecida, os comandos são enviados para Puck.js usando connection.write(). Os dados
são recebidos do Puck.js por meio de eventos de dados emitidos na conexão (figura 12.22), que são
manipulados pelo manipulador de eventos de dados registrados, parseData(). Nós vamos chegar a isso em
momento.
Figura 12.22. Para as comunicações bidirecionais no exemplo da campainha, a

biblioteca do cliente puck.js é usada para estabelecer uma conexão persistente entre
o navegador e o Puck.js. Os comandos podem ser enviados para Puck.js pela conexão,
e qualquer saída para Bluetooth por Puck.js aciona um evento de dados na conexão.
UAU! e-book
www.wowebook.org
Os objetos PuckChime enviam dois comandos para Puck.js: um comando reset() durante a
fase de inicialização para limpar qualquer teia de aranha ou esquisitices de Puck.js e, em
seguida, um comando mais complexo em watchButton(). O comando construído nesse
método, isento de todas as suas restrições e ignorando as restrições de quebra de linha,
é mostrado expandido na listagem a seguir. Ele faz uso da função global
setWatch(<callback>, <pin>, [<options>]) do Espruino.
Listagem 12.13. Comando Puck.js, expandido
setWatch(
função () { 1
Bluetooth.println('CHIME'); 2 LED1.set(); 3
setTimeout(() => { 4
LED1.reset();
}, 250);
},
BTN, 5
{
repetir: verdadeiro, 6 debounce: 250, 7
borda: 'subindo' 8
}
);
1 O primeiro argumento para setWatch(): uma função de callback
2 Registra a string CHIME por Bluetooth; isso acionará um evento de dados
3 Acende o LED vermelho

UAU! e-book
www.wowebook.org
4 Desliga o LED vermelho novamente após 250 ms
5 O pino para assistir
6 Continua assistindo este pino repetidamente
7 Reduz o pino (botão) para 250 ms para evitar o acionamento várias vezes por pressionamento ou
interferência com pressionamentos anteriores
8 Triggers em uma borda ascendente - a transição de LOW para HIGH
O retorno de chamada registrado no Puck.js para pressionamentos de botão desconecta uma string via Bluetooth
e também acende o LED vermelho integrado brevemente como feedback visual.
Os dados são emitidos do Puck.js sempre que algo é emitido no Bluetooth. Isso acontece quando
Bluetooth.println('CHIME') é executado no callback do buttonwatching, mas nem tudo que vem do Puck.js será
um comando CHIME. Por exemplo, várias linhas de depuração e saída de versão são geradas (automaticamente)
logo após o estabelecimento de uma conexão. Essas linhas não são relevantes para sua lógica, então o
parseCommand(cmd) garante que você tenha uma correspondência real para a string CHIME.
Antes de alimentar os comandos em parseCommand(), porém, você deve analisar os “comandos” dos outros
dados recebidos. Os dados vêm em blocos, então cabe ao manipulador parseData() manter um buffer simples e
quebrar os dados da string recebida em linhas — delimitadas por caracteres \n (quebra de linha). Essas linhas
são passadas para parseCommand() para ver se elas representam, de fato, um comando válido — CHIME
sendo seu único comando válido. Consulte a listagem a seguir.
Listagem 12.14. Analisando dados de Puck.js
parseData (dados)
{ this.dataBuffer += dados;
var cmdEndIndex = this.dataBuffer.indexOf('\n');
while (~cmdEndIndex) { var cmd = this.dataBuffer.substr(0, cmdEndIndex).replace(/\W/g, '');
this.parseCommand(cmd);
this.dataBuffer = this.dataBuffer.substr(cmdEndIndex + 1);
cmdEndIndex = this.dataBuffer.indexOf('\n');
}
}
parseCommand (cmd) {
if (cmd.match('CHIME')) {
this.chime();
}
}
UAU! e-book
www.wowebook.org
1 1 é o único valor que produzirá 0 (falso) diante do operador NOT bit a bit (~).
2 Retira quaisquer caracteres não alfanuméricos caso um caractere de controle tenha

ficado amontoado
3 Passa esta linha para parseCommand() para ver se significa alguma coisa
4 Corta o comando atual da frente do buffer de dados e vê se há mais linhas
O método final na classe PuckChime é o próprio chime(). O som que era
instanciado no construtor é reproduzido (com play()) e uma classe — .ding — é adicionada ao

elemento body e, em seguida, removida após 500 ms, conforme mostrado na listagem
a seguir. A classe .ding cria um toque visual no navegador, alterando temporariamente a cor de
fundo da página inteira.
Listagem 12.15. O carrilhão em si
carrilhão () {
window.document.body.classList.add('ding');
this.sound.play();
window.setTimeout(() => {
window.document.body.classList.remove('ding'); }, 500);
Web Audio e a classe Sound
Sound é uma classe JavaScript que encapsula o carregamento e a reprodução do arquivo de

som na url passada para seu construtor. Ele usa a API de áudio da Web. Sua fonte é
reproduzida na listagem 12.16, você pode colocá-la no topo do arquivo PuckChime.js.
Como alternativa, você pode encontrar todo o código-fonte do PuckChime.js, incluindo a classe
Sound, no repositório GitHub do livro.
No mesmo diretório da fonte PuckChime.js hospedada, você também pode encontrar o arquivo
de som chime.mp3 - ou sinta-se à vontade para usar seu próprio arquivo de som (não se esqueça de
atualizar a instanciação Sound no construtor do PuckChime se você der um nome de arquivo diferente).
Listagem 12.16. A aula de som
classe Som {
constructor (url) { // Contexto no qual
fazer qualquer coisa relacionada ao áudio.

// É prefixado com `webkit` em alguns navegadores
const AudioContext = janela.AudioContext || window.webkitAudioContext; UAU! e-book www.wowebook.org
this.url = url;this.context = new
AudioContext();
this.buffer = nulo;
} /**
* Usando XMLHttpRequest, carregue o arquivo de áudio em this.url

* decodificar e armazená-lo neste.buffer
* @return Promessa resolvendo para this.buffer */
carregar () {
return new Promessa((resolver, rejeitar) => {
if (this.buffer) { resolve(this.buffer); }
var request = new window.XMLHttpRequest();
request.open('GET', this.url, true);
request.responseType = 'arraybuffer';
request.onload = () =>
{ this.context.decodeAudioData(request.response, soundBuffer => { this.buffer = soundBuffer;
resolve(this.buffer);
});
};
request.send();
});
}
/**
* Carregue um AudioBuffer e crie um AudioBufferSourceNode para reproduzi-lo.
* Conecte o AudioBufferSourceNode ao destino (saída)
*/
jogar () {
this.load().then(buffer => {
// Cria um novo AudioBufferSourceNode que pode reproduzir som de // um buffer (objeto AudioBuffer)
const source = this.context.createBufferSource();
source.buffer = buffer;
// Conecta o AudioBufferSourceNode ao destino
// (por exemplo, os alto-falantes do seu laptop)
source.connect(this.context.destination);
source.start(0);
});
}
}
A API de áudio da Web é poderosa e, correspondentemente, um pouco complicada. A documentação

da API de áudio da Web do MDN é abrangente: https://developer.mozilla.org/en
US/docs/Web/API/Web_Audio_API.
Experimentando a campainha
Para recapitular, o projeto de campainha Puck.js deve conter os seguintes arquivos:
UAU! e-book
www.wowebook.org
index.js — Um servidor web simples.
app/index.html—Inclui estilo e marcação para o grande botão Turn It On, bem como um manipulador
de evento de clique para o botão inicializar a campainha (objeto PuckChime).
Ele também inclui a biblioteca JavaScript cliente Puck.js para comunicação com Puck.js, bem como
PuckChime.js.
app/PuckChime.js—Inclui as classes Sound e PuckChime.
app/chime.mp3 (ou outro arquivo de som de sua escolha)—O som tocado quando a campainha é
pressionada.
Inicie o servidor web:
$ node index.js
Abra seu navegador para localhost:3000. Também pode ser útil abrir o console do Web
Inspector em seu navegador para ver quaisquer mensagens ou erros registrados. Ao clicar no botão
Ativar, você verá uma solicitação de emparelhamento pop-up (figura 12.23).
Figura 12.23. Clicar no botão Ativar solicitará o emparelhamento com Puck.js.
Após o emparelhamento, o processo de inicialização leva alguns segundos — você verá alguns
registros no console. Você saberá que está pronto e bem-sucedido se ouvir o som da campainha
tocar e ver a tela piscar rapidamente em rosa (figura 12.24).
Figura 12.24. Quando o botão do Puck.js é pressionado, o som da campainha toca e a

tela pisca em rosa choque - pode-se até chamar de pank, é tão brilhante - momentaneamente.
UAU! e-book
www.wowebook.org
12.5. ULTRAPASSANDO AS FRONTEIRAS DE JAVASCRIPT E HARDWARE
Este experimento de campainha BLE é uma boa ilustração de onde estão as fronteiras no mundo
dos dispositivos físicos e do JavaScript. O Puck.js executa o interpretador Espruino, que é quase, mas
não totalmente, JavaScript completo — otimizações estão em vigor para possibilitar a execução de
JavaScript em hardware tão restrito. Web Bluetooth funciona em alguns navegadores, mas existem
algumas deficiências. No momento em que escrevo, você precisa reparar a cada recarga de página, o
que é uma chatice. E você pode achar que ele é intermitentemente não confiável de maneiras
complicadas de depurar.
Mas o próprio fato de o Puck.js existir e de o Web Bluetooth ser implementado em alguns navegadores
é notável, e é um grande salto em relação a apenas 12 ou 18 meses atrás. A popularidade
contínua e o crescimento do plug-in I/O do JohnnyFive, que completou cinco anos em 2017, é uma
indicação de que o interesse nessas áreas por parte dos desenvolvedores de JavaScript continua
forte. Esse crescente interesse na fusão de JavaScript e outras tecnologias da Web com
dispositivos físicos também é refletido na explosão de opções Node.jscapable gerenciadas em nuvem
para hardware IoT, especialmente na classe SBC de dispositivos capazes de executar Linux.
Construir competência em hacking eletrônico não significa plantar uma bandeira profunda e
inflexivelmente. O JavaScript não precisa ser seu martelo, sua abordagem única dogmática.
Em vez disso, pode servir como um paradigma para exploração, uma lente familiar através da qual
se examina o desconhecido. O JavaScript pode realmente levá-lo até onde você precisa ir. Mas para
outros casos, uma mente aberta e curiosa é inestimável.
Portanto, encorajo você não apenas a continuar aprendendo por meio do JavaScript, mas também, à
medida que se sentir mais confortável, a explorar mais. Leia mais sobre como diferentes protocolos
seriais funcionam, aprofunde-se na manipulação bit a bit, aprenda a escrever firmware baseado em C. E
UAU! e-book
www.wowebook.org
embora seja falso dizer que C é fácil, é certamente acessível: muitos acharam a linguagem de
programação Arduino (que, falando de forma grosseira, é basicamente C++ com alguns recursos
extras de controle de hardware adicionados) uma porta de entrada útil para a proficiência em C++.
Funileiro. Construir. Pergunte. Leia sobre tecnologia. Quebre as coisas de propósito. Saiba que,
mesmo que esta seja sua primeira vez construindo circuitos e trabalhando com E/S física, você pode
descobrir como construir as coisas que você sonha. Feliz hacking!
RESUMO
Houve uma explosão de serviços baseados em nuvem para gerenciamento e implantação de

aplicativos IoT, muitos voltados para empresas. Muitos desses serviços direcionados a SBCs
compatíveis com Linux oferecem suporte para Node.js.
A conteinerização é uma abordagem que isola os aplicativos e suas dependências dos caprichos
das variações do ambiente e é uma escolha popular para implantação de aplicativos de IoT.
A Web Bluetooth API ainda não está nos padrões oficiais da web, mas existem
implementações em vários navegadores. Alguns de seus recursos ainda não foram resolvidos e
os modelos de segurança e permissões permanecem controversos.
O Espruino fornece uma pequena biblioteca JavaScript do lado do cliente que usa Web Bluetooth
para se comunicar com o Puck.js.
A API de sensor genérico e outras APIs de sensor baseadas nela, como a API de sensor de luz
ambiente, estão em seus primeiros dias de definição de padrões, mas estão em desenvolvimento
ativo.
Para participar da Web física, um dispositivo BLE pode anunciar uma URL usando o protocolo
Eddystone aberto. Usuários próximos com software de descoberta compatível podem navegar e
interagir com esses beacons.
UAU! e-book
www.wowebook.org
História
Índice
[SÍMBOLO][ A ][ B ][ C ][ D ][ E ][ F ][ G ][ H ][ I ][ J ][ K ][ L ][ M ][ N ][ O ][ P ][ Q ][ R ][
Tópicos
S ][ T ][ U ][ V ][ W ][ X ][ Y ]
Tutoriais
SÍMBOLO
# personagem
= personagem
Destaques
Oh símbolo
Configurações
>> e << operadores de deslocamento de bits
Apoiar
A
Classe de acelerômetro, JohnnyFive
Acelerômetros Sign Out , adicionando recursos de exibição shaketoswap com
sensores de adafruit
nd terceiro
ADC (conversor analógico-digital), 2 , 3
função ajusteTempo()
LED de alerta
altDisplay
variável de altitude
pinos sempre conectados
API do sensor de luz ambiente
horas de amp
Ampères (ampères)
entrada analógica
sensores analógicos
conversão analógico-digital
nd
fotoresistores, 2
frequência
escala
limite
UAU! e-book
www.wowebook.org
tensões em circuitos
processamento de entrada com JohnnyFive
usando sensores de temperatura analógicos
interagindo com componentes usando JohnnyFive REPL
Sensores de temperatura TMP36
circuitos divisores de tensão
AnalogFirmata
função analogRead
animando LEDs com PWM
Aula de animação, JohnnyFive
ânodo
retornos de chamada anônimos
Sensores de gesto APDS9660
combinando com RemoteSwitch
reunindo informações sobre
Apoio JohnnyFive para
definições de configuração
constantes
metas para plug-ins de sensores de gestos
prototipagem prova de conceito
trabalhando com
escrevendo plugins
para Kinoma Element
para plataformas
para Puck.js
para Raspberry Pi 3
formulários
construindo em Tessel
criando com resina.io
código de ajustes
plataforma arduino
configurando como cliente
controlando com JavaScript

UAU! e-book
www.wowebook.org
Assinado
método hostclient
JohnnyFive
linguagem de programação
fluxo de trabalho
Pinos digitais do Arduino Uno
conectando LED a pinos digitais
programação LED piscando
esboços com Arduino IDE
arduino uno
adaptação de estações meteorológicas para
criando circuitos com
pinos digitais
carregando Firmata para
Processador ARM Cortex M4
comunicação serial assíncrona
construção de circuitos GPS
série de software com placas de fuga de GPS
UARTs
Microcontrolador ATmega328P
Microcontrolador Atmel ATmega328P
B
força eletromotriz traseira
tensão de retorno, gerenciando com diodos flyback
largura de banda
Classe de barômetro, JohnnyFive
baterias
visão geral
alimentando LEDs com

ª
capacitando projetos com, 2
terminais de bateria
beacons, configurando o Puck.js como
Plataforma BeagleBone Black, provisionamento
não pare
nd
deslocamento de bits, 2
UAU! e-book
nd
www.wowebook.org
nd
BLE (Bluetooth Low Energy), 2
módulo ble_eddystone
Blend Microboard
nd
método piscar, 2
blinkCount
blinkMax
BLLs (Bibliotecas BlinkingLight)
Campainhas Bluetooth, baseadas na web
codificando a classe PuckChime
criando HTML
montando a estrutura do projeto
API de áudio da Web e classe de som
BMP180 multissensores
construção de circuitos para
Pico e
Módulo Espruino BMP085
implantação de código
testando
variável bmp180
Objeto Board.Fn
freqüência de placa.loop
Pranchas
Compatível com Arduino
desenvolvimento
Bocoup
compatível com breadboard
tábuas de pão
circuitos de prototipagem com
circuitos de LED de fiação
diagramas e esquemas de circuitos
circuitos de alimentação
Seleção de resistores para LEDs
circuitos série e paralelo
pinos de cabeçalho separatistas
UAU! e-book
www.wowebook.org
quadros de fuga
GPS, serial de software com
visão geral
método de brilho
navegadores
Classe Button, JohnnyFive
botões
como entradas digitais
Classes JohnnyFive Button
níveis lógicos
botões de fiação com resistores pulldown
conectando
circuitos em série em expansão com
testando
retornos de chamada
capacitores.
Consulte capacitores de desacoplamento.
capas
cátodo
função centro()
nd
função change(), 2
chassis
função checkIfSupported()
função chime.init()
nd terceiro
função carrilhão (), 2 , 3
sinos, adicionando sinos piezo audíveis aos temporizadores.
Veja também sinos visuais.
circuitos
prédio
divisores de corrente
circuitos em série em expansão com botões
para multissensores BMP180
para controlar motores com JohnnyFive
para controlar motores com interruptores de botão
UAU! e-book
www.wowebook.org
para Raspberry Pi 3
para robôs
para projetos de comutação
para temporizadores com LCD
Circuitos de LED no Raspberry Pi 3
LEDs em circuitos em série
circuitos paralelos
alimentando projetos com baterias
prototipagem de circuitos com breadboards
circuitos servo
fiação de circuitos de LED em breadboards
Criando com Arduino Uno
atual
lei de ohm
problemas com
diagramas de
alimentando
alimentando motores em
circuitos de proteção com capacitores de desacoplamento
resistência
sem solda
usando fotoacopladores para isolar

nd
tensões, 2 .
Veja também circuitos GPS; ; circuitos de motores; ; circuitos paralelos; ; circuitos em série; ;
curtos-circuitos; ; circuitos divisores de tensão.
método clear()
CLI (interface de linha de comando)
clientes
configurando arduino como
controlando com SBCs
fechar função
circuito fechado
serviços baseados em nuvem
nuvem, IoT e
CMOS (metalóxido semicondutor complementar)
bateria coincell
aulas de cobrança
UAU! e-book
www.wowebook.org
Mixin de coleção, controlando vários switches com
bússola
combinando com saídas LCD
construindo código multisensor
configurando declinações magnéticas

2
digital com magnetômetro IC
Aula de bússola, JohnnyFive
plug-ins de componentes
configurar função
configurando
APDS9960
arduino como cliente
Elemento Kinoma
declinações magnéticas
plataformas
nd
Puck.js, 2
Raspberry Pi 3
conectando a rede wi-fi
sem cabeça
gerenciando arquivos em
tradicional
atualização de software
atualizando o Node.js em
Tessel
conectando
conectando a rede wi-fi
encontrando
instalando a CLI
provisionamento
renomear
nd
método connect(), 2
nd
função console.log(), 2
constantes, para APDS9960
construtores, implementando
decodificação de dados de gesto
processamento de dados de gesto

UAU! e-book
www.wowebook.org
lendo dados do sensor
eletrônicos de consumo, hacking
potenciômetros de controle de contraste, fiação
conversão de analógico para digital
atual
lei de ohm
problemas com
evitando curtos circuitos
evitando muita corrente
divisores de corrente
limitadores de corrente
resistor limitador de corrente
cortar fios
DAC (conversão digital para analógico)
serviço céu escuro
evento de dados
troca de dados
pinos de dados
Conector DC (corrente contínua)
adaptador DC
interface de depuração, JTAG
declinações, magnético
desacoplamento de capacitores, proteção de circuitos com
função padrão
você valoriza
objeto de dependências
trança de dessoldagem
nd terceiro
placas de desenvolvimento, 2 , 3
Grupo de Trabalho de Dispositivos e Sensores, W3C
Registro DEVICE_ID, APDS9660
diagramas
de circuitos
UAU! e-book
www.wowebook.org
de hardware, para Kinoma Element
de pinagem
pesquisa para plataformas
para Kinoma Element
dados digitais
comunicação paralela de
comunicação serial de
entradas digitais
usando botões como
Classes JohnnyFive Button
níveis lógicos
botões de fiação com resistores pulldown
pinos digitais
conectando LED a
no arduino uno
nd
função digitalWrite, 2
LEDs de escurecimento
diodos
flyback, gerenciando a tensão de retorno com
visão geral
desmontagem de unidades de controle remoto
imagens de disco, criando
para BeagleBone Black
para Raspberry Pi 3
exibe
monitores LCD paralelos
adicionando sinos de LED visuais
fazendo temporizadores cheios de recursos com LCDs
atualizando para mostrar temperatura e pressão
Contêineres de aplicativos Docker, definindo
Dockerfile.template
nd
botão para baixo, 2
pino de drenagem, MOSFET

nd
função de desenho, 2
UAU! e-book
E www.wowebook.org
E
Função E.getTemperature()
facilita a função
funções facilitadoras
erro de BUSY
nd
protocolo Eddystone, 2
EEPROM (ROM programável apagável eletricamente)
fluxo elétrico
pressão elétrica
eletroímã
componentes eletrônicos
sistemas embarcados
PT (ativar) pino
habilitar conexões, no driver do motor SN754410

nd
ativar método, 2
invólucros
Espruino API
Espruino Graphics library
Módulo Espruino PCD8544
Plataforma Espruino Pico
LEDs piscando com
configurando
aplicativo gravador
interface eth0
função eval()
cabeçalhos de expansão
Expressar
Fading, LEDs com PWM
farads
FETs (transistores de efeito de campo)
arquivos, gerenciando no Raspberry Pi 3

nd
Protocolo assinado, 2
firmware
protocolos de firmware
UAU! e-book
www.wowebook.org
memória flash
flexbox
função flip()
flutuando
diodos flyback, gerenciando a tensão de retorno com
atual para a frente
tensão direta
nd terceiro
queda de tensão direta, 2 , 3
tipos de quadro
quadros
parâmetro de frequência
frequência, ajustando
software fritzing
módulo fs
tábua de ensaio de tamanho normal
pino do portão, MOSFET
GATT (Perfil de atributo genérico)
registro GCONF
redução de marcha
pino de entrada/saída de uso geral.
Veja GPIO.
API de sensor genérico
genuíno
dados de gesto
decodificação
em processamento
sensores de gesto
integrando
combinando APDS9960 e RemoteSwitch
controlando vários switches com Collection
orquestrando vários switches
plug-ins.
Consulte também sensores de gesto APDS9660.
UAU! e-book
www.wowebook.org
função getHeight()
método getPressure
método getSeaLevel
função getWidthIO
Registro GFLVL (nível FIFO de gesto)
Repositórios Git
enviar arquivos de projeto para
inicializando
GoButton
Pino GPIO (entrada/saída de uso geral)
características do Puck.js
Características do Raspberry Pi 3
Placas de fuga de GPS, serial de software com
circuitos GPS, edifício
Biblioteca gráfica, Espruino
registro GSTATUS
H
Drivers Hbridge, controlando motores com
hackear eletrônicos de consumo
tábua de pão de meio tamanho
hardware
JavaScript e
Elemento Kinoma, diagramas de
prototipagem
kits de ferramentas
placas de desenvolvimento
componentes eletrônicos
componentes de entrada
poder
ferramentas
escrever software para
implementando construtores
implementando métodos de inicialização
UAU! e-book
www.wowebook.org
integração de sensores de gesto
integrando interruptores remotos
Suporte JohnnyFive para sensores de gesto APDS9660
Chip Honeywell HMC5883L
fios de conexão
nd
método hostclient, 2
configurações hostclient, sem fio
host, usando Raspberry Pi 3 como
Tutorial de como usar um multímetro, SparkFun
HTML (linguagem de marcação de hipertexto)
EU
camadas de E/S
nd
pinos de E/S, 2
plug-ins de E/S
2
CI (Circuito InterIntegrado)
método i2cRead
Método i2cReadOnce
CI (circuito integrado) chips
IDE (ambiente de desenvolvimento integrado)

nd terceiro
função init(), 2 , 3
métodos de inicialização, implementando
processamento de dados de gesto
lendo dados do sensor
entradas
combinando com saídas de LED
componentes
processamento de sensores analógicos com JohnnyFive
Classes de sensores
eventos de dados do sensor.
Consulte as entradas digitais.
instalando
Estrutura JohnnyFive Node.js
Tessel CLI
sinais invertidos
UAU! e-book
www.wowebook.org
opção inverterPWM
propriedade da opção io
IoT (Internet das Coisas), nuvem e
Scanner IP
propriedade isActive
circuitos de isolamento com fotoacopladores
propriedade isOn
linguagem JavaScript
combinações com hardware
controlando arduino com
configurando arduino como cliente
Assinado
método hostclient
JohnnyFive nd
incorporado, 2
Plataforma Espruino Pico
LEDs piscando com
configurando
experimentando com Kinoma Element
Referência da API
configuração
características principais de
exemplos e tutoriais
gerenciamento
diagramas de pinagem e hardware
fluxo de trabalho
experimentando com o Pico
BMP180 multissensores e
construindo dispositivos meteorológicos eficientes em termos de energia
Nokia 5110 LCD e
hardware e
Elemento Kinoma
novas plataformas
UAU! e-book
www.wowebook.org
configuração de
exemplos e tutoriais
diagramas de pinagem
documentação da API de referência
fluxo de trabalho
pico
rodando em SBCs
usando com hardware
Plataforma JohnnyFive
adaptando mini estação meteorológica
para arduino uno
para Raspberry Pi 3
LEDs piscando com
Classes de botão
controlar LCDs com
controle de motores com
usando transistores como interruptores
controlando interruptores remotos com plugins de componentes
prototipagem de projetos de switch
escrevendo plug-ins RemoteSwitch
controlando servos com
construindo circuitos servo
instalando o framework Node.js
processamento de entrada de sensores analógicos
plug-in raspiio I/O com
leitura de dados de GPS com
REPL (loop de readevaluateprint)
eventos de dados do sensor em
Configurando projetos Tessel
estruturação de roteiros com
suporte para sensores de gesto APDS9660
definições de configuração
constantes
reunindo informações sobre APDS9960
metas para plug-ins de sensores de gestos

UAU! e-book
www.wowebook.org
prototipagem prova de conceito
escrevendo plug-ins APDS9960
testar motores com
usando classes de sensores
interface de depuração JTAG

nd
fios jumper, 2
quadros-chave
pacote de pressionamento de tecla
Plataforma Kinoma Element
Referência da API
configurando
exemplos de
diagramas de hardware
gerenciando
diagramas de pinagem
tutoriais
fluxo de trabalho
nd
KVL (lei de voltagem de Kirchoff), 2
eu
Scanner LAN
função lcd.clear()
LCDs
combinando bússola com saídas
completando conexões
conectando
controlando com JohnnyFive
fazendo temporizadores cheios de recursos com
lógica do temporizador de programação
monitores paralelos
UAU! e-book
www.wowebook.org
LDR (resistor dependente de luz)
nd terceiro
Aula liderada, JohnnyFive, 2 , 3
Função LED.reset()
Função LED.set()
Método led.stop
LEDs (diodos emissores de luz)
animando com PWM
piscando
programando para piscar
com Espruino Pico
com JohnnyFive, 2º
com sysfs
com Tessel
construindo circuitos no Raspberry Pi 3
construindo bolas meteorológicas
combinando entrada com saída de LED
conectando a pinos digitais
controlando a partir de páginas da web
criando lógica de alternância de LED
criando circuitos
Fading com PWM
em circuitos paralelos
em circuitos em série
alimentando com baterias
LEDs RGB
sinos visuais, adicionando
fiação de circuitos de 3,3 V
circuitos de fiação em breadboards
diagramas e esquemas de circuitos
circuitos de alimentação
Seleção de resistores para LEDs
circuitos série e paralelo
escrevendo código piscando
mudança de nível
Classe leve, JohnnyFive
resistor dependente de luz

UAU! e-book
www.wowebook.org
Baterias LiPo (polímero de lítio)
carga, circuito
lógica
conexões lógicas, no driver do motor SN754410
controlando a direção do motor
controlando a velocidade do motor
tensão de nível lógico
seção de loop
LTS (Suporte de Longo Prazo)
declinações magnéticas, configurando
magnetômetros, fazendo bússola digital com
mAh (miliamperes horas)
Mapear unidade de rede, Windows
MCUs (microcontroladores)
guia de metal, MOSFET
animação metronômica
microcontrolador
mensagens MIDI
dispositivos móveis, permitindo a descoberta da Web física em
escudos modulares
módulos
nd
interruptores momentâneos, 2
MOSFETs (transistores de efeito de campo de semicondutores de metalóxido)
circuitos motores, completando

nd
Classe motora, JohnnyFive, 2
fonte de energia do motor
arquivo motortest.js
motores
direção de controle de
robôs de controle
completando circuitos motores
robôs de condução
acabamento da construção do chassi
SN754410 permite conexões
UAU! e-book
www.wowebook.org
SN754410 conexões de energia
Testando motores com JohnnyFive
escrevendo software de robô
velocidade de controle de
controlando com drivers Hbridge
usando transistores como interruptores
controlando com interruptores de botão
alimentando motores em circuitos
visão geral
alimentando
robôs e
Aula de motores, JohnnyFive
Mozilla Developer Network
ferramenta multímetro
banda multiplicadora
multissensores, adicionando aos dispositivos
Transistores do tipo Nchannel
pacote nanotimer
terminal negativo
Netduino
NMEA (Associação Nacional de Eletrônica Marítima)
Node.js
LEDs piscando com, no Raspberry Pi 3
instalando o framework JohnnyFive
atualizando no Raspberry Pi 3
Fórum da Comunidade NodeBots
Repositório de distribuições binárias NodeSource
margem de ruído
LCD Nokia 5110
UAU! e-book
www.wowebook.org
fazer temporizadores visuais de contagem regressiva com
Pico e
ligação ao Pico
Módulos Espruino PCD8544
motor não direcional
NOOBS (Novo Software OutofBox)
comando de inicialização npm
comando npm init sim
comando de instalação npm
npm start scripts, adicionando
valores numéricos
lei de ohm
ohms
ON luzes LED
função onLaunch()
função onQuit()
circuito aberto
OpenWrtName
optoisoladores
optoacopladores
saídas
construção de robôs
base do chassi
controlando motores de robôs
robôs e motores
componentes
LCD, combinando bússola com
LEDs
animando com PWM
construindo bolas meteorológicas
combinando entrada com saída de LED
Fading com PWM
LEDs RGB
fazendo barulho com piezos
motores
UAU! e-book
www.wowebook.org
controlando com interruptores de botão
visão geral
servos
P
package.json, atualizando dependências
embalagem
nd terceiro
circuitos paralelos, 2 , 3
comunicação paralela
interface paralela
controlando LCDs com JohnnyFive
função parseCommand()
método parseData()
PCB (placa de circuito impresso)
pcDuino
fotocélula
fotocondutor
fotoacopladores, usando para isolar circuitos
fotorresistor.valor
nd
fotoresistores, 2
frequência de ajuste
escala de ajuste
limite de ajuste
processamento de entrada de sensor analógico com JohnnyFive
Classes de sensores
eventos de dados do sensor
tensões em circuitos
produção física
UAU! e-book
nd
www.wowebook.org
nd
Web física, 2
Puck.js e
configurando Puck.js como beacon
protocolo Eddystone
permitindo a descoberta da Web física em dispositivos móveis
bico, spruin
BMP180 multissensores e
construindo circuitos BMP180
construindo dispositivos meteorológicos eficientes com o Pico
Nokia 5110 LCD e
ligação ao Pico
Módulos Espruino PCD8544
fazer temporizadores visuais de contagem regressiva com
Classe Piezo, JohnnyFive
efeito piezoelétrico
piezos
fazendo barulho com
tocando músicas
nd
função pinMode(), 2
pinagem
diagramas
pesquisa para plataformas
do Elemento Kinoma
em Puck.js
em Raspberry Pi 3
alfinetes
alta impedância de
microcomputadores
visão geral.
Veja também pinos digitais.
Função Pins.configure()
PIXEL (ambiente Xwindows melhorado Pi, leve)
plataformas
descobrindo os principais recursos de

UAU! e-book
www.wowebook.org
encontrar exemplos e tutoriais
encontrar diagramas de pinagem para
aprendendo sobre configuração de
aprendendo sobre o fluxo de trabalho
usando a documentação da API de referência
plugins
Noções básicas de estrutura de componentes
codificação
para componentes JohnnyFive
sensores de gesto
escrevendo para APDS9960
símbolo de polaridade
Terminal positivo
energia potencial
potenciômetros, controle de contraste

nd
poder, 2
circuitos
no driver do motor SN754410
trilhos de força
pressão, atualizando telas para mostrar
função process.exit()
método processGesture
em processamento
página do produto, SparkFun
memória de programa, microcontrolador
prova de conceito, prototipagem
prototipagem
circuitos com breadboards
hardware
prova de conceito
Programas
mudar de projeto
placas de prototipagem
Função puck.connect()
Puck.js, Espruino
UAU! e-book
www.wowebook.org
configuração de
controlando LEDs de páginas da web
recursos GPIO
Web física e
configurando Puck.js como beacon
protocolo Eddystone
permitindo a descoberta da Web física em dispositivos móveis
pinagens
tutoriais
campainhas Bluetooth baseadas na web
codificando a classe PuckChime
criando ouvintes de evento
criando HTML
API de áudio da Web e classe de som
fluxo de trabalho
nd
Função Puck.light(), 2
Função puck.write()
Classe PuckChime, codificação
resistores pulldown, botões de fiação com
implementações push, em Tessel
interruptores de botão, controlando motores com
alimentando motores em circuitos

nd terceiro
PWM (modulação por largura de pulso), 2 , 3
LEDs de animação com
LEDs de desbotamento com
Q
fila
Raspberry Pi
UAU! e-book
nd
www.wowebook.org
nd
Plataforma Raspberry Pi 3, 2
adaptação de estações meteorológicas para
construindo circuitos
fazendo alterações Pispecíficas
testando BMP180
configuração
gerenciando arquivos no Pi
atualização do software Pi
atualizando o Node.js no Pi
recursos GPIO
chapéus
configuração sem cabeça
Configurando WiFi no Pi
criando imagem de disco Raspbian inicializável
kit
pinagens
configuração tradicional
tutoriais
LED piscando com sysfs
construção de circuitos de LED
JohnnyFive com o plug-in raspiio I/O
WiringPi
usando como host
plug-in raspiio I/O, JohnnyFive com
função de leitura
readavaliar loop de impressão.
Consulte REPL (loop readevaluateprint).
lerGesto
nd
evento pronto, 2
comando de reinicialização
refatorando index.js para usar RemoteSwitch
unidades de controle remoto
adicionando em circuitos
desmontando
interruptores remotos, integrando

UAU! e-book
www.wowebook.org
combinando APDS9960 e RemoteSwitch
controlando vários switches com Collection
orquestrando vários switches
Remotos
Componente RemoteSwitch
combinando com APDS9660
refatorando index.js para usar
escrevendo plugins
retornos de chamada
plugins de codificação
fundamentos da estrutura do plug-in de componente
fila
refatorando index.js para usar RemoteSwitch
módulo RemoteSwitch
renomeando tessel
REPL (loop readevaluateprint), em JohnnyFive
interagindo com componentes usando
solicitar pacote
nd
exigir declaração, 2
função require()
botão de reset
método reset()
resina.io
adaptando software de aplicativo de clima
adicionando scripts de início npm
comprometendo e empurrando
definindo contêineres de aplicativos do Docker
inicializando o repositório Git
URLs públicos para aplicativos
ajustando o código do aplicativo
criando aplicativos
provisionamento BeagleBone Black
resistência
lei de ohm
nd
visão geral, 2
resistores
UAU! e-book
www.wowebook.org
pulldown, botões de fiação com
Raspberry Pi 3
efeito piezoelétrico reverso
diodo reversamente polarizado
interruptores de saída controlados por RF, modificando
adicionando aos circuitos de controle remoto
desmontagem de unidades de controle remoto
usando fotoacopladores para isolar circuitos
LEDs RGB
robôs
alimentado por bateria com Tessel
construindo circuitos de robôs
alimentando motores
atualizando o código rover
base do chassi de construção de
controle de motores de
completando circuitos motores
robôs de condução
acabamento da construção do chassi
SN754410 permite conexões
SN754410 conexões de energia
Testando motores com JohnnyFive
com motoristas Hbridge
escrevendo software de robô
motores e
RoHS (Diretiva de Restrição de Substâncias Perigosas)
rovers, atualizando o código
Pino RS (seleção de registro)
RX (receber)
S
satélites
salvar bandeira
função salvar()
nd
SBCs (computadores de placa única), 2
controlar clientes com
UAU! e-book
www.wowebook.org
Raspberry Pi 3
configuração sem cabeça
kit
configuração tradicional
escala, ajustando
esquemas
prefixo do esquema
campo de scripts
scripts, estruturando com JohnnyFive
enviar (cmd) método

nd
Classe de sensor, JohnnyFive, 2
sensores
eventos de dados em JohnnyFive
leitura de dados.
Veja também sensores analógicos; ; sensores de temperatura.
comunicação em série
assíncrono
construção de circuitos GPS
série de software com placas de fuga de GPS
UARTs
noções básicas de
de dados digitais
shaketochange widgets multissensor
adicionando multissensores a dispositivos
adicionando recursos de exibição shaketoswap com acelerômetros
combinando bússola com saídas LCD
atualizando telas para mostrar temperatura e pressão
síncrono
2
eu C
2
fazendo bússola digital com magnetômetro IC
SPI
dados seriais
Interface Periférica Serial.
Consulte SPI (Interface Periférica Serial).
circuitos em série
expandindo com botões
LEDs em
UAU! e-book
www.wowebook.org
função server.listen()
Classe servo, JohnnyFive
servos, controlando com JohnnyFive
construindo circuitos servo
método setContrast()
nd
setInterval, 2
nd
função setTimeout, 2
método de configuração
seção de configuração
nd
função setWatch(), 2
Chassis de sombra, SparkFun
shaketochange widgets multissensor
adicionando multissensores a dispositivos
adicionando recursos de exibição shaketoswap com acelerômetros
combinando bússola com saídas LCD
atualizando telas para mostrar temperatura e pressão
recursos de exibição shaketoswap, adicionando com acelerômetros
escudos
curtos-circuitos, evitando
função showRemaining()
computadores de placa única.
Consulte SBCs (computadores de placa única).
caderno de desenho
esboços
Arduino IDE com
carregando para piscar
SMI (Interface de Memória Secundária)
Motorista SN754410
habilitar conexões
conexões lógicas
controlando a direção do motor
controlando a velocidade do motor
conexões de energia
diodo de amortecimento
UAU! e-book
www.wowebook.org
Socket.IO, exibindo dados ao vivo com
Programas
prototipagem
escrevendo para robôs
escrevendo para hardware sofisticado
implementando construtores
implementando métodos de inicialização
integração de sensores de gesto
integrando interruptores remotos
Suporte JohnnyFive para sensores de gesto APDS9660
página de software, Arduino
série de software, com placas de fuga de GPS
pavio de solda
juntas soldadas
de solda
kits de montagem
guia passo a passo para
ferro de solda
circuitos sem solda
Classe de som, Web Audio API e
pino fonte, MOSFET
velocidade, de motores
SPI (Interface Periférica Serial)
PadrãoFirmataPlus
nd
função start(), 2
servidores web estáticos, configurados em Tessel
função stop()
descascando fios
componentes de montagem em superfície
comuta
controlando com Coleção
orquestrando
projetos de prototipagem
hardware de prototipagem
software de prototipagem
UAU! e-book
www.wowebook.org
remoto, controlando com plug-ins de componente JohnnyFive
interruptores de saída controlados por RF, modificando
usando transistores como.
Consulte também botões de pressão.
comunicação serial síncrona

2
eu C
2
fazendo bússola digital com magnetômetro IC
SPI
sysfs, LEDs piscando com
TCobbler, Adafruit
comando de apagar t2
comando de lista t2
nd
comando push t2, 2
comando de execução t2
comando de atualização t2
comando de versão t2
sensores de temperatura, analógicos
interagindo com componentes usando JohnnyFive REPL
temperatura, atualizando telas para mostrar
linhas terminais
nd
Tessel 2 plataforma, 2
robôs movidos a bateria com
construindo circuitos de robôs
alimentando motores
atualizando o código rover
LEDs externos piscando com
Configurando projetos JohnnyFive Tessel
fiação de circuitos de LED de 3,3 V
escrevendo código de LED piscando
leds piscando
construindo aplicativos em
capacidades de
configurando
conectando Tessel
UAU! e-book
www.wowebook.org
conectando Tessel à rede WiFi
encontrando Tessel
instalando a CLI
provisionamento Tessel
renomeando tessel
explorando pinos
implantações push
configurando
configurar servidores web estáticos
implantação push t2
atualizando
usando Socket.IO
módulo tesselcli npm
pacote tesselio
testando
BMP180 multissensores
botões
motores com JohnnyFive

nd terceiro
Aula de termômetro, JohnnyFive, 2 , 3
ferramenta de terceira mão
limite, ajustando
componentes de passagem
Tutorial de soldagem throughhole, SparkFun
função tick()
arquivo timeradvanced.js
temporizadores
adicionando sinos piezo audíveis para
tocando músicas em piezos
contagem regressiva, visual
fazendo com LCDs
controlando LCDs com JohnnyFive
acreditar
minúsculos computadores.
Consulte SBCs (computadores de placa única). UAU! e-book

www.wowebook.org
alternar método
faixa de tolerância
ferramentas
nd
transdutores, 2
transistores, usando interruptores como
TTL (lógica transistortransistor)
Botão Ligar
função desligar()
função ativar()
tutoriais
encontrando
para a plataforma Kinoma Element
para Puck.js
interpolação
TX (transmitir)
EM
UARTs (receptores/transmissores assíncronos universais)

nd
botão para cima, 2
função atualizar dados
atualizando
index.js
dependências package.json
Programa Raspberry Pi 3
código rover
Tessel
atualizando o Node.js no Raspberry Pi 3
Enviando
esboços de piscar
Assinado no Arduino Uno
URL, público
USBs, como fontes de energia
EM
UAU! e-book
www.wowebook.org
Botão de verificação
saída virtual
sinos visuais, LEDs
tensão
em circuitos
lei de ohm
circuitos divisores de tensão

nd
reguladores de tensão, 2
EM
Waldron, Rick
método watchButton()
software de aplicativo meteorológico, adaptando
adicionando scripts de início npm
comprometendo e empurrando
definindo contêineres de aplicativos do Docker
inicializando o repositório Git
URLs públicos para aplicativos
ajustando o código do aplicativo
dispositivos meteorológicos, construindo com o Pico
estações meteorológicas
adaptando para arduino uno
adaptando para Raspberry Pi 3
fazendo alterações Pispecíficas
testando BMP180
API de áudio da Web, classe de som e
API Web Bluetooth
páginas da web, controlando LEDs de
campainhas Bluetooth baseadas na web
rodas
redes wi-fi
UAU! e-book
www.wowebook.org
Configurando no Raspberry Pi 3
conectando Tessel a
bobinas de fio
sem fio, configurações de hostclient
fios
projetos sem fio
troca de dados
camadas de E/S
plug-ins de E/S
opções de comunicação
controlando clientes com SBCs
JavaScript embutido
configurações de hostclient sem fio
alimentando projetos com baterias
Tessel
exibindo dados ao vivo com Socket.IO
implantações push
configurando
configurar servidores web estáticos
USBs como fontes de energia
usando Tessel 2
fiação
botões com resistores pulldown
potenciômetros de controle de contraste
diagrama de fiação
WiringPi
interface wlan0
fluxo de trabalho
em plataformas
Elemento Kinoma
de arduino
Pinos digitais do Arduino Uno
conectando LED a pinos digitais
LED de programação para piscar
esboços com Arduino IDE
Puck.js
UAU! e-book
www.wowebook.org
método write()
XIP (executar no local)
Operador XOR (OR exclusivo)
e bandeira
UAU! e-book
www.wowebook.org
Lista de Figuras
Figura 1.1. Oh, as coisas mágicas em nosso mundo!
Figura 1.2. O sistema de ventilação automática precisa receber entrada de um sensor de temperatura e
gerenciar a saída de um ventilador motorizado.
Figura 1.3. O ventilador automático precisa de um cérebro. Uma opção popular é um microcontrolador, que
combina processador, memória e recursos de E/S em um único pacote.
Figura 1.4. Um desenho esquemático aproximado mostrando como as entradas, saídas e o
microcontrolador do ventilador estão conectados em um sistema com alimentação e circuitos. Não se estresse se o
os símbolos são novos para você - você aprenderá sobre circuitos à medida que continuamos nossa jornada.
Figura 1.5. Placas de desenvolvimento baseadas em microcontroladores tornam mais conveniente a conexão
dispositivos de entrada e saída.
Figura 1.6. Uma placa de ensaio fornece uma grade conectada eletricamente na qual prototipar
Circuitos eletrônicos.
Figura 1.7. Memória de programa não volátil (EEPROM e Flash) e placas de fácil utilização
tornaram mais fácil programar microcontroladores com firmware.
Figura 1.8. O ventilador automático completo e embalado é um exemplo de sistema embutido.
As entradas e saídas são processadas por um microcomputador baseado em microcontrolador e suportadas
por energia e circuitos. E a coisa toda está escondida dentro de uma caixa bem chique, porque,
por que não?
Figura 1.9. O método hostclient de controlar hardware com JavaScript
Figura 1.10. Para que o computador host e o hardware cliente se comuniquem neste método, eles
ambos precisam usar uma API comum.
Figura 1.11. Firmware específico converte o microcontrolador em um cliente.

UAU! e-book
www.wowebook.org
Figura 1.12. O host também precisa se comunicar usando a API comum.
Figura 1.13. À medida que o host executa a lógica do JavaScript, as instruções e os dados são
continuamente trocados entre cliente e host, usando uma API comum.
Figura 1.14. A plataforma Espruino combina pequenas placas de hardware com um IDE
ambiente de desenvolvimento.
Figura 1.15. O Tessel 2 é uma plataforma open source que roda Node.js nativamente.
Figura 1.16. Vários computadores de placa única (SBCs): Intel Galileo, Gen 2 (superior), Raspberry
Pi 2 Modelo B (canto inferior esquerdo) e Raspberry Pi Zero (canto inferior direito)
Figura 1.17. O serviço Resin.io ajuda a agilizar a implantação de aplicativos e
gerenciamento de SBCs compatíveis com Linux.
Figura 1.18. Neste exemplo de aplicação da Web física, um sinal de parada de ônibus usa um BLE
beacon para transmitir um URL uma vez por segundo (1); um humano nas proximidades pode procurar
beacons disponíveis em seu dispositivo e selecionar aquele correspondente ao ponto de ônibus (2); o dispositivo do
motorista de ônibus agora pode buscar a URL transmitida pelo beacon e exibi-la no
navegador (3).
Figura 1.19. Algumas placas de desenvolvimento típicas baseadas em microcontroladores, no sentido horário de cima
à esquerda: um Tiva CSeries LaunchPad da Texas Instruments, um Arduino Uno R3, um Adafruit
Trinket (modelo 5V) e um fóton de partícula
Figura 1.20. Esta placa Arduino Uno é alimentada pelo AVR ATmega 328P, um processador de 8 bits
microcontrolador.
Figura 1.21. Uma variedade de componentes comuns de entrada e saída
Figura 1.22. Componentes comuns como esses irão ajudá-lo a construir componentes eletrônicos funcionais
circuitos.
Figura 1.23. Uma amostra de fios e acessórios para alimentação e circuitos
Figura 1.24. Esta caixa de equipamento compacta tem espaço na parte superior para ferramentas e armazenamento para
componentes em empilhamento, recipientes removíveis.
Figura 2.1. O Arduino Uno é a placa mais popular do Arduino e a que seremos
UAU! e-book
www.wowebook.org
explorar ao longo dos próximos capítulos.
Figura 2.2. Partes principais de um Arduino Uno
Figura 2.3. O LED ON acende sempre que o Uno tem energia.
Figura 2.4. Alguns dos pinos de alimentação do Arduino Uno. Estes são alimentados sempre que a placa
é alimentado.
Figura 2.5. Os LEDs padrão têm um ânodo (terminal positivo) e um cátodo (terminal negativo
terminal). Normalmente, o ânodo é mais longo que o cátodo, facilitando a identificação.
Muitos LEDs também têm um ponto plano no lado negativo (cátodo).
Figura 2.6. Iluminando um LED com um Uno. Conectando a energia (3,3 V) ao terra (GND)
com o LED completa o circuito, removendo quaisquer lacunas e permitindo que os elétrons fluam
através.
Figura 2.7. Um diagrama do circuito básico de LED. Na forma convencional de representar
circuitos, a energia flui do positivo para o negativo. A energia flui para a extremidade do ânodo (positivo)
do LED e fora do cátodo (negativo).
Figura 2.8. Pinos digitais do Arduino Uno
Figura 2.9. Na primeira vez que você iniciar o Arduino IDE, ele criará um novo esboço vazio
para você.
Figura 2.10. É difícil para seus LEDs conectá-los diretamente a um pino de E/S digital Uno de 5V.
Figura 2.11. O minúsculo LED de montagem em superfície ao lado do pino 13 acende (laranja) sempre que o pino 13
está definido como ALTO.
Figura 2.12. Janela de esboço dentro do Arduino IDE
Figura 2.13. O esboço carregado deve fazer o LED integrado piscar a cada 500 ms.
Figura 2.14. A primeira etapa para definir a configuração do hostclient com o Uno é carregar um esboço Firmata que
permitirá que a placa se comunique usando o protocolo Firmata.
Figura 2.15. Selecionando StandardFirmataPlus a partir de esboços de exemplo disponíveis
Figura 2.16. Quando o script do host está em execução, o TX e o RX do Uno (transmitem e
receber) Os LEDs piscarão enquanto a comunicação é trocada entre o host e o cliente.
UAU! e-book
www.wowebook.org
Figura 3.1. Penhascos mais altos fornecem mais “tensão”, ou seja, potencial elétrico. Tensão é como
“pressão” elétrica, empurrando as cargas (água-viva) de alto potencial de energia para um local de menor potencial.
Figura 3.2. Tensão é energia potencial.
Figura 3.3. A corrente, o fluxo de eletricidade, pode ser medida contando quantas cargas
(água-viva) passam por um ponto específico em um penhasco durante um período de tempo definido.
Recomendado
Figura 3.4. Os habitantes da cidade adicionam resistência ao circuito canalizando águas-vivas que caem
através de uma série de tubos. O aumento da resistência reduz a corrente.

Figura 3.5. Um “circuito” completo de gnomeandjellyfish

História
Figura 3.6. O novo cookie de assinatura dos habitantes da cidade mostra a relação entre
Tópicostensão (V), corrente (I) e resistência (R).
Figura 3.7. Mordendo a borda do biscoito impresso com o fator, o cookieeater Tutoriais
quer descobrir, eles podem ver rapidamente a equação que precisam resolver. Por exemplo, se
Ofertas eeles querem

promoções determinar a resistência (R), eles podem morder e ver que R = tensão (V)
dividido pela corrente (I).
Destaques
Figura 3.8. Um problema comum da lei de Ohm do mundo real: qual valor do resistor é necessário para
Configurações fornecer um LED com 20 mA de corrente em um circuito com uma tensão de alimentação de 6 V?
suporteFigura 3.9. Um curto-circuito não tem carga para moderar a corrente. Uma ilustração comum de um curto-circuito de
é passar um fio diretamente do terminal positivo para o negativo de uma bateria
Sair (não
faça isso na vida real).
Figura 3.10. Uma breadboard típica e as conexões dentro dela
Figura 3.11. Esquema do circuito de LED simples. Os esquemas são concisos e padronizados
representações de circuitos, mas não mostram como posicionar componentes em
espaço.
Figura 3.12. Diagrama de fiação do circuito de LED simples, mostrando um layout físico específico
para implementar o circuito a partir de seu esquema. Este diagrama foi criado no código aberto
Fritzing aplicativo de desktop.
Figura 3.13. Um circuito em série tem apenas um caminho possível para as cargas (água-viva) fluirem UAU! e-
book
www.wowebook.org
completamente - não há ramos. A corrente é a mesma em qualquer ponto de um circuito em série,
o que significa que os pontos 1, 2, 3 e 4 têm corrente igual.
Figura 3 14 Valores do resistor somados em um circuito em série
Figura 3.15. Os pinos em lados opostos do botão estão sempre conectados eletricamente, enquanto os pinos
que compartilham um único lado são conectados apenas quando o botão é pressionado.
Figura 3.16. Um botão de pressão conectado a uma breadboard, abrangendo o entalhe central. Quando não
pressionado, os pares de pinos na parte superior e inferior do botão são conectados eletricamente
(horizontalmente). Quando pressionados e mantidos, os pares de pinos nos lados esquerdo e direito do
botão estão conectados eletricamente (verticalmente).
Figura 3.17. Esquema do circuito atualizado, integrando um botão de pressão
Figura 3.18. Diagrama de fiação do circuito de LED adaptado com um botão de pressão
Figura 3.19. À medida que a eletricidade passa por um LED, alguma voltagem é usada ou diminuída. O
quantidade de tensão usada é chamada de tensão direta do LED. Ele varia entre cerca de 1,8 V
e 3,5 V, dependendo da cor do LED - quanto maior a frequência do emissor
luz, maior a queda de tensão.
Figura 3.20. Voltando à analogia da voltagem como inclinação ou altura do penhasco, o
O mesmo circuito de LEDs em série pode ser visto de uma perspectiva diferente. À medida que a corrente
da água-viva passa pelo LED, 1,8 V é “consumido”, reduzindo a tensão restante para 3,2 V
(reduzindo a inclinação). Esses 3,2 V são então usados pelo resistor limitador de corrente. Quando
a água-viva atinge o ponto de menor potencial elétrico, toda a tensão no circuito foi
sido contabilizado.
Figura 3.21. Cada um dos dois LEDs diminui um pouco da tensão no circuito e, novamente, o
tensão restante é derrubada pelo resistor.
Figura 3.22. Os dois LEDs são ligados em série com um resistor de 100 V. Há apenas um único
caminho através deste circuito quando o botão é pressionado: através do primeiro LED, através do
segundo LED, através do resistor, e de volta ao terra.
Figura 3.23. Esquema elétrico de dois LEDs em série
Figura 3.24. Em um circuito paralelo, há mais de um caminho, ou ramificação, que a corrente pode seguir. Em
Neste exemplo, existem duas ramificações: cada uma tem seu próprio LED e resistor.
Figura 3.25. Porque as duas ramificações neste circuito paralelo têm a mesma resistência (100 WOW! eBook
www.wowebook.org
V), metade da corrente irá para um ramo e metade para o outro.
Figura 3.26. Este circuito em série consome 50 mA porque 5 V / 100 V = 0,05 A.
Figura 3.27. Cada ramificação de um circuito paralelo isoladamente atua como seu próprio circuito em série. Nós
pode usar a lei de Ohm para verificar se esse ramo também consumirá 50 mA.
Figura 3.28. A corrente total que entra no circuito é de 100 mA (ponto A). Ele se divide igualmente em duas
ramificações - cada ramificação recebe 50 mA (pontos B, C). A corrente se junta e no ponto
D é novamente 100 mA. Em um circuito paralelo, a tensão fornecida é constante para cada ramo, mas
a corrente varia.
Figura 3.29. No esquema do circuito de LED paralelo, cada um dos ramos A, B, C,
e D é alimentado com 5 V. Cada ramo recebe 1/4 da corrente total do circuito.
Figura 3.30. A fiação de LEDs em paralelo permite que você conecte mais em um único circuito porque
cada ramo recebe a mesma tensão (5 V).
Figura 3.31. Alimentar o circuito de LED paralelo com uma bateria de 9 V envolve a troca
alguns resistores e conectando um snap de bateria de 9 V aos trilhos de energia.
Figura 4.1. O ventilador de temperatura controlada do capítulo 1 usou uma temperatura analógica
sensor para coletar informações sobre mudanças de temperatura no ambiente ao redor.
Figura 4.2. Um sensor analógico como um sensor de temperatura (topo) transduz mudanças em
temperatura em um sinal analógico suave. Uma entrada digital como um interruptor de inclinação (inferior)
pode ter apenas dois valores de saída discretos: um quando orientado normalmente (desligado, BAIXO, 0 ou
falso) e outro quando invertido (ligado, ALTO, 1, verdadeiro).
Figura 4.3. O sinal de saída de um sensor de temperatura analógico varia em tensão ao longo do tempo
conforme a temperatura muda.
Figura 4.4. ADC é suportado pelo microcontrolador ATmega328P em pinos específicos (feitos
disponível como A0A5 no Uno). Os ADCs convertem sinais analógicos em valores digitais discretos.
Figura 4.5. À medida que as condições de luz mudam, a resistência do fotoresistor muda. Isto
torna-se mais condutivo - isto é, menos resistivo - quando mais luz o atinge. Quando é
mais escuro, a resistência é maior.
Figura 4.6. Com um circuito como este, não haverá nenhuma variação de tensão significativa no pino WOW!
e-book
www.wowebook.org
A0.
Figura 4.7. Em um circuito em série, a corrente é a mesma em todos os pontos.
Figura 4.8. Em um circuito em série, a tensão pode diferir em pontos diferentes. Cada componente usa
aumenta ou reduz sua própria parcela da tensão disponível do circuito.
Figura 4.9. A lei de tensão de Kirchoff afirma que somar todas as tensões em um circuito sempre produz 0. Ou
seja, toda a tensão no circuito precisa ser contabilizada (ser usada).
Figura 4.10. As tensões em diferentes pontos em um circuito em série variam com base na quantidade de tensão
foi derrubado por componentes no circuito.
Figura 4.11. Com apenas o fotoresistor no circuito, não há ponto de referência em
qual para ler mudanças de tensão mensuráveis.
Figura 4.12. Um divisor de tensão fornece uma nova tensão mais baixa em Vout, disponível em pontos
entre dois resistores, R1 e R2. Existem várias maneiras de desenhar um divisor de tensão
esquema; os dois circuitos descritos aqui são funcionalmente idênticos.
Figura 4.13. Quando R1 e R2 têm a mesma resistência em um circuito, Vout é metade de Vin, como
cada resistor cai 50% da tensão de alimentação.
Figura 4.14. Vout é 1/5 (20%) da tensão de alimentação porque R1 fornece 80% do total
resistência no circuito.
Figura 4.15. O esquema para o circuito fotoresistor
Figura 4.16. Diagrama de fiação para o circuito divisor de tensão do fotoresistor. O fio jumper
conectada a A0 precisa ter sua outra ponta conectada a Vout, entre o fotoresistor (R1) e o resistor de 4,7 kV (R2).
Figura 4.17. O esquema para o circuito TMP 36
Figura 4.18. Fiação do sensor TMP36
Figura 4.19. Um resistor pulldown “puxa” o pino digital para nível lógico BAIXO quando o
componente (botão) não é pressionado (conectado).
Figura 4.20. O circuito do botão com um resistor pulldown de 10 kV
UAU! e-book
www.wowebook.org
Figura 5.1. Os LEDs emitem uma única cor e estão ligados ou desligados.
Figura 5.2. Diagrama de fiação para experimentação de LED
Figura 5.3. Perdemos a capacidade de discernir piscadas individuais quando um LED está se movendo
rapidamente.
Figura 5.4. Um ciclo de trabalho de 25%
Figura 5.5. Apenas alguns dos pinos digitais do Arduino Uno suportam PWM. eles estão marcados
com ~.
Figura 5.6. inOutSine é uma das dezenas de opções de funções de easing disponíveis em
JohnnyFive por meio de sua dependência do pacote npm do componente easy.
Figura 5.7. A animação de pulso fará um loop metronomicamente entre dois quadros-chave básicos
(brilho 0 e brilho 255) com easing inOutSine.
Figura 5.8. Diagrama de fiação para luz noturna automática
Figura 5.9. Deslocar um número de 10 bits para a direita por 2 resulta em um número de 8 bits.
Figura 5.10. A operação XOR compara cada dígito binário, produzindo um 1 se o binário
dígitos são diferentes.
Figura 5.11. Os LEDs RGB de catodo comum têm três LEDs componentes (vermelho, verde, azul)
em um pacote. A perna mais longa é o cátodo compartilhado.
Figura 5.12. Diagrama de fiação para a bola do tempo
Figura 5.13. Módulos LCD paralelos 16x2 estão disponíveis em muitos fabricantes. Eles
tem 16 pinos e uma luz de fundo LED.
Figura 5.14. O temporizador LCD totalmente construído
Figura 5.15. Diagrama de fiação mostrando apenas os botões: Down, Up e Go
Figura 5.16. Um módulo LCD paralelo 16x2
Figura 5.17. Diagrama de fiação do temporizador, incluindo potenciômetro e posicionamento do LCD
Figura 5.18. Potenciômetros são resistores variáveis. Eles vêm em várias formas e tamanhos.
UAU! e-book
www.wowebook.org
Figura 5.19. Diagrama de fiação mostrando as conexões de energia da breadboard para o LCD
Figura 5.20. Diagrama de fiação mostrando todas as conexões do LCD
Figura 5.21. O diagrama de fiação completo, com LED
Figura 5.22. O cronômetro, marcando o tempo!
Figura 5.23. Alguns piezos têm fios condutores e outros têm pernas. Piezos têm dois pinos: +
e.
Figura 5.24. Diagrama de fiação mostrando a substituição do LED por um piezo
Figura 6.1. Um típico motor DC de passatempo
Figura 6.2. A corrente elétrica através de um fio cria um campo magnético em um ângulo reto para
fluxo de corrente.
Figura 6.3. A corrente através da bobina cria um campo magnético que magnetiza o ferro
núcleo do eletroímã.
Figura 6.4. A inversão do fluxo de corrente inverte a polaridade do eletroímã.
Figura 6.5. Um eletroímã em um eixo entre dois ímãs fixos vai querer
orientar-se - girando - como ditam as forças magnéticas.
Figura 6.6. Os eletroímãs de um motor com escovas são conectados a um anel dividido chamado
comutador (A). O comutador e os eletroímãs giram conforme o motor gira. Fixo
as escovas de posição (B) são conectadas à fonte de alimentação e as “escovas” alternam as polaridades
no comutador conforme ele gira abaixo deles, alterando a polaridade dos eletroímãs
na armadura do motor (C).
Figura 6.7. Quando um motor é girado por uma força externa, uma corrente elétrica é gerada.
Figura 6.8. Quando um motor é conectado a uma fonte de alimentação, a corrente flui do negativo (baixo
potencial) em direção ao positivo (potencial mais alto). O fluxo de corrente faz com que o motor gire.
Quando o fluxo de corrente é removido do motor, a inércia faz com que o motor continue
girando brevemente. Durante este tempo, o motor atua como um gerador, gerando eletricidade com
tensão oposta à tensão de entrada anterior.
Figura 6.9. No circuito desprotegido mostrado aqui, o fluxo de corrente é controlado com um botão WOW! e-
book
www.wowebook.org
botão (interruptor). Quando o interruptor é pressionado e mantido, a corrente flui como esperado,
alimentando o motor. O motor consome a tensão fornecida.
Figura 6.10. Ao soltar o botão (interruptor aberto), o motor continua girando por um tempo. Durante este tempo
está gerando tensão negativa. O lead anteriormente conectado
ao terminal positivo da bateria (através do interruptor) pode criar um grande
potencial negativo - centenas de volts, digamos - que é muito, muito menor do que os +9 V de
a bateria.
Figura 6.11. Diodos são componentes semicondutores que permitem apenas que a corrente flua em um
direção.
Figura 6.12. Diagrama de circuito de um motor básico controlado por botão, incluindo um
diodo protetor
Figura 6.13. Se um diodo flyback for usado em um circuito com um indutor como um motor, ele pode
fornecer um caminho para a tensão negativa reprimida que está tentando seguir o caminho errado. Ele pode encaminhá-lo
de volta através do motor em um loop até que se dissipe.
Figura 6.14. Um MOSFET e seu símbolo de circuito. Uma pequena tensão aplicada ao pino gate (G) fará uma
conexão entre os pinos dreno (D) e fonte (S).
Figura 6.15. Diagrama de circuito para um controle de motor com transistor
Figura 6.16. Um servo e suas partes básicas. Os chifres vêm em diferentes formas e tamanhos: discos,
estrelas, braços simples.
Figura 6.17. Um servo (com chifre anexado) posicionado em um ângulo mínimo, um ângulo neutro,
e um ângulo máximo. Diferentes servos têm diferentes faixas de ângulo da vida real.
Figura 6.18. Os capacitores vêm em vários pacotes e tamanhos diferentes; capacitores eletrolíticos
capacitores e capacitores cerâmicos são bastante comuns. Cuidado: alguns, mas não todos,
capacitores são polarizados.
Figura 6.19. Diagrama de fiação para um servo com um capacitor de desacoplamento
Figura 6.20. Os fios de servo vêm em várias cores e possuem conectores diferentes. Lá
deve ser um fio vermelho - ele se conecta a Vcc (fonte de alimentação). O fio mais escuro - preto ou
marrom - é moído. O fio restante é o fio de sinal - abreviado aqui como S - para
controlando a posição do servo.
Figura 6.21. Um robô básico precisa de um chassi (corpo). Dois ou mais motoredutores se conectam ao WOW!
e-book
www.wowebook.org
rodas ou trilhos para impulsionar o bot. Claro, você também precisará de circuitos, um cérebro
(microcontrolador) e uma fonte de alimentação.
Figura 6.22. Um circuito Hbridge contém quatro interruptores, com o motor no centro.
Diferentes combinações de estados de comutação podem direcionar a corrente através do motor em diferentes
instruções.
Figura 6.23. Ativando diferentes interruptores em uma Hbridge, um motor pode ser feito para girar em
uma direção para frente ou para trás.
Figura 6.24. Fechar os dois interruptores em ambos os lados do Hbridge causa “disparo”—
um curto-circuito!
Figura 6.25. Drivers de motor baratos, como este Texas Instruments SN754410, oferecem
controle lógico sobre circuitos Hbridge internos. Eles também incluem outros componentes, como
diodos, tornando o controle do motor mais simples e menos sujeito a erros. O SN754410 é um H duplo
ponte - pode controlar dois motores.
Figura 6.26. A placa inferior do chassi Peewee Runt Rover, com lateral anexada
suportes e breadboard. Se você estiver usando um chassi diferente, parecerá um pouco diferente, claro
curso.
Figura 6.27. A placa superior do chassi Peewee Runt Rover, mostrada com engrenagem anexada
motores, rodas, suporte para placa de desenvolvimento e Arduino Uno. Certifique-se de que os fios dos motores estejam
orientado para o interior do chassis. Os fios do motor podem passar por baixo do Uno
e através do orifício central da placa do chassi.
Figura 6.28. A pinagem do driver do motor SN754410
Figura 6.29. O SN754410 precisa ser conectado a uma fonte de alimentação do motor em VCC2
(pino físico 8) e a alimentação lógica em VCC1 (pino físico 16). os dois permitem
os pinos devem ser conectados diretamente a 5 V para defini-los como ALTO. Existem também quatro pinos GND
que, sem surpresa, precisam se conectar ao terra.
Figura 6.30. Fiação das conexões de energia do SN754410 na placa de ensaio do robô
Figura 6.31. Cada um dos dois drivers de motor tem dois pinos de entrada e dois pinos de saída.
Figura 6.32. O primeiro controlador de motor: dois pinos de entrada e dois pinos de saída. vamos usar um
dos pinos de entrada para controlar a direção do motor e o outro para controlar sua velocidade.
Figura 6.33. Quando a primeira entrada é definida como ALTA e a segunda entrada é definida como BAIXA, o
motor WOW! e-
vai virar para a frente.
Figura 6.34. Quando a primeira entrada é BAIXA e a segunda é ALTA, o motor gira na
direção oposta (reversa).
Figura 6.35. Com a direção definida como LOW (reversa) no pino 1A e um ciclo de trabalho de 25% no pino 2A
(velocidade), o motor será alimentado 25% do tempo na direção reversa.
Figura 6.36. Com a direção definida como HIGH (para frente) no pino 1A e um ciclo de trabalho de 25% no pino
2A (velocidade), o motor será alimentado 75% do tempo no sentido direto.
Figura 6.37. Diagrama de circuito para o circuito do motor completo do rover
Figura 6.38. O robô completo, visto de frente
Figura 7.1. Com um sensor analógico simples como o TMP36, você pode obter um valor para um único
ponto de dados (temperatura) por amostragem da tensão do sinal em diferentes pontos no tempo (A, B, C).
Figura 7.2. Os dados digitais complexos de sensores como acelerômetros, bússolas e
Os módulos GPS requerem um método mais sofisticado de troca de dados.
Figura 7.3. Na comunicação serial (topo), um bit é enviado de cada vez sequencialmente. Em contraste,
a comunicação paralela (parte inferior) transmite vários bits ao mesmo tempo.
Figura 7.4. Para que os dispositivos troquem dados usando comunicação serial, eles precisam saber
como falar um com o outro.
Figura 7.5. A troca de dados seriais assíncronos: cada um dos dois dispositivos conectados pode
transmitir dados (TX) para e receber dados (RX) do outro componente. Observe que um
o TX de um dispositivo se conecta ao RX do outro e vice-versa. Uma placa de fuga de GPS como
Adafruit é um exemplo de um componente que comunica seus dados usando assíncrono

serial.
Figura 7.6. Um quadro de dados seriais assíncronos. Um único bit de início é seguido por 5 a 9 bits de dados. Um
bit de paridade pode ser usado para detecção de erro. Em seguida, um ou dois bits de parada indicam o
final do quadro.
Figura 7.7. A estrutura do quadro de dados de 9600/8N1: bit de início, 8 bits de dados, sem bit de paridade, um
parar um pouco
UAU! e-book
www.wowebook.org
Figura 7.8. Um UART é um hardware especializado para comunicação serial assíncrona e
conversão paralelo-serial.
Figura 7.9. Antes de poder usá-lo em uma breadboard, o GPS precisa ter alguns pinos de cabeçalho
soldado a ele.
Figura 7.10. A solda vem em um carretel enrolado, como um fio.
Figura 7.11. Um ferro de solda comum e barato. Os baratos normalmente não têm
configurações de controle de temperatura - eles obtêm apenas um sabor quente.
Figura 7.12. Seu ferro de solda precisa de um suporte para segurá-lo quando não estiver em uso e protegê-lo
coisas ao seu redor queimem.
Figura 7.13. Principais coisas que você precisa para começar a soldar
Figura 7.14. Proteja seus componentes antes de soldar. Uma terceira mão é uma ferramenta conveniente
por esta.
Figura 7.15. Coloque a ponta do ferro de solda na almofada de conexão de metal e o pino para aquecer
eles para cima.
Figura 7.16. O pino aquecido fará com que a solda derreta e flua ao redor da junta.
Figura 7.17. Uma conexão bem soldada se assemelha a um pequeno vulcão de solda.
Figura 7.18. Diagrama de fiação do circuito GPS
Figura 7.19. Em uma configuração SPI simples - um mestre, um escravo - apenas três fios
pode ser usado para troca de dados: uma linha de relógio compartilhada (SCK) gerenciada pelo mestre, mestre
outslavein (MOSI) e masterinslaveout (MISO).
Figura 7.20. Quando mais dispositivos são adicionados, pelo menos uma linha adicional—slaveselect (SS)
— é necessário, embora algumas configurações de SPI exijam uma linha SS por dispositivo escravo.
Figura 7.21. Não importa quantos dispositivos estejam conectados juntos, com I2C existem
sempre apenas duas linhas: SCL (relógio) e SDA (dados).
Figura 7.22. A placa de fuga da bússola, como a fuga de GPS, precisará ser soldada
nos pinos do cabeçote.
Figura 7.23. Diagrama de fiação para bússola
UAU! e-book
www.wowebook.org
Figura 7.24. Diagrama de fiação, etapa 1. Os fios na placa de ensaio com a bússola
breakout board são organizados para abrir espaço para sensores que serão adicionados posteriormente.
Figura 7.25. Placa de fuga BMP180 da Adafruit
Figura 7.26. Diagrama de fiação para adicionar o breakout BMP180 ao circuito
Figura 7.27. A placa de acelerômetro ADXL345 tripleaxis da Adafruit. Pode
ser conectado a um barramento I2C (via pinos SDA e SCL) ou, com alguns pinos fazendo dupla função
conforme observado na imagem, uma configuração SPI de quatro fios (via pinos CS, SDO, SDA e SCL).
Figura 7.28. Diagrama de fiação para adicionar o acelerômetro ao circuito
Figura 8.1. Este esboço do capítulo 1 descreve as comunicações teóricas hostclient para
um widget de fã automático. Em seus experimentos até agora, o Arduino Uno atuou como um fino
cliente e seu computador como host.
Figura 8.2. Como o Uno, essas placas possuem microcontroladores restritos, mas ambos podem
comunicar sem fios.
Figura 8.3. Esta classe de dispositivos combina microcontroladores restritos com
variantes de JavaScript e tempos de execução semelhantes a JavaScript. Exploraremos tanto o Pico como o
Elemento no capítulo 10.
Figura 8.4. A placa de desenvolvimento de código aberto Tessel 2
Figura 8.5. O circuito de LED básico original para o Uno. O Uno opera em 5,5 V, enquanto
o Tessel é um dispositivo de 3,3 V. O circuito precisa ser ajustado para a tensão diferente do
Tessel
Figura 8.6. Conecte o ânodo do LED à porta A do Tessel, pino 5, e seu cátodo ao GND
conexão na porta A.
Figura 8.7. Os pinos do Tessel são divididos em duas “portas”, cada uma com 8 pinos de E/S.
Figura 8.8. Tessel 2 pinos e suas características. Qualquer pino numerado pode ser usado como E/S digital.
Figura 8.9. Um Tessel serve como centro nervoso para uma miniestação meteorológica. Um Node.js
aplicativo em execução no Tessel lerá os dados do multissensor BMP180 e executará um
servidor web para que outros computadores na mesma rede Wi-Fi possam ver o clima
UAU! e-book
www.wowebook.org
informações em um navegador da web.
Figura 8.10. Conecte o sensor BMP180 I2C à alimentação (GND e pinos 3,3 V da porta A),
SCL (A0) e SDA (A1).
Figura 8.11. Nada chique! Navegando para o endereço IP e a porta do Tessel em um navegador
exibe o arquivo index.html, que ainda não faz muita coisa.
Figura 8.12. Os valores de temperatura e pressão são atualizados em tempo real no seu navegador, via
websockets.
Figura 8.13. A configuração de motores duplos para o robô no capítulo 6 usou uma fonte de energia externa
ao Uno para alimentar os motores DC: uma bateria de 9 V.
Figura 8.14. O Tessel pode fornecer energia de 5 V dos pinos de alimentação destacados aqui.
Figura 8.15. A soldagem de pinos de cabeçalho fêmea aos pinos de alimentação de 5 V fornece slots reutilizáveis úteis
para fios de jumper.
Figura 8.16. Para soldar conectores fêmea na placa, vire a placa e solde no
fundo. Você precisará de um pedaço de fita para prender os pinos no lugar enquanto solda.
Figura 8.17. Soldar fios sólidos aos pinos de alimentação também é uma opção.
Figura 8.18. Substituindo o Uno no robô itinerante do capítulo 6 por um Tessel, fazendo um par
de ajustes de fiação e conectando uma bateria USB ao Tessel, você pode criar uma rede de fios
bot itinerante gratuito.
Figura 8.19. O circuito do robô rover usando o Tessel e a potência de 5 V do Tessel. O
A alimentação de 5 V do Tessel precisa alimentar ambos os trilhos de alimentação - certifique-se de conectar o positivo
colunas dos trilhos de alimentação juntas usando um fio jumper adicional (vermelho) (próximo ao topo).
Figura 8.20. O circuito do rover usando duas fontes de energia: o Tessel de 3,3 V e um de 9 V
bateria para os motores.
Figura 9.1. Conjuntos de tomadas com controle remoto são baratos e amplamente disponíveis em
lojas de ferragens e home centers. A unidade de controle remoto é alimentada por uma bateria de baixa voltagem.
Figura 9.2. O controle remoto desconstruído
UAU! e-book
www.wowebook.org
Figura 9.3. Quando um botão é pressionado, ele faz contato com os dois lados do ziguezague
contatos abaixo dela. Você pode reproduzir esse efeito conectando os dois lados com um
fio jumper.
Figura 9.4. Sem multímetro? Você pode usar um LED para descobrir qual lado da
os contatos do botão são do lado do terra. Um LED é um diodo - ele só permitirá que a corrente flua se
está alinhado corretamente no circuito. Quando acende, isso significa que seu cátodo está no
lado terra do botão.
Figura 9.5. Uma configuração ideal seria soldar os fios diretamente em cada lado de cada botão
almofada de contato.
Figura 9.6. Minha solução de fiação homebrew, aproveitando a estrutura do
placa de circuito particular
Figura 9.7. Se desejar, você pode conectar um ou mais de seus botões com fio a um push
botão para testá-lo.
Figura 9.8. Para cada botão do controle remoto, você deseja pressionar e soltar o
botão usando o Tessel como um controlador switchlike. Você deseja que a aplicação de corrente
entre os pontos 1 e 2 (o lado da entrada) faz com que a corrente flua entre os pontos 3 e 4 (o
saída, lado remoto), mas você não quer que os dois circuitos sejam conectados fisicamente.
Figura 9.9. A corrente aplicada ao lado de entrada de um fotoacoplador ativa um infravermelho interno
LIDERADO. O LED brilha em um transistor fotossensível, ativando-o e permitindo que a corrente
fluxo no lado da saída.
Figura 9.10. Diagrama de fiação para o primeiro conjunto de botões liga/desliga
Figura 9.11. A fiação do interruptor/fotoacoplador concluída. As saídas do
os fotoacopladores devem ser conectados aos fios de contato do botão.
Figura 9.12. O APDS9960 amontoa três sensores em um pacote, incluindo um gesto
sensor. O SparkFun oferece um breakout board que facilita o trabalho com o chip.
Figura 9.13. Nesta representação simplificada da máquina de estado parcial do seu plug-in, um plug-in
instância do objeto começa em um novo estado. Por meio de um método de configuração, ele se move para um estado inicializado
estado, em que ponto o dispositivo APDS9960 é inicializado, mas não detecta ativamente gestos.
Um método enable ativa o modo de gesto no dispositivo.
Figura 9.14. Existem 128 bytes de FIFO RAM, começando no endereço de memória 0xFC,
disponível para armazenar dados de gestos. Neste exemplo, há três conjuntos de dados disponíveis no
UAU! e-book
www.wowebook.org
Fila FIFO. Um conjunto de dados é composto de quatro bytes, cada um representando dados para um
direção - para cima, para baixo, para a esquerda e para a direita.
Figura 9.15. A máquina de estado do plug-in ganha mais detalhes à medida que a pesquisa continua. quando um
interrupção é detectada, a instância do plugin entra em uma fase de ciclo de leitura e, em seguida, um processamento
fase antes de retornar ao estado ativado de escuta ativa.
Figura 9.16. Diagrama de fiação para placa de breakout APDS9960
Figura 9.17. O valor no registro DEVICE_ID no endereço 0x92 no APDS9960
deve ser sempre 0xAB (10101011 em binário).
Figura 9.18. A máquina de estado do plug-in agora está completa. O próximo passo é implementá-lo.
Figura 9.19. Uma amostra dos registradores APDS9960 que são gravados durante a configuração e
habilitar
Figura 9.20. Diferentes faixas de bits dentro do registro GCONF correspondem a diferentes
configurações. Os dois bits nas posições 6 e 5 definem o ganho do gesto, por exemplo. O bit 7 não é usado.
Figura 9.21. O ciclo de leitura começa verificando se o bit 0 no registrador GSTATUS está
1. Em caso afirmativo, GFLVL é lido para ver quantas amostras estão disponíveis (0101, ou seja, 5) e, em seguida,
o número indicado é lido no FIFO. O ciclo continua até que GSTATUS<0> seja
0.
Figura 9.22. processData executa aritmética nos dados; decodeData deriva a direção do gesto
dos resultados calculados e dispara eventos. Por fim, o objeto de dados do gesto é redefinido na instância para que
esteja pronto para coletar dados do próximo gesto.
Figura 9.23. Diagrama de fiação mostrando a combinação da placa de breakout APDS9960
e os circuitos de botão/fotoacoplador.
Figura 10.1. Duas plataformas JavaScript incorporadas: Espruino Pico e Kinoma Element
Figura 10.2. O Pico tem 18 pinos (duas fileiras de 9 cada) em um passo de 0,1 polegada—breadboard
compatível. Eles precisarão ser soldados nos pinos de cabeçalho. Uma extremidade da placa Pico é moldada
para que possa ser conectada diretamente a uma porta USB.
Figura 10.3. Você pode usar um cabo de extensão USB para conectar seu Pico ao seu computador,
permitindo que o Pico seja colocado em uma breadboard. Os slots de extremidade USB do Pico em um USB A
UAU! e-book
www.wowebook.org
conexão feminina.
Figura 10.4. O aplicativo Espruino Chrome IDE
Figura 10.5. Este experimento fará com que os LEDs internos do Pico - um vermelho, um verde -
piscar alternadamente. O acesso aos LEDs é feito através das variáveis globais LED1 e LED2.
Figura 10.6. Inserindo o código LEDblink no Espruino IDE (tamanho da fonte aumentado para
visibilidade)
Figura 10.7. As principais características do Espruino Pico, listadas no site do Espruino
Figura 10.8. Oito dos pinos de E/S do Pico estão em um passo de 0,05 polegada: muito estreito para encaixar
breadboards.
Figura 10.9. Detalhe do diagrama de pinagem para o Espruino Pico
Figura 10.10. A documentação da API do Espruino em www.espruino.com/Reference
Figura 10.11. Diagrama de fiação para o sensor Espruino Pico e BMP180
Figura 10.12. Não se esqueça! Os trilhos de energia em uma breadboard de tamanho normal têm uma quebra no meio do caminho
para baixo da placa.
Figura 10.13. Depois que o script BMP180 for carregado no Pico, você deverá ver o log de saída no lado
esquerdo da tela uma vez por segundo.
Figura 10.14. O Nokia 5110 LCD tem resolução de 48x84 pixels e uma interface SPI
fornecido pelo driver Phillips Semiconductor PCD8544. O visor é mostrado aqui o
lado direito para cima.
Figura 10.15. Esquema elétrico para a adição de um componente Nokia 5110 LCD ao
o circuito
Figura 10.16. O visor do temporizador. O retângulo preenchido é “animado” e cresce até o
certo com o passar do tempo.
Figura 10.17. A saída do gadget meteorológico mostrará a temperatura e a pressão do ar, bem
formatado.
Figura 10.18. Usando o suporte gráfico do Espruino para criar formas e desenhar strings de texto
Figura 10.19. O Elemento Kinoma UAU! e-

book
www.wowebook.org
Figura 10.20. Diagrama de pinagem para o Elemento Kinoma
Figura 10.21. Software Kinoma Code IDE
Figura 10.22. A fonte para um projeto de exemplo de blinkingLED Kinoma. A estrutura de um
O projeto Kinoma é mais envolvente do que o projeto Espruino.
Figura 10.23. Detalhe da exibição do navegador, mostrando a direção da bússola. A direção da bússola
irá atualizar, ao vivo, sem a necessidade de recarregar o navegador. Neste caso, o título atual foi
190,62 graus - um pouco a oeste do sul.
Figura 10.24. Elemento Kinoma e HMC5883L
Figura 10.25. A estrutura para o projeto Element livecompass. O arquivo main.js fornece
lógica de aplicativo e um servidor WebSocket, contando com o suporte do BLL em HMC5883L.js para
interagir com o magnetômetro. O arquivo project.json define o projeto,
usando as convenções de Kinoma. Index.html é executado em um navegador da Web em seu computador e
mostra os cabeçalhos da bússola com atualização ao vivo.
Figura 11.1. Computadores de placa única (SBCs), da esquerda para a direita: módulo Intel Edison com
Arduino breakout, Raspberry Pi 2 Modelo B e BeagleBone Black
Figura 11.2. Raspberry Pi 2 Modelo B (esquerda), Raspberry Pi Zero (primeiro plano central) e
Raspberry Pi 3 Modelo B (em um estojo, com SparkFun Pi Wedge anexado)
Figura 11.3. O Raspberry Pi 3 Modelo B
Figura 11.4. Kit Raspberry Pi 3 Modelo B SparkFun construído com Pi Wedge, mostrado aqui
conectado a uma placa de ensaio. Também é mostrado um Adafruit TCobbler (à direita), que fornece
o mesmo tipo de funcionalidade que o Wedge.
Figura 11.5. A área de trabalho PIXEL. Observe o ícone WiFi no canto superior direito.
Figura 11.6. Baixe a versão completa do Raspbian de Raspberry Pi's Raspbian
página de download.
Figura 11.7. O Etcher é um utilitário direto: selecione o arquivo de imagem do disco, selecione a unidade (é
geralmente seleciona automaticamente para você) e pronto.
Figura 11.8. Usando LanScan para Mac, posso ver que a interface Ethernet do Raspberry Pi
UAU! e-book
www.wowebook.org
foi atribuído o endereço IP 192.168.1.13.
Figura 11.9. Depois de configurar o WiFi, o Pi agora tem dois endereços IP - um para a Ethernet
interface e outra para sua interface WLAN (WiFi).
Figura 11.10. Destaques das especificações do Raspberry Pi 3 Modelo B no site do Raspberry Pi
Figura 11.11. pinout.xyz é um site inteiramente dedicado às informações de pinagem do Raspberry Pi.
Este detalhe de pinout.xyz mostra os muitos aliases do pino físico 33.
Figura 11.12. Diagrama de fiação para conectar o LED diretamente aos pinos do Pi, usando macho
fios jumper tofemale
Figura 11.13. Diagrama de fiação, usando o TCobbler da Adafruit
Figura 11.14. Diagrama de fiação, usando o Pi Wedge do SparkFun
Figura 11.15. O mini aplicativo meteorológico fornece dados de temperatura e pressão atualizados ao vivo
que podem ser visualizados em um navegador em qualquer computador na mesma rede.
Figura 11.16. Diagrama de fiação para o BMP180, mostrando conexões diretas com o Pi
Figura 11.17. Diagrama de fiação para o BMP180 e o SparkFun Pi Wedge
Figura 11.18. Diagrama de fiação para o BMP180 e o Adafruit TCobbler
Figura 11.19. Diagrama de fiação para o BMP180 e o Arduino Uno
Figura 11.20. O BeagleBone Black SBC
Figura 11.21. A página de informações do BeagleBone Black no site da BeagleBoard
Figura 11.22. Recursos de pino BeagleBone Black disponíveis através do plug-in beagleboneio JohnnyFive I/O
Figura 11.23. O botão BOOT/USER no BeagleBone Black
Figura 11.24. Diagrama de fiação para o BMP180 e o BeagleBone Black
Figura 12.1. Ambos os serviços Particle (https://www.particle.io) e ARTIK da Samsung
(https://www.artik.io) são as chamadas ofertas “end-to-end” para IoT.
UAU! e-book
www.wowebook.org
Figura 12.2. Os dispositivos que executarão o aplicativo são provisionados pela instalação e inicialização
uma imagem personalizada do sistema operacional resin.io em cada um. Enviando o código do aplicativo para um projeto específico
resin.io Git remoto aciona a reconstrução do contêiner do aplicativo e sua reimplantação para
dispositivos conectados e provisionados.
Figura 12.3. Crie uma conta em resin.io.
Figura 12.4. Detalhe da etapa de criação do aplicativo mostrando a lista de tipos de dispositivos suportados
Figura 12.5. Detalhe do painel do projeto resin.io durante o processo de provisionamento de um
Dispositivo BeagleBone Black. O dispositivo, chamado automaticamente de “rednight” pelo resin.io, está no meio
da instalação da imagem do sistema operacional resin.io específico do aplicativo.
Figura 12.6. Mantenha pressionado o botão BOOT/USER do BeagleBone Black para inicializar a partir do SD
cartão.
Figura 12.7. Detalhe do painel do aplicativo resin.io mostrando onde encontrar o comando
para adicionar o controle remoto Git resin.io do seu aplicativo
Figura 12.8. Painel do aplicativo Resin.io durante a implantação
Figura 12.9. Habilite URLs públicos para seu aplicativo na guia Ações do aplicativo.
Figura 12.10. Veja a URL pública de um dispositivo navegando até as Ações específicas do dispositivo
aba.
Figura 12.11. O aplicativo da estação meteorológica, rodando em um BeagleBone Black, acessado por uma resina
URL público gerado por .io
Figura 12.12. Com a Web física, beacons Bluetooth Low Energy (BLE) conectados ou
incorporado em um objeto físico transmite uma URL pertinente à interação com esse dispositivo.
Os usuários próximos podem detectar e interagir com dispositivos, abrindo suas páginas da Web associadas em um
navegador.
Figura 12.13. Puck.js é um dispositivo beacon BLE que, como o Pico, executa o interpretador Espruino
JavaScript.
Figura 12.14. Algumas das funcionalidades do Puck.js, listadas no site do Espruino
Figura 12.15. Um detalhe da pinagem Puck.js de Espruino.com. O pino D11 pode detectar
entrada capacitiva. O suporte I2C, SPI e USART está disponível em qualquer pino (há suporte para
uma interface de hardware cada, mas suporte de software ilimitado para I2C e SPI).
UAU! e-book
www.wowebook.org
Figura 12.16. IDE baseado na web do Espruino
Figura 12.17. O LED do Puck.js pode ser controlado por meio de uma página da Web em um Web Bluetooth
navegador.
Figura 12.18. O JavaScript executado pelo navegador chama o método write() no Puck
objeto fornecido pela biblioteca puck.js. Essa biblioteca usa Web Bluetooth para enviar a string para
o Puck.js físico, que o avalia. O \n no final do comando string permite
Puck.js sabe que o comando está completo, é quase como digitar em um REPL virtual e apertar Enter.
Figura 12.19. Você será solicitado a emparelhar com Puck.js quando clicar em um botão pela primeira vez.
Figura 12.20. Suporte físico da Web por meio do widget do Chrome no iOS. Puck.js está configurado
para transmitir a URL https://www.lyza.com usando o protocolo Eddystone.
Figura 12.21. No momento, index.html mostra um botão muito grande, mas não tem nenhum
funcionalidade.
Figura 12.22. Para as comunicações bidirecionais no exemplo da campainha, a biblioteca do cliente puck.js é
usada para estabelecer uma conexão persistente entre o navegador e o Puck.js.
Os comandos podem ser enviados para Puck.js pela conexão e qualquer saída para Bluetooth por
Puck.js aciona um evento de dados na conexão.
Figura 12.23. Clicar no botão Ativar solicitará o emparelhamento com Puck.js.
Figura 12.24. Quando o botão do Puck.js é pressionado, o som da campainha toca e a tela
pisca em rosa choque - pode-se até chamá-lo de pank, é tão brilhante - momentaneamente.
UAU! e-book
www.wowebook.org
História
Lista de mesas
Capítulo 3. Como construir circuitos Tópicos
Tabela 3.1. Tensão, corrente e resistência

Tutoriais
Tabela 3.2. Ajustando tensão, corrente e resistência em eletrônicos de hobby
Destaques
Tabela 6.1. Controle de direção do driver do motor para o motor 1
Configurações Capítulo 10. JavaScript e hardware restrito
SuporteTabela 10.1. Conexões Nokia 5110 LCD
Sair
UAU! e-book
www.wowebook.org
recomendado
Lista de Listagens
aylists
Capítulo 1. Reunindo JavaScript e hardware
temperatura
Listagem 1.1. Pseudocódigo para a história lógica do ventilador acionado por
Capítulo 2. Embarcando em hardware com a ótica do Arduino
digitalListagem 2.1. Exemplo de configuração de tutoriais de pinos de saída
Listagem 2.2. Configurando um pino de saída digital

fers & Deals
Listagem 2.3. Um esboço completo para piscar um LED

Destaques
Listagem 2.4. Configurações da preparação do primeiro projeto

JohnnyFive
Listagem 2.5. ola.js
Apoiar
Listagem 2.6. Executando hello.js em um terminal Sair

Listagem
2.7. LED piscando com a linguagem de programação Arduino
Listagem 2.8. LED piscando com JohnnyFive
Listagem 2.9. Usando callbacks de LED em hello.js
Listagem 2.10. Executando o script hello.js alterado
Listagem 4.1. Instanciando um novo objeto Sensor com JohnnyFive
Listagem 4.2. Registrando o valor de um sensor
Listagem 4.3. Registrando valores usando o evento de dados
UAU! e-book
www.wowebook.org
.
Listagem 4.6. Parâmetro de frequência do sensor
Listagem 4.7. Registrando a alteração dos valores do fotoresistor
Listagem 4.8. temperatura.js
Listagem 4.9. REPL de JohnnyFive
Listagem 4.10. E se você quiser obter informações de um componente JohnnyFive...?
Listagem 4.11. Injetando no REPL
Listagem 4.12. Alteração de temperature.js para usar injeção de REPL
Listagem 4.13. botão.js
Listagem 5.1. experimentled.js
Listagem 5.2. Etapas para animar componentes no JohnnyFive
Listagem 5.3. Opções de animação para pulsar
Listagem 5.4. animated.js
Listagem 5.5. Instanciação e enfileiramento de animação
Listagem 5.6. Maneira mais fácil de pulsar um LED
Listagem 5.7. O cronômetro mais simples do mundo
Listagem 5.8. Uma luz noturna ingênua
Listagem 5.9. Luz noturna ligeiramente melhorada
Listagem 5.10. Luz noturna de autocalibração
Listagem 5.11. Configurações para a bola do tempo
Listagem 5.12. Instanciando uma placa
UAU! e-book
www.wowebook.org
Listagem 5.13. Solicitando dados da API Dark Sky
Listagem 5.14. Faça a bola do tempo ir
Listagem 5.15. Teste os botões em timeradvanced.js
Listagem 5.16. Teste o LCD
Listagem 5.17. Visão geral da estrutura do aplicativo de timer
Listagem 5.18. Configurando alguns valores
Listagem 5.19. Inicializando e exibindo o tempo restante do temporizador
Listagem 5.20. Adicionar funções do manipulador de ajuste de tempo
Listagem 5.21. Fazendo o timer funcionar
Listagem 5.22. Adicionar um toque visual
Listagem 5.23. Instanciando um piezo
Listagem 5.24. A nova função chime()
Listagem 6.1. teste de motor
Listagem 6.2. Teste de servo
Listagem 6.3. Test drive do motorista
Listagem 6.4. Instanciando motores
Listagem 6.5. A classe Rover
Listagem 6.6. Estrutura de index.js
Listagem 6.7. index.js: configurando os motores e o rover
Listagem 6.8. index.js: configurando pressionamento de tecla
Listagem 6.9. index.js: manipulação de pressionamentos de tecla
UAU! e-book
www.wowebook.org
Listagem 7.1. Usando um plug-in de E/S diferente com JohnnyFive
Listagem 7.2. JohnnyFive GPS
Listagem 7.4. Instanciando uma bússola com um controlador específico
Listagem 7.5. compass.js: lendo dados HMC5883L com JohnnyFive
Listagem 7.6. multisensor.js: configuração
Listagem 7.7. multisensor.js: corrigindo a declinação
Listagem 7.8. multisensor.js: formatação de exibição para a direção da bússola
Listagem 7.9. multisensor.js: exibindo a direção da bússola
Listagem 7.10. multisensor.js: atualizando a formatação do display
Listagem 7.11. multisensor.js: atualizando o callback pronto da placa
Listagem 7.12. multisensor.js: manipulador de aceleração
Listagem 8.1. lista t2
Listagem 8.2. t2 renomear
Listagem 8.3. lista t2 após o provisionamento
Listagem 8.4. Inicialize o projeto BlinkingLED Tessel
Listagem 8.5. hellotessel.js
Listagem 8.6. corrida t2
Listagem 8.7. led.js
UAU! e-book
www.wowebook.org
Listagem 8.9. Executando o código LEDblink no Tessel
Listagem 8.11. Diretório do projeto e estrutura de arquivos, até agora
Listagem 8.13. Diretório do projeto e estrutura de arquivos com .tesselinclude
Listagem 8.15. Executando index.js
Listagem 8.19. estilo.css
Listagem 8.20. Estrutura completa de arquivos e diretórios do projeto
Listagem 8.22. detalhe updateData()
Listagem 8.23. saída push t2
Listagem 9.1. Protótipo de código de pressionamento de botão
Listagem 9.2. RemoteSwitch.js: ponto de partida
Listagem 9.3. RemoteSwitch.js: construtor
Listagem 9.4. RemoteSwitch.js: métodos de protótipo
Listagem 9.5. index.js refatorado
Listagem 9.6. O plugin RemoteSwitch completo
UAU! e-book
www.wowebook.org
Listagem 9.7. Testando a conexão com o APDS9960
Listagem 9.8. ponto de partida APDS9960.js
Listagem 9.9. Constantes APDS9960
Listagem 9.10. APDS9960: redefinição de dados do construtor e do gesto
Listagem 9.11. APDS9960: preenchendo a configuração e habilitando
Listagem 9.12. Lendo dados de gesto
Listagem 9.13. Processando dados de gesto
Listagem 9.14. Decodificação de dados de gesto
Listagem 9.15. Test drive APDS9960
Listagem 9.16. APDS9960 controlando um único interruptor com o sensor de gesto
Listagem 9.17. Um par de botões gerenciados por uma instância RemoteSwitch tem uma fila
Listagem 9.18. Cada RemoteSwitch tem sua própria fila
Listagem 9.19. Usando RemoteSwitches
Listagem 9.20. RemoteSwitches
Listagem 9.21. Juntando tudo em index.js
Listagem 10.1. Piscando os LEDs do Pico
Listagem 10.2. Usando o módulo BMP085 Espruino
Listagem 10.3. Configurando o temporizador
Listagem 10.4. Iniciando o cronômetro
Listagem 10.5. Desenhando o cronômetro
Listagem 10.6. Configurando o gadget de clima
UAU! e-book
www.wowebook.org
Listagem 10.7. Renderizando a exibição do clima
Listagem 10.8. projeto.json
Listagem 10.9. Estrutura de main.js
Listagem 10.10. Detalhe do código BLL
Listagem 10.11. Configurando pinos
Listagem 10.12. Configuração do servidor WebSocket
Listagem 10.13. Lendo e atualizando as direções da bússola
Listagem 10.14. Código do cliente (página HTML) para mostrar a direção da bússola
Listagem 11.1. Um script bash para piscar um LED anexado uma vez
Listagem 11.2. Piscando um LED com sysfs e Node.js
Listagem 11.4. Piscando o LED com JohnnyFive
Listagem 11.5. Testando o Pi, JohnnyFive, raspiio e BMP180
Listagem 11.6. Exemplo de saída para o script BMP180 de teste
Listagem 11.7. Diretório do projeto e estrutura de arquivos
Listagem 11.8. Dependências Package.json do projeto Tessel
Listagem 11.9. Uma versão compatível com Pi do index.js
Listagem 11.10. Exemplo de saída ao iniciar o aplicativo da estação meteorológica
Listagem 11.11. LED piscando no BeagleBone Black
Listagem 11.12. server.listen() atualizado
UAU! e-book
www.wowebook.org
Listagem 12.1. Dockerfile.template
Listagem 12.2. Scripts Package.json
Listagem 12.3. Desativar JohnnyFive REPL
Listagem 12.4. Mude a porta do servidor web para 80
Listagem 12.7. Ouvintes de evento para alternar LEDs
Listagem 12.9. Manipulador de cliques para o botão Ativar
Listagem 12.10. A superfície da API para PuckChime
Listagem 12.11. PuckChime: construtor e métodos de inicialização
Listagem 12.12. Métodos de comunicação com Puck.js
Listagem 12.13. Comando Puck.js, expandido
Listagem 12.14. Analisando dados de Puck.js
Listagem 12.15. O carrilhão em si
Listagem 12.16. A aula de som
UAU! e-book
www.wowebook.org

JavaScript On Things PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

JavaScript On Things PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

www.manning.com. A editora oferece descontos neste livro quando encomendado em quantidade.

Para mais informações por favor entre em contato

Ofertas e promoções especiais do departamento

©2018 da Manning Publications Co. Todos os direitos reservados.

Nenhuma parte desta publicação pode ser reproduzida, armazenada em um sistema de

sem permissão prévia por escrito do editor.

em letras maiúsculas ou todas em letras maiúsculas.

Editor de desenvolvimento: Susanna Kline

Impresso nos Estados Unidos da América

Capítulo 2. Embarcando em hardware com Arduino

Capítulo 3. Como construir circuitos

2. Noções básicas do projeto: entrada e saída com JohnnyFive

Capítulo 4. Sensores e entrada

Capítulo 5. Saída: fazendo as coisas acontecerem

Capítulo 6. Saída: fazendo as coisas se moverem

3. Projetos mais sofisticados

Capítulo 7. Comunicação serial

Capítulo 9. Construindo suas próprias

Capítulo 10. JavaScript e hardware restrito

Capítulo 11. Construindo com Node.js e computadores minúsculos

Capítulo 12. Na nuvem, no navegador e além

Sobre este livro

1.1. A anatomia dos projetos de hardware

1.1.1. Entradas e saídas

1.1.3. Energia, circuitos e sistemas

1.1.4. Lógica e firmware

1.1.5. Invólucros e embalagens

1.1.6. Sistemas embarcados

1.2. Como o JavaScript e o hardware funcionam juntos

1.2.2. JavaScript embutido

1.3. JavaScript é uma boa opção para hardware?

1.4. Montando um kit de ferramentas de hardware

1.4.1. placas de desenvolvimento

1.4.2. Componentes de entrada e saída

1.4.3. Outros componentes eletrônicos

1.4.4. Energia, fios e acessórios

Capítulo 2. Embarcando em hardware com Arduino

2.1. Conhecendo o Arduino Uno

2.1.1. Criando seu primeiro circuito com um Arduino Uno

2.2. Trabalhando com o fluxo de trabalho do Arduino

2.2.1. Pinos digitais do Arduino Uno

2.2.2. Esboços e o IDE do Arduino

2.2.3. Conectando o LED a um pino digital

2.2.4. Programando o LED para piscar

2.3. Controlando o Arduino com JavaScript

2.3.1. Configurando o Arduino como cliente

2.3.2. Instalando a estrutura JohnnyFive Node.js

2.3.3. Hello World LED piscando com JohnnyFive

2.3.4. Firmata, JohnnyFive e o método hostclient

Capítulo 3. Como construir circuitos

3.1. Tensão, corrente e resistência

3.1.1. lei de ohm

3.1.2. Problemas e perigos

3.2. Construir circuitos

3.2.1. Usando breadboards para prototipar circuitos

3.2.2. Fiação de um circuito de LED simples em uma placa de ensaio

3.2.3. Expandindo um circuito em série com um botão

3.2.4. LEDs em série

3.2.5. Circuitos paralelos e divisores de corrente

3.2.6. Alimentando seu projeto com baterias

2. Noções básicas do projeto: entrada e saída com JohnnyFive

Capítulo 4. Sensores e entrada