Exploring Arduino 101 200.en - PT

Capítulo 4 ■Usando transistores e condução Motors 1
você pode descobrir por que ele é chamado de H-ponte? Observe que o motor no com-
combinação com os quatro interruptores forma um maiúscula H. Embora o diagrama
mostra-lhes como interruptores, os componentes de comutação são realmente
transistores,
semelhantes aos que utilizou no exercício anterior. Alguns circuitos adicionais, incluindo diodos de
proteção, também é construída no circuito integrado da H-ponte.
O H-ponte tem quatro principais estados de funcionamento: aberto, travagem, para a frente, e
para trás. No estado aberto, todos os interruptores estão abertos e o motor não irá girar. No estado para a
frente, dois interruptores diagonalmente opostas estão envolvidos, fazendo com que a corrente flua de
9V, através do motor, e para baixo para terra. Quando o
interruptores opostas são invertidas, corrente, em seguida, atravessa o motor no

sentido oposto, fazendo com que ele gire na direcção oposta. Se o H-ponte é colocada no estado de
travagem, todo o movimento residual causada por impulso é cessaram, e o motor pára.
Criação de circuitos curtos com pontes H
BeawareofoneextremelyimportantconsiderationwhenusingH-bridges.Whatwouldhappenifbothswitchesontheleftorbothswit
Itwouldcauseadirectshortbetween9Vandground.Ifyou'veevershorteda9Vbatterybefore, youknowthatthisisnotsome-thingyo
inrarecircumstances, couldburstorleak.Furthermore, ashortcoulddestroytheH-bridgeorotherpartsofthecircuit.AnH-
bridgeisararescenariowhereyoucouldpotentiallydestroyapieceofhardwarebyprogrammingsomethingwrong.Forthisexperim
HDriver.Thischiphasabuilt-inthermalshutdownthatshouldkickinbeforeashortcircuitdestroysanything, butit'sstillagoodideato
Toensurethatyoudon'tblowanythingup,sempredisablethechipbefore
flippingthestatesofanyoftheswitches.Thisensuresthatashortcannotbecreatedevenwhenyouquicklyswitchbetweenmotordire
oneforcontrollingthetoptwogates, oneforcontrollingthebottomtwogates, andoneforenablingthecircuit.
Construir um circuito de ponte H
Com as considerações anteriores em mente, é hora de construir o circuito. O chip ponte-H que você
usa é o motorista SN754410 Quádruplo Half-H. Two Half-H
condutores são combinadas em um controlador completa-H, tal como o mostrado na Figura 4-5.
Para este exercício, basta usar dois dos quatro pilotos Half-H para conduzir um motor DC. Se você
quiser fazer um carro de RC, por exemplo, você poderia usar este chip para controlar dois motores
DC (um para as rodas da esquerda e um para as rodas direita). Antes de realmente obtê-lo prendido
acima, dê uma olhada no pin-out e mesa lógica da folha de dados do item (veja a Figura 4-6).
2 parte II ■Controlar o Seu
Imagem usada com permissão cortesia

de Instrumentos Texas.
Figura 4-6: H-ponte pin-out e mesa de lógica
Pin numeração em circuitos integrados (ICs) começa sempre no pino superior esquerdo
e vai em torno da parte anti-horário. Fritas sempre terá algum tipo de indicador para mostrar o pino que
é Pin 1, de modo que você não ligar o IC na cabeça para baixo. Em partes através de buracos (que é o
que você vai usar exclusivamente neste capítulo), um semi-círculo em uma extremidade do chip indica
o topo do chip (onde o pino 1 está localizado). Alguns chips podem ter um pequeno círculo marcada ao
lado de um pino sobre o invólucro de plástico, além de, ou em vez do semi-círculo.
Vamos percorrer os pinos e como você vai usá-los:
■ G■ND (pinos 4, 5, 12, e 13): Os quatro pinos no meio conectar a um terreno compartilhado entre
seus 9V e 5V suprimentos.
■ V■
CC2 (Pin 8): V fornece a corrente do motor, de modo que o ligar ao
CC2
V■ 9V.
■
(Pin 16): V
poderes lógica do chip, para que você conectá-lo a 5V.
CC1 CC1
■ 1■Y e 2A (pinos 3 e 6):Estas são as saídas do controlador para a esquerda. Os fios do motor ligar
a estes pinos.
■ 1■A e 2A (pinos 2 e 7): Os estados dos interruptores à esquerda são con-trolada por estes pinos,
então eles estão ligados à I / O pinos no Arduino para alternar.
■ 1■,2EN (Pin 1):Este pino é usado para ativar ou desativar o driver esquerda. Ele é ligado a um
pino de PWM no Arduino, de modo que a velocidade pode ser controlada dinamicamente.
■ 3■Y e 4Y (pinos 11 e 14): Estas são as saídas do driver correto.

Porque você está usando apenas o motorista esquerda, você pode deixá-los desligados.
■ 3■A e 4A (pinos 10 e 15): Os estados dos interruptores à direita são

controlados por estes pinos, mas você estiver usando apenas o condutor esquerda neste
exemplo, para que você possa deixá-los desligados.
■ 3■,4EN (Pin 9):Este pino é usado para ativar ou desativar o driver correto. Porque
você não vai estar usando o driver correto, você pode desativá-lo, ligando este pino
diretamente para GND.
Para referência, confirme sua fiação com a Figura 4-7. Mantenha o potenciômetro
com fio, como era antes.
Bateria
Imagem criada com o Fritzing.

H-ponte
Potenciômetro
motor DC
Figura 4-7: esquema de ligações H-ponte
Você pode confirmar que o circuito está a funcionar antes de programá-lo enganchando
-se o pino de permitir a 5V, ligando um dos UMA pinos para a terra, ea outra UMA
fixar a 5V. Você pode inverter a direção, trocando o que oUMA pinos estão conectados.
ATENÇÃO shoulddisconnectthe9VbatterywhileswappingtheUMApinsto
ensurethatyoucan'tpossiblycauseanaccidentalshortcircuitwithintheH-ponte.
A operação de um circuito de ponte H
Em seguida, você escrever um programa para controlar a direcção do motor e velocidade

usando o potenciômetro eo H-ponte. Ajuste do potenciómetro em uma faixa intermediária
pára o motor, definindo o potenciómetro numa gama acima do meio aumenta a velocidade para a frente,
e definir o potenciómetro numa gama abaixo do meio aumenta a velocidade para trás. Esta é mais uma
oportunidade perfeita para empregar funções em seu programa Arduino. Você pode escrever uma função
para parar o motor, um para fazer com que ele gire para a frente a uma velocidade set, e uma para
causar- lhe a girar para trás a uma velocidade set. Certifique-se de desativar corretamente o H-ponte no início
da função antes de alterar o modo de motor; isso reduz a probabilidade de que você vai cometer um erro e
acidentalmente curto o H-ponte.
Seguindo o diagrama lógico da Figura 4-6, você pode rapidamente descobrir como
é preciso controlar os pinos para alcançar os resultados desejados:
■ P■ara interromper o fluxo de corrente através do dispositivo, defina o pino de baixo habilitar.
■ P■ara definir as opções para a rotação em uma direção, definir um alto, outro baixo.
■P■ara definir comutadores para a rotação no sentido oposto, de comutação que é elevado e
que é de baixo.
■ P■ara fazer com que o motor pare imediatamente, defina ambos os interruptores baixa.
NOTA waysdisablethecurrentflowbeforechangingthestateoftheswitches
toensurethatamomentaryshortcannotbecreatedastheswitchesflip.
Primeiro, você deve desenvolver as funções que com segurança executar o anteriormente
movimentos descritos. Criar um novo esboço Arduino e começar a escrever o seu
novas funções:
// Motor vai para a frente em uma determinada taxa (0-255)

para a frente void (taxa int)
{
digitalWrite (PT, LOW); digitalWrite
(MC1, HIGH); digitalWrite (MC2,
LOW); analogWrite (PT, a taxa);
// Motor vai para trás em uma determinada taxa (0-255) vazio

reverso (taxa int)
{
(MC1, LOW); digitalWrite (MC2,
HIGH); analogWrite (PT, a taxa);
// Pára freio
motorvoid ()
{
LOW); digitalWrite (PT, HIGH);
Note-se que no início de cada função da PT pin é sempre definido baixo, e

então o MC1 e MC2(pinos de controle do motor) são ajustados. Quando isso é feito, o fluxo de
corrente pode ser reativado. Para variar a velocidade, é só usar a mesma técnica que você fez antes.
Usando PWM, você pode mudar o dever com o qual
a PTpin é alternado, controlando assim a velocidade. otaxa variável deve ser

entre 0 e 255. O circuito principal se encarrega de fazer a direita taxa a partir dos dados de entrada
do potenciômetro.
Em seguida, considerar o loop principal do programa:
void loop ()
{
val = analogRead (POT);
// Ir forwardif (val>
562)
{
velocidade = map (val, 563, 1023, 0, 255); para a frente
(velocidade);
// Ir backwardelse if (val
<462)
{
= velocidade de mapa (Val, 461, 0, 0, 255); reversa
(velocidade);
// brakeelse
{
freio();
}
}
No circuito principal, o valor de potenciômetro é lido, ea função apropriada

ção pode ser chamada com base no valor do potenciómetro. Lembre-se que as entradas analógicas
são convertidas em valores digitais entre 0 e 1023. Consultar a Figura 4-8 para melhor
compreender o esquema de controle e comparar isso com o código de ciclo anterior.
Figura 4-8: plano de controle do motor.
Quando o potenciómetro se encontra dentro dos 100 unidades que rodeiam o ponto
central, a freiofunção é chamada. Conforme o valor aumenta de potenciómetro 562para
1023, A velocidade aumenta a frente. Da mesma forma, a velocidade de aumento no
inverso
direção entre valores potenciômetro de 462e 0. omapafunção deve
parece familiar para você a partir do capítulo anterior. Aqui, ao determinar o
velocidade reversa, observe a ordem das variáveis: 461é mapeado para 0e 0é
mapeado para 255; amapafunção pode inverter o mapeamento, quando as variáveis são passados em
ordem decrescente. Colocar o loop juntamente com as funções e oconfiguração, Você recebe
um programa completo que se parece com o mostrado na Listagem 4-3. Certifique-se de que o
seu programa corresponde a um aqui e carregá-lo em seu Arduino.
Listagem 4-3: H-Ponte Potenciómetro Motor Control-hbridge.ino
// Hbridge Motor Controlconst int PT = 9; // Meia

Ponte 1 Enableconst int MC1 = 3; // Controle Motor
1const int MC2 = 2; // Controle Motor 2const int POT
= 0; // POT na Analog Pin 0
int val = 0; // Para armazenar a leitura a partir da velocidade POTint = 0; // Para

armazenar a velocidade desejada (0-255)
void setup ()
{
pinMode (PT, OUTPUT); pinMode (MC1,
OUTPUT); pinMode (MC2, OUTPUT); freio (); //
Inicializar com motor parado
void loop ()
{
val = analogRead (POT);
// Ir forwardif (val>
562)
{
Capítulo 4 Usando transistores e condução Motors
■ 7
velocidade = map (val, 563, 1023, 0, 255); para a frente

(velocidade);
// Ir backwardelse if (val
<462)
{
= velocidade de mapa (Val, 461, 0, 0, 255); reversa
(velocidade);
// brakeelse
{
freio();
}
}
// Motor vai para a frente em uma determinada taxa (0-255)

para a frente void (taxa int)
{
(MC1, HIGH); digitalWrite (MC2,
LOW); analogWrite (PT, a taxa);
// Motor vai para trás em uma determinada taxa (0-255) vazio

reverso (taxa int)
{
HIGH); analogWrite (PT, a taxa);
// Pára freio
motorvoid ()
{
LOW); digitalWrite (PT, HIGH);
Será que tudo funciona como esperado? Se não, certifique-se de que você fio o seu
circuito corretamente. Como um desafio adicional, pegue um segundo motor DC e um
gancho
-lo para a outra metade do chip ponte-H. Você deve ser capaz de conduzir dois
motores em simultâneo com o mínimo esforço.
DrivingServoMotors
motores de corrente contínua servir como excelentes motores de acionamento, mas eles não são tão ideal
para trabalhos de precisão, porque nenhum feedback ocorre. Em outras palavras, sem o uso de um encoder
externo de algum tipo, você nunca vai saber a posição absoluta de um motor DC. servo motores, ou
servos, em contraste, são os únicos que você comandá-los para rodar para uma posição angular particular
e eles ficam lá até que você diga a eles para se mover para uma nova posição. Isto é importante para
quando você precisa mover o seu sistema para uma posição conhecida. Exemplos incluem a actuação
fechaduras de portas, movendo
armaduras para rotações específicas, e precisamente controlando a abertura de uma

abertura. Nesta seção, você aprenderá sobre os servos motores e como controlá-los a partir do seu
Arduino.
UnderstandingtheDifferenceBetweenContinuousRotationandStandardServos
Você pode comprar ambos os servos de rotação padrão e contínuos. servos não
modificados ter sempre uma faixa fixa (geralmente de 0 a 180 graus), porque existe uma
potenciômetro em linha com o eixo de acionamento, que é usado para relatar a posição pres-ent.
servo- controlo é conseguido através do envio de um impulso de um determinado comprimento. O
comprimento do pulso, no caso de uma rotação do servo padrão, determina a posição absoluta que
o servo irá rodar para. Se remover o potenciómetro, no entanto, o servo é livre para rodar continuamente,
eo comprimento de impulso define a velocidade do motor, em vez.
Neste livro, você usa servos standard que giram para uma posição absoluta. Você
pode experimentar com servos rotação contínua, quer através da abertura de um
padrão servo e remover com cuidado o potenciômetro, ou através da compra
premodified servos configurado para rotação contínua.
UnderstandingServoControl
Ao contrário de suas contrapartes do motor DC, servo motores têm três pinos: Potência (usu-aliado
vermelho), terra (geralmente marrom ou preto), e de sinal (geralmente de cor branca ou laranja).
Estes fios são codificados por cores, normalmente na mesma ordem, e geralmente olhar como os
mostrados na Figura 4-9. Alguns fabricantes podem usar ordenação não-padrão, por isso sempre se
esqueça de verificar a folha de dados para garantir que está a fiação do servo corretamente.
A coloração pode variar ligeiramente entre servos, mas os esquemas de cores listados
anteriormente são os mais comuns. (Verifique a documentação do servo se você estiver
inseguro.) Como motores de corrente contínua, servos pode tirar um pouco de uma corrente
(normalmente
Capítulo ■Usando transistores e condução 8
mais do que o Arduino pode fornecer). Embora às vezes você pode executar um ou dois servos
diretamente da fonte de 5V do Arduino, você aprender aqui como usar uma fonte de alimentação
separada para os servos de modo que você tem a opção de adicionar mais
se você precisar.
Usado com permissão de Parallax Inc. Copyright © 2013 Parallax

Inc. Todos os direitos reservados.
Figura 4-9: servomotores
Servos têm um pino de controle dedicado, ao contrário de motores de corrente contínua, que instrui-los
que posição a quem recorrer. As linhas de alimentação e terra de um servo deve sempre ser
conectado a uma fonte de energia constante.
Servos são controlados usando larguras de pulso ajustável na linha de sinal. Para
um servo standard, o envio de um pulso 1ms 5V liga o motor para 0 graus, e enviando um pulso 2ms 5V
liga o motor a 180 graus, com comprimentos de pulso no meio de escala de forma linear. Um pulso
1.5ms, por exemplo, o motor gira a 90 graus. Uma vez que um pulso foi enviada, o servo se volta
para essa posição e estadias
lá até que outra instrução de pulso é recebido. No entanto, se você quer um servo para
"Segurar" a sua posição (resistir a ser empurrado e tentar manter a posição exata),
você apenas reenviar o comando uma vez a cada 20 ms. Os comandos de servo Arduino que serão,
posteriormente empregar cuidar do presente para você. Para entender melhor como funciona o controle
de servo, estudar o diagrama de tempo mostrado na Figura 4-10.
Imagem criada com o

Figura 4-10: Servo diagrama de tempo do motor
Note-se que em cada um dos exemplos na Figura 4-10 do impulso é enviado a cada 20ms.
Como o comprimento do pulso aumenta de 1 ms a 2 ms, o ângulo de rotação do
motor (mostrado à direita do gráfico de pulso) aumenta de 0 a 180 graus.
Como mencionado antes, servos pode desenhar mais corrente do que o Arduino pode
ser capaz de fornecer. No entanto, a maioria dos servos são projetados para funcionar em 5V, não 9V
ou 12V como um motor DC. Mesmo que a tensão é a mesma que a de um Arduino, você quer usar uma
fonte de energia separada que pode fornecer mais corrente.
Para fazer isso, você aprender aqui como usar uma bateria de 9V e um regulador linear para
gerar uma fonte de 5V a partir de sua bateria de 9V. Um regulador linear é um dispositivo
terrestres.
extremamente simples, que geralmente tem três pinos: tensão de entrada, tensão de saída, e
O pino terra está ligado tanto a base da alimentação de entrada e no chão da saída. No caso dos
reguladores lineares tensão, a tensão de entrada sempre deve ser maior do que a tensão de saída, e a
tensão de saída é ajustada a um valor fixo de acordo com o regulador de utilizar.
A queda de tensão entre a entrada e a saída é queimado na forma de calor,

e o regulador cuida de assegurar que a saída permanece sempre a mesma, mesmo que a tensão da
entrada de gotas (no caso de um discharg-ing bateria ao longo do tempo). Para estas experiências, você
usa um regulador de tensão L4940V5 5V. É capaz de fornecer até 1,5 amps em 5V. Figura 4-11 mostra
um esquema de como ligar o regulador.
Imagem criada com o Águia

Figura 4-11: 5V Linear esquema regulador
Observe os capacitores em cada lado do regulador. Estes são chamadosdissociação

capacitores; eles são usados para suavizar o sinal de tensão de cada oferta volt-idade com cargas e
descargas a opor-se ondulações na tensão. A maioria das folhas de regulador linear incluir um circuito
sugeriu que inclui valores ideais e tipos para esses capacitores baseados em seu cenário de caso de
uso. Também tenha em mente que o 5V criado por este regulador deve ser mantido separado do trilho de
alimentação 5V do Arduino. Suas terras, no entanto, devem ser amarrados juntos.
Usando todas essas informações, é hora de conectar um servo. Fazendo referência a Figura 4-12,
conectar o servo, o regulador de 5V, eo potenciômetro. Deixar o potenciômetro
ligado ao pino analógico 0, conectar o pino de controle servo ao pino 9, e garantir que o regulador de
5V fornece o poder do servo.
Enquanto fiação, tenha em mente algumas coisas importantes. Em primeiro lugar, garantir que você
ter a orientação correcta do regulador. Com a guia de metal no lado
mais distante de você, conectar a bateria ao pino mais à esquerda, o terreno para o pino central, ea linha de
alimentação do servo para o pino direita. Em segundo lugar, se estiver usando capacitores eletrolíticos
polarizados (como na Figura 4-12), certifique-se de colocá-los na direção correta. A faixa indica o
terminal negativo e deve ser ligado à terra comum. Certifique-se de que os pinos não tocam; caso contrário,
poderá provocar um curto. Depois que você está todo ligado, passar para a próxima seção para
aprender a programar o controlador servo.
capacitores de desacoplamento
Bateria
Imagem criada com o

servo
regulador de 5V Potenciômetro
Figura 4-12: Servo diagrama de fiação experimento
ENTENDENDO Reguladores lineares e os limites das fontes de alimentação

ARDUINO
Whyisitnecessarytouseanexternalpowersupplywhencertainitemsrequiremorecurrent? Therearefewreasons.TheI / Opinscannotsupp

each.BecauseaDCorservomotorcancon-sumehundredsofmilliamps, thei / Opinsarenotcapableofdrivingthemdirectly.Eveniftheywere
youwouldn'twanttobecauseofthedamagethatcanbecausedbyinductivevoltagespikes.
ItmakessensethatyouneedtouseanexternalsupplywithaDCmotorbecauseyouneedthehighervoltage, butwhydoesaservoneedane
supplyifitisatthesamevoltageastheArduino? TheArduinogeneratesthe5VusedforthelogiceitherdirectlyfromtheUSBorbyusingabuilt-
inlinearregulatorwiththeDCbarreljackasthesupplyvoltage.WhenyouuseUSB, amaximumof500mAisavailabletotheArduinoandallitsp
becausethatiswhattheUSBspecificationallows.Whenyouuseanexternalsupplyofsufficientcurrent, thebuilt-inregulatorcansupplyupto
Servoshaveatendencytoconsumecurrentinburstsastheyturn.They
generallyconsumelittlecurrentwhilestationary,
andtheyconsumeseveralhundredmilliampsforafewmillisecondswhentheyareactuated.Thesecurrentspikescanrippleonthe5V
componentes, likeLEDs.Bykeepingthesupplyfortheservoonaseparaterail, youensurethatthisdoesnothappen.
Insufficientcurrentforaservomightalsocauseittobehaveerratically.
. Whenyoufinishthefinalprojectforthischapter, tryhookingtheservosup-plypinuptothebuilt-in5Vrail (Don'tworry;. Thiswon'td
WhentheservoispoweredoverUSB, youmayseetheservodoingallkindsofunexpectedmotionsduetoaninsufficientcurrentsuppl
thedegreeofthisbehaviordependsonthespecificationofyourparticularservo.
ControllingaServo
O Arduino IDE inclui uma biblioteca interna que torna o controle servos um
brisa. Uma biblioteca de software é um conjunto de código que é útil, mas não é sempre necessária
em desenhos. O Arduino IDE contém um número de bibliotecas para tarefas com-mon. A biblioteca servo
abstrai as rotinas de tempo que você precisa para escrever em seu próprio país para pulsar o pino
servo. Tudo que você tem a fazer é anexar um "objeto" servo a um pino especial e dar-lhe um ângulo
para girar para. A biblioteca cuida do resto, mesmo definindo o pino como uma saída. A maneira
mais simples para testar a funcionalidade do seu servo é mapear o potenciômetro diretamente a posições
servo. Virando o potenciômetro para
0move o servo para 0 graus,

e movê-lo para 1023move o servo para 180 graus. Criar um novo desenho com o código da
Listagem 4- 4 e carregá-lo para o seu Arduino para ver este funcional-dade em ação.
Listagem 4-4: Servo Potentiometer Control-servo.ino
// Servo controle do potenciômetro
#include <Servo.h>
const int SERVO = 9; // Servo no Pino 9const int POT

= 0; // POT na Analog Pin 0
Servo myServo; int val = 0; // Para armazenar a leitura do POT
void setup ()
{
myServo.attach (SERVO);
void loop ()
{
val = analogRead (POT); // Leia Potval = map (val, 0, 1023, 0, 179); // Escalá-
lo para myServo.write gama servo (val); // Define o atraso de servo (15); //
Espera para o servo
o incluirinstrução na parte superior do programa adiciona a funcionalidade de

a biblioteca servo ao seu esboço. servo myServofaz com que um objecto servo chamada
myServo. Em seu código, sempre que você quer dizer ao servo o que fazer, você
vai referir-se myServo. Dentroconfiguração(), Anexando o servo inicializa tudo o
necessário
para controlar o servomecanismo. Você pode adicionar vários servos chamando os objetos diferentes
coisas e anexando um pino diferente para cada um. Dentroloop (), O pote é lido, escalado
para um valor apropriado para o servo-controlo, e é, em seguida, "escrita" para o servo pulsando o
pino
apropriado. O atraso 15ms garante que o servo chega ao seu destino antes de tentar enviá-lo outro
comando.
BuildingaSweepingDistanceSensor
Para encerrar este capítulo, você aplicar seu conhecimento a partir dos últimos capítulos para
construir um sensor de distância varrendo light-up. O sistema consiste de um infravermelho
sensor (RI) distância montado sobre um servo motor e quatro LEDs. À medida que o servomotor
ciclos, ele roda o sensor de distância ao redor da sala, o que lhe permite determinar
aproximadamente onde os objetos estão perto e onde eles estão agora. Os quatro LEDs cor-responder a
quatro quadrantes do brilho de varredura e mudança dependendo de como próximo um objeto é
nesse quadrante.
Porque a luz IR é uma parte do espectro electromagnético que os seres humanos

não pode ver, um sistema como este pode ser implementado para criar "visão noturna." As obras
sensor de distância IR brilhando um LED IR e utilizando alguns circuitos bastante complexo para
calcular o ângulo em que essa luz IR retorna a um sensor fotográfico montado ao lado LED de IR.
Usando voltagens analógicas criados pela
as leituras de sensor fotográfico de IV, a distância é calculada e convertida em

um sinal de tensão analógico que você pode ler no microcontrolador. Mesmo que a sala é escura
e você não pode ver o quão perto um objeto é, este sensor pode porque está usando um
comprimento de onda de luz que o olho humano não consegue detectar.
Diferentes modelos de telémetros IR pode ter interfaces diferentes. Se vocês são

usando um telêmetro que é diferente do que o utilizado neste exemplo, consulte a folha de dados
para certificar-se ele envia uma tensão variável como uma saída.
NOTA oucanwatchademovideoofthesweepingdistancesensoronline:
www.exploringarduino.com/content/ch4.YoucanalsofindthisvideoontheWileywebsiteshownatthebeginningofthischapter.
Comece quente colando-o sensor de distância para o topo de um servo-motor, como mostrado
na Figura 4-13. Eu gosto de usar cola quente porque mantém bem e é bastante fácil de remover, se
você precisar. No entanto, você também pode usar super-cola, massa de vidraceiro, ou fita
para começar o trabalho feito.
Figura 4-13: sensor de distância IR montado para o servo
Em seguida, ligar o seu servo até o Arduino, usando o regulador de 5V ao poder

-lo, assim como você fez antes. O sensor de distância IR substitui o potenciômetro e se conecta a pino
analógico 0. Quatro LEDs ligar para os pinos 3, 5, 6, e 11 por meio de resistências de 1k. O Arduino
Uno tem seis pinos PWM totais, mas pinos 9 e 10 não pode criar sinais PWM (usando analogWrite) Quando você
estiver usando a biblioteca servo. Isto é porque a biblioteca servo usa o mesmo temporizador de
hardware como a utilizada
PWM para controlar nesses dois pinos. Assim, foram escolhidas as outras quatro pinos PWM.
(Se você quer fazer este projecto com mais LEDs, use o Arduino Mega ou implementar uma
solução PWM software, algo que este livro não cobre.) Siga o diagrama de fiação na Figura 4-14
para confirmar que você tem tudo
com fio corretamente. Eu escolhi usar LEDs azuis, mas você pode usar qualquer cor que você
quiser. Depois de ter tudo cabeada, considere gravá-la para baixo, como mostrado na Figura 4-13.
distância do IR
sensor
Dissociação
capacitores
Bateria
Imagem criada com o

servo
regulador de 5V LEDs
Figura 4-14: distância de varrer diagrama de fiação do sensor
O último passo é programar o sensor. O sistema funciona da seguinte

forma: Girar a uma determinada posição, medir a distância, convertê-lo para um valor que pode ser
utilizado para o LED, que altere o brilho do diodo emissor de luz, mover-se para a posição
seguinte, e assim por diante, e assim por diante. Listagem 4-5 mostra o código para fazer isso. Copiá-lo
para um novo esboço e enviá-lo para o seu Arduino.
Listagem 4-5: Distância de varrer Sensor-sweep.ino
// Varrendo Distância Sensor

#include <Servo.h>
const int SERVO = 9; // Servo no Pino 9const int IR = 0; // IR Sensor

de Distância em Analog Pin 0const int LED1 = 3; // Output LED
1const int LED2 = 5; // Output LED 2const int LED3 = 6; // Output
LED 3const int LED4 = 11; // Output LED 4
Servo myServo; // Servo Objectint dist1 = 0; //

Quadrante 1 Distanceint dist2 = 0; // Quadrante
2 Distanceint dist3 = 0; // Quadrante 3
Distância
int dist4 = 0; // Quadrante 4 Distância
void setup ()
{
myServo.attach (SERVO); // Fixe o ServopinMode (LED1,
OUTPUT); // Conjunto de LED para OutputpinMode (LED2,
OUTPUT); // Conjunto de LED para saída
void loop ()
{
// Varrer o Servo em 4 regiões e alterar o LEDsdist1 = readDistance (15); // Medida
Distância IR em 15 degreesanalogWrite (LED1, dist1); // Ajuste Brightnessdelay
LED (300); // Atraso antes próxima medição
dist2 = readDistance (65); // Medida Distância IR em 65 degreesanalogWrite (LED2,

dist2); // Ajuste Brightnessdelay LED (300); // Atraso antes próxima medição
dist3 = readDistance (115); // Medida Distância IR a 115 degreesanalogWrite (LED3,

dist4 = readDistance (165); // Medida Distância IR a 165 degreesanalogWrite (LED4,

int readDistance (int pos)

{
myServo.write (pos); // Move to dada positiondelay (600); // Espere por Servo
para moveint dist = analogRead (IR); // Leia IR Sensordist = map (dist, 50,
500, 0, 255); // Escala-lo para LED faixa de dist = constranger (dist, 0, 255); //
Restringir dist itreturn; // Retorna distância à escala
O programa emprega uma função simples que roda o servo ao solicitado

grau, toma a medida de distância, dimensiona-lo, e, em seguida, retorna para o
loop (). Mapa que você escolher para a faixa de LED depende da configuração do seu
sistema. Descobri que o objeto mais próximo que eu queria para detectar registrados
5e0m0,torno de e o objecto mais distante era torno 50, então o mapa()foi criado em
conformidaldooep. ()
executa esta função para cada um dos quatro LEDs, então repete. Quando completo,
o sistema deve funcionar de forma semelhante à mostrada na demonstração de vídeo
listados no início desta seção.
Resumo
Neste capítulo, você aprendeu sobre o seguinte:
■ m■otores de corrente contínua usar indução eletromagnética para criar ação

mecânica de mudanças na atual.
■O■s motores são cargas indutivas que devem utilizar uma protecção adequada e os circuitos de
energia para fazer a interface com segurança com o Arduino.
v elocidade do motor de corrente contínua e a direcção pode ser controlada com PWM e uma
■ ■
ponte-H.
s ervomotores permitem um posicionamento preciso e pode ser controlado usando a biblioteca

■ ■
Arduino Servo.
■ U■m regulador linear pode ser utilizado para criar uma fonte de 5V secundário a partir de uma
bateria de 9V.
s ensores de distância IR retornar valores analógicos que representam distâncias detectadas

■ ■
saltando luz infravermelha fora objetos.
■ C■ódigo comentando é fundamental para facilitar a depuração e partilha.

Capítulo
fazendo Sounds
Peças que você vai precisar para este capítulo
Arduino UnoUSB
cablePushbuttons (n5)
10kohms resistores (n5)
altifalante 150Ω
resistorJumper
wiresBreadboard10KΩ
potentiometer8Ω
CÓDIGO E CONTEÚDO DIGITAL PARA ESTE CAPÍTULO
downloads de código, vídeo e outros conteúdos digitais para este capítulo pode ser encontrada em
www.exploringarduino.com/content/ch5 .
Os downloads de código wiley.com deste capítulo foram encontrados ewmww.wiley.com/

go / exploringarduinona guia de transferência de código. O código está no capítulo 05
baixar e individualmente nomeados de acordo com os nomes de todo o capítulo.
91
Os seres humanos têm cinco sentidos. Como você deve ter adivinhado, você não vai ser a interface
o seu sentido do paladar com muitos produtos eletrônicos; lambendo seu Arduino é um pobre
idéia. Da mesma forma, cheiro não será geralmente entram em jogo. Na verdade, se você pode cheirar o
seu
eletrônica, algo provavelmente está queimando (e você deve parar o que está fazendo). Isso só deixa
os sentidos do tato, visão e som. Você já interligado com potenciômetros e botões que se aproveitam
de seu senso de toque, e você ter ligado LEDs que fazem interface com você sentido da visão. Agora, o que
acontece com os seus sentidos auditivos? Este capítulo se concentra no uso do Arduino para fazer
sons para que você possa mais facilmente recolher feedback dos seus projetos.
É possível gerar som com um Arduino em um número de maneiras. O mais simples

método consiste em utiltiozmar()ofunção, que este capítulo focaliza mais fortemente.
No entanto, você também pode usar vários escudos que agregam mais complexa, música-playing
capacidades ao Arduino com a ajuda de algum processamento externo. (Shields são add-on placas
que ligam a parte superior do seu Arduino para adicionar a função-ality específica. Você não vai usar
qualquer neste capítulo, mas você estará usando escudos variados em alguns dos capítulos
posteriores.) Se você possui o Arduino Due, você pode usar o seu verdadeiro conversor digital-
analógico (DAC) para produzir sons.
UnderstandingHowSpeakersWork
Antes que você possa fazer sons com o Arduino, você precisa entender o que são sons e como os seres
humanos percebem-los. Nesta primeira seção, você aprenderá sobre como as ondas sonoras são geradas,
suas propriedades, e como a manipulação dessas propriedades pode produzir música, vozes, e assim
por diante.
ThePropertiesofSound
O som é transmitido através do ar como uma onda de pressão. Como um objeto, como um alto-falante,
um tambor, ou um vibra sino, esse objeto também vibra o ar em torno dele. À medida que as partículas
de ar vibrar, transferem energia para as partículas em torno deles, vibrando estas partículas também.
Desta forma, uma onda de pressão é transferida da fonte para o tímpano, criando uma reação em
cadeia de vibrar par-tigos. Então, por que você precisa saber isso para entender como fazer sons
com o Arduino?
Você pode controlar duas propriedades dessas partículas vibrando com o seu Arduino:
frequência e amplitude. ofreqüência representa quão rapidamente as partículas do ar
vibrar e para trás, eo amplitude representa a magnitude da sua
vibrações. No sentido físico, sons de amplitude mais elevados são mais altos, e os sons de amplitude mais
baixos são mais silenciosos. sons de alta frequência são um tom mais alto (como uma soprano), e sons
de baixa frequência são um tom mais baixo (como baixo). Considere o diagrama na Figura 5-1, que mostra
representações senoidais de ondas sonoras de várias amplitudes e frequências.
capítulo fazendo
■ 9
Imagem criada com o

Figura 5-1: As ondas sonoras de diferentes frequências e amplitudes
Figura 5-1 mostra três notas de piano: baixo, médio e soprano C. Cada um
mostra as frequências dadas em ambas as amplitudes altas e baixas. Como exemplo, para entender
frequência e amplitude, foco no meio C. Oriente C tem uma frequência de 261,63 Hertz (Hz). Em
outras palavras, um alto-falante, uma corda de guitarra, ou
uma corda de piano iria completar 261.63 oscilações por segundo. Ao tomar o
recíproco desse valor, você pode encontrar o período da onda, que é fácil de ver na Figura 5-1. 1 /
261,63 milissegundos é igual a 3.822, que é a largura de uma oscilação completa no gráfico. Usando o
Arduino, você pode definir esse período para uma onda quadrada e, assim, ajustar o tom da nota.
Importante, o Arduino (excluindo verdadeira CAD da Due) não pode, na verdade,

fazer uma onda sinusoidal que você pode observar no mundo real. Um quadrado
onda é uma onda-lo periódica digital também oscila entre um alto e um valor baixo, mas ele muda
instantaneamente, em vez de lentamente como uma onda senoidal. Isso ainda cria uma onda de
pressão que resulta em som, mas não é tão "bonito" soando como uma onda sinusoidal.
Como para a amplitude, é possível controlar que, alterando o valor do

corrente permitida a fluir através do alto-falante. Usando um potenciômetro em linha com o alto-
falante, você pode ajustar dinamicamente o nível de volume do alto-falante.
HowaSpeakerProducesSound
Alto-falantes, bem como os motores que você aprendeu sobre no capítulo anterior, tirar proveito de forças
eletromagnéticas que transformam eletricidade em movimento. Tente segurar um pedaço de metal até
a parte traseira do seu alto-falante. Você notou alguma coisa interessante? O metal, provavelmente, varas
para a parte traseira de seu alto-falante, porque todos os alto-falantes têm um íman permanente
considerável montado na parte de trás. Figura 5-2
mostra um corte transversal de um altifalante comum.
GNU Free Documentation
Figura 5-2: seção transversal Speaker
O ímã permanente é montado atrás da bobina de voz e um pólo mostrado

na imagem. À medida que envia um sinal de tensão sinusoidal (ou uma onda quadrada, no caso de o
Arduino) para os fios da bobina, a actual mudança induz um campo magnético que faz com que a
peça polar e o diafragma a vibrar para cima e para baixo
como o ímã permanente é atraído e, em seguida, repelido pela magnética

campo que tem gerado. Esta vibração vai-e-vem, por sua vez, vibra o ar na frente do orador,
efetivamente criando uma onda sonora que pode viajar para o tímpano.
capítulo ■Fazendo sons
Usingtone () toMakeSounds
O Arduino IDE inclui uma função built-in para fazer facilmente sons de freqüências arbi-trário.
otom()função gera uma onda quadrada da frequência seleccionada no pino de sua escolha de
saída. o
tom()função aceita três
argumentos, embora o último é opcional:
■ O■primeiro argumento define o pino para gerar o sinal em.
■ O■segundo argumento define a frequência do tom.
■ O■terceiro (opcional) argumento define a duração do tom. Se o terceiro argumento não for
definida, o tom continua tocando até que você chamar
nenhum().
Porque tom()usa um dos temporizadores de hardware do ATMEGA, você pode iniciar uma
tom e fazer outras coisas com o Arduino ao mesmo tempo que continua a reproduzir o som de
fundo.
Nas seções seguintes, você aprender a tocar sequências sonoras arbitrárias.

Uma vez que você tenha obtido esse trabalho, você potodme()ucsoamr o resposta a várias
entradas (botões, sensores de distância, acelerômetros, etc.). No final do capítulo, você constrói um
simples de piano com cinco botões que você pode jogar.
IncludingaDefinitionFile
Quando se trata de reprodução de música, um arquivo de definição que mapeia frequências notar
nomes se mostrou útil. Isso torna mais intuitiva para reproduzir clipes musicais simples. Para aqueles
familiarizados com partituras leitura, você sabe que as notas são indicadas por letras que representam o
seu campo. O Arduino IDE inclui um arquivo de cabeçalho que correlaciona cada uma dessas notas
com sua respectiva frequência. Em vez de dig-Ging através do Arduino diretório de instalação para
encontrá- lo, basta visitar o Explorando
Capítulo Arduino 5 página web, e fazer o download do arquivo de campo para o seu
desktop (www.exploringarduino.com/content/ch5 ). Você vai colocá-lo em sua direção
esboço tory depois que você criou.
Em seguida, abra o IDE Arduino e salvar o esboço em branco que é automaticamente
criado quando você abre o IDE. Como você provavelmente já percebeu, quando você salvar um
esboço, ele realmente salva uma pasta com esse nome e coloca um arquivo .ino dentro dessa pasta. Ao
adicionar outros arquivos para essa pasta, você pode incluí-los em seu programa, tudo ao mesmo
tempo manter seu código melhor organizado. Copie o arquivo pitches.h você salvou na área de trabalho
para a pasta criada pelo IDE; em seguida, fechar o Arduino IDE. Abra o arquivo .ino no Arduino IDE e
observe as duas abas que aparecem agora (veja a Figura 5-3).
Figura 5-3: IDE Arduino com um arquivo de cabeçalho secundário
Clique na guia pitches.h para ver o conteúdo do arquivo. Note-se que é apenas uma lista
de instruções de definição, que mapeiam nomes legíveis para valores de frequência dadas. Basta ter
o arquivo de cabeçalho no IDE não é suficiente, no entanto. Para garantir que o compilador realmente usa
essas definições ao compilar o seu
programa para o Arduino, você precisa dizer ao compilador para procurar o arquivo. fazendo
por isso é fácil. Basta adicionar esta linha de código para o início do seu arquivo .ino:
#include "pitches.h" // arquivo de cabeçalho com definições de pitch
Para o compilador, este é essencialmente a mesma coisa que copiar e colar o

conteúdo do arquivo de cabeçalho no topo de seu arquivo principal. No entanto, este mantém o mais puro
arquivo e mais fácil para você ler. Nas próximas seções, você escreve o código para o resto desse
arquivo para que você possa realmente usar as definições passo que acabou importados.
WiringtheSpeaker
Agora que você tem seu arquivo de campos de cabeçalho incluído, você está pronto para construir um
circuito de teste e escrever um programa simples que pode jogar um pouco de música. A
instalação elétrica é bastante simples e envolve apenas ligar um alto-falante para um pino do seu
Arduino saída. No entanto, lembre-se que você aprendeu nos capítulos anteriores sobre resistores
limitadores de corrente.
Tal como aconteceu com LEDs, que pretende colocar um resistor limitador de corrente em série
com o alto-falante para garantir que você não tente chamar muita corrente de um dos
pinos de I / O do Arduino. Como você aprendeu anteriormente, cada pino de I / O podem fornecer
apenas um máximo de 40 mA, então escolha uma resistência que o impede de superior a isso. o
capítulo Fazendo sons
■
alto-falante que vem com kit deste livro tem uma resistência interna de 8Ω (como a maioria dos alto-
falantes que você pode comprar); esta resistência vem dos enrolamentos de fio que formam o
electroiman. Lembre-se que a lei de Ohm estabelece que V = IR. Neste cenário, o pino de I / O é saída 5V,
e você não quer exceder 40 mA. Resolvendo para R, você achar que a resistência mínima deve ser:
R = 5V / 40mA = 125Ω. 8Ω já está contabilizada pelo alto-falante, para que o seu resistor-line in deve
ser de pelo menos 125Ω - 8Ω = 117Ω. O resistor comum mais próxima é 150Ω, então você pode usar
isso. Ao ajustar esse valor resistor, você pode alterar o volume do alto-falante. Para fazer isto tão
fácil quanto possível, você pode usar um potenciômetro em linha com o resistor de 150Ω, conforme
mostrado na Figura 5-4. No esquema, o símbolo R1 representa o 150Ω
resistor, e R2 é o potenciómetro.
Figura 5-4: ligação do altifalante com o botão de ajuste de volume
Note-se que ao contrário de seus usos anteriores de potenciômetros esta configuração

usa apenas dois pinos: o Oriente (ou limpador) pino vai para o alto-falante, e qualquer um dos dois
dos pinos de extremidade se conecta ao resistor 150Ω. Quando o botão é girado toda a
caminho para o terminal sem ligação, toda a resistência do potenciómetro
é adicionado à resistência em série do resistor 150Ω, e diminui os volumes.
Quando o botão é girado todo o caminho em direção ao terminal final conectado, ele
acrescenta nenhuma resistência à série, eo orador é com o volume no máximo. Referenciando o esquema
na Figura 5-4, fio de seu alto-falante com o Arduino. Em seguida, confirme
sua fiação usando o diagrama na Figura 5-5.
Figura 5-5: diagrama de fiação Speaker

Alto-falantes não têm uma polaridade; você pode conectá-los em qualquer direção.
Depois da fiação seu alto-falante com sucesso, você está pronto para fazer música!
MakingSoundSequences
Para reproduzir algumas músicas, você primeiro aprender sobre como usar matrizes para armazenar
vários valores facilmente. Você, então, implementar um loop simples para percorrer as matrizes de
notas e reproduzi-los no alto-falante.
usando Arrays
Uma matriz é uma sequência de valores que estão relacionados de alguma forma. Agrupando-os em
conjunto, é um formato ideal para percorrer. Você pode pensar em uma matriz como uma lista
numerada. Cada posição tem um índice que indica sua localização na lista, e cada índice tem um valor
que você deseja armazenar. Você usar uma matriz aqui para armazenar a lista de notas que você
quer jogar, na ordem em que você quer jogar.
Para garantir que a memória do Arduino é adequadamente gerida, você precisa

declarar matrizes com um comprimento conhecido. Você pode fazer isso por especificar
explicitamente-ing o número de itens ou simplesmente preencher a matriz com todos os valores
que você está interessado. Por exemplo, se você quiser fazer uma matriz que contém quatro
valores inteiros, você pode criá-lo como esta:
números int [4];
Opcionalmente, é possível inicializar os valores quando você declará-lo. Se você inicializar

os valores, especificando o comprimento dos suportes é opcional. Se não for especificado, o
comprimento é assumido para igualar os elementos número que você inicializados:
// Ambos são números acceptableint [4] =

{-7, 0, 6, 234}; int números [] = {-7, 0, 6,
234};
Note-se que as matrizes são zero indexado. Em outras palavras, o primeiro número é a
posição 0, O segundo está na posição 1, e assim por diante. Você pode acessar os
elementos
em uma matriz em qualquer índice, colocando o índice do valor relevante em um colchete após o nome
da variável. Se você quiser definir o brilho de um LED conectado ao pino 9 para a terceira entrada
em uma matriz, por exemplo, você pode fazê-lo como este:
analogWrite (9, números [2]);

Observe que, como numeração começa em zero, o índice de 2representa o terceiro

valor na matriz. Se você quiser alterar um dos valores da matriz, você pode fazê-lo de forma semelhante:
números [2] = 10;
Em seguida, você vai usar matrizes (como mostrado nestes exemplos) para criar uma estrutura
que pode conter a sequência de notas que você quer jogar em seu alto-falante.
Fazendo a anotação e Duração Arrays
Para armazenar as informações sobre a música que você quer jogar, você pode usar duas matrizes do
mesmo comprimento. O primeiro contém a lista dos campos, ea segunda contém a lista de durações para
o qual cada nota deve jogar em milissegundos. Você pode então percorrer os índices dessas matrizes e
reproduzir a sua música.
Usando as habilidades musicais magros que eu mantidos de minhas aulas de

música de volta na escola, eu montei uma melodia curta e cativante:
// Nota Arrayint notas [] = {NOTE_A4, NOTE_E3, NOTE_A4, 0, NOTE_A4, NOTE_E3, NOTE_A4, 0, NOTE_E4,
NOTE_D4, NOTE_C4, NOTE_B4, NOTE_A4, NOTE_B4, NOTE_C4, NOTE_D4, NOTE_E4, NOTE_E3, NOTE_A4, 0
};
// A duração de cada nota (em ms) int vezes []

= {
250, 250, 250, 250,

250, 250, 250, 250,
125, 125, 125, 125, 125, 125, 125, 125,
250, 250, 250, 250
};
Note-se que ambas as matrizes têm o mesmo comprimento: 20 itens. Observe que alguns dos
são especificados como n0o. tEastes são restos musicais (batidas não reproduzidos). Cada pares de
notas
com uma duração da segunda matriz. Para aqueles familiarizados com a teoria da música, note que eu
fiz notas de um quarto 250ms e colcheias 125ms. A música está em "quatro por quatro" tempo, em
termos musicais.
Experimente esta sequência dada nota, em primeiro lugar; em seguida, tentar criar o seu próprio!
NOTA stentoarecordingofthistune, playedbyanArduino:

www.exploringarduino.com/content/ch5.YoucanalsofindthisrecordingontheWileywebsiteshownatthebeginningofthischapter.
Completando o Programa
A última etapa é realmente adicionar a funcionalidade de reprodução para o esboço. Isto pode
ser conseguido com um simples
paraloop que passa por cada índice na matriz,
e reproduz a nota dada para a duração dada. Desde que você provavelmente não
quer ouvir isso uma e outra vez, você pode colocar a funcionalidade de reprodução
no configuração()função para que ele só acontece uma vez. Você pode reiniciar a reprodução
pressionando o botão Reset. Listagem 5-1 mostra o programa de reprodução completa.
Listagem 5-1: Arduino Music Player-music.ino
// Toca uma música em um orador
#include "pitches.h" // arquivo de cabeçalho com definições de pitch
int COLUNA const = 9; // Pin Speaker
// Nota Arrayint notas [] = {NOTE_A4, NOTE_E3, NOTE_A4, 0, NOTE_A4, NOTE_E3, NOTE_A4, 0, NOTE_E4,
NOTE_D4, NOTE_C4, NOTE_B4, NOTE_A4, NOTE_B4, NOTE_C4, NOTE_D4, NOTE_E4, NOTE_E3, NOTE_A4,
0
};
// A duração de cada nota (em ms) int vezes []

= {
250, 250, 250, 250,

250, 250, 250, 250,
125, 125, 125, 125, 125, 125, 125, 125,
250, 250, 250, 250
};
void setup ()
{
// Tocar cada nota para a direita durationfor (int i
= 0; i <20; i ++)
{
tons (alto-falante, notas [i], tempos [i]);
atraso (vezes [i]);
}
}
void loop ()
{
// Pressione o botão Reset para jogar novamente.
}
Se você quiser fazer sua própria música, certifique-se de que as matrizes se manterem com
uma comprimento igual e que você alterar o limite superior na para()loop. Porque
a tom()função pode ser executado em segundo plano, é importante usar o demora()
função. Ao atrasar o código para uma quantidade de tempo igual à duração do
nota, você garante que o Arduino não joga a próxima nota até que a anterior não terminou jogando para
o tempo especificado.
UnderstandingtheLimitationsofthetone () função
o tom()função tem algumas limitações a ter em conta. Como a biblioteca de servo, tom()conta com um
timer de hardware que também é usado pela modulação por largura de pulso funcionalidade do
conselho (PWM). Se você usar
tom(), PWM não funciona
direito sobre os pinos 3 e 11 (em que não sejam o mega placas).
Lembre-se também que os / O pins Arduino I não são digital-analógico conversores
ers (DACs). Assim, eles saída somente uma onda quadrada com a frequência prevista, não uma onda
senoidal. Embora isso é suficiente para fazer sons com um alto-falante, você vai encontrá-lo
indesejável para a reprodução de música. Se você deseja reproduzir arquivos de onda, as opções
incluem o uso de um escudo música-playing (como o adafruit Onda
Escudo ou o escudo MP3 SparkFun), a implementação de um conversor DAC, ou

usando o built-in DAC disponível no Arduino Devido usando a biblioteca apenas de
áudio Due.
A última limitação é que você pode usar o tom()função em apenas um pino
de cada vez, por isso não é o ideal para a condução de vários alto-falantes. Se você quiser dirigir
várias caixas acústicas ao mesmo tempo a partir de um Arduino padrão, você tem que usar o controle
temporizador de interrupção manual de, algo que se aprende mais sobre no Capítulo 12, "Hardware
e interrupções timer".
NOTA oreadatutorialonadvancedmultispeakercontrolwithanArduino, visita

www.jeremyblum.com/2010/09/05/driving-5-speakers-simultaneously- com-um-arduino
/.YoucanalsofindthistutorialontheWileywebsiteshownatthebeginningofthischapter.
BuildingaMicroPiano
Reprodução de sequências de notas é ótimo para adicionar um feedback de áudio para projetos que
você já criou. Por exemplo, considere a substituição ou aumento de um LED com um som de
confirmação de confirmação verde. Mas, e se você quiser Dynami-camente controlar o som? Para encerrar
este capítulo, você construir um piano pentatônica simples. A escala pentatônica consiste de apenas
cinco notas por oitava vez dos habituais sete. Curiosamente, as notas de uma escala pentatônica tem
mínima Disso- tenção entre arremessos, o que significa que sempre soam bem juntos. Assim, faz
muito sentido usar notas pentatônicas para fazer um piano simples.
capítulo Fazendo sons
■
NOTA heSudoGlove, amongothersthings, isacontrolglovethatcansynthesize

musicusingthepentatonicscale.Youcanlearnmoreaboutitatwww.sudoglove.com.
Para fazer o seu piano Arduino, você usar esta escala pentatônica: C, D, E, G, A.
Você pode escolher o oitava a ser usado conforme a sua preferência. Eu escolhi usar a quarta oitava de
cabeçalho do arquivo.
Em primeiro lugar, fio cinco botões para cima no seu Arduino. Tal como acontece com os botões no Capítu
"Entradas digitais, saídas e Pulse-Width Modulation" você usa 10k pull-down resistores com os botões.
Neste cenário, você não precisa Debounce as, mas-toneladas, porque a nota será só jogou enquanto o
botão desejado é pressionado. Fios os botões, como mostrado na Figura 5-6 e manter o alto-falante ligado
como você tinha
que anteriormente.
Figura 5-6: diagrama de fiação Micro de piano

O código para o piano é realmente muito simples. Em cada iteração através do

loop, cada botão está marcado. Enquanto um botão é pressionado, uma nota é tocada. Aqui,
tom()é utilizado sem uma duração porque a nota será reproduzido, desde que o
botão é mantido. Ao invés,nenhum()é chamado no final de loop ()para garantir que o
falante
deixa de fazer barulho quando todos os botões foram liberados. Porque apenas algumas notas são necessários,
você pode copiar os valores do arquivo de cabeçalho que você se preocupa diretamente no arquivo principal
do programa. Em um novo esboço, carregar o código mostrado na Listagem 5-2 e enviá-lo para o seu
Arduino. Então, jam afastado em seu piano!
Listagem 5-2: Pentatonic Micro Piano-piano.ino
// Piano Pentatonic //
CDEGA
#define NOTE_C 262 // Hz

#define NOTE_D 294 // Hz
#define NOTE_E 330 // Hz
#define NOTE_G 392 // Hz
#define NOTE_A 440 // Hz
int COLUNA const = 9; // Speaker no pino 9
const int BUTTON_C = 7; // Int Botão pinconst

BUTTON_D = 6; // Botão pinconst int BUTTON_E
= 5; // Botão pinconst int BUTTON_G = 4;
// Botão pinconst int BUTTON_A = 3; //
Pino do botão
void setup ()
{
// Nenhuma configuração necessária
função Tone // define saídas
void loop ()
{
while (digitalRead (BUTTON_C)) Tom
(ALTO-FALANTE, NOTE_C), enquanto
(digitalRead (BUTTON_D)) Tom (ALTO-
FALANTE, NOTE_D), enquanto
(digitalRead (BUTTON_E)) Tom (ALTO-
FALANTE, NOTE_E), enquanto
(digitalRead (BUTTON_G)) tom (ALTO-
FALANTE, NOTE_G), enquanto
(digitalRead (BUTTON_A)) tom (ALTO-
FALANTE, NOTE_A);
// Pare de jogar, se todos os botões foram releasednoTone

(altifalante);
}
Cada enquanto()loop continuamente chamar o tom()função no for caso

frequência disso durante o tempo que o botão é pressionado. O botão pode ser lido dentro
doenquanto()avaliação loop para evitar ter de primeiro salvar a leitura para um valor temporário.
digitalRead ()
retorna um valor booleano "true" sempre que um botão
de entrada é alta; o valor pode ser avaliada directamente pela enquanto()loop. Para
manter o seu mais puro código, você não precisa usar parênteses para o conteúdo de um loop se o
conteúdo for apenas uma linha, como neste exemplo. Se você tiver várias linhas, você deve usar
colchetes como você tem nos exemplos anteriores.
NOTA owatchademovideoofthemicropiano, visitawww.exploringarduino.com/

content / CH5.YoucanalsofindthisvideoontheWileywebsiteshownatthebegin-
ningofthischapter.
Resumo
■A■lto-falantes criar uma onda de pressão que viaja através do ar e é por percebida como som
por suas orelhas.
■A■lterando corrente eléctrica induz um campo magnético que pode ser utilizado para criar
um som de um altifalante.
■ o■tom()função pode ser usada para gerar sons de FREQUEN-cies e durações arbitrárias.
■A■linguagem de programação Arduino suporta o uso de matrizes para iterat-ing através de

seqüências de dados.
■ o■volume das colunas pode ser ajustado usando um potenciômetro em série com um alto-
falante.
Capítulo
USB e Comunicação Serial
Arduino UnoArduino LeonardoUSB cabo (A a B para Uno) cabo USB (A a Micro B

para Leonardo) LED LEDRGB (cátodo comum) 150Ω resistor220Ω resistor
(n3) resistor 10k (n2) A temperatura PushbuttonPhotoresistorTMP36
sensorTwo eixo joystick (SparkFun, Parallax, ou adafruit sugerido) Jumper
wiresBreadboardPotentiometer
107
downloads de código, vídeo e outros conteúdos digitais para este capítulo pode ser encontrada em
www.exploringarduino.com/content/ch6 .
Além disso, todos os códigos podem ser
ewnwcwo.nwtirleayd.caosme/gmo/exploringarduinoem
a guia de transferência de código. O código está no capítulo 06 de download e individu-aliado
nomeado de acordo com os nomes de todo o capítulo.
Talvez a parte mais importante de qualquer Arduino é sua capacidade de ser pro-
programado diretamente através de uma porta serial USB. Esta funcionalidade permite-lhe programar a
Arduino sem qualquer hardware especial, como um AVR ISP MKII. Normalmente, microcontroladores
dependem de um pedaço específico de hardware externo (tal como o MKII) para servir como
umprogramadorque se conecta entre o computador e o microcontrolador você está tentando
programar. No caso de o Arduino, esta pró-gramática é essencialmente incorporada à placa, em vez de ser
uma peça externa de
hardware. Além do mais, isso lhe dá uma conexão direta com o ATmega integrada Universal
Synchronous / Asynchronous Receiver e Transmissor
(USART). Usando esta interface, você pode enviar informações entre o computador host eo
Arduino, ou entre o Arduino e outros componentes de série habilitados (incluindo outra Arduinos).
Este capítulo abrange praticamente tudo que você poderia querer saber sobre con-
necting um Arduino ao computador via USB e transmissão de dados entre os dois. Arduinos
diferentes têm diferentes capacidades de série, de modo que este capítulo aborda cada um deles, e você
construir projetos de amostra com cada tecnologia comu-nicação de série para ficar familiarizado
com a forma de aproveitá-las da melhor forma possível. Note-se que, como um resultado disto, a lista de
peças inclui vários tipos de Arduinos. Dependendo de qual Arduino você está tentando aprender
sobre, você pode escolher quais seções para ler, que exemplos
para explorar, e que as peças da lista de peças que você realmente precisa para o seu
explorações Arduino.
UnderstandingtheArduino'sSerialCommunicationCapabilities
Como já aludido na introdução deste capítulo, as diferentes placas Arduino oferecer lotes de
diferentes implementações de série, tanto em termos de como o hardware implementa os
adaptadores USB-a- série e em termos de suporte de software para vários recursos. Em primeiro
lugar, nesta seção, você aprenderá sobre as diversas interfaces de hardware de comunicação de
série oferecidos em diferentes placas Arduino.
Capítulo USB e Serial Comunicação
■
NOTA olearnallaboutserialcommunication, checkoutthistutorial:

comunicação e processamento de www.jeremyblum.com/2011/02/07/arduino-tutorial-6-serial-
/.YoucanalsofindthistutorialontheWileywebsiteshownatthebeginningofthischapter.
Para começar, você precisa entender as diferenças entre série e USB.

Dependendo de como você está velho, você pode até não se lembrar de série (ou téc-
camente, RS-232) portas, porque eles foram substituídas principalmente por USB. Figura 6-1
mostra o que uma porta serial padrão parece.
Figura 6-1: Porta serial
As placas Arduino originais veio equipado com uma porta serial que você con-
conectado ao computador através de um cabo serial de 9 pinos. Hoje em dia, alguns computadores
ainda tem essas portas, embora você possa usar adaptadores para fazer DB-9 (o tipo de 9 pinos
conector) portas seriais de portas USB. Microcontroladores como o ATmega328P que você
encontra no Arduino Uno tem uma porta serial hardware. Ele inclui uma transmissão (TX) e receber o
pino (RX) que pode ser acessado nos pinos digitais 0 e
1. Como explicado na barra lateral no Capítulo 1, "Getting Up e piscando com o Arduino", o

Arduino é equipado com um bootloader que permite pro gram-lo através desta interface serial. Para
facilitar isso, os pinos são "multiplexado" (o que significa que eles estão ligados a mais de uma
função); eles se conectam, indiretamente, para a transmissão e recepção linhas de seu cabo USB.
No entanto, serial e USB não são directamente compatíveis, de modo que um dos dois métodos é
utilizado para colmatar
os dois. Uma opção é usar um circuito secundário integrado (IC) para facilitar a conversão entre os
dois (dentro ou fora da placa Arduino). Este é o tipo de interface presente em um Uno, em que um
IC intermediário facilita a comunicação USB-to-serial. Opção dois é optar por um microcontrolador que
tem um controlador USB construído em (como a do Arduino Leonardo 32U4 MCU).
ArduinoBoardswithanInternalorExternalFTDIUSB-a-SerialConverter
Como foi explicado, muitas placas Arduino (e clones Arduino) utilizam um circuito integrado secundário
para facilitar a conversão USB-to-serial. O chip "FTDI" é um chip popular que tem apenas uma função:
converter entre série e USB. Quando o computador se conecta a um chip FTDI, ele mostra-se no seu
computador como uma "porta serial virtual", que você pode acessar como se fosse uma porta DB9 com
fio para a direita em seu computador. A Figura 2/6 mostra a parte inferior de um Arduino nano, que
utiliza um chip FTDI integrada.
FTDI chip
Figura 6-2: Arduino Nano com o chip FTDI integrada mostrado

Capítulo ■USB e Serial Comunicação
NOTA oryourcomputertocommunicatewithaFTDIserial-to-USBadapter, você

needtoinstalldrivers.YoucanfindthemostrecentversionsforWindows, OSX, andLinuxatwww.ftdichip.com/Drivers/VCP.htm.Thisis
Chapter6pageontheExploringArduinowebsite.
Em algumas placas, normalmente para reduzir o tamanho da placa, o chip FTDI é externo ao
placa principal, com um 6-pin padronizado "conector FTDI" esquerda para a conexão com um
cabo FTDI (Um cabo USB com um chip FTDI construído para o fim do
cabo) ou uma pequena placa de fuga FTDI. Figuras 6-3 e 6-4 mostram essas opções.
.
www.adafruit.com
Crédito: Indústrias Adafruit
Figura 6-3: cabo FTDI
Figura 6-4: placa de adaptador de SparkFun FTDI

Usando uma placa com um programador FTDI removível é grande se você estiver design-
ing um projeto que não precisará ser conectado a um computador via USB para ser executado. Isto irá
reduzir o custo se você estiver fazendo vários dispositivos, e irá reduzir o tamanho global do produto
acabado.
A seguir está uma lista de placas Arduino que usam um chip FTDI a bordo. Nota,
novas placas Arduino não usa um chip FTDI, de modo a maioria destes foram descontinuados. No
entanto, ainda existem muitos clones dessas placas disponíveis para a compra, assim que eles
são listados aqui para ser completo:
■ A■rduino Nano
■ A■rduino extrema
■ A■rduino NG
■ A■rduino Diecimila
■ A■rduino Duemilanove
■ A■rduino Mega (original)
A seguir está uma lista de placas Arduino que usam um programador FTDI externo:
■ A■rduino Pro
■ A■rduino Pro Mini
■ A■rduino Lilypad
■ A■rduino Fio
■ A■rduino Mini
■ A■rduino Ethernet
ArduinoBoardswithaSecondaryUSB-CapableATMegaMCUEmulatingaSerialConverter
O Arduino Uno foi o primeiro bordo para introduzir a utilização de um circuito integrado
outra do que o chip FTDI USB para tratar-se de série de conversão. Funcionalmente, ele funciona
exatamente da mesma maneira, com algumas pequenas diferenças técnicas. Figura 6-5 mostra o
conversor serial 8U2 do Uno (agora um 16U2 em revisões mais recentes).
Segue-se uma breve lista das diferenças:
■P■rimeiro, no Windows, placas com esta nova conversão solu-ção USB-to-serial exigir um
driver personalizado para ser instalado. Este controlador vem com o Arduino IDE quando
você baixá-lo. (Drivers não são necessários para OS X ou Linux.)
E■m segundo lugar, a utilização desta segunda unidade microcontrolador (MCU) para a
■
conver- sion permitido um costume Arduino identificação do fornecedor e ID do produto

a ser relatado para o computador host quando a placa está conectada. Quando uma base-
FTDI
placa foi conectada a um computador, ele só mostrou-se como USB-serial genérico

dispositivo. Quando um Arduino usando um conversor não-FTDI IC (a ATmega 8U2 no caso
de início Arduino Unos, agora um 16U2) está ligado, é
identificados para o computador como um Arduino.
Atmel 8U2 ou
chip 16U2
Figura 6-5: Vista do chip conversor de série 8U2 do Arduino Uno
P■or último, porque o MCU secundário é totalmente programável (ele está executando uma
■
pilha firmware chamado LUFA que emula um USB-a-série conversor), você pode mudar o seu
firmware para fazer o Arduino mostrar-se como algo diferente de uma porta serial virtual, tais
como um dispositivo de joystick, teclado ou MIDI. Se você fosse fazer esse tipo de mudança, a
série USB-to-LUFA
firmware não iria ser carregado, e você teria que programar o

Arduino diretamente usando o programador de série no circuito com um
dispositivo como o AVR ISP MKII.
A seguir está uma lista de placas Arduino que utilizam uma MCU secundário a bordo
para lidar com USB-a-série de conversão:
■ A■rduino Uno
■ A■rduino mega 2560
■ A■rduino mega ADK (com base em 2560)
■ A■rduino Due (também pode ser programado diretamente)
ArduinoBoardswithaSingleUSB-CapableMCU
O Arduino Leonardo foi a primeira placa de ter apenas um chip que atua tanto como a MCU
programável pelo usuário e como a interface USB. O Leonardo (e
placas Arduino similares) emprega o microcontrolador ATmega 32U4, um chip

que tem comunicação direta USB embutido. resultados esse recurso em várias novas funcionalidades
e melhorias.
Em primeiro lugar, o custo é reduzido porque bordo menor número de peças são necessárias, e porque
um a menos etapa da programação de fábrica é necessária para produzir as placas. Em segundo lugar,
a placa pode mais facilmente ser usado para emular outros do que uma porta serial (como um teclado,
mouse ou joystick) dispositivos USB. Em terceiro lugar, a porta USART comum único no ATmega não
têm ser multiplexados com o programador USB, assim, a comunicação com o computador central e um
dispositivo de série secundário (tal como uma unidade de GPS) pode ocorrer em simultâneo.
A seguir está uma lista de placas Arduino que usam um único MCU USB com capacidade de:
■ A■rduino Due (também pode ser programado através de MCU secundária)
L ilyPad Arduino USB

■ ■
■ A■rduino Esplora
■ A■rduino Leonardo
■ A■rduino Micro
ArduinoBoardswithUSB-HostCapabilities
Algumas placas Arduino pode se conectar a dispositivos USB como um host, permitindo-lhe con-
dispositivos NECT tradicionais USB (teclados, mouses, telefones Android) para um Arduino.
Naturalmente, deve haver drivers apropriados para apoiar o dispositivo que são con-necting para.
Por exemplo, você não pode simplesmente ligar uma webcam para um Arduino Devido
e esperar para ser capaz de tirar fotos sem trabalho adicional. A Devido presentemente
■
suporta uma classe host USB que permite conectar um teclado ou mouse para os de vencimento em-
the-go porta USB para controlá-lo. O Arduino mega ADK utiliza o Android Open Acessório Protocol
(AOA) para facilitar a comunicação entre
o Arduino e um dispositivo Android. Isto é usado principalmente para

controlar Arduino I / O de um aplicativo em execução no dispositivo Android.
Duas placas Arduino que têm capacidades USB host são o Arduino Devido
eo Arduino mega ADK (baseado em mega 2560).
ListeningtotheArduino
A função de série mais básica que você pode fazer com um Arduino é imprimir ao terminal de série
do computador. Você já fez isso em vários dos capítulos PREVI-ous. Nesta seção, você explora
a funcionalidade de forma mais aprofundada, e mais tarde no capítulo você construir alguns
aplicativos de desktop que respondem aos dados que você enviar em vez de apenas imprimi-lo
para o terminal. Este processo é o mesmo para todos os Arduinos.
UsingprintStatements
Para imprimir os dados para o terminal, você só precisa utilizar três funções:
■S■erial.begin (BAUD_RATE)
■S■erial.print ( "Mensagem")
■S■erial.println ( "Mensagem")
Onde taxa de transmissãoe "Mensagem"são variáveis que você especificar.
Como você já aprendeu, Serial.begin () deve ser chamado uma vez no

início do programa em configuração()para preparar o porta serial para comunicação.
Depois de
de ter feito isso, você pode usar livrementeSerial.print () e Serial.println ()
funções para escrever dados para a porta serial. A única diferença entre os dois é que Serial.println ()
adiciona um símbolo de retorno no final da linha (de modo que
a próxima coisa impressa aparece na linha seguinte). Para experimentar com esta funcionalidade,
conectar um circuito simples com um potenciômetro conectado ao pino A0 no Arduino, como
mostrado na Figura 6-6.
Figura 6-6: Diagrama de Ligação do potenciómetro
Depois de fiação do potenciômetro, carga sobre o programa simples mostrado na

Listagem 6-1 que irá ler o valor do potenciômetro e imprimi-lo tanto como um valor bruto e um
valor percentual.
Listagem 6-1: Potentiometer Serial impressão Teste Programa-pot.ino
// Teste simples impressão de série com um potenciômetro
const int POT = 0; // Pot no pino analógico 0
void setup ()
{
Serial.begin (9600); // Inicie porta serial com transmissão = 9600
}
void loop ()
{
int val = analogRead (POT); // Leia potentiometerint per = map (val, 0, 1023, 0,
100); // Converte em percentageSerial.print ( "Analog Reading:"); Serial.print
(Val); // Imprimir valueSerial.print analógico raw ( "Percentual:"); Serial.print
(per); // Percentagem impressão analógico valueSerial.println ( "%"); //
Impressão
% sinal e newlinedelay (1000); // Espere um segundo, em seguida, repita
Usando uma combinação de Serial.print () e Serial.println () declarações,

Esse código imprime ambos os valores brutos e percentuais uma vez por segundo. Observe que,
nosso usoSerial.println ()
por apenas na última linha, cada transmissão anterior
sion permanece na mesma linha.
Abra o monitor serial do Arduino IDE e garantir que seus transmissão
taxa é definida para 9600 para coincidir com o valor definido no esboço Arduino. Você deve ver os
valores imprimindo uma vez por segundo como você girar o potenciômetro.
UsingSpecialCharacters
Você também pode transmitir uma variedade de "caracteres especiais" ao longo de série, que
permitem que você alterar a formatação dos dados de série que pretende imprimir. Você indicar
esses caracteres especiais com um caractere de barra escape (
\), Seguido de um com-
caráter mand. Há uma variedade destes caracteres especiais, mas os dois de maior interesse são os
caracteres de tabulação e nova linha. Para inserir um caractere de tabulação, adicionar um\ tpara a
cadeia. Para inserir um caractere de nova linha, adicionar um
\ npara a cadeia. este
prova particularmente útil se você quiser uma nova linha a ser inserido no início de uma cadeia, em
de no final como a
vez Serial.println () função faz. Se, por
alguma razão, você realmente deseja imprimir\ nou \ tna seqüência, você pode fazê-lo
impressão \\ nou \\ t, Respectivamente. Listagem 6-2 é uma modificação do código anterior para
usar esses caracteres especiais para mostrar os dados em um formato tabular.
Listagem 6-2: Tabular Impressão usando caracteres especiais-pot_tabular.ino
teste de impressão serial // tabular com um potenciômetro
void setup ()
{
Serial.begin (9600); // Iniciar Porta Serial com Baud = 9600
}
void loop ()
{
Serial.println ( "\ nAnalog Pin \ tRaw Valor \ tPercentage");
Serial.println ( "----------------------------- ------------- "); for (int i = 0; i
<10; i ++)
{
int val = analogRead (POT); // Leia potentiometerint per = map (val, 0, 1023, 0,
100); // Converte em porcentagem
Serial.print ( "A0 \ t \ t"); Serial.print (val); Serial.print ( "\ t \ t"); Serial.print

(per); // Percentagem impressão analógico valueSerial.println ( "%"); //
Impressão% sinal e newlinedelay (1000); // Espere um segundo, em
seguida, repita
}
}
Como você gira o potenciômetro, a saída deste programa deve olhar

algo parecido com os resultados mostrados na Figura 6-7.
Figura 6-7: Captura de tela do terminal serial com dados tabulares

■
ChangingDataTypeRepresentations
o Serial.print () e Serial.println () funções são bastante inteligente

quando se trata de imprimir dados no formato que você está esperando. No entanto,
você tem
opções para a saída de dados em vários formatos, incluindo hexadecimal, octal e binário.
ASCII Decimal codificados é o formato padrão. o
Serial.print ()
e Serial.println () funções têm um segundo argumento opcional que espe-
fies o formato de impressão. Tabela 6-1 inclui exemplos de como você iria imprimir os mesmos dados
em vários formatos e como ele iria aparecer no seu terminal serial.
Tabela 6-1: Opções de Tipo de dados Serial
TIPO DE DADOS exemplo de código SAÍDA SERIAL
Decimal Serial.println (23); 23
hexadecimal Serial.println (23, HEX); 17
octal Serial.println (23, OCT) 27
Binário Serial.println (23, BIN) 00010111
TalkingtotheArduino
Que bom é uma conversa com o seu Arduino se ele só vai em um direc-ção? Agora que você entende
como o Arduino envia dados para o computador, vamos passar algum tempo discutindo como
enviar comandos do seu computador para o Arduino. Você provavelmente já percebeu que o monitor
serial Arduino IDE tem um campo de entrada de texto na parte superior, e um menu drop-down na
parte inferior.
Figura 6-8 destaca ambos.
Figura 6-8: Captura de tela do terminal serial destacando campo de entrada de texto e de fim de linha no menu
suspenso Opções
Primeiro, certifique-se de que o drop-down está definida para nova linha. O menu drop-down
determina o que, se alguma coisa, é anexado ao fim dos seus comandos quando você enviá-los para o
Arduino. Os exemplos nas seções seguintes assumem que
você tem nova linha selecionada, que apenas acrescenta um\ npara o final de qualquer coisa
que você enviar a partir do campo de entrada de texto na parte superior da janela do monitor de série.
Ao contrário de alguns outros programas de terminal, monitor serial do Arduino IDE
envia a sua cadeia de comando inteira de uma só vez (na taxa de transmissão que você
especificar) quando você pressiona a tecla ou botão Send Enter. Isso está em contraste com
outros terminais de série como massa de vidraceiro (ligadas a partir da página de conteúdo digital
deste capítulo no
www.exploringarduino.com) Que enviar caracteres enquanto você digita-los.
ReadingInformationfromaComputerorOtherSerialDevice
Você começa usando o monitor serial Arduino IDE para enviar comandos manualmente para o Arduino.
Uma vez que está trabalhando, você vai aprender como enviar vários valores COM-mand de uma
vez e como construir uma interface gráfica simples para o envio de comandos.
É importante lembrar que a porta serial do Arduino tem um buffer. em outra

palavras, você pode enviar vários bytes de dados ao mesmo tempo e o Arduino vai fila-los e processá-
los em ordem com base no conteúdo do seu esboço. Você não precisa se preocupar com o envio
de dados mais rápido do que o seu tempo de volta, mas você precisa se preocupar com o envio de
tantos dados que transborda o tampão e as informações são perdidas.
Dizer a Arduino para eco dos dados de entrada
A coisa mais simples que você pode fazer é ter o Arduino eco de volta tudo o que você enviá-lo. Para
alcançar este objetivo, o Arduino basicamente só precisa monitorar seu buffer de entrada serial e
imprimir qualquer personagem que ele recebe. Para fazer isso, você precisa implementar dois novos
comandos a partir da
Serialobjeto:
■S■erial.available () devolve o número de caracteres (ou bytes) que são

atualmente armazenado no buffer serial de entrada do Arduino. Sempre que é mais do que
zero, você vai ler os caracteres e eco-los de volta para o computador.
■S■erial.read () lê e retorna o próximo caractere que está disponível

em o tampão.
Note-se que cada chamadSaerpiaal.rreaad () só retornará 1 byte, então você precisa

executá-lo por tanto teSmerpiaol.aqvuaailnabtole () está a devolver um valor
maior do que zero. Cada vez Serial.read () agarra um byte, que byte é removido do
tampão,
bem como, para o próximo byte está pronto para ser lido. Com este conhecimento, agora você pode
escrever e carregar o programa de eco na Listagem 6-3 no seu Arduino.
Listagem 6-3: Arduino Serial Eco Test-echo.ino
// Eco cada personagem
de dados char; // Armazena caráter entrante
void setup ()
{
Serial.begin (9600); // Porta Serial em 9600
}
void loop ()
{
// Só imprimir quando os dados é receivedif
(Serial.available ()> 0)
{
data = Serial.read (); // Leia byte de dataSerial.print (de
dados); // Byte impressão de dados
}
}
Inicie o monitor serial e escrever o que quiser na entrada de texto

campo. Assim que você pressionar Enviar, o que você digitou é ecoado volta e dis-jogado no monitor
serial. Você já selecionado para anexar uma "nova linha" ao final de cada comando, que irá garantir que
cada resposta é em uma nova linha. É por isso queSerial.print ()
é utilizado em vez de Serial.println () no

anterior esboço.
Entender as diferenças entre Chars e Ints
Quando você envia um caractere alfanumérico através do monitor serial, você não está real-
aliado passando uma "5", ou um "A". Você está enviando um byte que o computador interpreta como um
personagem. No caso da comunicação serial, o conjunto de caracteres ASCII é usado para representar
todas as letras, números, símbolos e comandos especiais que você pode querer enviar. O conjunto de
caracteres ASCII de base, mostrada na Figura 6-9, é um conjunto de 7 bits e contém um total de 128
personagens únicas ou comandos.
Ao ler um valor que enviou a partir do computador, como você fez no

Listagem 6-3, os dados devem ser lidos comcaorbuomniazardigitar. Mesmo que você só está esperando
para enviar os números do terminal serial, você precisa ler valores como um personagem em primeiro
lugar, e depois converter conforme necessário. Por exemplo, se você tivesse que modificar o código
para declarardadoscomo tipo int, Enviando um valor de 5retornaria 53para o monitor em série devido a
representação decimal do carácter 5 é o número
53. Você pode confirmar isso olhando para a tabela de referência ASCII na Figura 6-9.
.
Crédito: Ben Borowiec,www.benborowiec.com
Figura 6-9: tabela ASCII
No entanto, muitas vezes você vai querer enviar valores numéricos para o Arduino. Então, como
você faz aquilo? Você pode fazê-lo em algumas maneiras. Em primeiro lugar, você pode
simplesmente comparar os caracteres diretamente. Se você quiser virar um LED ligado quando envia
um
1, você pode
comparar os valores de caracteres como estei:f (Serial.read () == '1') . Observe
que as aspas simples ao redor do '1'indicam
que ele deve ser tratado como um personagem.
Uma segunda opção é converter cada byte de entrada para um número inteiro subtraindo
o caráter de valor zero, como este: int val = Serial.read () - '0' . Contudo,
isso não funciona muito bem se você pretende enviar números que são maiores do que
9,
porque eles vão estar vários dígitos. Para lidar com isso, o Arduino IDE inclui uma função
chamadaparseInt ()
útil que tenta extrair números inteiros de um
fluxo de dados serial. Os exemplos que se seguem elaborado sobre estas técnicas.
Envio de caracteres simples para controlar um LED
Antes de seu mergulho para analisar cadeias maiores de números de vários dígitos, começar por
escrever um esboço que usa uma comparação simples personagem para controlar um LED.
■
Você vai enviar um 1para ligar um LED, e um 0para desligá-lo. Fio de um LED-se ao
pino 9 do seu Arduino como mostrado na Figura 6-10.
Figura 6-10: Único LED ligado ao Arduino no pino 9
Como foi explicado na seção anterior, quando apenas o envio de um único

personagem, a coisa mais fácil a fazer é fazer uma comparação simples personagem em
Eumsedeclaração.
Cada vez que um carácter é adicionado ao tampão, ele é comparado co'm0'ouumum '1'e
a ação apropriada seja tomada. Carregar o código na Listagem 6-4 e experiências com o envio
de uma0ou um 1de série do terminal.
Listagem 6-4: Controle único LED usando caracteres de single_char_control.ino
// Controle único caractere de um LED
const int LED = 9;
de dados char; // Armazena caráter entrante
void setup ()
{
Serial.begin (9600); // Porta Serial em 9600 baudpinMode
(LED, OUTPUT);
void loop ()
{
// Agir apenas quando os dados está disponível no bufferif
{
data = Serial.read (); // Leia byte de dados // sua
vez, levou onif (dados == '1')
{
digitalWrite (LED, HIGH);
Serial.println ( "LED ON");
}
// Sua vez, levou offelse
if (dados == '0')
{
digitalWrite (LED, LOW);
Serial.println ( "LED OFF");
}
}
Note-se que um else if comunicado é utilizado em vez de um simpleosutrodeclaração.

Porque o seu terminal também está definido para enviar um caractere de nova linha com cada
trans- missão, é fundamental para limpar estes a partir do buffer.
Serial.read ()
vai ler
o caractere de nova linha, ver que não é equivalente a uma '0'ou um '1', E será
substituídas na próxima vez Serial.read () é chamado. Se apenaosuutrmodaeclaração
foram
utilizado, tanto '0'e '\ N'desencadearia transformando o LED. Mesmo quando o envio de um'1', O
LED se desligue imediatamente novamente quando o
'\ N'foi recebido!
■
Envio de listas de valores para controlar um LED RGB
Envio de um único caractere de comando é bom para controlar um único pino digital, mas o que se quer
realizar alguns esquemas de controle mais complexas? Esta seção explora o envio de vários valores
separados por vírgulas para comandar simultaneamente vários dispositivos. Para facilitar a testar este,
fio até um cátodo comum
LED RGB como mostrado na Figura 6-11.
Figura 6-11: RGB LED conectado ao Arduino

Para controlar esse LED RGB, você envia três valores de 8 bits separados (0-255) para definir
o brilho de cada LED cor. Por exemplo, para definir todas as cores para cheia brilhante-ness, você
envia"255,255,255". Isto apresenta alguns desafios:
■ V■ocê precisa diferenciar entre números e vírgulas.
■V■ocê precisa ativar essa sequência de caracteres em números inteiros que você pode passar
para analogWrite ()funções.
■V■ocê precisa ser capaz de lidar com o facto de que os valores podem ser um, dois, ou três
dígitos.
Felizmente, o Arduino IDE implementa uma função muito útil para a identificação de
e extrair números inteiros: Serial.parseInt () . Cada chamada para esta função espera até
um valor não numérico entra no buffer serial, e converte os dígitos anteriores em um número inteiro.
Os dois primeiros são valores lidos quando são detectadas as virgulas, e o último valor é lido quando a
nova linha é detectada.
Para testar essa função para si mesmo, carregar o programa mostrado na Listagem 6-5 na
no seu Arduino.
Listagem 6-5: Controle de LED RGB via Serial-list_control.ino
// Enviar várias variáveis de uma vez
const int VERDE = 10;; //

Definir pinsconst int RED =
11 LED const int AZUL = 9;
// Variáveis para RGB levelsint

rval = 0; int gval = 0; int bval =
0;
void setup ()
{
Serial.begin (9600); // Porta Serial em 9600
// configura pinos como

outputspinMode (RED, OUTPUT);
pinMode (VERDE, OUTPUT); pinMode
(azul, OUTPUT);
void loop ()
{
// Continue trabalhando enquanto dados estão no bufferwhile
■
{
rval Serial.parseInt = (); // Integergval Primeira válido =
Serial.parseInt (); // Integerbval Segundo válido =
Serial.parseInt (); // Inteiro válido Terceira
if (Serial.read () == '\ n') // Feito transmissão

{
// Configura LEDanalogWrite (RED, rval);
analogWrite (VERDE, gval); analogWrite
(azul, bval);
}
}
}
O programa continua olhando para os três valores inteiros até que uma nova linha é
detectou. Uma vez que isto acontece, os valores que foram lidos são usados para definir a luminosidade
ness dos LEDs. Para usar isso, abra o monitor serial e entrar três valores entre 0 e 255 separados por
uma vírgula, como
"200,30,180". Tente misturar tudo
tipos de cores bonitas!
TalkingtoaDesktopApp
Eventualmente, você é obrigado a se cansar de fazer toda a sua comunicação de série através do
monitor serial Arduino. Convenientemente, praticamente qualquer ambiente de trabalho linguagem pro-
gramação que você pode pensar tem bibliotecas que permitem a interface com as portas seriais em
seu computador. Você pode usar a sua linguagem favorita de desktop programa-ming para escrever
programas que enviam comandos seriais para o seu Arduino
e que reage a dados em série a ser transmitido a partir do Arduino para o computador.
Neste livro, o processamento é a linguagem de programação de desktop de escolha
porque é muito semelhante à linguagem Arduino que você já tenha se tornado
familiar com. Na verdade, a linguagem de programação Arduino é baseado em processamento de!
Outros idiomas desktop populares (que bem documentados bibliotecas de série comu-nicação)
incluem Python, PHP, Visual Basic, C, e muito mais. Primeiro, você vai aprender a ler dados seriais
transmitidos em Processing, e então você vai aprender como você pode usar o processamento para
criar uma simples interface gráfica do usuário (GUI) para enviar comandos para o Arduino.
TalkingtoProcessing
Processamento tem uma interface de programação bastante simples, e é semelhante ao

uma que já tenha vindo a utilizar para o Arduino. Nesta seção, você instala
Processamento e, em seguida, escrever uma interface gráfica simples para gerar um gráfico
saída com base em dados seriais transmitidos a partir do seu Arduino. Uma vez que isso é trabalho-
ing, você implementar a comunicação na direção oposta para controlar o seu Arduino a partir de
uma interface gráfica no seu computador.
Processamento de instalar
Primeiro de tudo, você precisa instalar o processamento em sua máquina. Isto é o

mesmo processo que você seguiu no primeiro capítulo para obter o Arduino IDE
instalado. Visitahttp://processing.org/download/ (Ou encontrar o link para
download na página de conteúdo digital para este capítulo sobwreww.exploringarduino.com) e
fazer o download do pacote compactado para seu sistema operacional. Basta descompactá-lo para o
seu local preferido e você está pronto para ir! Execute o pedido de Processamento
ção, e você deve ver um IDE que se parece com o mostrado na Figura 6-12.
Figura 6-12:O IDE Processing. Será que ela parece familiar?

Controlar um esboço de processamento do seu Arduino
Para sua primeira experiência com Processing, você usa um potenciômetro conectado ao Arduino para
controlar a cor de uma janela no seu computador. Fio-se o Arduino com um potenciômetro, consultando
a Figura 6-6 novamente. Você já sabe o código Arduino necessário enviar os valores analógicos do
potentiometer para o seu computador. O fato de que agora você está alimentando os dados seriais
em Processamento não tem qualquer impacto sobre a maneira como você transmiti-lo.
Referenciar o código na Listagem 6-6 e carregá-lo no seu Arduino. Ele envia um

valor atualizado do potenciômetro para a porta serial do computador a cada 50 mil-liseconds. Os
50ms é importante; se você fosse para enviá-lo o mais rápido possível, o esboço de processamento não
seria capaz de lidar com isso tão rapidamente como você está enviando a ele, e você acabaria por
estouro do buffer de entrada serial no seu computador.
Listagem 6-6: Código Arduino para enviar dados para o computador-pot_to_processing / arduino_read_pot
// Enviando valor POT para o computador
int val; // Para a realização de valor pot mapeada
void setup ()
{
Serial.begin (9600); // Iniciar Serial
}
void loop ()
{
val = map (analogRead (POT), 0, 1023, 0, 255); // Leia e mapear POTSerial.println (val); //
Enviar valuedelay (50); // Atraso de modo que não inundar // o computador
Agora vem a parte interessante: escrever um esboço de processamento para fazer algo
interessante com esses dados de entrada. O esboço na Listagem 6-7 lê os dados no buffer de
série e ajusta o brilho de uma cor na tela do seu computador com base no valor que recebe. Primeiro,
copie o código da Listagem 6-7 em um novo esboço de processamento. Você precisa mudar apenas uma
parte importante. O esboço de processamento precisa saber qual porta serial que esperar de dados para
chegar a. Esta é a mesma porta que você foi a programação do Arduino a partir. No
seguinte listagem, substitua "COM3"com o seu número de porta serial. Lembre-se que em Linux e
Mac será parecido com
/ Dev / ttyUSB0, por exemplo. Você pode copiar o
nome exato de dentro do Arduino IDE se não tiver certeza.
port = nova série (este, "COM3", 9600); // Série de configuração
Listagem 6-7: Código de processamento para ler dados e mudam a cor na tela-pot_to_processing /
processing_display_color
// Esboço de processamento para ler valor e muda de cor na tela
// Import e inicializar porta serial libraryimport

processing.serial. *; Porta serial;
flutuador brilho = 0; // Para a realização de valor a partir de pot
void setup ()
{
tamanho (500.500); // Janela sizeport = new Serial (this, "COM3", 9600); //
Configurar serialport.bufferUntil ( '\ n'); // Configurar porta para ler até //
nova linha
draw void ()
{
fundo (0,0, brilho); // Atualiza a janela
}
serialEvent void (porta serial)

{
luminosidade = float (port.readStringUntil ( '\ n')); // Obtém val
}
Depois de ter carregado o código em seu processamento IDE e definir a série

port corretamente, certifique-se de que o monitor serial Arduino não está aberta. Somente um
programa no seu computador pode ter acesso à porta serial de cada vez. Clique no botão Executar no
IDE Processing (o botão no canto superior esquerdo da janela com um triângulo); ao fazê-lo, uma
pequena janela pop-up (veja a Figura 6-13). Como você gira o potenciômetro, você deve ver a cor da
mudança janela do preto ao azul.
Agora que você já viu isso funcionar, vamos percorrer o código para obter uma melhor
compreensão de como o esboço de processamento está funcionando. Ao contrário do
Arduino, a biblioteca de série não é importado automaticamente. chamando
processamento de
importação
.serial.*; ePorta serial; está a importar a biblioteca de série e

MAK ing um objeto de série chamapodrata.
Capítulo ■USB e Comunicação 1
Figura 6-13: janelas exemplo de esboço Processing
Como o Arduino, Processing tem um configuração()função que é executada uma vez no

começando do esboço. Neste esboço, ele configura a porta serial e cria um
janela de tamanho 500n500 pixels com o comando tamanho (500.500). O comando
port = nova série (este, "COM3", 9600) diz Processamento de tudo o que precisa
saber sobre a criação da porta serial. A instância (referido como "port") será executado neste esboço e
comunicar em COM3 (ou qualquer que seja sua porta serial é) em 9600. O Arduino e do programa no seu
computador devem concordar com a velocidade com que eles se comunicam; caso contrário, você vai
ter caracteres de lixo.
port.bufferUntil ( '\ n') informa Processing para tamponar a entrada serial e não
fazer nada com as informações até que vê um caractere de nova linha.
Ao invés de loop (), Processamento define outras funções especiais. Este programa
usa desenhar()e serialEvent () . odesenhar()função é similar a Arduino de loop ();
ele é executado continuamente e atualiza a exibição. o fundo()função define o
cor da janela, definindo valores de vermelho, verde e azul (as três argumentos da função). Neste caso,
o
valor a partir do potenciômetro está controlando a intensidade azul e vermelho e verde estão definidos
para
0. Você pode mudar a cor que o seu
pote está ajustando simplesmente troca que argumento brilhoestá preenchendo. RGB
valores de cor são valores de 8 bits que variam0pdaera 255, Razão pela qual o
potenciômetro é mapeado para esses valores antes de serem transmitidos.
serialEvent () é chamado sempre que o bufferUntil () condição de que você
especificado na configuração()é cumprida. Sempre que um caractere de nova linha é
recebida, o serialEvent () função é acionado. A
informação em série de entrada é lido
como uma string com port.readStringUntil ( '\ n') . Você pode pensar em uma string como um
matriz de texto. Para usar a string como um número, você deve convertê-lo para um
ponto flutuante comflutuador()
número de . Isso define a variável de brilho, mudando a
cor de fundo da janela do aplicativo.
Para parar a aplicação e fechar a porta serial, clique no botão Parar na
IDE de transformação; é a praça localizada ao lado do botão Executar.
SUDOGLOVE PROCESSAMENTO DEBUGGER
uggingdisplaythatgraphically
TheSudoGloveisacontrolglovethatdrivesRCcarsandcontrolsotherhardware.IdevelopedaProcessingdeb ors.Youcanlearnmoreaboutithere:
DownloadthesourcecodefortheProcessingdisplayhere: visual-depurador
/.YoucanalsofindthissourcecodeontheWileywebsiteshownatthebeginningofthischapter.
Envio de dados de processamento à sua Arduino
O próximo passo óbvio é fazer o oposto. Fio-se um LED RGB para o seu
Arduino, como mostrado na Figura 6-11 e carga sobre o mesmo programa de mais cedo
que você usou para receber uma seqüência de três valores separados por vírgula para definir o
intensidades de vermelho, verde e azul (Listagem 6-5). Agora, em vez de enviar uma série de três
valores do monitor serial, você seleciona uma cor usando um seletor de cores.
Carregar e executar o código na Listagem 6-8 em Processamento, lembrando-se de ajustar o

número da porta serial de acordo como você fez com o esboço anterior. Em processamento
esboços carregar automaticamente arquivos de garantia de uma pasta chamada "dados" no
esboço pasta. O arquivo hsv.jpg está incluído no download do código deste capítulo. Baixá-lo e colocá-lo
em uma pasta chamada "dados" no mesmo diretório que o seu esboço. Processamento padrão para
salvar desenhos em sua pasta Documentos. o
estrutura será semelhante à mostrada na Figura 6-14.
Figura 6-14: estrutura de pastas
A imagem na pasta de dados servirá como o seletor de cores.

Listagem 6-8: Processamento de esboço para definir Arduino RGB Colors- processing_control_RGB /
processing_control_RGB
importar processing.serial. *; // Import libraryPImage série

img; // Imagem Porta objectSerial; // Objeto de porta serial
void setup ()
{
tamanho (640.256); // Tamanho do HSV imageimg = loadImage ( "hsv.jpg"); //
Carregar no fundo imageport = new Serial (this, "COM9", 9600); // Porta serial Aberto
draw void ()
{
fundo (0); // Preto BackgroundImage (img, 0,0); //
Imagem Overlay
anular mousePressed ()
{
cor c = get (mouseX, mouseY); // Obter a cor RGB, em que o mouse foi pressedString
cores = int (vermelho (c)) + "," + int (verde (c)) + "," + int (azul (c)) + "\ n"; // Extrair valores
de Colorprint (cores); cores // impressão para debuggingport.write (cores); // Envia valores
ao Arduino
Quando você executar o programa, você deve ver uma tela como a mostrada na
Figura 6-15 aparecer. Clique cores diferentes e os valores RGB serão transmitidos
ao Arduino para controlar a cor do LED RGB. Observe que o console serial também exibe os comandos
de serem enviados para ajudá-lo em qualquer depuração.
Depois de terminar a olhar para todas as cores bonitas, olhar para trás, o código e
considerar como ele está trabalhando. Como antes, a biblioteca de série é importado e um objeto de
série chamadaportaé criado. UMAPImagechamada de objeto imgTambém é criado. Isto irá manter a
imagem de fundo. No
configuração(), A porta serial é inicializado, o
janela de exibição está definido para o tamanho da imagem, ea imagem é importado para o
objeto imagem chamando img = loadImage ( "hsv.jpg") .
No desenhar()função, a imagem é carregada na janela com imagem (img, 0,0).
imgé a imagem que você quer desenhar na janela, e 0, 0são coordenadas onde
a imagem vai começar a ser desenhado0.,0é o canto superior esquerdo da janela do aplicativo.
Figura 6-15: tela de seleção de cores de processamento
Cada vez que o botão do mouse é pressionado, o mousePressed ()função é

chamada. A cor do pixel em que você clicou é salvo em um corobjeto nomeado c. o
obter()método conta a aplicação, onde para obter a cor a partir de (neste caso, o
localização do X do mouse e posição Y no esboço). O esboço converte o objetocem uma cadeia que
pode ser enviado para o Arduino, convertendo a inteiros
representando vermelho, verde e azul. Estes valores também são impressos ao tratamento
console de modo que você possa ver o que está sendo enviado.
Certifique-se de que o Arduino está conectado e programado com o código de
Listagem 6-5. Execute o esboço de processamento (com a porta serial correta especificado) e
clique em torno do mapa de cores para ajustar a cor do LED conectado ao Arduino.
LearningSpecialTrickswiththeArduinoLeonardo (andOther32U4-
BasedArduinos)
O Leonardo, além de outros Arduinos que implementam MCUs que con-gar directamente para
USB, tem a capacidade única para emular dispositivos não seriais, como um teclado ou mouse. Nesta
seção, você aprenderá sobre como usar um Leonardo de
emular estes dispositivos. Você precisa ser extremamente cuidadoso para implementar essas funções de
uma forma que não faz a reprogramação difícil. Por exemplo, se você escrever um esboço que emula
um mouse e continuamente move o ponteiro ao redor da tela, você pode ter problemas para clicar no botão
Upload no Arduino IDE! Nesta seção, você aprende alguns truques que você pode usar para evitar
estas circunstâncias.
DICA Ifyougetstuckwithaboardthat'stoohardtoprogramduetoitskeyboardor
mouseinput, holddowntheResetbuttonandreleaseitwhilepressingtheUploadbuttonintheArduinoIDEtoreprogramit.
Quando você conectar um Leonardo a um computador com Windows, você precisa instalar
motoristas, assim como você fez com o Arduino Uno no primeiro capítulo. Siga as mesmas
instruções emhttp://arduino.cc/en/Guide/ArduinoLeonardoMicro#toc8
para obter instruções específicas-Leonardo. (Estas instruções também estão ligados a partir da página
de conteúdo digital para este capítulo da
www.exploringarduino.com.)
EmulatingaKeyboard
Usando capacidade única do Leonardo para emular dispositivos USB, você pode facilmente transformar
o seu Arduino em um teclado. Emulando um teclado permite que você facilmente enviar comandos-
chave combinação para o seu computador ou tipo de dados diretamente em um arquivo que está
aberto no seu computador.
Digitando dados no computador
O Leonardo pode emular um teclado USB, enviando teclas e chave com-combinações. Esta seção
explora como usar ambos os conceitos. Primeiro, você escreve um
programa simples que registra os dados de alguns sensores analógicos em uma vírgula
separados por valor (.csv) formato que mais tarde você pode se abrir com planilhas do Excel ou o
Google para gerar um gráfico dos valores.
Comece abrindo o editor de texto de sua escolha e salvar um documento em branco

com uma extensão .csv. Para fazer isso, você pode geralmente escolher o tipo de arquivo na caixa
de diálogo Salvar, selecione "Todos os arquivos" e digite manualmente o nome do arquivo com a
exten- sion, como "data.csv." O vídeo de demonstração mostra também como criar um arquivo .csv.
Em seguida, criar um circuito simples, como o mostrado na Figura 6-16. Ele irá acompanhar
ambos os níveis de temperatura luz e usando sensores analógicos que você já viu no capítulo
3, "Leitura Sensores analógicos." Além dos sensores, o circuito inclui um botão para virar a
funcionalidade de log on e off, e um LED que vai indicar se atualmente está registrando
dados.
indicador LED Sensor de botão Ativar photoresistor

temperatura
Figura 6-16: circuito de temperatura e sensor de luz
Usando a mesma função debouncing que você implementou no Capítulo 2,

"Entradas digitais, saídas e Pulse-Width Modulation," você usar o botão para alternar o modo de log on e
off. Enquanto no modo de registo, as pesquisas Arduino
os sensores e "tipos" esses valores em seu computador em um formato separado por vírgulas uma vez
por segundo. Um indicador LED permanece aceso enquanto você está registrando dados. Porque
você quer o Arduino estar constantemente polling o estado
do botão, você não pode usar uma demora()função que esperar 1000ms entre cada
atualizar. Em vez disso, você usa omillis () função, que retorna o número de
milissegundos desde o Arduino foi a última reinicialização. Você pode fazer o Arduino enviar
cada vez que o função retorna um múltiplo de 1000 ms, de forma
dados millis ()
eficaz
a criação de um atraso não bloqueante de 1 segundo entre as transmissões. Para fazer isso, você
pode usar o operador de módulo (
%). Modulo devolve o resto de uma divisão. E se,
por exemplo, você executou 1,000% 1,000, Você teria que encontrar o resultado é 0
porque 1000/1000 = 1, com um resto de 0. 1500% 1000, Por outro lado, iria retornar
500 porque 1500/1000 é igual a 1, com um resto de 500. Se você tomar o módulo de millis ()
com 1000, O resultado é zero cada vez millis () alcances
um valor que é um múltiplo de 1000. Ao verificar isso com um E se()declaração,
pode executar um código, uma vez a cada segundo.
Examinar o código na Listagem 6-9 e carregá-lo para o seu Arduino Leonardo.
Certifique-se de que você selecionou "Arduino Leonardo" no menu Ferramentas> Board no Arduino
IDE.
Listagem 6-9: Temperatura e luz Data Logger-csv_logger.ino
// Luz e Logger Temp
const int TEMP = 0; // Sensor de Temp no pino analógico LUZ 0const int = 1; //
Sensor de luz no pino analógico 1const int LED = 3; LED // Red no pino
13const int BUTTON = 2; // O botão está ligado ao pino 2
boolean lastButton = LOW; // Última botão stateboolean currentButton =

LOW; // Stateboolean atual running botão = false; // Não está em
execução por defaultint counter = 1; // Um índice para as entradas de
dados registrados
void setup ()
{
pinMode (LED, OUTPUT); // Definir LED azul como
outputKeyboard.begin (); // Iniciar emulação de teclado
void loop ()
{
currentButton = estabilização (lastButton); // Leia estado filtrada por
if (lastButton == LOW && currentButton == HIGH) // Se ele foi pressionado ... correndo =
correndo!; // Alternar estado de execução
lastButton = currentButton; // Repor valor de botão
se (em execução) // Se logger está em execução

{
digitalWrite (LED, HIGH); // Vire o LED onif (millis ()% 1.000 == 0) // Se
o tempo é múltipla // de 1000ms
{
temperatura = int analogRead (TEMP); // Leia o brilho temperatureint = analogRead
(LUZ); // Leia o levelKeyboard.print luz (contador); // Imprimir o numberKeyboard.print
índice ( ","); // Imprimir um commaKeyboard.print (temperatura); // Imprimir o
temperatureKeyboard.print ( ","); // Imprimir um commaKeyboard.println (brilho); //
Brilho Print, newlinecounter ++; // Incrementa o contador
}
}
outro
{
digitalWrite (LED, LOW); // Se logger não está em execução, vire LED off
}
}
/*
* Função Debouncing
* Passe-o estado do botão anterior,
* E voltar o estado do botão filtrada por corrente.
*/
boolean debounce (boolean passado)
{
boolean atual = digitalRead (botão); // Leia o botão stateif (durar! = Atual) // Se é diferente
...
{
atraso (5); // Espere 5mscurrent = digitalRead (botão); // Leia de novo
}
voltar corrente; // Retorna o valor atual //
Antes de testar o registrador de dados, vamos destacar algumas das novas funcionalidades
que foi implementado neste esboço. Da mesma forma como você inicializado a comunicação serial, a
comunicação teclado é inicializado, colocando
Keyboard.begin ()no configuração().

Cada vez através loop (), o Arduino verifica o estado do botão e é executado
a função debouncing que você já está familiarizado. Quando o botão é pressionado, o valor
docorrendovariável é invertida. Isso é conseguido definindo-o como o seu oposto com o
!operador.
Enquanto o Arduino é em correndo modo, a etapa de registro é executado somente a cada
1000 ms utilizando a lógica descrita anteriormente. As funções do teclado funciona muito semelhante
funções de série.
às Keyboard.print () "tipos" a string dada em
seu computador. Depois de ler os dois sensores analógicos, o Arduino envia os valores para
o computador como teclas. Quando você usa
Keyboard.println () ,
o Arduino emula pressionando a tecla Enter ou Return no teclado depois de enviar a string dada. Um
contador incrementar e ambos os valores analógicos são inseridos em um formato separado por
vírgulas.
Siga o vídeo de demonstração a partir da página web deste capítulo para ver este esboço em
açao. Certifique-se de que o cursor é posicionado activamente num documento de texto e, em seguida,
pressione o botão para iniciar o registo. Você deverá ver o documento começa a preencher com
dados. Segure a mão sobre o sensor de luz para alterar o valor ou espremer o sensor de temperatura para
ver o aumento de valor. Quando tiver terminado, pressione o botão novamente para parar o registro.
Depois de salvar o arquivo, você pode importá-lo para o aplicativo de planilha de sua escolha e
representar graficamente ao longo do tempo. Isso é mostrado no vídeo de demonstração.
NOTA owatchademovideoofthelivetemperatureandlightlogger, visita

Comandando o computador a fazer o seu lance
Além de digitação como um teclado, você também pode usar o Leonardo para a UEM-final combinações
de teclas. Em computadores Windows, pressionando as teclas Windows + L bloqueia a tela do
computador (em Linux, você pode usar Control + Alt + L). Usando esse conhecimento emparelhado
com um sensor de luz, você pode ter o seu bloqueio de computador auto-maticamente quando você
desligar as luzes. OS X usa o Control + Shift + Eject ou teclas Shift + Poder de Controle + para
bloquear a máquina, que não pode ser imitado pelo Leonardo, pois não pode enviar um Eject ou
Power simulado pressione o botão. Neste exemplo, você aprende como bloquear um computador
Windows. É possível continuar a utilizar o mesmo circuito mostrado na Figura 6-16, embora apenas o
sensor de luz será utilizada neste exemplo.
Execute o esboço anterior em alguns níveis diferentes de luz e ver como a luz
mudanças de leitura do sensor. Usando essas informações, você deve escolher um limiar abaixo
do qual você vai querer o seu computador para bloquear. (No meu quarto, eu achei que com as
luzes apagadas o valor foi de cerca de
300, E foi cerca de 700com o
luzes acesas. Então, eu escolhi um valor limite5d0e0). Quando as gotas valor do sensor de luz
abaixo desse valor, a trancarcomando irá ser enviada para o computador. Você pode
querer ajustar esse valor para o seu ambiente.
Coloque o desenho na Listagem 6-10 no seu Arduino. Apenas certifique-se que você tem
o limite definido para um valor razoável, em primeiro lugar, por meio de testes que luz níveis no seu
quarto correspondem a vários níveis analógicos. Se você pegar um valor mal calibrado, pode bloquear o
computador assim que você enviá-lo!
Listagem 6-10: Light-Based Computer Lock-lock_computer.ino
// Bloqueia o computador quando você desligar as luzes
int LUZ const = 1; // Sensor de luz no pino analógico 1const int THRESHOLD = 500; // Brilho
deve cair abaixo deste nível // para bloquear computador
void setup ()
{
Keyboard.begin ();
}
void loop ()
{
int brilho = analogRead (LUZ); // Leia o nível de luz
if (brilho <limiar)
{
Keyboard.press (KEY_LEFT_GUI);
Keyboard.press ( 'L'); atraso (100);
Keyboard.releaseAll ();
}
}
Depois de carregar o programa, tente virar as luzes apagadas. Seu computador deve
bloquear imediatamente. O seguinte vídeo de demonstração mostra isso em ação. este
esboço implementa duas novas funções do teclado: Keyboard.press () e
Teclado
.releaseAll () . CorrendoKeyboard.press ()é equivalente ao de partida para realizar

uma baixo chave. Então, se você quer segurar a tecla Windows ea tecla L para baixo
no mesmo tempo, você corre Keyboard.press ()em cada. Então, você atrasar por um curto
período
de tempo e executar o Keyboard.releaseAll () função para deixar de ir, ou a
liberação, as chaves. teclas especiais são definidas no site do Arduino:
http://arduino.cc/
pt / Referência / KeyboardModifiers . (Esta tabela definição também está ligada a

partir a página de conteúdo para este capítulownwow.exploringarduino.com/content/ch6 .)
NOTA owatchademovideoofthelight-activatedcomputerlock, visita

EmulatingaMouse
Usando um joystick de dois eixos e alguns botões, você pode usar um Arduino
Leonardo para fazer seu próprio mouse! O joystick irá controlar a localização do mouse,
e os botões irá controlar a esquerda, meio e direito botões do mouse.
Assim como com a funcionalidade do teclado, a linguagem Arduino tem algumas grandes funções
internas em que se torna mais fácil para controlar a funcionalidade do mouse.
Primeiro de tudo, se o seu circuito configurado com um joystick e alguns botões como
mostrado na Figura 6-17. Não se esqueça que seus botões precisa ter resistências de pull-down!
O
joystick irá se conectar aos pinos analógicas 0 e 1. (Joysticks são realmente apenas dois potenciômetros
ligados a um botão.) Quando você move o joystick todo o caminho na direção x, ele atinge o máximo do x
potenciômetro, eo mesmo vale
para a direção y.
Controle de video game Botão do meio botão

esquerdo do direito do
do mouse mouse
botão
mouse
Figura 6-17: circuito Joystick Leonardo rato
O diagrama mostra um joystick SparkFun, mas qualquer vai fazer. (No vídeo descrito
após o anúncio, eu usei um joystick Parallax.) Dependendo da orientação do joystick, você pode precisar
de ajustar os limites da função de mapa ou trocar o X / Y no código abaixo.
Depois de ter ligado o circuito, é hora de carregar um código para o Leonardo.

Carregar o código na Listagem 6-11 e jogar com o joystick e botões; o ponteiro na tela devem
responder em conformidade.
Listagem 6-11: Código de controlo do rato para o Leonardo-mouse.ino
// Faz um rato!
const int LEFT_BUTTON = 4; // Pino de entrada para o int buttonconst esquerda

MIDDLE_BUTTON = 3; // Pino de entrada para o meio buttonconst int RIGHT_BUTTON
= 2; // Pino de entrada para o int buttonconst direito X_AXIS = 0; // Joystick eixo x
analógico pinconst int Y_AXIS = 1; // Pino analógico eixo y Joystick
void setup ()
{
Mouse.begin ();
}
void loop ()
{
int xVal = readJoystick (X_AXIS); // Obter eixo x movementint yVal = readJoystick
(Y_AXIS); // Obter movimento do eixo y
Mouse.move (xVal, yVal, 0); // Move o mouse
readButton (LEFT_BUTTON, MOUSE_LEFT); // Controle deixou buttonreadButton

(MIDDLE_BUTTON, MOUSE_MIDDLE); // Controle meio buttonreadButton (RIGHT_BUTTON,
MOUSE_RIGHT); // O controlo botão direito
atraso (5); // Isto controla a capacidade de resposta

}
// Lê valor joystick, dimensiona-lo, e acrescenta gama mortos em middleint

readJoystick (eixo int)
{
int val = analogRead (eixo); // Leia analógico valueval = map (val, 0, 1023,
-10, 10); // Mapa da leitura
if (val <= 2 && val> = -2) // Criar zona morta para parar rato driftreturn 0;
else // Retorno escalado valuereturn val;

// Leia um botão e emitir um rato commandvoid readButton

(pino int, char mouseCommand)
{
// Se o botão for pressionado, clique se não tiver já sido clickedif (digitalRead
(pino) == HIGH)
{
if (! Mouse.isPressed (mouseCommand))
{
Mouse.press (mouseCommand);
}
}
// Solte o mouse se tiver sido clicked.else
{
Se (Mouse.isPressed (mouseCommand))
{
Mouse.release (mouseCommand);
}
}
}
Este é definitivamente um dos desenhos mais complicados que foram cobertos

até agora, então vale a pena percorrendo-o para ambos entendem o recém-lançado
funções e o fluxo do programa utilizado para realizar o rato joystick.
Cada um dos botão e joystick pinos são definidos no topo do esboço, e
a biblioteca do mouse é iniciado na instalação. Cada vez através do loop, o joystick
Os valores são lidos e mapeadas para valores de movimento para o mouse. Os botões do
mouse também são monitoradas e o botão prensas são transmitidos, se necessário.
UMA readJoystick () função foi criada para ler os valores do joystick e mapa
eles. Cada eixo possui um joystick gama de 1024 quando os valores lidos no conversor analógico-para-
digital (ADC). No entanto, os movimentos do mouse são relativos. Em outras palavras, a passagem de um
valor de 0 aMouse.move ()para cada eixo resultará em nenhum movimento nesse eixo. Passar um valor
positivo para o eixo-x irá mover o mouse para a
direita, e um valor negativo vai movê-lo para a esquerda. Quanto maior o valor,
mais o mouse se moverá. Assim, no readJoystick () função, um valor de
0-1023 é mapeado para um valor de -10para 10.
Um valor tampão pequeno em torno0é
adicionada onde o mouse não se move. Isso ocorre porque, mesmo quando o joystick está na posição
média, o valor real pode flutuar em torno de
512. Definindo
a parte de trás distância desejada a 0 depois de ser mapeado em um determinado intervalo, você
garantir que o mouse não irá se mover por conta própria, enquanto o joystick não está sendo
accionado. Uma vez que os valores são determinadMoosu,se.move ()é dada a x e y
valores para mover o mouse. Um terceiro argumento parMaouse.move ()determina o
movimento da roda de rolagem.
Para detectar os cliques de rator,eoasdButton ()função foi criada para que ele possa
ser repetido para cada um dos três botões de detectar. A função detecta o estado cur-rent do mouse com o
Mouse.isPressed ()comando e controla
a rato de acordo com o Mouse.press ()e Mouse.release ()funções.
NOTA owatchademovideoofthejoystickmousecontrollingacomputer
ponteiro, check-outwww.exploringarduino.com/content/ch6.YoucanalsofindthisvideoontheWileywebsiteshownatthebeginningofthisch
Resumo
■ A■rduinos conectar ao seu computador através de um conversor USB-to-serial.
■ A■rduinos diferentes facilitar uma conversão USB-to-serial usando tanto ICs dedi-cado ou built-in
funcionalidade USB.
■ S■eu Arduino pode imprimir dados para o seu computador através de seu número de série USB
conexão.
■V■ocê pode usar caracteres especiais em série para formatar a sua impressão em série
com novas linhas e tabs.
■T■odos os dados em série são transmitidos como caracteres que podem ser convertidos em
números inteiros em uma variedade de formas.
■V■ocê pode enviar listas de números inteiros separados por vírgulas e usar funções integradas
para analisá-los em comandos para o seu esboço.
■ V■ocê pode enviar dados do seu Arduino para um aplicativo de desktop Processing.
■V■ocê pode receber dados de um aplicativo de processamento em seu desktop para controlar
periféricos conectados ao seu Arduino.
■ U■m Arduino Leonardo pode ser usado para emular um teclado ou mouse.
Capítulo
registos de
deslocame
Arduino UnoUSB cabo (A a B para Uno) LEDs vermelhos (n8) (LEDs

amarelosn3) LEDs verdes (n5) 220Ω resistores (n8) mudança
SN74HC595N registo DIP sensor de distância ICSharp
GP2Y0A41SK0F IR com cableJumper wiresBreadboard
downloads de código, vídeos e outros conteúdos digitais para este capítulo pode ser encontrada em
www.exploringarduino.com/content/ch7.
Além disso, todos os códigos podem ser
ewnwcwo.nwtirleayd.caosme/gmo/exploringarduinoem
145
Como você engole longe construção de novas e excitantes projectos com seu Arduino, você
pode já estar pensando: "O que acontece quando eu ficar sem pinos?" De fato, um dos projetos
mais comuns com o Arduino está usando a plataforma para colocar um enorme número de LEDs
piscantes sobre praticamente qualquer coisa. Ilumine o seu
quarto! Ilumine o seu computador! Acender seu cão! Ok, talvez não esse último.
Mas há um problema. O que acontece quando você quer começar a piscar 50 LEDs
(Ou controlar outras saídas digitais), mas você já usou de todos os seus pinos de I / O? Isso é
onde registos de deslocamento pode vir a calhar. Com registos de deslocamento, você pode
expandir os recursos de E / S do seu Arduino sem ter que pagar muito mais por um microcontrolador mais
caro com pinos de E / S adicionais. Neste capítulo, você aprenderá como registos de deslocamento
trabalhar, e você vai implementar o software e hardware necessários para fazer a interface seu Arduino
com registos de deslocamento com a finalidade de expandir as capacidades saída digital do seu
Arduino. Completando os exercícios deste capítulo irá familiarizá-lo com registos de deslocamento, e irá
ajudá-lo a tomar uma decisão design mais informado quando você está desenvolvendo um projeto
com um grande número de saídas digitais.
ESCOLHER O Arduino certa para o trabalho
Presente capítulo, likemostoftheearlierchapters,

usestheArduinoUnoasthedevelopmentplatform.AnyotherArduinowillworkjustaswe
butit'sworthconsideringwhyyoumightwanttouseoneArduinooveranotherforaparticularprojectyoumaybepursu-ing.Forexample,
youmightalreadybewonderingwhyyouwouldn'tjustuseanArduinowithmoreI / Opins, suchastheMega2560ortheDue.Ofcourse,
thatisacompletelyreasonablewaytocompleteprojectsthatrequiremoreoutputs.However, asanengineer,
youshouldalwaysbemindfulofotherconsiderationswhendesigninganewproject.Ifyouonlyneedtheprocess-ingpowerofanUno, butyoun
addingafewshiftregisterswillbeconsiderablycheaperthanupgradingyourentireplatform, andwillalsobemorecompact.Asatradeoff, itw
anditmightnecessitatemoredebuggingtimetogetitworkingright.
UnderstandingShiftRegisters
UMA registro de deslocamentoé um dispositivo que aceita um fluxo de bits em série e, simultaneamente,
envia os valores desses bits sobre os pinos de I / O em paralelo. Na maioria das vezes, estes são
utilizados para controlar um grande número de LED, tais como as configurações encontradas
Capítulo ■Registadores de deslocamento
em displays de sete segmentos ou matrizes de LED. Antes de mergulhar em usar um registrador

de deslocamento com o Arduino, considere o diagrama na Figura 7-1, que mostra as entradas e
saídas para um registrador de deslocamento série-paralelo. Variações a este
diagrama em todo o capítulo ilustram como entradas diferentes afetam as saídas.
Figura 7-1: entrada de registo de deslocamento diagrama / saída
Os oito círculos representam LEDs ligados aos oito saídas da mudança

Cadastre-se. As três entradas são as linhas de comunicação serial que ligam o registo de
deslocamento para o Arduino.
SendingParallelandSerialData
Existem essencialmente dois caminhos para enviar vários bits de dados. Recorde-se que
o Arduino, como todos os microcontroladores, é digital; ele só entende 1s e 0s.
Então, se você quiser dados suficientes para controlar oito LEDs digitalmente (cada um ligado
ou off), você precisa encontrar uma maneira de transmitir 8 bits totais de informações. em
ante- capítulos ous, você fez isso de forma paralela, usando o digitalWrite ()
eanalogWrite ()comandos para exercer o controle sobre vários pinos de I / O. Para um exemplo de
transmissão de informação paralelo, suponhamos que você fosse para ligar oito LEDs com oito
saídas digitais; todos os bits devem ser transmitidos em pinos de E / S, independentemente mais ou
menos ao mesmo tempo. No Capítulo 6 ", USB e Serial
Comunicação, "você aprendeu sobre a transmissão em série, que transmite 1 bit de dados em tempo.
registos de deslocamento permitem converter facilmente entre técnicas de transmissão de dados
seriais e paralelas. Este capítulo concentra-se em série-paralelo
registradores de deslocamento, às vezes chamados de série em, paralelo out (SIPO) registos de
deslocamento. Com estes dispositivos acessíveis, você pode "relógio em" múltiplos bytes de dados em série, e
enviá-
las a partir do registo de deslocamento de forma paralela. Você também pode encadear registos de
deslocamento e, assim, controlar centenas de saídas digitais de apenas três Arduino I / O pins.
Workingwiththe74HC595ShiftRegister
A mudança específica registrar, você estará usando é o registro 74HC595 turno. Levar
um olhar para o diagrama de pin-out da folha de dados mostrado na Figura 7-2.
Crédito: Imagem usada com permissão cortesia da Texas

.
www.ti.com
Figura 7-2: Registo de deslocamento diagrama de pin-out
Compreender a mudança Funções Register Pin
A seguir está uma repartição das funções dos pinos de registo de deslocamento:
■ p■inos através de Q representam as oito saídas paralelas do turno

UMA H
Q
register (ligada aos meios mostrados na Figura 7-1).
Capítulo ■ Registadores de deslocamento
■ V■CC irá se conectar a 5V.
■ G■ND vai ligar para um terreno compartilhado com o Arduino.
■ O■pino SER é representado pela entrada de dados na Figura 7-1. Este é o pino onde você vai
alimentar em 8 bit valores sequenciais para definir os valores das saídas paralelas.
■ O■pino SRCLK é representada pelo pino CLOCK na Figura 7-1. Cada

tempo este pino vai alto, os valores na mudança de registo de deslocamento de 1 bit. isto
será pulsado oito vezes para puxar todos os dados que você está enviando no pino de dados.
■O■pino RCLK é representada pelo pino de bloqueio na Figura 7-1. Também

conhecido
como o registar pin relógio, O pino de trava é usado para "cometer" o seu recentemente trocou
valores de série para as saídas paralelas tudo de uma vez. Este pino permite
sequencialmente os dados de deslocamento para o chip e ter todos os valores aparecem nas
saídas paralelas ao mesmo tempo.
Você não vai estar usando os SRCLR ou OE pinos nestes exemplos, mas você
pode querer usá-los para o seu projeto, então vale a pena entender o que eles fazem. OE significa
habilitar a saída. O bar com o nome de pino indica que ele está ativo baixo. Em outras palavras, quando
o pino é mantido baixo, a saída será ativada. Quando é erguida, a saída será desativada. Nestes
exemplos, este pino estará ligado directamente ao solo, de modo que as saídas paralelas estão sempre
activados. Você poderia, alternativamente, ligue a um pino de I / O do Arduino para ligar
simultaneamente todos os LEDs ligado ou desligado. O pino SRCLR é o pino clara serial. Quando puxado
baixo, ele esvazia o conteúdo do registrador de deslocamento. Para seus propósitos deste capítulo,
você amarrá-lo diretamente para 5V para impedir que os valores de registo de deslocamento de ser
apagada.
Entender como o registo de deslocamento Works
O registrador de deslocamento é um dispositivo síncrono; ele só age sobre a borda de subida do

sinal de relógio. Toda vez que as transições de sinal de relógio de baixo para cima, todos os valores
atualmente armazenados nas oito registradores de saída são deslocados sobre uma posição. (O
último é descartado ou saída no Q
'Pin se você estiver
H
cascata registos.) Ao mesmo tempo, o valor actualmente na entrada de dados é deslocado para a
primeira posição. Ao fazer isso oito vezes, os valores presentes são deslocados para fora e os novos
valores são deslocados para o registro. O pino de bloqueio é estabelecido alto no final deste ciclo para
fazer os valores recém-deslocados aparecem
nas saídas. O fluxograma mostrado na Figura 7-3 ilustra melhor a presente

o fluxo do programa. Suponha, por exemplo, que você deseja definir todos os outros LED
para o estado ON ,Q ,Q , ). Representada em binário, você quer a saída
(Q UMA Q G
C E
dos pinos paralelos sobre o registo de deslocamento para ficar assim: 10101010.
Figura 7-3: Mudando um valor em um registrador de deslocamento

Capítulo Registadores de deslocamento
■
Agora, siga os passos para escrever para o registo de deslocamento acima. Em primeiro lugar, o trinco
pino é definido como baixo para que os estados do LED actuais não são alteradas, enquanto os novos
valores são deslocados. Em seguida, os estados do LED são deslocados para os registradores em
ordem sobre a borda do relógio a partir da linha DATA. Depois de todos os valores foram deslocados
dentro, o
pino de bloqueio está situado no alto de novo, e os valores são emitidas pelo registo de deslocamento.
ShiftingSerialDatafromtheArduino
Agora que você entende o que está acontecendo nos bastidores, você pode escrever o código Arduino
para controlar o registo de deslocamento desta forma. Tal como acontece com todas as suas
experiências anteriores, você usa uma função conveniente que está construído para o Arduino
IDE para transferir dados para o registo IC. Você pode usar o shiftOut () a função
facilmente mudar a 8 bits de dados em um pino de I / O arbitrária. Ele aceita quatro
parâmetros:
■ O■número de pinos de dados
■ O■número relógio pin
■ A■ordem bit
■ O■valor para deslocar para fora
Se, por exemplo, você quer mudar o padrão alternado descrito na

seção anterior, você poderia usar o shiftOut () função como se segue:
shiftOut (DATA, relógio, MSBFIRST, B10101010);
o DADOSe RELÓGIOfunções são definidas para os números de pinos para essas linhas.
MSBFIRSTindica que o bit mais significativo irá ser enviado primeiro (o mais à esquerda
bit quando se olha para o número binário para enviar). Você pode alternativamente enviar os dados
com oLSBFIRSTdefinindo, que começaria por transmitir os bits a partir do lado direito dos dados binários.
O último parâmetro é o número a ser enviada. Ao colocar um capital
Bantes do número, você está dizendo ao Arduino IDE

para interpretar os seguintes números como valor binário em vez de um inteiro decimal.
Em seguida, você criar uma versão física do sistema que você acabou de aprender sobre
nas seções anteriores. Primeiro, você precisa para obter o registo de deslocamento com fio até o
Arduino:
■ O■pino de dados irá se conectar ao pino 8.
■ O■pino de bloqueio irá se conectar ao pino 9.
■ O■pino de clock irá se conectar ao pino 10.
Não se esqueça de usar resistores limitadores de corrente com os seus LEDs. referência do
diagrama mostrado na Figura 7-4 para configurar o circuito.
Figura 7-4: diagrama de circuito registo turno de oito LED
Agora, usando sua compreensão de como registos de deslocamento trabalhar, e sua compreensão
pé do shiftOut ()função, você pode usar o código na Listagem 7-1 para escrever o padrão de
alternância de LED para os LEDs anexados.
Listagem 7-1: Padrão alternado LED em um Shift Register-alternate.ino
const int SER = 8; // Saída de série para mudar registerconst int

TRAVA = 9; // Mudança registar trava pinconst int CLK = 10; //
Mudança pin relógio registo
void setup ()
■
{
outputspinMode (SER, OUTPUT);
pinMode (TRINCO, OUTPUT);
pinMode (CLK, OUTPUT);
digitalWrite (TRINCO, LOW); // Trava lowshiftOut (SER, CLK, MSBFIRST, B10101010); //

Mudança mais sig. bit firstdigitalWrite (TRINCO, HIGH); // Alta trava - padrão show
void loop ()
{
//Fazer nada
}
Porque o registo de deslocamento travará os valores, você precisa enviar-lhes apenas

uma vez na configuração; Eles, então, ficar no esses valores até que você alterá-los para outra
coisa. Este programa segue os mesmos passos que foram mostrados grafica-
camente na Figura 7-3. oTRAVApino é estabelecido baixo, os 8 bits de dados deslocada na

utilização do shiftO u t ()
f u n ção, e, em seguida, o TRAVApin está situado no alto novamente para
que o valores deslocados são emitidos nos pinos de saída paralelos do registo de deslocamento
IC.
Registos de deslocamento encadeamento
GettingeightdigitaloutputsfromthreeI / Opinsisaprettygoodtradeoff, butwhatifyoucouldgetevenmore? Youcan!

Bydaisychai youcouldtheoreticallyaddhundredsofdigitaloutputstoyourArduinousingjustthreepins.Ifyoudothis,
you'llprobablywanttouseabeefierpowersupplythanjustUSB.ThecurrentrequirementsofafewdozenLEDscanaddupveryquickly.
Recallfromthepin-outinFigure7-2thatthereisanunusedpincalled
Q '.Whentheoldestvalueisshiftedoutoftheshiftregister, Itisn'tdis-cardado; it'sactuallysentoutonthatpin.ByconnectingtheQ
H
'totheDATA
H
pinofanothershiftregister, andsharingtheLATCHandCLOCKpinswiththefirstshiftregister, youcancreatea16-bitshiftregistertha
Youcankeepaddingmoreandmoreshiftregisters, eachconnectedtothelastone, toaddacrazyofnumberoutputstoyourArduin
outbyhookingupanothershiftregisterasdescribedandsimplyexecutingtheshiftOut () função inyourcodetwice. (Eachcalltoshi

()canhandleonly8bitsofinformation).
ConvertingBetweenBinaryandDecimalFormats
Na listagem 7-1, as informações de estado LED foi escrito como uma cadeia binária de dígitos. Esta string
ajuda a visualizar quais LEDs será ligado e desligado. No entanto, você também pode escrever o
padrão como um valor decimal, convertendo entre os sistemas de base2 (binário) e Base10 (decimal). Cada
bit em um número binário (a partir da extremidade direita ou menos significativo, bit) representa um
poder cada vez maior de 2. Conversão de representações binárias para decimal representações é
muito simples. Considere o número binário de mais cedo exibido na Figura 7-5 com
os passos de conversão apropriadas decimais.
Figura 7-5: Binário para decimal conversão
O valor binário de cada bit representa um incremento de energia 2. No

caso de esse número, os bits de 7, 5, 3 e 1 são elevados. Então, para encontrar o decimal emprestou-
equiva, você adic7i o na 2
, 52 3, 2 , E dois1. O valor decimal resultante é 170. Você pode provar
para si mesmo que este valor é equivalente substituindo-o no código listado anteriormente.
Substitua oshiftOut ()
linha com esta versão:
shiftOut (SER, CLK, MSBFIRST, 170);
Você deverá ver o mesmo resultado que quando você usou a notação binária.
ControllingLightAnimationswithaShiftRegister
No exemplo anterior, você construiu uma exposição estática com um registo de deslocamento. No
entanto, você provavelmente vai querer exibir informações mais dinâmica em seus LEDs. Nos próximos
dois exemplos, você usar um registrador de deslocamento para controlar um efeito de iluminação e
um gráfico de barras física.
Buildinga "LightRider"
O piloto da luz é um efeito puro que faz com que ele se parece com os LEDs estão perseguindo um ao
outro e para trás. Continuar a usar o mesmo circuito que usou anteriormente.
o shiftOut () função é muito rápido, e você pode usá-lo para atualizar a mudança
cadastre-se vários milhares de vezes por segundo. Devido a isso, você pode rapidamente atualizar as
saídas de registo de deslocamento para fazer animações de iluminação dinâmica. Aqui,
você ilumina cada LED, por sua vez, da esquerda para a direita, em seguida, da direita para a esquerda.
Veja vídeo de demonstração ligados no final desta seção para ver este circuito acabado em ação.
Primeiro você quer descobrir cada estado de animação de modo que você pode facilmente ciclo
por eles. Para cada passo de tempo, o LED atualmente iluminado desliga, ea próxima luz acende.
Quando as luzes chegar ao fim, a mesma coisa acontece em sentido inverso. O diagrama de
temporização na Figura 7-6 mostra como as luzes vão olhar
para cada passo de tempo eo valor decimal necessário para transformar esse LED específico.
Figura 7-6: etapas de animação cavaleiro Luz

Recordando o que você aprendeu no início do capítulo, converter os valores binários

para cada etapa de luz em valores decimais que podem ser facilmente reciclados através. Usando um
paraloop, você pode percorrer uma matriz de cada um desses valores e transferi-los
para o registo de deslocamento uma ao tempo. O código na Listagem 7-2 faz exatamente isso.
Listagem 7-2: Luz Rider Sequence Code-lightrider.ino
// Faz uma animação piloto luz
const int SER = 8; // Saída de série para mudar registerconst int

TRAVA = 9; // Mudança registar trava pinconst int CLK = 10; //
Mudança pin relógio registo
// Seqüência de LEDsint seguintes [14]

= {}
1,2,4,8,16,32,64,128,64,32,16,8,4,2;
void setup ()
{
void loop ()
{
for (int i = 0; i <14; i ++)
{
digitalWrite (TRINCO, LOW); // Trava baixo - começar sendingshiftOut (SER, CLK,
MSBFIRST, seq [i]); // Mudança mais sig. bit firstdigitalWrite (TRINCO, HIGH); // Trava
alta - parar sendingdelay (100); //Velocidade da animação
}
}
Ao ajustar o valor dentro do demorafunção, você pode alterar a

velocidade da animação. Tente alterar os valores da seqmatriz para fazer
diferente sequências padrão.
NOTA owatchademovideoofthelightrider, check-outwww.exploringarduino
.com / content / CH7.YoucanalsofindthisvideoontheWileywebsiteshownatthebeginningofthischapter.

RespondingtoInputswithanLEDBarGraph
Utilizando o mesmo circuito, mas a adição de um sensor de distância IR, você pode fazer um gráfico
de barras que responde a quão perto você começa. Para misturar-se um pouco mais, tente usar
várias cores LED. O diagrama do circuito na Figura 7-7 mostra o circuito modi-
cadas com diferentes LEDs coloridos e um sensor de distância IR.

Figura 7-7: gráfico de barras Distância de resposta
Usando o conhecimento que você já tem de trabalhar com sensores analógicos

eo registo de deslocamento, você deve ser capaz de fazer limiares e definir os LEDs em conformidade
com base na leitura à distância. Figura 7-8 mostra os valores decimais que correspondem a cada
representação binária de LEDs.
Figura 7-8: representações decimais gráfico de barras
Como você descobriu no capítulo 3, "Leitura Sensores analógicos", a gama de utilizável

Os valores para o sensor de distância IR não é na gama de 10-bit. (Eu achei que um valor máximo de
cerca de 500 funcionou para mim, mas sua configuração provavelmente será diferente.) O seu mínimo
pode não ser 0 ou. É melhor testar o alcance do seu sensor e preencha os valores apropriados. Você
pode colocar todas as representações decimais gráfico de barras em uma matriz de nove valores. Ao
mapear o sensor de distância IR (e restringindo-la) de 0 a 500 para baixo para 0-8, você pode
rapidamente e facilmente atribuir distâncias para barrar configurações gráficas. O código na Listagem
7-3 mostra esse método em ação.
■
Listagem 7-3: Gráfico de Barras Controle de Distância-bargraph.ino
// Um gráfico de barras que responde a como você está perto
const int SER = 8; // Saída de série para mudar registerconst int TRAVA
= 9; // Mudança registar trava pinconst int CLK = 10; // Mudança
registar relógio pinconst int DIST = 0; // O sensor de distância no pino
analógico 0
// Possíveis vals settingsint LED [9]

= {} 0,1,3,7,15,31,63,127,255;
// Valor máximo previsto pelo sensorint MAXVAL

= 500;
// Valor mínimo previsto pela sensorint minval

= 0;
void setup ()
{
void loop ()
{
distância int = analogRead (DIST); distância = map (distância,
minval, MAXVAL, 0, 8); distância = constranger (distância, 0,8);
digitalWrite (TRINCO, LOW); // Trava baixo - começar sendingshiftOut (SER, CLK, MSBFIRST,
vals [distância]); // Enviar dados, MSB firstdigitalWrite (trinco, HIGH); // Trava alta - parar
sendingdelay (10); //Velocidade da animação
Carregar o programa acima para o Arduino, e mover sua mão para trás e
outro na frente do sensor de distância, você deve ver a responder gráfico de barras, indo para
cima e para baixo, em paralelo com a mão. Se você achar que o gráfico paira muito em "all on"
ou "tudo fora", tente ajustar a
MAXVALe minval
valores para melhor atender as leituras do seu sensor de distância. Para testar os valores que
você está recebendo em várias distâncias, você pode inicializar uma conexão serial
naconfiguração()e chamada Serial.println (distância);
direito depois de executar a
analogRead (DIST);passo.
NOTA owatchademovideoofthedistanceresponsivebargraph, visita

Resumo
■ C■omo funciona um registrador de deslocamento
■ A■s diferenças entre a transmissão de dados serial e paralela
■ A■s diferenças entre decimal e representações de dados binários
■ C■omo criar animações usando um registrador de deslocamento

par t
III
Interfaces de comunicação
InThisPart
Capítulo 8: a I 2
C Bus
Capítulo 9: O Bus SPICapítulo 10: Interface com ecrãs de ais
crist líquidosCapítulo 11: Comunicação sem fio com XBee
rádios
Capítulo
a I2C Bus
cabo Arduino UnoUSB (A a B para

Uno) LEDs vermelhos LEDYellow
(n3) LEDs verdes (n4) 220Ω
resistores (n8)
4.7kΩ resistores (n2) mudança SN74HC595N

registo DIP ICTC74A0-5.0VAT temperatura I2C
sensorJumper wiresBreadboard
downloads de código, vídeo e outros conteúdos digitais para este capítulo pode ser
encontrada em www.exploringarduino.com/content/ch8 .
Além disso, todos os códigos podem ser ewnwcwo.nwtirleayd.caosme/gmo/exploringarduinoem
163
1 parte III ■Interfaces de
Você já aprendeu como conectar analógica e entradas / saídas digitais,

mas o que sobre os dispositivos mais complicados? O Arduino pode expandir suas capacidades
por interface com uma variedade de componentes externos. Muitos circuitos integrados implementar
protocolos de comunicação digital com padronizados para facilitar a comuni-cação entre o
microcontrolador e uma grande variedade de possíveis módulos. Este capítulo explora a I
2
bus C (pronuncia-se "olho quadrado ver" ou "olho Two Veja").
a I2bus C permite robusta de alta velocidade, comunicação de duas vias, entre
dispositivos enquanto usando um número mínimo de E / S pinos de I para facilitar a comunicação.
uma I2barramento C é controlada por um dispositivo principal (normalmente um microcontrolador), e
contém um ou mais dispositivos escravos que recebem informação do mestre. Neste capítulo, você
aprenderá sobre o I 2
protocolo C, e implementá-lo a com-
2
nicam com um digital I sensor de temperatura C capaz de retornar
medição
mentos como valores de grau em vez de valores analógicos como arbitrária. Você constrói sobre o
conhecimento dos capítulos anteriores, combinando o que você aprende neste capítulo para expandir
projetos anteriores.
NOTA ollowthestepsofthischapterwiththistutorialvideo:www.jeremyblum
.com / 2011/02/13 / arduino-tutorial-7-i2c-and-processamento /.YoucanalsofindthisvideoontheWileywebsiteshownatthebeginningofthi
2
HistoryoftheI Cbus
Quando se trata de protocolos de comunicação, a compreensão de como o protocolo evoluiu ao longo d o

tempo faz com que seja muito mais fácil de entender por que ele funciona da maneira que ele faz. a
I2protocolo C foi inventado por Phillips no início de 1980 para permitir relativamente comunicação
de baixa velocidade entre vários ICs. O protocolo foi padronizado pela década de 1990, e de outras
empresas rapidamente começou a adotar a
protocolo, libertando os seus próprios chips compatíveis. Genericamente, o protocolo é conhecida

como o protocolo "de dois fios", porque duas linhas são utilizadas para a comunicação, um relógio e
linha de dados. Embora nem todos os dispositivos de protocolo de dois fios pagou a taxa de licença
para ser chamado I
2
dispositivos de C, que são vulgarmente referidos como tod2oCs. Eu
Esta é semelhante à forma como Kle®eénmexuitas vezes utilizado para se referir a todos os tecidos, mesmo
®
aqueles que não são fabricados pela Kleenex . Se você encontrar um dispositivo que diz que usa o
"Two-wire" protocolo de comunicação, você pode estar certo de que ele vai trabalhar na forma
descrita neste capítulo.
Eu2CHardwareDesign
Figura 8-1 mostra uma configuração de referência comum p2aCrasiusmtemI a de comunicação.

2
Ao contrário de comunicação digital anterior que você viu neste livro, eu Cé
único em que múltiplos dispositivos todos compartilham as mesmas linhas de comunicação: um relógio
Capítulo ■ O I2C Bus
sinal (SCL) e uma linha de dados bidirecional usado para o envio de informações e para trás entre
o mestre e os escravos (SDA). Observe, também, que a I 2
C
bus requer pull-up resistores em ambas as linhas de dados.

Figura 8-1: Eu2 configuração de hardware de referência C
CommunicationSchemeandIDNumbers
a I2bus C permite que múltiplos dispositivos escravos para compartilhar as linhas de comunicação com um
único dispositivo mestre. Neste capítulo, o Arduino atua como o dispositivo mestre. O mestre de
rede é responsável por iniciar todas as comunicações. dispositivos escravos
Não é possível iniciar comunicações; eles só podem responder a pedidos que são
enviado pelo dispositivo mestre. Como vários dispositivos escravos compartilham as mesmas linhas
com- comunica-, é muito importante que somente o dispositivo mestre pode iniciar a comunicação. Caso
contrário, vários dispositivos podem tentar falar ao mesmo tempo e os dados iria ficar ilegível.
Todos os comandos e pedidos enviados a partir do mestre são recebidas por todos os dispositivos
2
no ônibus. cada I dispositivo escravo C tem um endereço de 7 bits único, ou número de identificação.
2
Quando comunicação é iniciada pelo dispositivo mestre, um ID do dispositivo é transmitido. Eu C
dispositivos escravos reagir aos dados no ônibus somente quando ela é dirigida pelo seu número de identificação.
Porque todos os dispositivos estão recebendo todas as mensagens, cada dispositivo na I2C
barramento deve ter um endereço exclusivo. alg2duinsspoesuitivos C têm endereços selecionáveis,
enquanto outros vêm do fabricante com um endereço fixo. Se você quiser ter vários números do
mesmo dispositivo em um ônibus, você precisa para identificar os componentes que estão
disponíveis com diferentes IDs.
Os sensores de temperatura, por exemplo, estão vulgarmente disponíveis com vários pré-
Eu programei2C aborda porque é comum a querer mais de um em um único I 2bus C. Neste capítulo,
você usa o sensor de temperatura TC74. Uma espiada
o TC74 folha de dados revela que ele está disponível com uma variedade de diferentes endereços.
Figura 8-2 mostra um trecho da folha de dados. Neste capítulo, você usa TC74A0-
5.0VAT, que é a 5V, T0-220 versão do IC com um endereço de 1.001.000.
Crédito: © 2013 Microchip Technology,
Figura 8-2: opções de endereço TC74
Você pode comprar este IC especial com oito números de identificação diferentes;
2
conseqüentemente, você pode colocar até oito deles em um I C ônibus e ler cada um deles inde-
dentemente. Enquanto você estiver escrevendo programas para fazer a interface com este sensor de
temperatura mais adiante neste capítulo, certifique-se de estar ciente do ID do dispositivo que você
pediu para que você enviar os comandos certos!
Outros I2chips de C, como o AD7414 e AD7415, têm endereço de escolha (AS)

2
pinos que permitem configurar o I C endereço do dispositivo. Dê uma
olhada o trecho da AD7414 datasheet na Figura 8-3.
Capítulo O Bus
■ 1
Crédito: Analog Devices, Inc.,

Figura 8-3: AD7414 abordando
Como se mostra na Figura 8-3, o AD7414 disponível em quatro versões, com dois
um pino de AS e dois sem. As versões com como pinos cada um pode ter três
possíveis números de identificação, dependendo se o pino como é deixado desconectado, está ligada
à VCC, ou está ligada a GND.
HardwareRequirementsandPull-UpResistors
2
Você deve ter notado na Figura 8-1 que a I padrão configuração do barramento C
requer resistores pull-up em ambos o relógio e linhas de dados. O valor para essas resistências
depende dos dispositivos escravos e quantos deles estão ligados. Neste capítulo, você usa resistores
4.7kΩ para ambos os pull-ups; este é um valor bastante normal que será especificado por muitas
fichas.
2
CommunicatingwithanI CTemperatureProbe
2
Os passos para se comunicar com diferentes I C dispositivos variam de acordo com o
2
requisitos do dispositivo específico. Felizmente, você pode usar o Arduino I C
biblioteca para abstrair a maioria do trabalho momento difícil. Nesta seção do capítulo, você
com o I 2
conversar C sensor de temperatura descrito anteriormente. Você aprende como
para interpretar as informações folha de dados à medida que avança de modo que você pode aplicar
esses conceitos para outros 2I
dispositivos C com relativa facilidade.
Os passos básicos para controlar qualquer2CI dispositivo são os seguintes:
1. Mestre envia um bit de início.
2. Mestre envia endereço do escravo de 7 bits de dispositivo que quer falar.
3. mestre envia ler (1) ou escrever (0) bit, dependendo se ele quer escrever dados em um
I2registo do dispositivo de C ou se quer ler a partir de um do Grupo I2registros do dispositivo
C.
4. Slave responde com um "reconhecer" ou bit ACK (uma lógica baixa).

5. No modo de gravação, mestre envia um byte de informação de cada vez, e o escravo

responde com ACK. No modo de leitura, mestre recebe 1 de informações byte de cada
vez e envia um ACK para o escravo após cada byte.
6. Quando a comunicação tenha sido concluída, o mestre envia um bit de parada.
SettingUptheHardware
Para confirmar que o seu primeiro programa funciona como esperado, você pode usar o monitor
serial para imprimir as leituras de temperatura a partir de
sensor de temperatura para
um2 I
C
seu computador. Porque este é um sensor digital, imprime a temperatura no
graus. Ao contrário dos sensores de temperatura que você usou nos capítulos
anteriores, você não precisa se preocupar com a conversão de uma leitura analógica
para um real temperatura. Quão conveniente! Agora, ligar um senor temperatura para o
Arduino como mostrado na Figura 8-4.
Figura 8-4: Sensor de temperatura

Capítulo ■O I2C Bus
Note que o SDA e SCL pinos são conectados aos pinos A4 e A5, respectivamente.
Lembre-se de mais cedo no capítulo que a SDA e SCL são os dois pinos utilizados
2
para se comunicar com I dispositivos de eles C transportar dados e sinais de relógio, res-
pectivamente. Você já aprendeu sobre pinos multiplexados em capítulos anteriores. No Arduino, pinos
A4 e A5 são multiplexados entre o conversor analógico-para-digital (ADC) e o hardware I
2
Interface C. Quando você inicializar o fio
2
biblioteca em seu código, os pinos conectar a I do ATmega C controlador, permitindo
-lo a se comunicar com o Fioobjeto a I2dispositivos C via os pinos. Ao usar a biblioteca Wire, você não
pode usar pinos A4 e A5 como entradas analógicas, porque eles são reservados para comunicação
com I
2
dispositivos C.
ReferencingtheDatasheet
Em seguida, você precisa escrever o software que instrui o Arduino para solicitar dados do I 2C sensor
de temperatura. A biblioteca Arduino fio faz com que este
razoavelmente fácil. Para usá-lo corretamente, você precisa saber como ler a folha de dados
para determinar o esquema de comunicação que este chip em particular usa. Vamos dissecar
o
esquema de comunicação apresentada na folha de dados usando o que você já sabe sobre como eu
2
C funciona. Considere os diagramas de folha de dados
mostrado nas Figuras 8-5 e 8-6.
Figura 8-5: esquema de comunicação do sensor TC74

Figura 8-6: TC74 registrar informações
Você pode ler e escrever para esta IC, como mostrado na folha de dados em
Figura 8-5. O TC74 tem dois registos, um que contém a temperatura actual no
Celsius e que contém informações de configuração sobre o chip (incluindo o estado de espera e estado
de dados pronto). Tabela 4-1 da folha de dados mostra isso. Você não fazer
Capítulo ■O I2C Bus
precisa mexer com a informação de configuração; você só quer ler a temperatura do dispositivo. As
tabelas 4-3 e 4-4 dentro Figura 8-6 mostram a forma como a informação sobre a temperatura é
armazenada dentro do registo de dados de 8 bits.
A seção "Leia Format Byte" da figura 8-5 descreve o processo de leitura

a temperatura do TC74:
1. Enviar para o endereço do dispositivo no modo de gravação e esc0repvaerar

uinmdicar que você quiser ler a partir do registo de dados.
2. Enviar para o endereço do dispositivo em modo de leitura e solicitar 8 bits (1 byte) de

informações do dispositivo.
3. Espere para receber todos os 8 bits de informação da temperatura.
Agora que você compreende os passos necessários para solicitar informações

este dispositivo, você deve ser capaz de entender melhor I quão semelhantes 2dispositivos C
também funcionaria. Quando se duvidar, pesquisar na web para exemplos de código que
como conectar o Arduino para vários I 2
mostram dispositivos C. Em seguida, você escreve o
código que executa as três etapas descritas anteriormente.
WritingtheSoftware
I do Arduino2biblioteca de comunicação C é chamado o Fiobiblioteca. Depois que você incluí-

lo no topo do seu esboço, você pode facilmente gravar e ler a partir de I 2
C
dispositivos. Como um primeiro pass2oCpdaerateomspeuerIatura sistema de sensores,
carregar o código na listagem 8-1, que tira proveito das funções embutidos no
Fiobiblioteca.
Veja se você pode combinar-se vários Fiocomandos no código a seguir
com as etapas descritas na seção anterior.
Listagem 8-1: 2ECu Temperatura Impressão Sensor Code-read_temp.ino
// Lê Temp a partir de sensor de temperatura I2C

// e imprime-lo na porta serial
// Incluir biblioteca Wire I2C

#include <Wire.h> int temp_address = 72; // 1001000 escrita como número
decimal
void setup ()
{
// Iniciar comunicação serial em 9600 baudSerial.begin
(9600);
// Criar um fio
objectWire.begin ();
void loop ()
{
// Enviar um pedido // Comece a falar com o dispositivo na
addressWire.beginTransmission especificado (temp_address); // Enviar
um pouco pedindo para registo zero, o registerWire.write dados (0); //
Wire.endTransmission transmissão completa ();
// Leia a temperatura do dispositivo // Pedido de 1 byte do

addressWire.requestFrom especificado (temp_address, 1);
// Aguarde a resposta while (Wire.available () == 0); //
Obter a temperatura e lê-lo em um variableint c =
Wire.read ();
// Fazer alguma matemática para converter a Celsius

para Fahrenheitint f = round (c * 9.0 / 5.0 32,0);
// Enviar a temperatura em graus C e F da monitorSerial.print série (C);

Serial.print ( "C"); Serial.print (f); Serial.println ( "F");
atraso (500);
}
Considere como os comandos deste programa referem-se mencionado

anteriormente passos. Wire.beginTransmission () inicia a comunicação com um
dispositivo escravo com o ID fornecido. Em seguida, Woire.write () comando envia
uma 0, indicando que
você quer ser a leitura do registo de temperatura. Você, então, enviar um bit de parada
oWire.endTransmission ()
com para indicar que você terminar de escrever a
2
o dispositivo. Com as próximas três etapas, o mestre lê a partir do escravo I C dispositivo.
Porque você emitir um Wire.requestFrom ()comando, o mestre vai esperar para receber um byte
de dados de volta do escravo. o
Wire.available () comando
dentro do enquanto()ciclo irá bloquear o programa de executar o resto do código até que os
está disponível no I 2
dados linha C. Isto dá a hora do dispositivo escravo
responder. Finalmente, o valor de 8 bits é lido em uma variável inteira com um
Fio. ler()comando.
O programa na Listagem 8-1 também lida com a conversão da temperatura Celsius para
Fahrenheit, para aqueles que não são metricamente inclinado. Você pode encontrar a fórmula

Exploring Arduino 101 200.en - PT

Enviado por

Direitos autorais:

Formatos disponíveis

Exploring Arduino 101 200.en - PT

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

Exploring Arduino 101 200.en - PT

Enviado por

Direitos autorais:

Formatos disponíveis

Capítulo 4 ■Usando transistores e condução Motors 1

interruptores opostas são invertidas, corrente, em seguida, atravessa o motor no

Criação de circuitos curtos com pontes H

Construir um circuito de ponte H

Imagem usada com permissão cortesia

Vamos percorrer os pinos e como você vai usá-los:

■ 3■Y e 4Y (pinos 11 e 14): Estas são as saídas do driver correto.

■ 3■A e 4A (pinos 10 e 15): Os estados dos interruptores à direita são

Imagem criada com o Fritzing.

Figura 4-7: esquema de ligações H-ponte

A operação de um circuito de ponte H

Em seguida, você escrever um programa para controlar a direcção do motor e velocidade

// Motor vai para a frente em uma determinada taxa (0-255)

// Motor vai para trás em uma determinada taxa (0-255) vazio

Note-se que no início de cada função da PT pin é sempre definido baixo, e

a PTpin é alternado, controlando assim a velocidade. otaxa variável deve ser

Em seguida, considerar o loop principal do programa:

No circuito principal, o valor de potenciômetro é lido, ea função apropriada

Figura 4-8: plano de controle do motor.

Listagem 4-3: H-Ponte Potenciómetro Motor Control-hbridge.ino

// Hbridge Motor Controlconst int PT = 9; // Meia

int val = 0; // Para armazenar a leitura a partir da velocidade POTint = 0; // Para

velocidade = map (val, 563, 1023, 0, 255); para a frente

// Motor vai para a frente em uma determinada taxa (0-255)

// Motor vai para trás em uma determinada taxa (0-255) vazio

armaduras para rotações específicas, e precisamente controlando a abertura de uma

Usado com permissão de Parallax Inc. Copyright © 2013 Parallax

Imagem criada com o

A queda de tensão entre a entrada e a saída é queimado na forma de calor,

Imagem criada com o Águia

Observe os capacitores em cada lado do regulador. Estes são chamadosdissociação

Imagem criada com o

ENTENDENDO Reguladores lineares e os limites das fontes de alimentação

Whyisitnecessarytouseanexternalpowersupplywhencertainitemsrequiremorecurrent? Therearefewreasons.TheI / Opinscannotsupp

0move o servo para 0 graus,

Listagem 4-4: Servo Potentiometer Control-servo.ino

// Servo controle do potenciômetro

const int SERVO = 9; // Servo no Pino 9const int POT

Servo myServo; int val = 0; // Para armazenar a leitura do POT

o incluirinstrução na parte superior do programa adiciona a funcionalidade de

Porque a luz IR é uma parte do espectro electromagnético que os seres humanos

as leituras de sensor fotográfico de IV, a distância é calculada e convertida em

Diferentes modelos de telémetros IR pode ter interfaces diferentes. Se vocês são

para começar o trabalho feito.

Figura 4-13: sensor de distância IR montado para o servo

Em seguida, ligar o seu servo até o Arduino, usando o regulador de 5V ao poder

Imagem criada com o

O último passo é programar o sensor. O sistema funciona da seguinte

Listagem 4-5: Distância de varrer Sensor-sweep.ino

// Varrendo Distância Sensor

const int SERVO = 9; // Servo no Pino 9const int IR = 0; // IR Sensor

Servo myServo; // Servo Objectint dist1 = 0; //

int dist4 = 0; // Quadrante 4 Distância

dist2 = readDistance (65); // Medida Distância IR em 65 degreesanalogWrite (LED2,

dist3 = readDistance (115); // Medida Distância IR a 115 degreesanalogWrite (LED3,

dist4 = readDistance (165); // Medida Distância IR a 165 degreesanalogWrite (LED4,

int readDistance (int pos)

O programa emprega uma função simples que roda o servo ao solicitado

Neste capítulo, você aprendeu sobre o seguinte: