ARDUINO – RoboHelp Guia

2015
ARDUINO – RoboHelp Guia
Akasaka
Sênior Consultoria
19/4/2015
Luiz Henrique Akasaka Ferreira
Sênior Consultoria
2015
1
ARDUINO – RoboHelp Guia
por Luiz Henrique Akasaka Ferreira
© 2014 por Sênior Consultoria
http://www.seniorcti.com.br
SKU190412
Este e-Book é indicado para quem quer iniciar experiências
utilizando o ARDUINO como plataforma de desenvolvimento, o seu
estudo e prática será de grande ajuda para que o leitor
compreenda como funciona esta ferramenta incrível de
aprendizado e possa replicar seu conhecimento.
Abre as portas para seu envolvimento em projetos maiores e no
desenvolvimento de produtos de sua autoria. Mais informações
sobre o Arduino, Raspberry Pi, e produtos para automação,
eletrônica e robótica visite o website:
http://www.robohelp.com.br
2
ARDUINO – RoboHelp Guia
ARDUINO – RoboHelp Guia
1ª Edição
São Paulo
2015
3
Akasaka
4
Este estudo visa estabelecer as bases que o
leigo possa iniciar seus estudos na plataforma
de
desenvovlvimento
ARDUINO,
ou
simplesmente saiba usar e obter o máximo de
seu potencial. Os experimentos são oriundos
dos laboratórios da Senior Consultoria. São
Paulo, 2015
1
O Arduino .............................................................................................................................. 7
2
Circuitos Eletrônicos o Início ................................................................................................. 9
2.1
O que é um circuito? ..................................................................................................... 9
2.2
Circuitos em Serie versos Paralelo .............................................................................. 10
2.3
Circuitos analógicos e Circuitos Binários ..................................................................... 10
2.4
Os conceitos centrais .................................................................................................. 11
2.5
A analogia com a HIDRÁULICA .................................................................................... 11
2.6
Corrente ...................................................................................................................... 12
2.7
Tensão Elétrica ............................................................................................................ 12
3
Resistencia........................................................................................................................... 13
3.1
Resistor de fio.............................................................................................................. 14
3.2
Resistor de filme de carbono ...................................................................................... 14
3.3
Resistor de filme metálico ........................................................................................... 15
3.4
Código de Cores .......................................................................................................... 15
3.5
Potência nos resistores ............................................................................................... 17
4
Capacitores .......................................................................................................................... 18
5
Leitura de diagramas esquemáticos.................................................................................... 21
6
Referência rápida de Instruções Arduino............................................................................ 23
7
Juntando tudo – A Prática ................................................................................................... 36
8
Benefícios de utilização em ambiente Industrial ................................................................ 38
9
led com botão liga e desliga ................................................................................................ 40
10
controlar um led com um potenciômetro ...................................................................... 44
11
botão que acende leds com efeito .................................................................................. 48
12
led RGB controlar as cores com botões .......................................................................... 52
13
Controle 8 leds com o Arduino usando o CI 74HC595, fazendo uma contagem binária. 57
14
Iluminação Automatizada ............................................................................................... 64
15
Alarme com Arduino e sensor de movimentos PIR......................................................... 67
16
Display LCD ...................................................................................................................... 71
17
Relógio LCD com Arduino ................................................................................................ 72
18
Sensor de detecção de Luz com fotocélula, som e Arduino ........................................... 76
19
Termômetro LCD com LM335 e Arduino ........................................................................ 79
5
SUMÁRIO
Como adicionar um LED RGB ao Arduino........................................................................ 82
21
adicionar um Buzzer ao Arduino ..................................................................................... 84
22
sensor Ultrassônico HC-SR04 ao arduino ........................................................................ 86
23
motor de passo ao Arduino ............................................................................................. 89
24
CI 74HC595 para aumentar número de portas do Arduino ............................................ 91
25
LDR três níveis de luz a Led com Arduino ..................................................................... 101
26
LED com efeito Fade com Arduino ................................................................................ 105
27
matriz de led 5×7 ao Arduino ........................................................................................ 107
28
Temômetro LCD com sensor LM35 e Arduino Indicador de temperatura Média, Mínima
e Máxima ................................................................................................................................... 111
29
LCD Shield com teclado para Arduino e exemplo de aplicação .................................... 114
30
Ligando relé com botão ao Arduino Uno ...................................................................... 117
31
Sensor de proximidade infravermelho com Arduino .................................................... 121
32
Relógio LCD com RTC DS1307 e Arduino ...................................................................... 126
33
Ligando um display lcd 16X2 ao Arduino ...................................................................... 134
34
temperatura e luminosidade com display LCD ............................................................. 143
35
Controlando a velocidade de um motor CC no Arduino com potenciômetro. ............. 149
36
Motor CC/DC no Arduino e ponte H dupla. Controle de velocidade e sentido da rotação
153
37
Motor CC no Arduino com controle de velocidade e leds medidores de potência. ..... 160
38
Controlando um servomotor com potenciômetro no arduino ..................................... 165
39
servomotor robótico e display LC ................................................................................. 168
40
joystick no Arduino e ler as posições X, Y e Z ................................................................ 174
41
CONSTRUINDO UM RELÉ SHIELD .................................................................................. 178
42
CLP Shield para ARDUINO ............................................................................................. 186
43
Arduino ISP Shield ......................................................................................................... 198
44
Protoboard - How To Use .............................................................................................. 202
45
Montagem utilizando placa universal ........................................................................... 220
46
Referências bibliográficas ............................................................................................. 225
6
20
Os apaixonados por tecnologia certamente já pensaram em prover soluções eletrônicas que
resolvessem probleminhas do dia a dia. Com o Arduino, uma placa fabricada na Itália utilizada
como plataforma de prototipagem eletrônica que torna a robótica mais acessível a todos.
Projeto italiano iniciado em 2005 tinha primeiramente cunho educacional e interagia com
aplicações escolares.
O sucesso nessa fase foi tão grande que mais de 50 mil placas open source foram vendidas e
rendeu um documentário de 2010 sobre a trajetória de desenvolvimento da plaquinha. As
unidades são constituídas por um microcontrolador Atmel AVR de 8 bits, pinos digitais e
analógicos de entrada e saída, uma entrada USB que permite conexão com computadores e
possui código aberto, que quando modificado, dá origem a outros derivados “ino”, que por
questões comerciais, levam nomes como Netduino, Produino e Garagino. A placa Arduino não
possui recursos de rede, mas pode ser combinada com outros Arduinos criando extensões
chamadas de shields.
É aí que entram ideias como a automação de casas, acender luzes por meio da controladora ou
projetos mais ousados como o Biometric Security Toy Box, que une a biometria, mais
especificamente a ideia do novo sensor de identidade digital da Apple, o Touch ID do iPhone 5S,
ao Arduino.
O projeto do designer inglês Grant Gibson consiste em trocar a fechadura convencional da caixa
de brinquedos (que abriga a coleção de carrinhos do seu filho) por um acesso por impressão
digital. O sistema é baseado em placa Arduino Uno e um sensor de impressão digital óptico.
Uma vez cadastrada a digital da criança, só ela consegue ter acesso a sua caixa de brinquedos.
7
1 O ARDUINO
O Arduino pode perceber o ambiente por receber a entrada de uma variedade de sensores e
pode afetar seus arredores por luzes controladoras como leds e lâmpadas, motores e outros
atuadores. Projetos do Arduino podem ser stand-alone ou podem se comunicar com software
rodando em um computador (por exemplo, Flash, Processing, MaxMSP ).
Arduino pode perceber o ambiente ao receber a entrada de uma variedade de sensores e pode
afetar seus arredores por luzes de controle, motores e outros atuadores. Projetada com
um microcontrolador Atmel AVR de placa única, com suporte de entrada/saída embutido, usa
uma linguagem de programação padrão, a qual tem origem em Wiring, o ambiente de
desenvolvimento Arduino (baseada em processamento ) que é essencialmente em C/C++. O
objetivo do projeto é criar ferramentas que são acessíveis, com baixo custo, flexíveis e fáceis de
se usar por profissionais e amadores, principalmente para aqueles que não teriam alcance aos
controladores mais sofisticados e de ferramentas mais complicadas.
As placas podem ser construídas a mão ou compradas pré-montadas e o software pode
ser baixado gratuitamente. Os designs de referência do hardware (arquivos de CAD)
estão disponíveis sob uma licença open-source, ou seja, você é livre para adaptá-los às suas
necessidades.
Pode ser usado para o desenvolvimento de objetos interativos independentes, ou ainda para
ser conectado a um computador hospedeiro. Uma típica placa Arduino é composta por um
controlador, algumas linhas de E/S digital e analógica, além de uma interface serial ou USB, para
interligar-se ao hospedeiro, que é usado para programá-la e interagi-la em tempo real.
Os fundadores do Arduino são: Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino
e David Mellis.
8
O Arduino é baseado em uma plataforma de prototipagem eletrônica flexível e baseada em
código-aberto (open-source), com hardware e software fáceis de usar. É destinado a artistas,
profissionais, designers, hobbistas e qualquer pessoa interessada em criar objetos ou
ambientes interativos.
Se você já encontrou discussões online sobre circuitos, a perspectiva de ingressar neste mundo
pode parecer bastante assustadora, há um monte de jargões, vários símbolos misteriosos, e um
monte de matemática. Vamos tentar acabar com isso.
Você pode começar a desenvolver projetos com componentes eletrônicos associados ao
Arduino, você pode fazer algum progresso sem saber muito sobre eletricidade e circuitos. Ao
seguir guias on-line você pode anexar sensores, displays e motores a um Arduino ou outro
microcontrolador, sem entender o que é que você está realmente fazendo. No entanto, se você
quiser passar a fase de novato, e começar a fazer emocionantes, projetos personalizados, você
vai ter que começar a aprender os conceitos básicos de engenharia elétrica.
E, na verdade, é um tema complexo, com muita coisa para aprender. Mas felizmente, você não
tem que saltar para o fundo do poço de uma vez. Neste guia de iniciação, cobre os princípios
mais básicos de construção de circuito, com detalhe suficiente para prepará-lo para construir e
compreender alguns circuitos simples.
É necessário aprender os primeiros tópicos para que você tenha uma base e possa entender
como funciona a eletrônica, em seguida vou descrever como usar esses conceitos para construir
um circuito simples com Arduino. Nos capítulos subsequentes você poderá utilizar estes
conhecimentos para elaborar uma série de exemplos com Arduino que selecionamos para você,
você pode usá-los para aprender, para ensinar outras pessoas a gostar de eletrônica e usar como
base para aprimorar seus conhecimentos, e quem sabe obter as bases para executar um grande
projeto baseado em alguma invenção para melhorar o seu ambiente.
2.1 O QUE É UM CIRCUITO?
Há um monte de ciência muito interessante sobre como, exatamente, a eletricidade funciona,
mas para uma compreensão prática de circuitos elétricos simples, você não precisa entrar no
material realmente de baixo nível. A única coisa que você precisa entender é simplesmente que
a carga elétrica flui através de condutores, como fios, e através de todos os tipos de
componentes elétricos, com vários efeitos sobre os componentes à medida que fluem através
deles. Um componente elétrico simples é uma lâmpada, o efeito de uma carga elétrica que flui
através do bulbo em seu interior é que produz a luminosidade que você pode ver. Se um fio e
componentes diferentes estão ligados uns aos outros de modo que eles formem um elo, a
corrente elétrica fluindo de um ponto ao outro produz um efeito qualquer, acender as luzes,
desligar um motor, etc.
9
2 CIRCUITOS ELETRÔNICOS O INÍCIO
Um circuito pode ser tão simples como um fio, que a partir de um lado (polo positivo) de uma
bateria, segue para uma lâmpada, e depois de volta para o outro lado (polo negativo) de uma
bateria. É possível, é claro, adicionar várias lâmpadas ou outros componentes no circuito. Se
você adicionar as lâmpadas para que eles fiquem assim:
Você criou um circuito em serie. Em um circuito em série, a corrente passa através de cada
componente na seqüência. Se você construir o circuito de modo que a corrente pode tomar
vários caminhos através do circuito, como abaixo, você construiu um circuito em paralelo. Ele
não vai ficar claro logo de cara, mas a diferença entre construção paralela e em série vem à tona
constantemente na construção de circuitos eletrônicos, por isso é importante lembrar as duas
formas diferentes. Componentes em série são todos em uma linha, componentes paralelos são
lado a lado.
2.3 CIRCUITOS ANALÓGICOS E CIRCUITOS BINÁRIOS
Se você está trabalhando com um microcontrolador Arduino, vai ter que lidar bastante com
circuitos digitais e analógicos. Estes são circuitos que utilizam fios para transmitir dados, em vez
de apenas para componentes de potência. Circuitos binários ou digitais, fazem a transferência
de dados binários (1s e 0s, como em um computador), enquanto os dados de transferência de
circuitos analógicos (como um toca-discos) produzem seus efeitos através da variação e
interrupção da carga elétrica que flui através dos componentes. A placa Arduino Uno, por
exemplo, inclui 14 pinos digitais que você vai se conectar a sensores, atuadores e outros
10
2.2 CIRCUITOS EM SERIE VERSOS
ERSOS PARALELO
ARALELO
A principal informação que você precisa lembrar sobre circuitos digitais e circuitos analógicos é
simplesmente que há uma diferença, e que quando você for recuperar informações externas de
seus componentes (como sensores), para seus projetos, você deve verificar se eles se
comunicam com o Arduino usando pinos digitais ou pinos analógicos.
2.4 OS CONCEITOS CENTRAIS
Agora que eu já falei sobre o que um é circuito, vamos ver como funcionam. Vale reiterar que
isto é um compendio básico, não substituirá o aprendizado formal que você deverá obter na
medida em que progredir em seu aprendizado. Os conceitos aqui propostos são apenas a base
do conhecimento para você iniciar neste mundo estranho. Se você entende isso, você vai ter
uma grande plataforma para abordar os tópicos mais avançados em engenharia elétrica.
2.5 A ANALOGIA COM A HIDRÁULICA
Um maneira realmente útil de abordar os conceitos básicos de eletricidade é com o que é
chamado de analogia hidráulica. Em um nível baixo, a eletricidade em um circuito se comporta
muito como um fluido, o que significa que podemos discutir os conceitos, comparando-os a um
sistema de água que flui através de tubos, um conceito que a maioria das pessoas têm uma
compreensão mais intuitiva do que a eletricidade.
A premissa básica da analogia hidráulica é um circuito que é como uma rede de tubos totalmente
cheios de água. Cada um dos tubos é conectado em qualquer fim, de modo que um está
conctado ao outro, de modo que a água pode fluir através dele como um circuito, mas nunca
pode sair fora dele. Adicionando diferentes componentes elétricos a um circuito são
equivalentes a adição de conexões, controladores de vazão e torneiras diferentes para o sistema
de tubos.
11
componentes que enviam ou recebem dados binários através de um fio. Ele também inclui 6
pinos analógicos, que são usados quando existe a adição de sensores analógicos ao seu projeto.
Na analogia hidráulica, a corrente é equivalente vazão que a água flui através do tubo. A unidade
de medida da intensidade da corrente elétrica é o ampère e é representada pelo símbolo A.
2.7 TENSÃO ELÉTRICA
Tensão, é a diferença de potencial elétrico entre dois pontos em um circuito. Para explicar o que
quero dizer com potencial elétrico, é útil para voltar à analogia hidráulica, e falar sobre um
fenômeno familiar para mais pessoas: pressão da água.
Se você imaginar um circuito feito de tubos cheios de água, tensão é a diferença de pressão de
água entre dois pontos quaisquer. Intuitivamente nós entendemos que, em um sistema de
tubos, se a pressão da água é maior em um ponto do que em outro, e não há uma via disponível
entre esses dois pontos, a água vai fluir a partir do ponto de pressão alta ao ponto de pressão
baixa.
Para reforçar ainda mais a analogia, o equivalente hidráulico de uma bateria AA é uma bomba
que mantém uma diferença especificado na pressão da água. Assim como uma bomba que faria
a água fluir através de tubos ligados às suas duas extremidades, uma bateria ocasiona uma
corrente eléctrica que flui através de um circuito em um laço, que é formado ligando os seus
dois terminais, positivo e negativo através de um circuito lementar qualquer, uma lâmpada que
se acende aou ligarem-se os dois terminais a ela através de fios.
A tensão é medida em Volts. É a diferença de potencial entre dois pontos, mas as pessoas vão
frequentemente obter a tensão em um único ponto do circuito. O segundo ponto é
implicitamente o terra, ou a parte de um circuito com o menor potencial elétrico.
12
2.6 CORRENTE
A definição de um circuito é importante para compreender como um conceito básico funciona.
A carga elétrica flui através de um fio, a maioria dos componentes elétricos requerem corrente
que flui através deles para realmente fazer alguma coisa. Uma corrente elevada pode destruir
um componente ou torná-lo inerte, o esforço de construção de um componente é garantir que
a quantidade certa de corrente vá fluir através de cada ponto de um circuito.
13
3 RESISTENCIA
O conceito final necessário à compreensão de circuitos simples é a resistência, que pode ser
explicada como a quantidade que qualquer componente eléctrico impõe resistência ao fluxo da
corrente eléctrica. Cada componente elétrico tem uma determinada resistência, inclusive o fio
condutor. Um resistor é um componente projetado para adicionar uma quantidade específica
de resistência ao sistema, e é um dos componentes mais comuns que você vai ter lidar na
construção de circuitos eletrônicos.
Na analogia hidráulica, a resistência é a maneira como as tubagens e outros objectos de um
circuito de água tem capacidade de resistir ao fluxo de água por meio do atrito. A versão de
analogia de um resistor é um lugar em que o tubo é comprimido para um diâmetro mais estreito,
aumentando o atrito com a água que flui causando logicamente a resistência a sua vazão pelo
circuito.
Como você pode imaginar a partir da analogia, maior o atrito faz com que menos corrente flua
através do tubo.
Resistores são componentes que têm por finalidade oferecer uma oposição à passagem de
corrente elétrica por meio de seu material. A essa oposição damos o nome de resistência
elétrica, que possui como unidade o ohm [Ω], onde encontramos como múltiplos mais usuais:
Quilo-ohm (KΩ) : 1KΩ = 10³ Ω
Mega-ohm(MΩ) : 1MΩ = 106 Ω
Classificamos os resistores em dois tipos, sendo fixos e variáveis. Os resistores fixos são aqueles
cujo valor da resistência não pode ser alterado, enquanto as variáveis têm a sua resistência
modificada dentro de uma faixa de valores por meio de um cursor móvel.
Os resistores fixos são comumente especificados por três parâmetros: o valor nominal da
resistência elétrica, a tolerância, ou seja, a máxima variação em porcentagem do valor nominal,
e a máxima potencia elétrica dissipada.
Exemplo: Tomemos um resistor de 100Ω ± 5% - 0,33W. Isso significa que possui um valor
nominal de 100Ω, uma tolerância sobre esse valor de mais ou menos 5% e pode dissipar uma
potência de no máximo 0,33 watts.
Dentre os tipos de resistores fixos destacamos os de fio, de filme de carbono e de filme metálico.
Resistores de fio.
Os resistores de fio são encontrados com valores de resistência de alguns ohms até alguns quiloohms, e são aplicados onde se exigem altos valores de potência, acima de 5W, sendo suas
especificações impressas no próprio corpo.
3.2 RESISTOR DE FILME DE CARBONO
Consiste em um cilindro de porcelana recoberto por um filme (película) de carbono. O valor da
resistência é obtido mediante a formação de um sulco, transformando a película em uma fita
helicoidal. Esse valor pode variar conforme a espessura do filme ou a largura da fita. Como
revestimento, encontramos uma resina protetora sobre a qual é impresso um código de cores,
identificando seu valor nominal e tolerância.
Resistor de filme de carbono.
Os resistores de filme de carbono são destinados ao uso geral e suas dimensões físicas
determinam a máxima potencia que eles podem dissipar.
14
3.1 RESISTOR DE FIO
Consiste basicamente em um tubo cerâmico que serve de suporte para enrolarmos um
determinado comprimento de fio, de liga especial para obter o valor de resistência desejado. Os
terminais desse fio são conectados às braçadeiras presas ao tubo. Além deste, existem outros
tipos construtivos esquematizados, conforme é mostrado na figura.
Resistor de filme metálico.
3.4 CÓDIGO DE CORES
Os valores ôhmicos dos resistores podem ser reconhecidos pelas cores das faixas em suas
superfícies, cada cor e sua posição no corpo do resistor representam um número, de acordo
com o seguinte esquema:
Código de Cores
15
3.3 RESISTOR DE FILME METÁLICO
METÁLICO
Sua estrutura é idêntica à de filme de carbono, somente que se utiliza uma liga metálica (níquelcromo) para formar a película, obtendo valores mais precisos de resistência, com tolerância de
1% e 2%.
A SEGUNDA FAIXA dá o SEGUNDO DÍGITO. Essa é uma faixa violeta, então o segundo dígito é 7.
A TERCEIRA FAIXA é chamada de MULTIPLICADOR e não é interpretada do mesmo modo. O
número associado à cor do multiplicador nos informa quantos "zeros" devem ser colocados após
os dígitos que já temos. Aqui, uma faixa vermelha nos diz que devemos acrescentar 2 zeros. O
valor ôhmico desse resistor é então 4700 ohms, quer dizer, 4 700Ωou 4,7 kΩ.
Ilustração de código de cores no resistor.
Verifique novamente, nosso exemplo, para confirmar que você entendeu realmente o código
de cores dados pelas três primeiras faixas coloridas no corpo do resistor.
A QUARTA FAIXA (se existir), um pouco mais afastada das outras três, é a faixa de tolerância. Ela
nos informa a precisão do valor real da resistência em relação ao valor lido pelo código de cores.
Isso é expresso em termos de porcentagem.
Nosso resistor apresenta uma quarta faixa de cor OURO. Isso significa que o valor nominal que
encontramos 4700Ωtem uma tolerância de 5% para mais ou para menos. Ora, 5% de 4 700Ω são
235Ω então, o valor real de nosso resistor pode ser qualquer um dentro da seguinte faixa de
valores: 4 700Ω-235Ω= 4 465Ωe 4700Ω+ 235Ω= 4 935Ω.
Observação: - A ausência da faixa de tolerância indica que esta é de ±20%.
Para os resistores de precisão encontramos cinco faixas. As três primeiras representam o
primeiro, segundo e o terceiro algarismos significativos e as demais, respectivamente, fator
multiplicador e tolerância.
16
A PRIMEIRA FAIXA em um resistor é interpretada como o PRIMEIRO DÍGITO do valor ôhmico da
resistência do resistor. Para o resistor mostrado abaixo, a primeira faixa é amarela, assim o
primeiro dígito é 4.
A rapidez de conversão de energia, em qualquer campo ligado à Ciência, é conhecida pela
denominação de potência. A potência de um dispositivo qualquer nos informa "quanto de
energia" foi convertido de uma modalidade para outra a cada "unidade de tempo" de
funcionamento.
Potência = Energia convertida / Tempo para a conversão
As unidades oficiais para as grandezas da expressão acima são: Potência em watt (W), Energia
em joule (J) e Tempo em segundo (s).
Em particular, na Eletrônica, a potência elétrica nos informa quanto de energia elétrica, a cada
segundo, foi convertida em outra modalidade de energia. Em termos de grandezas elétricas a
expressão da potência pode ser posta sob a forma:
Potência elétrica = tensão x intensidade de corrente = v.i
Dentro da Eletrônica, para os resistores, onde a energia elétrica é convertida exclusivamente em
energia térmica, essa potência passa a ser denominada potência dissipada no resistor. Desse
modo, podemos escrever:
P = v . i = (R.i). i = R .i2
A cada finalidade, prevendo-se as possíveis intensidades de corrente que o atravessarão, devese adotar um resistor de tamanho adequado (potência adequada) para seu correto
funcionamento. Quanto maior o tamanho físico de um resistor maior será a potência que pode
dissipar (sem usar outros artifícios).
A ilustração a seguir mostra resistores de tamanhos diferentes:
Potência nos resistores com diferentes dimensões.
Simbologia
17
3.5 POTÊNCIA NOS RESISTORES
RESISTORES
Quando a corrente elétrica circula através de resistores, especificamente, e nos condutores, em
geral, esses sempre se aquecem. Neles ocorre conversão de energia elétrica em energia térmica.
Essa energia térmica produzida é transferida para fora do corpo do resistor sob a forma de calor.
Os capacitores são elementos de um circuito que reagem a sinais que se alternam rapidamente
em comparação a sinais que mudam lentamente ou que são estáticos. Esses componentes
podem armazenar energia e devolvê-la ao circuito conforme necessário. O uso mais comum dos
capacitores é para absorver ruídos, o que, por definição, são sinais que se alternam
rapidamente, e separá-los do sinal que realmente interessa. Para capturar tipos diferentes de
ruídos, são necessários valores diferentes de capacitores. Use as dicas abaixo para aprender a
ler as características de um capacitor e determinar o seu valor.
Compreenda as unidades de medida dos capacitores. A unidade de capacitância é o Farad (F).
Esse valor é muito grande para ser usado em um circuito. Em circuitos eletrônicos, são utilizadas
denominações menores de capacitância.
Leia uF como microFarad. O valor de 1 microFarad é 1 x 10-6 Farad.
Leia pF como picoFarad. O valor de 1 picoFarad é 1 x 10-12 Farad.
18
4 CAPACITORES
19
Nos capacitores maiores, leia o valor diretamente no corpo do componente. Se a superfície do
capacitor for suficientemente grande, o valor estará impresso nela. Por exemplo, 47uF indica
que o valor dele é 47 microFarads.
A capacitância de capacitores menores estará disposta em dois ou três números. Além disso,
os designadores uF ou pF não estarão impressos devido ao tamanho reduzido do componente.
Considere um número de dois dígitos como o valor em picoFarads (pF). Por exemplo, 47 deve
ser lido como 47pF.
Considere um número de três dígitos como o valor de base da capacitância em pF e um
multiplicador. Os primeiros dois dígitos indicarão o valor do componente em picoFarads. O
terceiro será um multiplicador do valor anterior, usado para encontrar o valor real da
capacitância.
Utilize o terceiro dígito (varia de 0 a 5) para colocar o número correspondente de zeros ao lado
do número que representa o valor. Se o terceiro dígito for 8, você deve multiplicar o valor do
componente por 0,01; se for 9, multiplique o valor por 0,1. Por exemplo, 472 indicaria um
capacitor de 4700 pF, e 479 um capacitor de 4,7 pF.
Procure por um código com letras. O valor de alguns capacitores é definido por um código de
três números seguido por uma letra. Essa letra representa a tolerância do componente, o que
significa o quão perto o valor real pode estar do valor nominal. As tolerâncias são indicadas
como a seguir:
•
•
•
•
•
•
•
•
•
•
•
•
•
Leia B como 0.10%
Leia C como 0.25%
Leia D como 0.5%
Leia E como 0.5%. Essa é uma duplicação do código D.
Leia F como 1%
Leia G como 2%
Leia H como 3%
Leia J como 5%
Leia K como 10%
Leia M como 20%
Leia N como 0.05%
Leia P como mais 100% a menos 0%.
Leia Z como mais 80% a menos 20%.
O capacitor também pode listar informações sobre tensões de operação. O componente deve
suportar uma tensão maior do que a do circuito em que ele está inserido; caso contrário, pode
romper (possivelmente explodir) durante a operação.
1.000.000 picoFarads é igual a 1 microFarad. Muitos valores comuns de capacitores estão perto
dessa área de transição e podem ser comumente identificados com uma das duas unidades
citadas. Por exemplo, 10.000 pF é mais facilmente encontrado como 0,01 uF.
Códigos com três dígitos alfanuméricos, normalmente Z5U ou X7R, podem aparecer no corpo
do capacitor. Eles indicam como o componente se comportará sob certos aspectos, como
grandes mudanças de temperatura. Mas, para a leitura de seus valores, esses códigos são
irrelevantes.
20
Dígito-Caractere-Dígito. Alguns capacitores pequenos são marcados com códigos do tipo 1n0.
Os dígitos representam os valores antes e após o ponto decimal, e o caractere informa a
dimensão. Sendo assim, nesse exemplo, o valor seria 1,0 nF (nanoFarad).
Até aqui, sempre utilizamos ilustrações detalhadas para descrever a montagem de nossos
circuitos. Porém, como você pode imaginar, não será muito prático desenhar um diagrama
desses quando você quiser simplesmente documentar um experimento.
Problemas semelhantes surgem, mais cedo ou mais tarde, em todas as áreas de atuação. Na
música, por exemplo, depois de compor uma bela canção, você terá de anotá-la utilizando cifras
musicais.
Engenheiros, pessoas práticas que são, desenvolveram uma forma rápida de capturarmos a
essência de um circuito, para que possamos documentá-lo e reconstruí-lo posteriormente, ou
mesmo passáio a outra pessoa.
Em eletrônica, diagramas esquemáticos permitem que você descreva seu circuito de uma forma
que possa ser compreendida pelo restante da comunidade. Componentes individuais são
representados por símbolos que representam abstrações de seu próprio formato, ou de sua
essência. Por exemplo, o capacitor é formado por duas placas de metal separadas por ar ou
plástico; assim, seu símbolo é:
Outro exemplo evidente é o indutor, formado por um fio de cobre espiralado em formato
cilíndrico; seu símbolo pode ser visto à esquerda. Conexões entre componentes são geralmente
feitas utilizando-se fios ou as próprias conexões da placa de circuito impresso e representadas
no diagrama como linhas simples. Quando dois fios estão conectados, utilizamos um ponto para
representar o local em que as duas linhas se cruzam, como na ilustração à esquerda.
Isso é tudo que você deve saber para compreender o básico dos diagramas esquemáticos. Veja
a seguir uma lista mais completa de símbolos e seus significados.
21
5 LEITURA DE DIAGRAMAS ESQUEMÁTICOS
22
Talvez você encontre variações desses simbolos (mostramos, por exemplo, os dois tipos de
simbolos para resistores). Consulte en.wikipedia.org/wiki/Electroni_symbol para uma lista mais
completa de simbolos eletrônicos. Por convenção, diagramas são desenhados da esquerda para
a direita. O circuito de um rádio, por exemplo, seria desenhado com sua antena à esquerda,
seguido pelo caminho que o sinal de rádio percorre até o alto-falante (desenhado à direita).
O diagrama esquemático a seguir descreve o circuito com botão de pressão que vimos neste
livro.
Nesta seção forneceremos uma rápida explicação de todas as instruções básicas aceitas pela
linguagem do Arduino.
Para um a referência mais detalhada, consulte: arduino.cc/en/reference/HomePage.
Estrutura
Um sketch do Arduino é executado em duas partes:
void setup()
Local em que você coloca seu código de inicialização - instruções que preparam a placa antes do
inicio do loop principal do sketch.
void IoopO
Seção que contém o código principal de seu sketch e que deve apresentar um conjunto de
instruções a serem repetidas seguidas vezes até que a placa seja desligada.
Simbolos especiais
O Arduino inclui alguns simbolos que devem ser empregados em linhas de código, comentários
e blocos de código:
; (ponto e vírgula)
Toda instrução (linha de código) é encerrada por um ponto e vírgula. Essa sintaxe permite que
você formate seu código livremente. Você pode até colocar duas instruções na mesma linha,
desde que as separe por um ponto e virgula. (Esteja atento, pois isso dificultará a leitura de seu
código»
Exemplo:
delay(100);
( ) (chaves)
Essa notação é utilizada para marcar blocos de código. Por exemplo, quando você escreve código
para a função loop(), tem de utilizar chaves antes e depois do código.
Exemplo:
void loop() {
Serial.println(“ciao”);
}
23
6 REFERÊNCIA RÁPIDA DE INSTRUÇÕES ARDUINO
Porções do texto ignoradas pelo processador do Arduino, mas extremamente úteis para que
você se recorde do que fez nesse trecho do código, ou para explicar essa funcionalidade a outras
pessoas.
Há dois tipos de comentários no Arduino:
// de linha única: o texto até o flm da linha será ignorado
/* de várias linhas:
você pode escrever
um poema inteiro aqui
*/
Constantes
O Arduino inclui um conjunto de palavras-chave predefinidas com valores especiais. HIGH e LOW
são utilizadas, por exemplo, quando você deseja ligar ou desligar um pino do Arduino. INPUT e
OUTPUT são utilizadas para definir um pino específico como entrada ou saida.
true e false indicam se uma condição ou expressão é verdadeira ou falsa, respectivamente.
Variáveis
Variáveis são áreas nomeadas da memória do Arduino nas quais você pode armazenar dados a
serem utilizados e manipulados em seu sketch. Como sugere o nome, variáveis podem ser
modificadas quantas vezes você quiser
Como o Arduino é um processador muito simples, quando você declara uma variável, deve
também especificar seu tipo, ou seja: dizer ao processador o tamanho do valor que você deseja
armazenar
Veja os tipos de dados disponivets:
boolean
Pode ter um de dois valores: verdadeiro ou falsa
char
Armazena um único caractere, como A. Da mesma forma que qualquer computador, o Arduino
armazena esse valor como um número, ainda que você veja um texto. Quando caracteres são
utilizados para armazenar números, eles podem armazenar valores de -128 a 127.
NOTA: Há dois grandes grupos de caracteres disponíveis a sistemas de computadores: ASCII e Unicode. ASCII éum
conjunto de 127 caracteres, utilizado, dentre outras coisas, para transmitir textos entre terminais seriais e sistemas
de computadores de tempo compartilhado como mainframes e minicomputadores. Unicode, por sua vez, é um
conjunto muito maior de valores utilizados por sistemas operacionais modernos para representar caracteres em
muitos idiomas diferentes. ASCII ainda éútil, por exemplo, para transferência de pequenas quantidades de
informações, em idiomas como italiano e inglês, que utilizam caracteres latinos, numerais arábicos e simbolos
datilográficos comuns para pontuação.
24
Comentários
Armazena um valor entre O e 255. Assim como no caso de char, bytes utilizam apenas um byte
de memória.
int
Utiliza dois bytes da memória para representar um número entre -32.768 e 32767; trata-se do
tipo de dado mais comum utilizado no Arduino.
unsigned irit
Assim como int, utiliza 2 bytes, mas o prefixo unsigned significa que não pode armazenar
números negativos. Seu alcance, portanto, e de O a 65.535.
Iong
Duas vezes o tamanho de um int e armazena números de -2.147.483.648
2.147.483.647.
a
unsigned Iong
Versão não assinalada de long; vai de O a 4.294.967.295.
float
Tipo de dado de tamanho considerável, capaz de armazenar valores de ponto flutuante, ou seja:
números com ponto decimal. Um float consumirá 4 bytes de seus preciosos recursos de RAM.
As funções que podem utilizá-Lo também consomem muita memória, por isso utilize floats
apenas quando estritamente necessário.
double
Número ponto flutuante de precisão dupla, com valor máximo de 17976931348623157 x 10308.
Nossa, que número enorme!
string
Conjunto de caracteres ASCII utilizados para armazenar informações textuais (você pode utilizar
uma string quando quiser enviar uma mensagem por meio de uma porta serial, ou para mostrála em um monitor LCD). Quanto ao armazenamento, uma string utiliza um byte para cada
caractere, mais um caractere nulo para avisar ao Arduino que o fim da linha foi atingido. As duas
linhas seguintes são equivalentes:
char string1[] = “Arduino”; II 7 caracteres + 1 caractere nulo
char string2[8] =”Arduino”; //igual à linha anterior
array
Lista de variáveis que podem ser acessadas por meio de um índice. Um array é utilizado para
criar tabelas de valores que podem ser acessados com facilidade. Por exemplo, caso você queira
25
byte
int light[6] = {0, 20, 50, 75, 100};
A palavra “array” não chega a ser utilizada na declaração da variável: os símbolos [] e {} são
suficientes.
Estruturas de controle
O Arduino inclui palavras-chave para controlar o fluxo lógico de seu sketch.
if... else
Essa estrutura é responsável pela tomada de decisões em seu programa. if deve ser seguido por
uma questão, especificada como uma expressão entre parênteses. Se a expressão for
verdadeira, o que vier depois dela será executado. Se falsa, o bloco de código que segue else
será executado. É possível utilizar apenas íf, sem especificar uma cláusula else.
Exemplo:
if (val == 1) {
digitalwrite(LED, HIGH);
}
for
Permite que você repita um bloco de código por um número especificado de vezes.
Exemplo:
for (int i =0; i < 10; i++) {
Serial.print(“ciao”);
}
switch case
Enquanto a instrução if funciona como uma bifurcação que oferece duas opções ao seu
programa, switch case se parece mais com uma enorme rotatória. Ela permite que seu programa
receba várias orientações, dependendo do valor de uma variável, sendo ótima para manter seu
código organizado, uma vez que substitui listas de instruções if.
Exemplo:
switch (sensorValue) {
case 23:
digitaliWrite(13, HIGH);
break;
case 46:
26
armazenar níveis diferentes de brilho a serem utilizados por um LED, pode criar seis variáveis,
nomeadas lightel, l±ght62 e assim por diante. Melhor ainda, você poderia utilizar um array bem
simples, como:
break;
default: II se nenhum case é executado, executa-se esta linha
digitalWrite(12, [0W);
digitallWrite(13, [0W);
}
while
Semelhantemente a if, while executará um bloco de código enquanto determinada condição for
verdadeira.
Exemplo:
II pisca o LED enquanto o valor do sensor estiver abaixo de 512
sensorvalue = analogRead(1);
while (sensorValue ( 512) {
digitalWrite(13, HIGH);
delay(100);
digitalwrite(13, HIGH);
delay(100);
sensorvalue = analogRead(1);
}
do... while
Idêntica à while. A única diferença é que, aqui, o código será executado antes de a condição ser
avaliada. Essa estrutura é utilizada quando você deseja que seu bloco de código seja executado
ao menos uma vez antes de conferir a condição.
Exemplo:
do {
digitalWrite(13, HIGH);
delay(100);
digitalWrite(13, HIGH);
delay(100);
sensorvalue = analogRead(1);
}
while (sensorValue < 512);
27
digitaliWrite(13, HIGH);
Esse termo permite que você saia de um loop e continue a execução do código que aparece
depois dele. break também é utilizado para separar seções distintas de uma instrução switch
case.
Exemplo:
//
pisca o [E0 enquanto o valor do sensor estiver abaixo de 512
do {
II sai do loop se um botão é pressionado
if (digitalRead(7) HIGH)
break;
digitalWrite(13, HIGH);
delay(100);
digitalwrite(13, LOW);
delay(100);
sensorValue analogRead(1);
} while (sensorvalue 512);
continue
Quando utilizado dentro de um loop, continue permite que você pule o resto do código e faça
com que a condição seja testada novamente.
Exemplo:
for (light = 0; light < 255; light++)
{
//pula as intensidades entre 140 e 200
if ((x > 140) && (x
200))
continue;
analogWrite(PWMpin, light);
delay(10);
}
return
Interrompe a execução de uma função, retornando-a. Você também pode utilizar esse comando
para retornar um valor de dentro da função.
28
break
int computeTemperature() {
int ternperature = 0;
temperature = (analogRead(0) + 45) / 100;
returr ternperature;
}
Aritmética e fórmulas
Você pode utilizar o Arduino para realizar cálculos complexos utilizando uma sintaxe especial. +
e – funcionam como você aprendeu na escola. A multiplicação é representada com por * e a
divisão, por /.
Há um operador adicional, chamado “módulo” (%), que retorna o resto da divisão de um inteiro.
Você pode utilizar quantos níveis de parênteses forem necessários para agrupar as expressoes.
Ao contrário do que você aprendeu na escola, colchetes e chaves estão reservados a outros
propósitos (índices e blocos de arrays, respectivamente).
Exemplos:
a = 2 = 2;
light = ((12 * sensorValue) - 5) / 2;
remainder = 3 % 2; II retorna 1
Operadores de comparação
Quando você especifica condições ou testes para instruções if, while e for, estes são os
operadores que podem ser utilizados:
== igual a
!= não igual a
< menor que
> maior que
<= menor que ou igual a
> = maior que ou igual a
Operadores booleanos
Operadores booleanos serão utilizados quando você quiser combinar várias condições. Por
exemplo, caso você queira verificar se o valor vindo do sensor está entre 5 e 10, deve escrever:
if ((sensor => 5) && (sensor (<=10))
Há três operadores: e, representado por &&; ou, representado por II; por fim, não, representado
por !.
29
Por etemplo, se você tiver uma função de nome computeTemperature() e quiser retornar seu
resultado para a seção do código que a invocou, poderia escrever algo como:
Operadores compostos são operadores especiais utilizados para tornar o código mais conciso
quando temos de realizar operações comuns, como incrementar o valor de uma variável.
Por exemplo, para incrementar a variável vaLe em uma unidade, você poderia escrever:
value = value +1;
Utilizando um operador composto, essa linha se tornará:
value++;
Incremento e decremento (-- e ++)
Incrementam e decrementam determinado valor em uma unidade.
Tenha cuidado: ao escrever i++, você incrementa o valor de 1 em uma unidade e avalia um
resultado equivalente a i+1; ++i, por sua vez, avalia o valor de i e só então faz o incremento. O
mesmo se aplica a --.
Esses operadores facilitam o uso de certas expressões. As duas expressões a seguir são
equivalentes:
a = a + 5;
a += 5;
Funções de entrada e saída
O Arduino inclui funções para a manipulação de entradas e saídas. Você já viu algumas delas nos
programas deste livro.
pinMode(pino, modo)
Reconfigura um pino digital para que ele se comporte como entrada ou saída.
Exemplo:
pinMode(7,INPUT);
II transforma o pino 7 em entrada
diqitalWrite(pino, valor)
Liga ou desliga um pino digital. Pinos devem ser marcados explicitamente como saída, utilizando
pinMode, antes que digitalwrite possa ter qualquer efeito.
Exemplo:
digitalwrite(8, HIGH); //liga o pino digital 8
int digitalRead(pino)
Lê o estado de um pino de entrada, retornando HIGH se o pino recebe voltagem, ou LOW se não
há voltagem aplicada.
Exemplo:
30
Operadora compostos
int analogRead(pino)
Lê a tensão aplicada a um pino de entrada analógica e retorna um número entre O e 1023,
representando voltagens entre 0 e 5V
Exemplo:
val = analogRead(0); // lê o valor da entrada analógica 0,
// atribuindo a val
analogWrite(pino, valor)
Altera a taxa PWM em um dos pinos marcados PWM. pin pode ser 11,10,9, 6,5 e 3. value pode
ser um número entre 0 e 255, representando a escala entre 0 e 5V da tensão de saída.
Exemplo:
analoglarite(9,128); // Diminui a limiinosidade de um LED no pino 9 em 50%
shiftOut(dataPin, clockPin, bitOrder, valor)
Envia dados para um registrador de deslocamento, dispositivo utilizado para expandir o número
de saídas digitais. Esse protocolo utiliza um pino para dados e um para o clock. bitorder indica a
ordem dos bytes (do menos significativo para o mais significativo) e valor é o byte em si que será
enviado.
Exemplo:
shiftout(dataPin, clockPin, LSBFIRST, 255);
unsigned Iong pulseln(pino, valor)
Mede a duração de um pulso vindo de uma das entradas digitais. Isso é útil quando queremos,
por exemplo, ler sensores infravermelhos ou acelerômetros que emitem seus valores como
pulsos de duração diferente.
Exemplo:
time = pulsein(7, HIGH); // mede o tempo que o próximo
// pulso permanece high
Funções de tempo
O Arduino inclui funções capazes de medir o tempo transcorrido e também pausar o sketch.
unsigned Iong millis()
Retorna o número de milissegundos transcorridos desde que o sketch teve início.
Exemplo:
duration = millis()-lastTime;
II computa tempo transcorrido desde
31
val digitalRead(7); // lê o valor do pino 7, atribuindo-o a val
32
// “lastTime”
delay(ms)
Pausa o programa pelo tempo especificado em milissegundos.
Exemplo:
delay(500);
II interrompe o programa por meio segundo
delayMicroseconds(us)
Pausa o programa pelo tempo especificado em microssegundos.
Exemplo:
delayMicroseconds(1000); //
espera 1 milissegundo
Funções matemáticas
O Arduino inclui muitas funções matemáticas e trigonométricas comuns:
min(x,y)
Retorna o menor x e y.
Exemplo:
val = min(10,20); II agora, val é 10
max(x, y)
Retorna o maior x e y.
Exemplo:
val = max(10,20); II agora, vai é 20
abs(x)
Retorna o valor absoluto de x, o que transforma números negativos em positivos. Se x for 5, ela
retornará 5; se x for -5, ela ainda retornará 5.
Exemplo:
Val = abs(-5); II agora, val é 5
constrain(x, a, b)
Retorna o valor de x, entre a e b. Se x for menor que a, ela retorna a. Se x for maior que b, ela
retorna b.
Exemplo:
Val = constrain(analogRead(0), 0, 255); II
rejeita
//que 255
valores
maiores
Mapeia um valor no intervalo defromLow a maxLow, a um intervalo entre toLow e toHigh. Esse
recurso é muito útil para processar valores de sensores analógicos.
Exemplo:
val = map(analogRead(0),0,1023,100, 200); II mapeia o valor do pino
// analógico 6 a um valor
II entre 100 e 260
double pow(base expoente)
Retorna o resultado da potenciação de um número (base) por um valor especifico (expoente).
Exemplo:
double x pow(y, 32);
//define x como y elevado à 32ª potência
double sqrt(x)
Retorna a raiz quadrada de um numero.
Exemplo:
double a = sqrt(1138); II aproximadamente 33,73425674438
double sin(rad)
Retorna o seno de um ângulo especificado em radianos.
Exemplo:
double sine = sin(2); II aproximadamente 0,90929737091
double cos(rad)
Retorna o cosseno de um ângulo especificado em radianos.
Exemplo:
double cosine = cos(2); II aproximadamente -0,41614685058
double tan(rad)
Retorna a tangente de um ângulo especificado em radianos.
Exemplo:
double tangent = tan(2); 1/ aproximadamente -2,10503975868
Funções de números aleatórios
Caso você tenha de gerar números aleatórios, pode utilizar o gerador de números
pseudoaleatórios rduino.
33
map(valor, from~ow, fromHigh, totow, toHigh)
Essa função redefine o gerador de números pseudoaleatórios do Arduino. Ainda que a
distribuição dos números retornados por random() seja essencialmente aleatória, a sequência
que ela oferece é previsível. Por isso, você deve redefinir o gerador utilizando um valor aleatório.
Caso você tenha um pino analógico conectado, ele deve captar ruídos variados do ambiente
(como ondas de rádio, raios cósmicos, interferência eletromagnética de celulares e luzes fluorescentes e assim por diante) que podem ser utilizados nesse caso.
Exemplo:
randomSeed(analogRead(5)); // randomiza utilizando o ruído do pino
Iong random(max)
Iong random(min, max)
Retorna um valor de inteiro long pseudoaleatório, entre mim e max -1. Se o valor mínimo não
for especificado, seu limite será 0.
Exemplo:
long randnum = random(0, 100);
long randnum = random(11);
II um número entre 0 e 99
// um número entre 0 e 10
Comunicação serial
Como vimos, você pode efetuar a comunicação com dispositivos por meio da porta USB
utilizando um protocolo de comunicação serial. Veja, a seguir, as funções seriais.
Serial.begin(taxa)
Prepara o Arduino para iniciar a transferência de dados seriais. No caso do monitor serial do IDE
do Arduino, você geralmente utilizará uma taxa de 9.600 bits por segundos (bps), mas há outras
taxas de transferência disponíveis, normalmente inferiores a 115.200 bps.
Exemplo:
Serial. begin(9600);
Serial.print(dados)
Serial.print(dados, codificação)
Envia dados para a porta serial. A codificação é opcional; se não especificada, os dados serão
tratados como texto simples.
Exemplos:
Serial.print(75); // imprime “75”
Serial.print(75, DEC); // igual ao comando anterior
Serial.print(75, HEX); // “4B” (75 em notação hexadecimal)
34
randomseed(semente)
Serial.print(75, BIN); // ‘1001011” (75 em notação binária)
Serial.print(75, BYTE); // “K’ (o byte que representa
// 75 no conjunto ASCII)
Serial.println(dados)
Serial.println(dados, codificação)
Funciona como Serial.print(), exceto adiciona um retorno de carro e um avanço de linha (\r\n),
como se você tivesse digitado os dados e pressionado Return ou Enter.
Exemplos:
Serial.println(75); // imprime “75\r\n”
Serial.println(75, DEc); // igual ao comando anterior
Serial.println(75, HEX); // “4B\r\n”
Serial.println(75, 0CT); // “113\r\n”
Serial.println(75, BIN); // “1001011\r\n”
Serial.println(75, BYTE); // “K\r\n”
int SeriaI.available()
Retorna o número de dados não lidos, disponíveis na porta serial para leitura por meio da função
readfl. Depois que você tiver lido todos os dados disponíveis, serial.available retornará O até
que novos dados cheguem à porta serial.
Exemplo:
int count = Serial.available();
int SeriaI.read()
Busca um byte dos dados seriais entrantes.
Exemplo:
int data = Serial.read();
Seriaiflush()
Como os dados podem chegar à porta serial mais rápido do que seu programa é capaz de
processá-los, o Arduino armazenará todos os dados entrantes em um buffer. Caso você tenha
de limpar o buffer para preenchê-lo com novos dados, utilize a função fIush().
Exemplo:
Serial.flush();
35
Serial.print(75, 0CT); // “113’ (75 em notação octal)
Agora que os conceitos básicos que você precisa saber (circuitos em série e paralelo, tensão e
resistência), é hora de colocar tudo junto, falando sobre um circuito exemplo simples. Digamos,
por exemplo, que você deseja anexar uma luz indicadora de LED para seu projeto Arduino.
Tensão de funcionamento do Arduino Uno é de 5 Volts, o que significa (entre outras coisas), que
qualquer fio ligado ao pino de saída terá uma tensão de 5 volts. Qualquer circuito que começa
em um pino de saída e termina conectado ao terra terá uma queda total de tensão de 5 volts.
Então como é que você sabe o quanto da corrente fluirá através do nosso LED se anexá-lo ao
pino fonte de 5 volts?
Como discutimos antes, há uma relação entre tensão, corrente e resistência. Esta relação é
chamada Lei de Ohm, e é a única matemática que eu estou incluindo neste artigo. Felizmente,
é bastante simples:
V=I/R
Onde V é a voltagem, I é a corrente, e R é a resistência. Em outras palavras, se você mantiver a
tensão constante (é a situação mais provável encontrada em qualquer circuito básico), e em
seguida, efetuar um aumento da resistência, você diminuirá a voltagem atual, e vice-versa.
A equação acima indica que quando a resistência se aproxima de zero, a tensão e permanece
constante, e a corrente se aproxima do infinito. Esta situação é chamada de um curto-circuito,
e tende a fazer com que as coisas derretão, pegem fogo ou explodão. Se você já conectou duas
extremidades de uma bateria com um fio, por exemplo, você já deve ter notado que todo o
circuito quase que imediatamente fica, provoca uma faísca, e a conseuqnetemente a bateria vai
se esgotar rapidamente e com certeza vai estourar.
Você não vai querer um curto-circuito! O circuito precisa de uma carga, ou um componente que
realmente consuma a energia. O LED do nosso projeto representa a carga, a tensão para a
corrente LED, na maioria dos casos, é de 20 mA (miliamperes 1mA ou é correspondente a 1/1000
amps), mas você pode com segurança aumentar a corrente até aproximadamente 30 mA a fim
de obter um brilho mais intenso.
36
7 JUNTANDO TUDO – A PRÁTICA
37
Diagrama de estudo de um relógio com o arduino
Para limitar a resistência atual, você tem que aumenta-la, por isso vamos adicionar um resistor
em série com o LED. Estes dois elementos em série, terão que dividir entre si a quantidade de
corrente que irá fluir através de ambos. Isso significa que podemos descobrir uma linha de base
segura, ligando as duas figuras que já conhecemos (a corrente de 20 mA para o LED e a tensão
de 5V do circuito), aplicando a lei de Ohm, temos:
V=I/R
R=V/I
R = 5V / 0.02A
R = 250 Ohms
Então, se colocarmos uma resistência de 250 ohms no circuito, a corrente não pode ser superior
a 20 mA, e o LED estará seguro. No entanto, esta não é a resistência ideal para o nosso circuito.
Com esse cálculo, estamos assumindo que a queda de tensão ocorre através do resistor, mas na
verdade, parte da queda de tensão ocorre através do LED. No nosso exemplo, o LED absorve
1.8V, assim, teremos:
Resistência = Tensão Total da Fonte - Queda de Tensão do LED / Corrente
R = 5V – 1.8 V / 0,02A
R = 160 Ohms
E é assim que sabemos que o resistor ideal para este circuito é de 160 Ohms. Usando um resistor
menor obtemos um LED mais brilhante, mas este circuito também irá drenar a bateria mais
rapidamente.
Se você foi capaz de seguir este exemplo, significa que você tem uma idéia sobre corrente,
tensão, resistência e lei de Ohm. Já é um grande começo. Com um pouco de educação, e os
grandes recursos on-line para aprender sobre os tópicos mais avançados, você vai ser capaz de
construir qualquer coisa que colocar em sua mente.
Cada dia mais cresce o número de engenheiros, técnicos e gerentes de plantas industriais de
grande porte que começam a perceber os benefícios de usar a placa Arduino também em
ambientes industriais de grande impacto. Um exemplo disso está no projeto mostrado por Paul
M Furley em seu blog que descreve como em 2009, trabalhando em uma indústria familiar,
produziu o software de operação do usuário para sua nova máquina de impressão digital e
decidiu usar Arduino em sua fabricação.
“Eu vinha estudando a placa Arduino e chip controlador Atmega 328P - PU desde o meu projeto
de mestrado e ele veio em um momento perfeito para JF Máquinas. Eles haviam acabado de
desenvolver o seu novo sistema de circulação de tinta: um assunto sério com 5 frascos de tinta
separados subindo e descendo para alterar a pressão junto com o controle preciso da
temperatura. Eles precisavam de uma maneira de conduzir os motores de elevação de garrafa,
lidos em sinais de alarme e as entradas de comutação, bem como de saída de várias sequências
piscando para o benefício do operador. Embora uma PLC (Programmable logic controller, em
portugues controlador lógico programável) pudesse ser mais adequado, o Arduino parecia ser
uma ótima opção.”
As vantagens mais interessantes Citadas por ele são:
Fornecer segurança - mesmo que a Arduino parasse de fornecer placas amanhã, outros
fabricantes estariam oferecendo clones funcionais, e o hardware é de design livre. Mesmo se
mudarem sua concepção física, não seria muito difícil fazer um conversor para adaptar novo
shields. Na pior das hipóteses, JF Máquinas poderia fabricar toda a placa Arduino dos projetos,
enquanto o microcontrolador Atmega 328 ou um compatível permanecer disponível.
38
8 BENEFÍCIOS DE UTILIZAÇÃO
UTILIZAÇÃO EM AMBIENTE INDU
NDUSTRIAL
STRIAL
39
Baixo custo - Muitas vezes argumentaram a mítica cena do hobby e do hacker, culturalmente
associado ao Arduino e ao Raspberry Pi.
ReleShield para controlar cargas externas.
Concordo que para integrar a placa Arduino em um produto de consumo, o preço off-the-shelf
do Arduino é inviável do ponto de vista econômico, utilizando para este fim o Arduino em stand
alone, projetando e fabricando o lote necessário por um valor irrisório e que facilmente poderá
ser agregado ao produto final, comercialmente viável. Entretanto, quando integrado em uma
máquina de impressão industrial de cinco dígitos, o custo chega perto de zero, especialmente
quando se considera a alternativa PLC (Programmable logic controller) e os benefícios do
suporte técnico.
A seguir iremos utilizar o Arduino como plataforma de testes e aprendizado. Selecionei diversas
experiências interessantes para o aprimoramento técnico que você se dispôs a aprender.
Constantemnte irei atualizar e melhorar seu conteúdo. Ele estará sempre disponível on-line no
site: Robohelp e Sênior Consultoria.
Este projeto consiste em controlar o funcionamento de um led, ligando e desligando o mesmo
através de um push button. Este projeto básico introduz a utilização de botões, ou push
buttons, em projetos arduino, permitindo a você dar um passo a mais no seu aprendizado.
Lista de Componentes utilizados:
•
•
•
•
•
1 protoboard;
7 fios jumper, sendo 3 pequenos e 4 médios;
1 led;
1 resistor de 150 ohms e um resistor de 100 ohms;
1 push button;
Vamos iniciar o nosso projeto arduino conectando o botão na protoboard, atentando para a sua
posicação, que pode ser vista na imagem abaixo.
Agora você vai conectar uma perna do resistor de 150 ohms na coluna 48, a mesma do botão, e
a outra perna do resistor você vai conectar na coluna 45. Conecte um fio jumper ligando a perna
do resistor na coluna 45 (fio preto neste caso) a linha horizontal negativa (linha azul no caso
desta protoboard). Conecte outro fio jumper ligando a perna do botão da coluna 50 (fio
vermelho neste caso) a linha horizontal positiva (linha vermelha no caso desta protoboard).
Conecte um fio jumper, amarelo neste caso, entre a perna do botão e a do resistor na coluna
48.
40
9 LED COM BOTÃO LIGA E DESLIGA
41
Agora chegou a hora de ligar o led na protoboard. O led usado pode ser de qualquer cor.
Conecte a perna grande do led na coluna 55 e a perna pequena do led na coluna 56. Conecte
um resistor de 100 ohms entre o led e o fio jumper, conforme mostra a imagem abaixo.
Esquemático de Ligações
Conecte um fio jumper na coluna 56 e na linha negativa da protoboard, ligando a perna
pequena do led com a linha negativa. Conecte um fio jumper no inicio da linha negativa, o
preto neste caso, e outro no inicio da linha positiva, o vermelho neste caso.
Para facilitar o entendimento e a explicação usarei como referência as cores dos fios jumper
usados neste projeto. Abaixo os passos para realizar as ligações dos fios jumper da protoboard
ao arduino.
•
•
•
fio amarelo ao pino digital 2 do arduino;
fio azul ao pino digital 8 do arduino;
fio vermelho ao pino de alimentação 5V;
fio preto ao pino GND.
Chegou a hora mais interessante, que é a programação do seu arduino. Agora você vai definir
o que o arduino vai fazer, neste caso acender ou apagar um led de acordo com o
pressionamento do botão que está na protoboard. Abra a IDE do arduino no seu computador e
também conecte o arduino ao seu computador com o cabo USB.
Segue abaixo o código fonte do programa que vai controlar o arduino, conforme o
presionamento do botão, que se estiver apertado acende o led, se não apaga o led. Neste
projeto introduzimos o uso de constantes em programas arduino. A diferença de uma
constante para uma variável é que uma variável pode ter seu valor alterado quantas vezes for
necessário dentro do programa. Já a constante, uma vez que se define o valor inicial não se
pode mais alterar este valor. Mostramos também o comando digitalRead que, neste caso, faz a
leitura do pino digital 2, detectando se o mesmo está ou não recebendo energia.
Em síntese este programa captura o estado do botão, pressionado ou não pressionado, e de
acordo com este estado envia ou não energia para acender o led. O programa abaixo foi
compilado e testado, caso você queira é só copiar e colar na ide do arduino.
Código Fonte do Projeto
/*
Projeto Arduino acendendo e apagando o led com botão.
Por João Paulo - Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//Declaração das constantes
const int led = 8; //constante led refere-se ao pino digital 8.
const int botao = 2; //constante botão refere-se ao pino digital 2.
//Variável que conterá os estados do botão (0 LOW, 1 HIGH).
int estadoBotao = 0;
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
pinMode(led,OUTPUT); //Definindo pino digital 8 como de saída.
pinMode(botao,INPUT); //Definindo pino digital 2 como de entrada.
}
42
•
//Verificando o estado do botão para definir se acenderá ou
//apagará o led.
if (estadoBotao == HIGH) {
digitalWrite(led,HIGH); //Botão pressionado, acende o led.
} else {
digitalWrite(led,LOW); //Botão não pressionado, apaga o led.
}
}
43
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {
//Lendo o estado do pino 2, constante botao, e atribuindo
//o resultado a variável estadoBotao.
estadoBotao = digitalRead(botao);
Como controlar o intervalo de piscagem de um led usando um potenciômetro. Este projeto
Arduino introduz o uso do potenciômetro, que é um componente eletrônico que possui a
resistência elétrica ajustável, e aproveitando este recurso, deste componente, alteraremos em
tempo real o intervalo de piscagem de um led que será controlado pelo arduino. Este projeto
pode ser desenvolvido em um Arduino Leonardo, Uno, ou em um Duemilanove sem
problemas, neste caso foi usado um Arduino Leonardo e a programação feita na IDE oficial do
Arduino.
Lista de Componentes utilizados:
•
•
•
•
•
1 protoboard;
1 led;
7 fios jumper, 3 pequenos e quatro médios;
1 potenciômetro de 10k;
1 resistor de 100 ohms.
O primeiro passo é conectar o led, o potenciômetro e o resistor na protoboard. Neste caso o
led teve a sua perna maior conectada na coluna 55 e a menor conectada na coluna 56. O
resistor de 100 ohms apenas uma de suas pernas conectada na coluna 55 e o potenciômetro
teve uma perna conectada na coluna 40, outra na 42 e outra na 44. Veja a disposição dos
componentes na imagem abaixo.
44
10 CONTROLAR UM LED COM UM POTENCIÔMETRO
Conecte os fios jumper médios na protoboard, um na coluna 42 que é a perna do meio do
potenciômetro, no caso do fio azul conecte-o direto na perna do resistor, não é necessário
conectar nem esta perna do resistor nem o fio azul na protoboard, a ligação é direta entre o fio
azul e uma das perna do resistor. um fio na linha horizontal vermelha (5V) e um na linha
horizontal azul (terra).
Agora chegou a hora de conectar os fios da protoboard no arduino, usarei as cores dos fios
usadas neste projeto como referência para explanar esta ligação.
Esquemático de Ligações
•
•
•
•
•
A conexão será feita da seguinte forma:
fio azul (resistor e led) no pino digital 8;
fio verde (perna central do potenciômetro) no pino analógico A2;
fio preto no pino GND;
fio vermelho no pino 5V.
O potenciômetro foi ligado ao pino analógico pelo fato deste pino poder assumir valores
diversos e não apenas 0 e 1 que é o caso do pino digital.
Após fazer as ligações entre o arduino e a protoboard o seu projeto físico está pronto, faltando
agora a programação que irá controlar o arduino nesta tarefa de piscar o led em intervalos
45
Usando os fios jumper pequenos conecte uma perna do led, a da coluna 56, na linha horizontal
azul, que será o terra do projeto. Conecte a perna da coluna 40 do potenciômetro também na
linha horizontal azul e a perna da coluna 44 na linha horizontal vermelha, que fornecerá os 5V
do projeto.
Segue abaixo o código fonte deste projeto, que é bem simples e fácil de entender. Copie e cole
na IDE do arduino.
Código Fonte do Projeto
/*
Pisca um led, onde a velocidade das piscadas é
controlada por um potenciômetro.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
int ledAzul = 8;
int potenciometro = 2;
int tempoDeEspera = 0;
void setup() {
pinMode(ledAzul,OUTPUT);
}
void loop() {
//Leitura do valor do potenciômetro que é usada como delay
46
definidos via potenciômetro. Para programar o arduino conecte-o no seu computador usando
um cabo USB e execute a IDE.
digitalWrite(ledAzul, HIGH);
delay(tempoDeEspera);
digitalWrite(ledAzul, LOW);
delay(tempoDeEspera);
}
Em resumo este código fonte define que o tempo de espera entre as piscadas do led será lido
do protenciômetro através do pino analógico A2 e será aplicado utilizando o comando delay.
Pronto! seu projeto está concluído e a medida que você girar o potênciômetro o intervalo de
piscagem do led irá diminuir ou aumentar dependendo do sentido em que você girar o
potenciômetro.
47
tempoDeEspera = analogRead(potenciometro);
Este projeto acende vários leds ao se pressionar um botão. Neste projeto arduino um pequeno
efeito é gerado, pois foi definido um intervalo de tempo entre o acendimento de cada led. Este
projeto reforça o projeto arduino led com botão liga desliga que também usa um botão para
acender um led e que tem uma programação mais simples. Neste projeto usei um Arduino
Uno R3, mas você também pode usar outras versões do arduino, como a versão Arduino
Leonardo.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
•
uma protoboard;
quatro leds de cores diferentes;
quatro resistores de 100 ohms;
um resistor de 150 ohms;
um botão do tipo push button;
sete fios jumper grandes;
cinco fios jumper pequenos;
a IDE do arduino instalada no seu computador;
um cabo USB para conectar o arduino ao computador;
um alicate de bico (opcional).
A primeira coisa que vamos fazer é colocar os leds e o botão na protoboard. Neste caso as
pernas grandes dos leds foram conectadas nas colunas 40, 45, 50, 55. As pernas pequenas dos
leds foram conectadas nas colunas 41, 46, 51, 56. O botão teve suas perninhas conectadas as
colunas 33 e 35.
Agora chegou a vez dos resistores. Conecte os quatros resistores de 100 ohms nas colunas que
estão conectadas as pernas grandes dos leds (colunas 40, 45, 50 e 55) conforme mostra a
imagem abaixo. Os resistores dos leds devem ter apenas uma de suas pernas conectadas a
protoboard, pois a outra perna do resistor será ligada aos fios jumper que serão conectados ao
Arduino. Conecte o resistor de 150 ohms na coluna 33 e na linha horizontal negativa da
protoboard (linha azul neste caso) como na imagem abaixo.
Conecte os fios jumper pequenos na linha horizontal negativa da protoboard e nas colunas das
pernas pequenas dos leds, no caso as colunas 41, 46, 51, 56. Conecte a coluna 35, que esta a
perninha do botão um fio jumper ligado a linha horizontal positiva da protoboard, linha
vermelha neste caso.
48
11 BOTÃO QUE ACENDE LEDS
LEDS COM EFEITO
Chegou a hora de conectar os fios jumper maiores na protoboard. Para cada perna grande de
um led você vai ligar um fio jumper, neste caso o fio azul esta ligado no resistor da coluna 55, o
fio vermelho no resistor da coluna 50, o fio verde no resistor da coluna 45 e o fio amarelo no
resistor da coluna 40. Na coluna 33 entre o botão e o resistor você vai ligar outro fio jumper,
neste caso é o fio jumper roxo. Para finalizar conecte um fio jumper na linha horizontal
negativa azul, neste caso foi o fio preto, e outro fio na linha horizontal positiva vermelha, neste
caso foi o fio cinza.
Exemplificado como deve ser feita a ligação entre cada um dos leds, resistores e fios jumper.
49
Esquemático de Ligações
•
•
•
•
•
•
•
fio azul no pino digital 11;
fio vermelho no pino digital 10;
fio verde no pino digital 9;
fio amarelo no pino digital 8;
fio roxo no pino digital 2;
fio preto no pino GND;
fio cinza no pino 5V.
Os pinos digitais 8, 9, 10, e 11 do arduino serão responsáveis por enviar a energia para acender
os leds conectados na protoboard. O pino digital 2 será um pino de entrada, que receberá ou
não energia, conforme o presionamento do botão, possibilitando a leitura do estado do botão
(pressionado ou não pressionado). O pino GND é o terra do arduino, onde estão conectadas
todas as perninhas menores dos leds. E o pino 5V é o responsável por mandar energia para o
botão possibilitando o controle do seu estado, juntamente com o pino digital 2 do arduino.
Pronto! o seu projeto físico está totalmente pronto, mas ainda falta a parte mais legal, que é
programar o arduino para que ele faça o que desejamos. Então vamos conectar o arduino ao
computador abrir a IDE do arduino e mãos a obra.
Agora chegou a hora da programação do arduino. Segue abaixo, após a imagem da IDE, o
código fonte completo e testado deste projeto. Copie e cole ou faça você mesmo a sua versão
do programa de controle do arduino, compile, e posteriormente faça o upload do programa
para o arduino.
Código Fonte do Projeto
/*
Projeto Arduino acendendo com efeito e apagando os leds com botão.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
50
Os fios jumpers grandes serão conectados da seguinte forma:
//Declaração da variável que possuirá os estados do botão.
int estadoBotao = 0;
//Método setup, executado uma vez assim que o Arduino é ligado.
void setup() {
pinMode(ledAmarelo,OUTPUT); //Definindo pino 8 como saída.
pinMode(ledVerde,OUTPUT); //Definindo pino 9 como saída.
pinMode(ledVermelho,OUTPUT); //Definindo pino 10 como saída.
pinMode(ledAzul,OUTPUT); //Definindo pino 11 como saída.
pinMode(botao,INPUT);
//Definindo pino 2 como entrada.
}
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {
estadoBotao = digitalRead(botao);
if (estadoBotao == HIGH) {
//Acendendo os leds caso o botão esteja pressionado, com
//um intervalo de tempo (delay) entre os acendimentos para
//criar um pequeno efeito.
digitalWrite(ledAmarelo,HIGH);
delay(200);
digitalWrite(ledVerde,HIGH);
delay(200);
digitalWrite(ledVermelho,HIGH);
delay(200);
digitalWrite(ledAzul,HIGH);
delay(200);
} else {
//Apagando os leds caso o botão não esteja pressionado.
digitalWrite(ledAmarelo,LOW);
digitalWrite(ledVerde,LOW);
digitalWrite(ledVermelho,LOW);
digitalWrite(ledAzul,LOW);
}
}
51
//Declaração das constantes referentes aos pinos digitais.
const int ledAmarelo = 8;
const int ledVerde = 9;
const int ledVermelho = 10;
const int ledAzul = 11;
const int botao = 2;
Comtrolar cada uma das cores de um led RGB usando botões. Neste projeto arduino você terá
a possibilidade de acender separadamente cada cor do led e também acender várias cores
simultaneamente fazendo uma mistura que cria novas cores tudo isso através dos botões. Este
projeto pode ser desenvolvido em um Arduino Leonardo, Uno, Duemilanove ou qualquer outra
versão do arduino. Então prepare sua placa e vamos começar o projeto.
Lista de Componentes utilizados:
•
•
•
•
•
1 protoboard;
12 fios jumper, sendo 8 médios e 4 pequenos;
3 botões;
1 led RGB;
resistores, sendo 3 de 150 ohms e 3 de 330 ohms.
Esquema das pernas de leds RGB.
Primeiramente conecte o led RGB na protoboard, que de acordo com o esquema acima, terá a
sua perna azul conectada na coluna 53 da protoboard, a verde na coluna 54, o terra na 55, e a
vermelha na 56. Conecte também os três botões, onde o primeiro será conectado nas colunas
50 e 48, o segundo nas colunas 45 e 43 e o terceiro nas colunas 40 e 38. Veja na imagem
abaixo.
O próximo passo é conectar os resistores na protoboard. No caso do led você irá conectar em
cada perna que representa uma cor um resistor de 330 ohms. E nos botões você irá conectar
três resistores de 150 ohms, um na coluna 48, um na coluna 43 e outro na coluna 38 e os
resistores de 150 ohms também deverão ser conectados na linha horizontal azul (negativa).
52
12 LED RGB CONTROLAR AS CORES COM
COM BOTÕES
Agora conecte os demais fios jumper na protoboard da seguinte forma:
•
•
•
•
•
•
•
•
coluna 38 um fio azul entre o resistor e o botão;
coluna 43 um fio verde entre o resistor e o botão;
coluna 48 um fio vermelho entre o resistor e o botão;
coluna 53 um fio azul após o resistor;
coluna 54 um fio verde após o resistor;
coluna 56 um fio vermelho após o resistor;
um fio vermelho na linha vermelha (positivo)
um fio preto na linha azul (negativo).
Esquemático de Ligações
A ligação entre o led, os 3 resistores e os fios jumpers vermelho, verde e azul seria como
mostrado na imagem abaixo.
53
Usando os fios jumper pequenos conecte os botões a linha horizontal vermelha (positivo) nas
colunas 50, 45 e 40. Conecte a perna terra do led, coluna 55, a linha horizontal azul (negativo).
54
Conecte os fios da protoboard no arduino da seguinte forma:
•
•
•
•
•
•
•
•
pino digital 2 fio azul do botão;
pino digital 3 fio verde do botão;
pino digital 4 fio vermelho do botão;
pino digital 8 fio azul do led, fio ligado direto no resistor;
pino digital 9 fio verde do led, fio ligado direto no resistor;
pino digital 10 fio vermelho do led, fio ligado direto no resistor;
pino 5V fio vermelho (positivo);
pino GND fio preto (negativo).
A perna do resistor do led que vai ligada ao fio dos pinos digitais não é conectada na coluna da
protoboard e sim conectada direto no fio.
55
Após conectar todos os fios, seu projeto físico para controlar as cores de um led RGB através
de botões está pronto. Agora o próximo passo é conectar o arduino ao seu computador
através do cabo USB para iniciar a programação das funcionalidades desejadas.
Código Fonte do Projeto
/*
Projeto Arduino controla led RGB com botões.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//Declaração das constantes
const int ledAzul = 8; //ledAzul refere-se ao pino digital 8.
const int ledVerde = 9; //ledVerde refere-se ao pino digital 9.
const int ledVermelho = 10; //ledVermelho refere-se ao pino digital 10.
const int botaoAzul = 2; //botaoAzul refere-se ao pino digital 2.
const int botaoVerde = 3; //botaoVerde refere-se ao pino digital 3.
const int botaoVermelho = 4; //botaoVermelho refere-se ao pino digital 4.
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
//Definindo os pinos digitais (8, 9, 10) como de saída.
pinMode(ledAzul,OUTPUT);
pinMode(ledVerde,OUTPUT);
pinMode(ledVermelho,OUTPUT);
//Definindo os pinos digitais (2, 3, 4) como de entrada.
pinMode(botaoAzul,INPUT);
pinMode(botaoVerde,INPUT);
pinMode(botaoVermelho,INPUT);
}
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {
//Lendo o estado dos botões através dos pinos digitais.
estadoBotaoAzul = digitalRead(botaoAzul);
estadoBotaoVerde = digitalRead(botaoVerde);
estadoBotaoVermelho = digitalRead(botaoVermelho);
//Acendendo o led RGB conforme os botões pressionados.
//Tratando a cor azul
if (estadoBotaoAzul == HIGH) {
digitalWrite(ledAzul,HIGH);
} else {
digitalWrite(ledAzul,LOW);
}
//Tratando a cor verde
if (estadoBotaoVerde == HIGH) {
digitalWrite(ledVerde,HIGH);
} else {
digitalWrite(ledVerde,LOW);
}
//Tratando a cor vermelha
if (estadoBotaoVermelho == HIGH) {
digitalWrite(ledVermelho,HIGH);
} else {
digitalWrite(ledVermelho,LOW);
}
}
56
//Variáveis que conterão os estados dos botões (pressionados ou não).
int estadoBotaoAzul;
int estadoBotaoVerde;
int estadoBotaoVermelho;
57
13 CONTROLE 8 LEDS COM O ARDUINO USANDO O CI 74HC595,
FAZENDO UMA CONTAGEM BINÁRIA.
Contador binário com o arduino, que usa 8 leds para formar um byte, onde um led aceso
representa 1 e o led apagado representa 0, e esse conjunto de 8 leds que forma o byte irá
representar um número entre 0 e 255, ou melhor, irá contar de 0 até 255 só que em base
binária. O componente principal desse projeto, além do arduino e dos leds e o circuito
integrado 74HC595, que vai ser responsável pelo controle dos 8 leds do projeto. O circuito
integrado 74HC595 tem a capacidade de transformar uma entrada serial em uma saída
paralela de 8 vias, e cada uma dessas 8 vias da saída paralela irá controlar um led. E o melhor é
que para controlar esses 8 leds vamos usar apenas 3 pinos do arduino.
Neste projeto os número decimais entre 0 e 255 vão ser representados de forma binária. Para
você entender melhor segue abaixo uma tabela de equivalência entre binários e decimais.
•
•
•
•
00000001 (binário) é igual a 1 (decimal);
00000010 (binário) é igual a 2 (decimal);
00100001 (binário) é igual a 33 (decimal);
11111111 (binário) é igual a 255 (decimal).
Lembro que um led aceso é igual a 1 e um led apagado é igual a 0.
Numa visão geral este projeto funcionará da seguinte forma, o arduino avisa ao CI 74HC595
que vai enviar dados, o CI se prepara para receber os bits, então o arduino envia 8 bits, um de
O CI 74HC595 é muito bom para controlar muitos leds usando poucos pinos do arduino. O
projeto do contador binário apresentado neste post é apenas um exemplo entre milhares de
projetos de controle de leds que podem ser desenvolvidos com o 74HC595. Então chega de
teoria e vamos ao projeto.
Segue abaixo o datasheet do 74HC595, para que você conheça cada um dos pinos do mesmo.
Lista de Componentes utilizados:
Bem, para começar vamos conectar na protoboard os componentes do projeto, que são os
oito leds, de 5mm neste caso, o CI 74HC595, e os oito resistores de 330 ohms, um em cada
perna positiva dos leds.
58
cada vez, ou seja sequencialmente, o CI apenas armazena cada um dos 8 bits enviados, o
arduino envia um sinal ao CI para que ele libere os 8 bits armazenados, e o CI libera os 8 bits de
uma vez, ou seja paralelamente. E esses passos se repetem para a formação de cada um dos
número entre 0 e 255.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
pino 1 do 74HC595 ligado ao positivo do 2º led;
pino 2 do 74HC595 ligado ao positivo do 3º led;
pino 3 do 74HC595 ligado ao positivo do 4º led;
pino 4 do 74HC595 ligado ao positivo do 5º led;
pino 5 do 74HC595 ligado ao positivo do 6º led;
pino 6 do 74HC595 ligado ao positivo do 7º led;
pino 7 do 74HC595 ligado ao positivo do 8º led;
pino 8 do 74HC595 ligado ao GND do arduino;
pino 9 do 74HC595 sem ligação;
pino 10 do 74HC595 ligado ao 5V do arduino;
pino 11 do 74HC595 ligado ao pino digital 2 do arduino;
pino 12 do 74HC595 ligado ao pino digital 3 do arduino;
pino 13 do 74HC595 ligado ao GND do arduino;
pino 14 do 74HC595 ligado ao pino digital 4 do arduino;
pino 15 do 74HC595 ligado ao positivo do 1º led;
pino 16 do 74HC595 ligado ao 5V do arduino;
E para completar segue abaixo o esquema da ligação do projeto controlando 8 leds com o
arduino usando o CI 74HC595.
Esquemático de Ligações - Fritzzing
Depois de concluir o projeto físico, ou seja, a montagem e as conexões entre arduino e
componentes, chegou a hora de programar o arduino para que ele faça o que queremos.
Então usando o cabo USB conecte o arduino ao seu computador e execute a IDE do arduino.
Segue abaixo o código fonte todo comentado deste projeto.
59
Agora conecte os fios jumper entre os componentes da protoboard e entre a protoboard e o
arduino. O esquema detalhado da ligação dos fios jumpers entre os componentes e o arduino
está detalhado logo abaixo.
/*
Projeto Arduino contador binário
com saída em 8 leds que formam 1 byte.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//Constantes associadas aos pinos do arduino
int const clock = 2; //ligado ao clock do 74HC595
int const latch = 3; //ligado ao latch do 74HC595
int const data = 4; //ligado ao data do 74HC595
void setup() {
//definindo os pinos como de saída
pinMode(clock,OUTPUT);
pinMode(latch,OUTPUT);
pinMode(data,OUTPUT);
}
void loop() {
//Contando de 0 até 255
for (int i = 0; i <= 255; i++) {
//permite o fluxo dos dados.
digitalWrite(latch,LOW);
for (int x = 0; x <= 7; x++) {
//pronto para receber o bit.
digitalWrite(clock,LOW);
if (i & (1 << x)) {
digitalWrite(data,HIGH);
} else {
digitalWrite(data,LOW);
}
//grava o bit recebido.
digitalWrite(clock,HIGH);
}
//finaliza o fluxo dos dados e envia os 8 bits.
digitalWrite(latch,HIGH);
//tempo de espera entre a exibição de um
//número e o outro.
delay(100);
}
}
Após introduzir o código fonte deste projeto na IDE do arduino, compile-o e posteriormente
faça o upload. Aguarde alguns segundos e logo o seu projeto estará em funcionamento,
60
Código Fonte do Projeto
Bargraph de LDR
Com este exemplo você aprenderá como criar um bargraph com LED e fazê-lo acender de
maneira proporcional a intensidade da luminosidade em cima do LDR.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
Cabo USB A para B
Protoboard 400
Resistor 330Ω
Resistor 10KΩ
LDR
LED Vermelho
LED Amarelo
LED Verde
Alguns Jumpers
Esquemático de Ligações - Fritzzing
61
contando de 0 até 255 em base binária, e além disso o efeito dos leds apagando e acendendo
durante a contagem é muito legal.
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
LDR A0 //Define LDR como A0
L_1 2 //Define L_1 como 2
L_2 3 //Define L_2 como 3
L_3 4 //Define L_3 como 4
L_4 5 //Define L_4 como 5
L_5 6 //Define L_5 como 6
L_6 7 //Define L_6 como 7
L_7 8 //Define L_7 como 8
L_8 9 //Define L_8 como 9
L_9 10 //Define L_9 como 10
L_10 11 //Define L_10 como 11
float luminosidade; //Variável para armazenar o valor da luminosidade
float amostra; //Variável para armazenar o amostratória
void setup()
{
//Configura todos os pinos do Bargraph (2 a 10) e desligao s LEDs
for(int i=2 ; i<= 10 ; i++)
{
pinMode(i, OUTPUT); //Configura os pinos de acionamento dos LED como
saída
digitalWrite(i, LOW); //Desliga todos os LEDs
}
//===============================================================
}
void loop()
{
amostra = 0; //Zera a variável amostra
//Pega 1000 amostras
for(int i=0; i < 100 ; i++)
{
luminosidade = analogRead(LDR);//Armazena o valor lido pelo
LDRluminosidade = (luminosidade / 1024) * 100; //Transforma o valor
lido em porcentagem
amostra = amostra + luminosidade; //Armazena na variável amostra
}
//=================
amostra = amostra/100; //Tira a média das amostras
delay(250); //Delay de 250 milissegundos
bargraph(); //Vai para a função do Bargraph e depois volta
}
void bargraph()
{
if(amostra >= 10) digitalWrite(L_1, HIGH); //Aciona o L_1 se
luminosidade for maior ou igual que 10%
else digitalWrite(L_1, LOW); //Senão desliga o L_1
62
Código Fonte do Projeto
if(amostra >= 30) digitalWrite(L_3, HIGH); //Aciona o L_3 se
luminosidade for maior ou igual que 30%
else digitalWrite(L_3, LOW); //Senão desliga o L_3
if(amostra >= 40) digitalWrite(L_4, HIGH); //Aciona o L_4 se
luminosidade for maior ou igual que 40%
else digitalWrite(L_4, LOW); //Senão desliga o L_4
if(amostra >= 50) digitalWrite(L_5, HIGH); //Aciona o L_5 se
luminosidade for maior ou igual que 50%
else digitalWrite(L_5, LOW); //Senão desliga o L_5
if(amostra >= 60) digitalWrite(L_6, HIGH); //Aciona o L_6 se
luminosidade for maior ou igual que 60%
else digitalWrite(L_6, LOW); //Senão desliga o L_6
if(amostra >= 70) digitalWrite(L_7, HIGH); //Aciona o L_7 se
luminosidade for maior ou igual que 70%
else digitalWrite(L_7, LOW); //Senão desliga o L_7
if(amostra >= 80) digitalWrite(L_8, HIGH); //Aciona o L_8 se
luminosidade for maior ou igual que 80%
else digitalWrite(L_8, LOW); //Senão desliga o L_8
if(amostra >= 85) digitalWrite(L_9, HIGH); //Aciona o L_9 se
luminosidade for maior ou igual que 85%
else digitalWrite(L_9, LOW); //Senão desliga o L_9
if(amostra >= 95) digitalWrite(L_10, HIGH); //Aciona o L_10 se
luminosidade for maior ou igual que 90%
else digitalWrite(L_10, LOW); //Senão desliga o L_10
}
63
if(amostra >= 20) digitalWrite(L_2, HIGH); //Aciona o L_2 se
luminosidade for maior ou igual que 20%
else digitalWrite(L_2, LOW); //Senão desliga o L_2
Lista de Componentes utilizados:
01x LDR (sensor de luinosidade) / 01x Reistor de 10k / 01x Led de Alto
Brilho / 01x Resistor de 300 / cabos diversos.
Esquemático de Ligações - Fritzzing
Código Fonte do Projeto
const int LDR = 0;
int ValorLido = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
ValorLido = analogRead(LDR);
Serial.print("Valor lido pelo LDR = ");
Serial.println(ValorLido);
delay(500);
}
64
14 ILUMINAÇÃO AUTOMATIZADA
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
02x Led Verde
02x Led Amarelo
02x Led Vermelho
01x Led de Alto Brilho
01x Buzzer 5V
07x Resistor 300
02x Resistor 10k
01x NTC
01x LDR / cabos diversos.
Esquemático de Ligações - Fritzzing
65
Projeto Alarme Multipropósito
const int LDR = 0;
const int NTC = 1;
const int Buzzer = 2;
const int led1 = 5;
const int led2 = 6;
const int led3 = 7;
const int led4 = 8;
const int led5 = 9;
const int led6 = 10;
const int ledAB = 11;
int ValorLDR = 0;
int ValorNTC = 0;
int pwm = 0;
void setup(){
pinMode(Buzzer, OUTPUT);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(ledAB, OUTPUT);
}
void loop(){
ValorLDR = analogRead(LDR);
ValorNTC = analogRead(NTC);
if (ValorNTC > 0){
digitalWrite(led1, HIGH);
}
else{
digitalWrite(led1, LOW);
}
if (ValorNTC > 935){
digitalWrite(led2, HIGH);
}
else{
digitalWrite(led2, LOW);
}
if (ValorNTC > 945){
digitalWrite(led3, HIGH);
digitalWrite(Buzzer, HIGH);
}
else{
digitalWrite(led3, LOW);
digitalWrite(Buzzer, LOW);
}
if (ValorLDR > 600){
digitalWrite(led6, HIGH);
}
else{
digitalWrite(led6, LOW);
}
if (ValorLDR > 500){
digitalWrite(led5, HIGH);
66
Código Fonte do Projeto
15 ALARME COM ARDUINO E SENSOR DE MOVIMENTOS
MOVIMENTOS PIR
Como montar um alarme usando o Arduino e um sensor de movimento PIR. O sensor PIR
(Passive InfraRed sensor) é um sensor eletrônico que mede a luz infravermelha irradiada de
objetos. O sensor PIR também é conhecido como sensor de presença ou sensor de
movimentos, e ao conectá-lo ao Arduino você terá como controlar este sensor e disparar
diversas ações ao detectar movimentos.
Este projeto de alarme é capaz de detectar movimentos em um ambiente disparando um sinal
sonoro e acendendo um led. Pode ser usado por exemplo na porta de entrada da sua casa ou
em algum cômodo e quando alguém passar por lá o alarme será disparado. Então se você
necessita ser avisado da presença de alguém em um determinado lugar este projeto é uma
opção interessante e fácil de fazer.
O sensor PIR é fácil de se encontrar, a maioria das lojas virtuais e físicas que vendem Arduinos
e/ou componentes eletrônicos normalmente possuem este sensor. Só verifique se o sensor PIR
que você pretende adquirir possui controle de sensibilidade da detecção de movimentos. Este
que usei no projeto do alarme possui três pinos, controle de sensibilidade e controle de tempo
que o sensor fica "ligado" quando detecta algum movimento.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
sensor de movimentos/presença PIR;
led;
buzzer de 5 volts;
2 resistores de 220 ohms;
protoboard;
bateria de 9 volts;
suporte para bateria com plug para ligar no Arduino;
fios para interligar os componentes.
67
}
else{
digitalWrite(led5, LOW);
}
if (ValorLDR > 450){
digitalWrite(led4, HIGH);
digitalWrite(ledAB, LOW);
}
else{
digitalWrite(led4, LOW);
digitalWrite(ledAB, HIGH);
}
}
68
Segue abaixo o esquema detalhado do projeto do Alarme com Arduino e sensor de movimento
PIR. Através deste esquema fica mais fácil de se ter uma visão geral, e de como montar
corretamente o projeto. Este esquema foi montado no software Fritzing.
Abaixo segue o código fonte do projeto, prontinho e testado, é só copiar, colar, compilar e
fazer o upload para o Arduino.
Código Fonte do Projeto
/*
Projeto Arduino - Alarme com Arduino e sensor de movimento
PIR
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//Declaração das variáveis referentes aos pinos digitais.
int pinBuzzer = 7;
int pinSensorPIR = 8;
int pinLed = 9;
69
Esquemático de Ligações - Fritzzing
void setup() {
Serial.begin(9600); //Inicializando o serial monitor
//Definido pinos como de entrada ou de saída
pinMode(pinBuzzer,OUTPUT);
pinMode(pinSensorPIR,INPUT);
pinMode(pinLed,OUTPUT);
}
void loop() {
//Lendo o valor do sensor PIR. Este sensor pode assumir 2
valores
//1 quando detecta algum movimento e 0 quando não detecta.
valorSensorPIR = digitalRead(pinSensorPIR);
Serial.print("Valor do Sensor PIR: ");
Serial.println(valorSensorPIR);
//Verificando se ocorreu detecção de movimentos
if (valorSensorPIR == 1) {
ligarAlarme();
} else {
desligarAlarme();
}
}
void ligarAlarme() {
//Ligando o led
digitalWrite(pinLed, HIGH);
//Ligando o buzzer com uma frequencia de 1500 hz.
tone(pinBuzzer,1500);
delay(4000); //tempo que o led fica acesso e o buzzer toca
desligarAlarme();
}
void desligarAlarme() {
//Desligando o led
digitalWrite(pinLed, LOW);
//Desligando o buzzer
noTone(pinBuzzer);
}
70
int valorSensorPIR = 0;
Componentes utilizados: 01x LCD 16x2 / 01x Potenciômetro 10k / cabos diversos
Esquemático de Ligações - Fritzzing
Código Fonte do Projeto
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.print("Ola, meu nome e:");
lcd.setCursor(0,1);
lcd.print("XXX"); //Coloque seu nome no lugar dos XXX
}
void loop() {
}
71
16 DISPLAY LCD
Olá pessoal, este é o projeto de um relógio simples com LCD e Arduino que utiliza a biblioteca
Time, LCD por I2C e botões para alterar data e hora.
Esquemático de Ligações - Fritzzing
72
17 RELÓGIO LCD COM ARDUINO
Código Fonte do Projeto
#include <Time.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define TIME_MSG_LEN 11 // time sync to PC is HEADER followed by
unix time_t as ten ascii digits
#define TIME_REQUEST 7 // ASCII bell character requests a time sync
message
LiquidCrystal_I2C lcd(56,16,2);
//If
long previousmillis=0;
int hr=0;
int minut=0;
int dia=0;
int mes=0;
int ano=0;
int count=0;
void setup() {
lcd.init();
lcd.backlight();
pinMode(2,INPUT);
pinMode(3,INPUT);
pinMode(4,INPUT);
pinMode(5,INPUT);
pinMode(6,INPUT);
pinMode(7,INPUT);
Serial.begin(9600);
Serial.println(“Waiting for sync message”);
lcd.print(“Waiting”);
lcd.setCursor(0,1);
lcd.print(“for sync message”);
setTime(0,0,0,1,1,0);
}
void loop(){
if(Serial.available() )
{
processSyncMessage();
}
if((digitalRead(7)==HIGH))
//Change button
{
count=count+1;
Serial.println(“OK”);
if(count>1)
{
count=0;
}
}
if((digitalRead(3)==HIGH) && count==1) //Hour button
{
hr=3600;
adjustTime(hr);
}
if((digitalRead(2)==HIGH) && count==1)
//Minute button
{
minut=60;
adjustTime(minut);
73
Os botões servem para incrementar a hora, minuto, dia, mês e o ano do relógio. O
potenciômetro controla o contraste do LCD 16×2. A programação do TimeSerial foi modificada
e implementada no código do relógio.
74
}
if((digitalRead(6)==HIGH) && count==1)
//Day Button
{
dia++;
if(dia+day()>31)
{
dia=1-day();
}
}
if((digitalRead(5)==HIGH) && count==1)
//Month button
{
mes++;
if(mes+month()>12)
{
mes=1-month();
}
}
if((digitalRead(4)==HIGH) && count==1)
//Year Button
{
ano++;
}
if(timeStatus()!= timeNotSet)
{
digitalWrite(13,timeStatus() == timeSet); // on if synced, off if
needs refresh
digitalClockDisplay();
}
delay(1000);
}
void digitalClockDisplay(){
// digital clock display of the time
lcd.clear();
lcd.print(“Hora: “);
lcd.print(hour());
Serial.print(hour());
printDigits(minute());
printDigits(second());
lcd.setCursor(0,1);
Serial.print(” “);
Serial.print(dia+day());
lcd.print(“Data: “);
lcd.print(dia+day());
lcd.print(“.”);
Serial.print(” “);
Serial.print(mes+month());
lcd.print(mes+month());
lcd.print(“.”);
Serial.print(” “);
Serial.print(ano+year());
lcd.print(ano+year());
Serial.println();
}
void printDigits(int digits){
// utility function for digital clock display: prints preceding
colon and leading 0
Serial.print(“:”);
lcd.print(“:”);
if(digits < 10){
Serial.print(‘0′);
lcd.print(“0″);
}
Serial.print(digits);
lcd.print(digits);
}
void processSyncMessage() {
// if time sync available from serial port, update time and return
true
while(Serial.available() >= TIME_MSG_LEN ){ // time message
Foi adicionados os botões e a biblioteca LCD 16×2 por I2C. Para alterar a hora, por exemplo, é
necessário apertar o botão de mudança (localizado no pino digital 7). E depois apertar o botão
da hora (localizado no pino digital 3). Ao apertar o botão, incrementará a hora. Cuidado! Neste
projeto não estamos utilizando o RTC (Real Time Clock)! Se o Arduino desligar, a configuração
será perdida!
75
consists of a header and ten ascii digits
char c = Serial.read() ;
Serial.print(c);
if( c == TIME_HEADER ) {
time_t pctime = 0;
for(int i=0; i < TIME_MSG_LEN -1; i++){
c = Serial.read();
if( c >= ‘0’ && c <= ‘9’){
pctime = (10 * pctime) + (c – ‘0’) ; // convert digits to a number
}
}
setTime(pctime); // Sync Arduino clock to the time received on the
serial port
}
}
}
time_t requestSync()
{
Serial.write(TIME_REQUEST);
return 0; // the time will be sent later in response to serial mesg
}
Este é um projeto que mostra a variação da intensidade da luz utilizando uma fotocélula com
Arduino. De acordo com a variação da intensidade da luz, os leds acendem ou apagam e se não
houver luz nenhuma, um buzzer apita.
Lista de Componentes utilizados:
•
•
•
•
•
1 fotocélula
1 resistor de 10kOhm
8 leds
8 resistores de 220 Ohm
1 buzzer
Esquemático de Ligações - Fritzzing
A fotocélula é um resistor que varia de acordo com a intensidade da luz. Quanto maior a
luminosidade, maior a resistência da fotocélula. Na figura acima, mostra um divisor de tensão
com a fotocélula e um resistor de 10kOhm. Essa divisão é necessária para que a porta
analógica A0 do Arduino possa detectar a sua variação. Assim se caso haja muita luminosidade,
apenas 1 Led acenderá, se houver pouca luminosidade, alguns Leds acenderão e se houver
nenhuma luminosidade, todos os leds acenderão e o buzzer tocará.
76
18 SENSOR DE DETECÇÃO DE LUZ COM FOTOCÉLULA, SOM E ARDUINO
#include <Tone.h>
int LDRpin=A0;
int LDRval=0;
Tone player;
int note[]={NOTE_A3,NOTE_G4};
void setup()
//Setup the output pins and play the buzzer
{
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
player.begin(10);
Serial.begin(9600);
}
void loop()
{
LDRval=analogRead(LDRpin);
if(Serial.available()>0)
{
Serial.println(LDRval);
}
delay(100);
if(LDRval>850)
{
digitalWrite(2,HIGH);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
digitalWrite(10,LOW);
player.stop();
}
if(LDRval>800 && LDRval<850)
{
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
digitalWrite(10,LOW);
player.stop();
}
if(LDRval>750 && LDRval<800)
{
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
77
Código Fonte do Projeto
}
78
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
digitalWrite(10,LOW);
player.stop();
}
if(LDRval>700 && LDRval<750)
{
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
digitalWrite(10,LOW);
player.stop();
}
if(LDRval>650 && LDRval<700)
{
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
digitalWrite(10,LOW);
player.stop();
}
if(LDRval>600 && LDRval<650)
{
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
digitalWrite(10,LOW);
player.stop();
}
if(LDRval<600)
{
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6,HIGH);
digitalWrite(7,HIGH);
digitalWrite(8,HIGH);
digitalWrite(9,HIGH);
player.play(note[1]);
}
Termômetro LCD com LM335 e Arduino que tem como finalidade mostrar como ligamos um
sensor de temperatura LM335, mostrar os dados de temperatura no LCD, acender Leds e tocar
um buzzer caso a temperatura do termômetro esteja muito alta.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
3 leds verdes ou outra cor de preferência,
3 resistores de 200 ohm,
1 buzzer,
1 sensor de temperatura LM335,
1 resistor de 1K ohm,
1 display LCD 16×2,
1 potenciômetro e
jumpers diversos.
Esquemático de Ligações - Fritzzing
No projeto, o Arduino recebe dados analógicos do sensor de temperatura LM335 e converte
em graus Celsius ou Fahrenheight. Se a temperatura estiver entre 20ºC e 25ºC, um Led
acenderá. Se estiver entre 25 e 30, dois leds acenderão e se estiver mais que 30ºC, os três leds
acenderão e o buzzer apitará.
79
19 TERMÔMETRO LCD COM LM335 E ARDUINO
// include the library code:
#include <LiquidCrystal.h>
#include <Tone.h>
int sensorPin = 0;
int led1=9;
int led2=8;
int led3=7;
int led4=6;
int buzzer=10;
Tone player;
int note[]={NOTE_A3,NOTE_G4};
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// set up the LCD’s number of columns and rows:
Serial.begin(9600);
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print(“Lab de Garagem”);
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
pinMode(led4,OUTPUT);
pinMode(buzzer,OUTPUT);
player.begin(10);
}
void loop() {
int reading = analogRead(sensorPin);
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
float voltage = (reading) * 5.0;
voltage /= 1024.0;
// print out the voltage
Serial.print(voltage); Serial.println(” volts”);
// now print out the temperature
float temperatureC = (voltage – 0.5) * 10 ; //converting from 10 mv
per degree wit 500 mV offset
//to degrees ((volatge – 500mV) times 100)
Serial.print(temperatureC);
Serial.println(” degrees C”);
lcd.print(temperatureC);
lcd.print(” Celsius”);
// now convert to Fahrenheight
float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
Serial.print(temperatureF); Serial.println(” degrees F”);
if(temperatureC<25)
{
digitalWrite(led1,HIGH);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
digitalWrite(led4,LOW);
80
Código Fonte do Projeto
81
}
if((temperatureC>=25) && (temperatureC<30))
{
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,LOW);
digitalWrite(led4,LOW);
}
if((temperatureC>=30) )
{
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
player.play(note[0]);
delay(200);
player.play(note[1]);
delay(200);
player.stop();
}
delay(500);
}
O LED RGB é o LED (Light Emitting Diode – DiodoEmissor de Luz) de nova geração que contêm
num único encapsulamento três LED’s e da composição das três cores básicas, que são R-Red
para vermelho, G-Green para verde e B-Blue para azul, que são controlados
independentemente e pelo controle da sua intensidade, podem ser geradas aditivamente
quase todas as cores.
Lista de Componentes utilizados:
•
•
•
Mini protoboard
Led RGB
3 Resistores 220 ohms
Esquemático de Ligações - Fritzzing
82
20 COMO ADICIONAR UM LED RGB AO ARDUINO
int pino1 = 11;
// Definimos o pino 11 como sendo o primeiro pino
do LED
int pino2= 10;
// Definimos o pino 10 como sendo o terceiro pino
do LED
int pino3= 9;
// Definimos o pino 9 como sendo o quarto pino do
LED
void setup() {
// Definimos os pinos como sendo de saída
pinMode(pino1, OUTPUT);
pinMode(pino2, OUTPUT);
pinMode(pino3, OUTPUT);
}
void loop() {
// Vermelho
digitalWrite(pino1, HIGH);
digitalWrite(pino2, LOW);
digitalWrite(pino3, LOW);
delay(1000);
// Verde
digitalWrite(pino1, LOW);
digitalWrite(pino2, HIGH);
digitalWrite(pino3, LOW);
delay(1000);
// Azul
digitalWrite(pino1, LOW);
digitalWrite(pino2, LOW);
digitalWrite(pino3, HIGH);
delay(1000);
// Amarelo – Vermelho + Verde
digitalWrite(pino1, HIGH);
digitalWrite(pino2, HIGH);
digitalWrite(pino3, LOW);
delay(1000);
// Azul claro – Verde + Azul
digitalWrite(pino1, LOW);
digitalWrite(pino2, HIGH);
digitalWrite(pino3, HIGH);
delay(1000);
// Roxo – Vermelho + Azul
digitalWrite(pino1, HIGH);
digitalWrite(pino2, LOW);
digitalWrite(pino3, HIGH);
delay(1000);
// Branco – Vermelho + Verde + Azul
digitalWrite(pino1, HIGH);
digitalWrite(pino2, HIGH);
digitalWrite(pino3, HIGH);
delay(1000);
// Preto Nenhum ligado
digitalWrite(pino1, LOW);
digitalWrite(pino2, LOW);
digitalWrite(pino3, LOW);
delay(1000);
}
83
Código Fonte do Projeto
O buzzer é um transdutor ou espécie de alto-falante que já possui um oscilador interno para
produzir sons (semelhantes ao de uma sirene). Os transdutores são dispositivos de alta
impedância, fabricados com um material à base de uma cerâmica, denominada titanato de
bário. Eles são muito sensíveis podendo ser usados como fones ou pequenos alto-falantes em
sistemas de aviso ou alarmes.
Lista de Componentes utilizados:
•
•
•
Protoboard
Arduino Uno
Buzzer
Esquemático de Ligações - Fritzzing
84
21 ADICIONAR UM BUZZER AO ARDUINO
int buz = 8;
//define variavel buz como pino 8
void setup(){
pinMode(buz,OUTPUT);//define buz como saida digital
}
void loop(){
//play tone
tone(buz,2999,800);// esta linha de código é usada especialmente
para o buzzer
//O seu funcionamento é : o pino(buz = 8), a frequência e o tempo
de duração em milissegundos
//delay (ms)
delay(1000);
}
85
Código Fonte do Projeto
Neste tutorial vamos ver como adicionar o sensor ultrassônico HC-SR04 ao Arduino. O sensor
HC-SR04 envia um ping como nm submarino faz e mede o tempo entre o envio e o
recebimento de qualquer coisa quando um objeto está na frente do sensor. Como o uso de
som para suas medições que podem atingir até 4 metros. O módulo é de cerca de 45x20x15
mm de tamanho e tem uma ligação de quatro pinos.
Esquemático de Ligações - Fritzzing
Dois pinos são necessários para alimentar o módulo com 5 Volts. O trabalho atual é de cerca
de 15 mA. Um dos pinos é de ping gatilho e o último é utilizado para ler o resultado das
medições, o pino de eco. O ângulo de medida do sensor HC-SR04 é de 15 graus. A 4 metros de
distância dele deve ser um raio de cerca de 1 metro. A 1 metro é 26 centímetros por isso
temos que manter isso em mente quando se utiliza esta informação.
86
22 SENSOR ULTRASSÔNICO HCHC-SR04 AO ARDUINO
Código Fonte do Projeto
/*
HC-SR04 for Arduino
Original project from http://www.swanrobotics.com
This project demonstrates the HC-SR
The distance presented in the code is in mm, but you can uncomment
the line for distance in inches.
The schematics for this project can be found on
http://www.swanrobotics.com
This example code is in the public domain.
*/
const int TriggerPin = 8; //Trig pin
const int EchoPin = 9; //Echo pin
long Duration = 0;
void setup(){
pinMode(TriggerPin,OUTPUT); // Trigger is an output pin
pinMode(EchoPin,INPUT); // Echo is an input pin
Serial.begin(9600); // Serial Output
}
void loop(){
digitalWrite(TriggerPin, LOW);
delayMicroseconds(2);
digitalWrite(TriggerPin, HIGH); // Trigger pin to HIGH
delayMicroseconds(10); // 10us high
digitalWrite(TriggerPin, LOW); // Trigger pin to HIGH
Duration = pulseIn(EchoPin,HIGH); // Waits for the echo pin to get
high
// returns the Duration in microseconds
long Distance_mm = Distance(Duration); // Use function to calculate
the distance
87
MONITOR SERIAL
88
Serial.print(“Distance = “); // Output to serial
Serial.print(Distance_mm);
Serial.println(” mm”);
delay(1000); // Wait to do next measurement
}
long Distance(long time)
{
// Calculates the Distance in mm
// ((time)*(Speed of sound))/ toward and backward of object) * 10
long DistanceCalc; // Calculation variable
DistanceCalc = ((time /2.9) / 2); // Actual calculation in mm
//DistanceCalc = time / 74 / 2; // Actual calculation in inches
return DistanceCalc; // return calculated value
}
Motor de passo, é um motor feito para girar o eixo, ou rotor, em um ângulo controlado, ou
passos (daí seu nome), definidos pela estrutura do motor.
Os motores de passo são as melhores opções para montagens de precisão, com ângulo de
liberdade de 360°. Sua desvantagem está no consumo de corrente muito mais elevado do que
os motores comuns tipo servo e também de seu tamanho, elevando consequentemente o seu
peso. Para construções de robôs são necessárias uso de baterias de maior capacitades
justamente pelo alto consumo que o motor de passo tem .
Lista de Componentes utilizados:
•
•
•
•
Protoboard
CI L293B (CI driver, é uma ponte H que nos permite ligar motores de correntes
continua e motores de passo).
Motor de passo
Fonte ou bateria de 9V pois o motor consome muita corrente e não é aconselhado
deixar apenas na USB de seu computador.
89
23 MOTOR DE PASSO AO ARDUINO
Código Fonte do Projeto
#include <Stepper.h>
const int stepsPerRevolution = 300; // define os passos por volta
// Definindo os pinos de comunicação
// (8 e 9 de um lado, 10 e 11 do outro)
Stepper myStepper(stepsPerRevolution, 8,9,10,11);
void setup() {
//definindo velocidade (80 RPM):
myStepper.setSpeed(80);
// Inicializa a serial port
Serial.begin(9600);
}
//inicia o loop de repetição girando vamos definir para girar em
sentido horário e anti horário
void loop() {
// rotação em sentido horario clockwise
Serial.println(“clockwise”);
myStepper.step(stepsPerRevolution);
delay(500);
// anti horário counterclockwise
Serial.println(“counterclockwise”);
myStepper.step(-stepsPerRevolution);
delay(500);
}
90
Esquemático de Ligações - Fritzzing
O CI 74HC595 si refere a um “registrador de deslocamento de 8 bits serial-in, de série ou em
paralelo com a saída latches; 3-state”. Em outras palavras, você pode usá-lo para controlar 8
saídas de uma só vez, enquanto apenas tomando alguns pinos no microcontrolador. Você
pode ligar vários registros em conjunto para ampliar a sua produção ainda mais. (Os usuários
também podem querer procurar outros chips de driver com “595” ou “596” em seus números
de peças, existem muitos.
Como tudo isso funciona é através de uma coisa chamada “comunicação serial síncrona”, ou
seja, você pode pulsar uma pin up e para baixo comunicando assim um byte de dados para o
registo bit por bit. É pulsando segundo pino, o pino do relógio, que delineiam entre bits. Isto
está em contraste com a utilização da função que depende do remetente e do receptor deve
ser definido de forma independente mediante a uma taxa de dados determinada de acordo
“comunicação série assíncrona” do Serial.begin (). Uma vez que todo o byte é transmitido para
o registo das mensagens de alta ou baixa, realizada em cada bit são divididas entre cada um
dos pinos de saída individuais. Esta é a “saída paralela” parte, com todos os pinos fazer o que
você quer fazer tudo de uma vez.
A “produção em série” parte deste componente vem de seu pino extra que pode passar a
informação serial recebido do microcontrolador novamente inalterado. Isso significa que você
pode transmitir 16 bits em uma linha (2 bytes) e os primeiros 8 fluirá através do primeiro
registro para o segundo registo e ser expresso lá.
“Três estados” refere-se ao fato de que você pode definir os pinos de saída ou como alto,
baixo ou ” alta impedância “. Ao contrário os altos e baixos estados, você pode até definir
pinos para seu estado de alta impedância individualmente Você só pode definir todo o chip
juntos.
Isso é uma coisa muito especializada para fazer -.. Pense em uma matriz de LEDs que talvez
precise ser controlada por completamente diferentes microcontroladores, dependendo de
uma definição de modo específico construído em seu projeto. Nem exemplo, aproveita este
recurso e que você ganhou “t geralmente precisam de se preocupar com um chip que tem.
Aqui está uma tabela explicando os pinos outs adaptados a partir do datasheet da Phillip .
91
24 CI 74HC595 PARA AUMENTAR NÚMERO DE PORTAS DO ARDUINO
92
Exemplo utilizando um registrador shift
O primeiro passo é estender o Arduino com um registrador de deslocamento.
O Circuito
Para ligá-lo
Faça as seguintes conexões:
•
•
•
•
GND (pino 8) para o solo,
Vcc (pino 16) para 5V
OE (pino 13) ao terra
MR (pino 10) para 5V
Esta configuração faz com que todos os pinos de saída de ativos e endereçável o tempo
todo. A única falha desta configuração é que você acaba com as luzes de ligar para seu último
estado ou algo arbitrário cada vez que você primeiro ligar o circuito antes que o programa
começa a ser executado. Você pode contornar isso controlando os pinos MR e OE de sua placa
Arduino também, mas desta forma, trabalhar e deixá-lo com pinos mais abertas.
93
Ligação ao Arduino
•
•
•
DS (pino 14) para Ardunio DigitalPin 11 (fio azul)
SH_CP (pino 11) para a Ardunio DigitalPin 12 (fio amarelo)
ST_CP (pino 12) para Ardunio DigitalPin 8 (fio verde)
De agora em diante os será referido como o dataPin, o clockPin eo latchPin
respectivamente. Observe o capacitor de 0,1 f no latchPin, se você tiver algum piscar quando
os pulsos de pino de bloqueio você pode usar um capacitor para nivelá-la para fora.
Neste caso, você deve ligar o cátodo (short pin) de cada LED para um terreno comum, eo
ânodo (pino longo) de cada diodo emissor de luz ao seu respectivo registo de deslocamento
pino de saída. Usando o registrador de deslocamento para fornecer energia como isso é
chamado de terceirização atual. Alguns registradores de deslocamento podem não fonte de
corrente, eles só podem fazer o que é chamado de afundar atual. Se você tem um desses
significa que você terá que inverter a direção do LEDs , colocando os ânodos diretamente ao
poder e os cátodos (pinos de terra) para as saídas do registo de deslocamento. Você deve
verificar a sua folha de dados específico, se você aren “t usando um chip de série 595. Don” t
se esqueça de adicionar um resistor de 220 ohm em série para proteger os LEDs que está
sendo sobrecarregado.
Diagrama de Circuito
94
Adicionar 8 LEDs .
95
595 Tabela Logic
595 Diagrama de Tempo
Aqui estão três exemplos de código. O primeiro é apenas um código “Olá mundo” que
simplesmente gera um valor de byte de 0 a 255. O segundo programa de luzes de um LED de
cada vez. O terceiro ciclos, através de uma matriz.
O código é baseado em duas peças de informação na folha de dados: o diagrama de tempo ea
tabela lógica. A tabela lógica é o que diz que, basicamente, tudo de importante acontece em
uma batida para cima. Quando o clockPin passa de baixo para cima, o registo de deslocamento
lê o estado do pino de dados. Como os dados são deslocados em que é salvo em um registro
de memória interna. Quando o latchPin vai de alto a baixo os dados enviados é movido a partir
da mudança registra registo de memória já nos pinos de saída, iluminando a LEDs .
Exemplo de código 1 Olá Mundo
//**************************************************************//
// Name
: shiftOutCode, Hello World
// Author : Carlyn Maw,Tom Igoe, David A. Mellis
// Date
: 25 Oct, 2006
// Modified: 23 Mar 2010
// Version : 2.0
// Notes
: Code for using a 74HC595 Shift Register
//
//
: to count from 0 to 255
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
void setup() {
//set pins to output so you can control the shift register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
// count from 0 to 255 and display the number
// on the LEDs
for (int numberToDisplay = 0; numberToDisplay < 256;
numberToDisplay++) {
// take the latchPin low so
// the LEDs don't change while you're sending in bits:
digitalWrite(latchPin, LOW);
// shift out the bits:
shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);
//take the latch pin high so the LEDs will light up:
digitalWrite(latchPin, HIGH);
// pause before next value:
delay(500);
}
96
Código Fonte do Projeto
97
}
Amostra de código 2 One by One
/*
Shift Register Example
for 74HC595 shift register
This sketch turns reads serial input and uses it to set the pins
of a 74HC595 shift register.
Hardware:
* 74HC595 shift register attached to pins 2, 3, and 4 of the
Arduino,
as detailed below.
* LEDs attached to each of the outputs of the shift register
Created 22 May 2009
Created 23 Mar 2010
by Tom Igoe
*/
//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Serial.begin(9600);
Serial.println("reset");
}
void loop() {
if (Serial.available() > 0) {
// ASCII '0' through '9' characters are
// represented by the values 48 through 57.
// so if the user types a number from 0 through 9 in ASCII,
// you can subtract 48 to get the actual value:
int bitToSet = Serial.read() - 48;
// write to the shift register with the correct bit set high:
registerWrite(bitToSet, HIGH);
}
}
// This method sends bits to the shift register:
void registerWrite(int whichPin, int whichState) {
// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, LOW);
// turn on the next highest bit in bitsToSend:
bitWrite(bitsToSend, whichPin, whichState);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
}
Código de exemplo 3 Dois registradores de deslocamento
/*
Shift Register Example
Turning on the outputs of a 74HC595 using an array
Hardware:
* 74HC595 shift register
* LEDs attached to each of the outputs of the shift register
*/
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holders for infromation you're going to pass to shifting function
byte data;
byte dataArray[10];
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);
//Binary notation as
dataArray[0] = 0xFF;
dataArray[1] = 0xFE;
dataArray[2] = 0xFC;
dataArray[3] = 0xF8;
dataArray[4] = 0xF0;
dataArray[5] = 0xE0;
dataArray[6] = 0xC0;
dataArray[7] = 0x80;
dataArray[8] = 0x00;
dataArray[9] = 0xE0;
comment
//0b11111111
//0b11111110
//0b11111100
//0b11111000
//0b11110000
//0b11100000
//0b11000000
//0b10000000
//0b00000000
//0b11100000
98
// the bits you want to send
byte bitsToSend = 0;
}
void loop() {
for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
data = dataArray[j];
//ground latchPin and hold low for as long as you are
transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, data);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
}
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
99
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
}
//blinks the whole register based on the number of times you want
to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
100
//stop shifting
digitalWrite(myClockPin, 0);
Beleza pessoal! Estou aqui com mais um projetinho simples e muito interessante utilizando um
sensor LDR, O Sensor LDR com Três Níveis de Luz a Led com Arduino. Bem, falando um pouco
do sensor LDR (do inglês Light Dependent Resistor), em português Resistor Dependente de
Luz é um componente eletrônico passivo do tipo resistor variável, mais especificamente, é um
resistor cuja resistência varia conforme a intensidade da luz que incide sobre ele. Tipicamente,
à medida que a intensidade da luz aumenta, a sua resistência diminui.
O sensor LDR é construído a partir de material semicondutor com elevada resistência elétrica.
Quando a luz que incide sobre o semicondutor tem uma frequência suficiente, os fótons que
incidem sobre o semicondutor libertam elétrons para a banda condutora que irão melhorar a
sua condutividade e assim diminuir a resistência.
Neste projeto teremos um sensor LDR que ao captar a luz, será mostrado através do
acendimentos dos leds o nível de intensidade da mesma, sendo o led azul alta, vermelho
média e amarelo baixa intensidade. Este sensor LDR pode ser implementado em muitos
projetos, os valores dos níveis de luminozidade podem ser alterados, além de poder ser
aumentado o número de leds ligados a outras portas disponíveis do arduino .
Vocês podem também usar o monitor da porta série da IDE do Arduino para ler os valores do
sensor LDR.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
1 – Prontoboard
1 – LED Amarelo
1 – LED Azul
1 – LED Vermelho
1 – Sensor LDR
1 – Resistor 10KΩ
3 – Resistores 220Ω
101
25 LDR TRÊS NÍVEIS DE LUZ A LED COM ARDUINO
8 – Jumpers
Esquemático de Ligações - Fritzzing
O esquema de ligações é bem simples e o único cuidado é nas ligações das alimentações
positiva de 5v e negativa gnd, além das polaridades dos leds. O sensor LCD e os resistores não
tem polaridade.
Abaixo segue exemplo de 2 códigos que vocês podem estar testando para o projeto do sensor
LDR. O primeiro acende um por um dos leds de acordo com a intensidade da luz,
permanecendo sempre um aceso. O segundo código vai acendendo todos os leds com o
aumento da luz, como num V.U., e quando a iluminação estiver abaixo de 100 eles apagam
totalmente.
102
•
/*
‘*****************************************************************
‘* Projeto : Sensor LDR com três níveis de luz a Led
‘* Autor : Alessandro Gouvea
‘* Version : v1.0
‘* www.oarduino.com
‘*****************************************************************
*/
//Configurações
byte led_az=13; //configura o led azul na porta 13
byte led_vm=12; //configura o led vermelho na porta 12
byte led_am=11; //configura o led amarelo na porta 11
int ldr =A0; //sensro LDR na entrada analogica 0 (A0)
int luz=0; //variavel luz que guarda o valor lido no sensor LDR
void setup()
{
pinMode(led_az,OUTPUT); //led azul como saida
pinMode(led_vm,OUTPUT); //led vermelho como saida
pinMode(led_am,OUTPUT); //led amarelo como saida
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,0); //apaga o led vermelho
digitalWrite(led_am,0); //apaga o led amarelo
Serial.begin(9600); //inicializa a serial para ler o valor do
sensor ldr no serial monitor
}
void loop()
{
luz = analogRead(ldr); //armazena o valor lido do sensor ldr na
variavel luz
Serial.println(luz); // envia o valor da variavel luz para o pc
if(luz >700) // se luz for maior que 700…
{
digitalWrite(led_az,1); //acende o led azul
digitalWrite(led_vm,0); //apaga o led vermelho
digitalWrite(led_am,0); //apaga o led amarelo
}
else if(luz < 300) // e se for menor que 300…
{
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,0); //apaga o led vermelho
digitalWrite(led_am,1); //acende o led amarelo
}
else // se nao for maior que 700 e menor que 300…
{
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,1); //acende o led vermelho
digitalWrite(led_am,0); //apaga o led amarelo
}
delay(100); //aguarda 100 milisegundos
}
103
Código Fonte do Projeto 1
/*
‘*****************************************************************
‘* Projeto : Sensor LDR com três níveis de luz a Led
‘* Autor : Alessandro Gouvea
‘* Version : v2.0
‘* www.oarduino.com
‘*****************************************************************
*/
//Configurações
byte led_az=13; //configura o led azul na porta 13
byte led_vm=12; //configura o led vermelho na porta 12
byte led_am=11; //configura o led amarelo na porta 11
int ldr =A0; //sensor LDR ligado na entrada analogica 0 (A0)
int luz=0; //variavel luz que guarda o valor lido no sensor LDR
void setup()
{
pinMode(led_az,OUTPUT); //led azul como saida
pinMode(led_vm,OUTPUT); //led vermelho como saida
pinMode(led_am,OUTPUT); //led amarelo como saida
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,0); //apaga o led vermelho
digitalWrite(led_am,0); //apaga o led amarelo
Serial.begin(9600); //inicializa a serial para ler o valor do
sensor ldr no serial monitor
}
void loop()
{
luz = analogRead(ldr); //armazena o valor lido do sensor ldr na
variavel luz
Serial.println(luz); // envia o valor da variavel luz para o pc
if(luz <100) // se luz for menor que 100…
{
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,0); //apaga o led vermelho
digitalWrite(led_am,0); //apaga o led amarelo
}
else
if(luz >700) // se luz for maior que 700…
{
digitalWrite(led_az,1); //acende o led azul
digitalWrite(led_vm,1); //apaga o led vermelho
digitalWrite(led_am,1); //apaga o led amarelo
}
else if(luz < 300) // e se for menor que 300…
{
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,0); //apaga o led vermelho
digitalWrite(led_am,1); //acende o led amarelo
}
else // se nao for maior que 700 e menor que 300…
{
digitalWrite(led_az,0); //apaga o led azul
digitalWrite(led_vm,1); //acende o led vermelho
digitalWrite(led_am,1); //apaga o led amarelo
}
delay(100); //aguarda 100 milisegundos
}
104
Código Fonte do Projeto 2
Olá pessoal! Trago a vocês este projeto bem simples. Com ele podemos fazer piscar um LED
com efeito Fade no Arduino. Para quem não sabe o efeito Fade nada mais é do que a mudança
gradual na luminosidade do LED, ou seja, ele vai acendendo gradualmente seu brilho até o
máximo e depois diminui até apagar, e assim sucessivamente. O projeto Fade segue os
mesmos passos e hardware do Blink (pisca), o que diferencia é apenas na forma de piscar o
led, ao invés dele ter dois estados (aceso e apagado) ele terá vários, 255 para ser mais exato.
Lista de Componentes utilizados:
•
•
•
•
1 – LED (Qualquer cor);
1 – Resistor entre 100 e 220 Ohm
2 – Jumpers
1 – Protoboard
Esquemático de Ligações - Fritzzing
105
26 LED COM EFEITO FADE COM ARDUINO
Código Fonte do Projeto
/*
‘*****************************************************************
‘* Projeto : Piscando Led com Efeito Fade
‘* Autor : Alessandro Gouvea
‘* Version : v1.0
‘* www.oarduino.com
‘*****************************************************************
*/
//Constantes
const int led = 9; //Pino onde o LED está ligado
//Variáveis
int brilho = 0;
int fader = 5;
boolean acender = true;
boolean apagar = false;
void setup() {
pinMode(led,OUTPUT); //Pino do led definido como saída
}
//Início de loop do programa
void loop() {
analogWrite(led,brilho);
//No acendimento do led
if (acender == true) {
if (brilho < 255) {
brilho = brilho + fader; //aumentando o brilho do led.
} else {
acender = false;
apagar = true;
}
}
//No apagamento do led
if (apagar == true) {
if (brilho > 0) {
brilho = brilho – fader; // diminuindo o brilho do led.
} else {
acender = true;
apagar = false;
}
}
delay(30);
}
106
Como podem ver, o projeto é muito simples, basta ligar o pino 9 do arduino ao resistor, deste
ao anodo do led e o catodo ao Gnd do arduino. Abaixo segue os códigos do projeto Fade e do
Blink, pra quem quiser aproveitar e testar os dois, pois só vai mudar a programação.
O projeto é do Tiago Henrique que até criou uma biblioteca e que pode ser baixada através do
site dele aqui. A conexão com a Matriz pode ser direta nas portas digitais ou usando o chip
MAX 7219/7221, que já até existe uma biblioteca para a IDE do Arduino.
Lista de Componentes utilizados:
•
•
Matriz de LEDs 5×7
Fios
Esquemático de Ligações - Fritzzing
Foi utilizada uma matriz de LEDs 5×7. Como você vai ver nos exemplos em uma matriz de 5×7
existem pinos duplicados e a sequência dos pinos é chata de entender. Na parte inferior da
esquerda para a direita estão os pinos 1 a 7 e na parte superior da direita para a esquerda
estão os pinos 8 a 14.
Em cada pino de cada linha, observe que foi ligado um resistor, pode ser de 200 Ohms.
107
27 MATRIZ DE LED 5×7 AO ARDUINO
Funções da biblioteca:
LEDMatrix matrix(type); - cria o objeto matriz. type corresponde ao tipo de ligação: L –
positivo nas linhas ou C – positivo nas colunas.
matrix.begin(pin13, pin3, pin11, pin10, pin6, pin2, pin7, pin1, pin5, pin8, pin14, pin9) – pinos
da matriz corresponde ao pino no arduino;
matrix.setDot(coluna, linha, onOff) - acende/apaga um led.
matrix.printChar(caracter, duração, inverter, deslocamento) - escreve um caracter. Você
pode definir o tempo de exibição, inverter o estado dos LEDs, e também deslocar no máximo 5
colunas para a direita.
matrix.printCustomChar(Array, duração, inverter, deslocamento) – escreve um caracter
qualquer definido pelo usuário criando um array de 7 elementos.
Código Fonte do Projeto 1
Acender um led na matriz na posição coluna 1(da esquerda pra direita) e linha 4(de baixo pra
cima)
#include <font.h>
#include <LEDMatrix.h>
LEDMatrix mymatriz(L);
void setup(){
mymatriz.begin(7,6,5,4,3,8,9,10,11,12,13,2);
}
void loop(){
mymatriz.setDot(1, 4, true);
}
}
108
Note que existe duas ligações diferentes. No primeiro liga-se o positivo nas linhas e o terra nas
colunas. No segundo é invertido, liga-se o positivo nas colunas e o terra nas linhas. Foi criada
uma biblioteca especialmente para utilizar essa matriz 5×7 , que pode ser baixada aqui.
#include <font.h>
#include <LEDMatrix.h>
LEDMatrix mymatriz(L);
void setup(){
mymatriz.begin(7,6,5,4,3,8,9,10,11,12,13,2);
}
void loop(){
mymatriz.printChar(‘A’, 10, false, 0);
}
}
109
Código Fonte do Projeto 2
#include <font.h>
#include <LEDMatrix.h>
LEDMatrix mymatriz(L);
unsigned char Coracao[7] = {0B00000,
0B01010,
0B11111,
0B11111,
0B01110,
0B00100,
0B00000,
};
void setup()
{
//inicializa o display, com os seguintes pinos correspondentes
mymatriz.begin(7,6,5,4,3,8,9,10,11,12,13,2);
}
void loop()
{
//Imprime a imagem 'Coracao', durante 10 * 5ms, nao invertido,
deslocamento 0
mymatriz.printCustomChar(Coracao, 10, false, 0);
}
110
Código Fonte do Projeto3
No projeto de hoje vamos montar um Termômetro com display LCD 16X2 com o sensor de
temperatura LM35, e mostrar as informações de temperatura Atual, Média, Mínima e Máxima
no display. O LM35 deverá ser ligado a entrada analogica A0 enquanto o display segue as
ligações básica da maioria de nossos projetos. O potenciômetro ou trimpot deve ser de 10k e
serve para ajustar o contraste do lcd.
Lista de Componentes utilizados:
•
•
•
•
1 – LM35
1 – Potenciômetro ou trimpot de 10k
1 – Protoboard
Jumpers diversos
Esquemático de Ligações - Fritzzing
111
28 TEMÔMETRO LCD COM SENSOR LM35 E ARDUINO INDICADOR DE
TEMPERATURA MÉDIA, MÍNIMA E MÁXIMA
Código Fonte do Projeto
/*
'*****************************************************************
'* Projeto : Projeto - Temômetro LCD com sensor LM35 e Arduino
'* Indicador de temperatura Média, Mínima e Máxima
'* Autor : Alessandro Gouvea
'* Version : v1.0
'* www.oarduino.com
'*****************************************************************
*/
#include <LiquidCrystal.h> // include the LCD driver library
// Variaveis
float tempC = 0; // variavel de ponto flutuante para a temperatura
em Graus Celcius
int tempPin = 0; // Declaração do pino de entrada analógica 0 (A0)
no Arduino
float samples[8]; // matriz para armazenar oito amostras para o
cálculo da temperatura média
float maxi = 0,mini = 100; // variáveis de temperatura
máxima/mínimo com valores iniciais
int i;
// Inicialização do display e pinos correspondentes
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
lcd.begin(16, 2); // configura o número de linhas e colunas do LCD
lcd.setCursor(0, 0); // seta posição do cursor (coluna, linha) do
LCD
lcd.print("OArduino.com "); // imprime texto no LCD
lcd.setCursor(0, 1);
lcd.print("Projeto com LM35"); // imprime texto no LCD
delay(3000); // aguarda 3s
lcd.clear(); // limpa LCD
}
void loop()
{
// Início dos cálculos para o laço FOR
for(i = 0;i<=7;i++){ // colhe 8 amostras de temperatura
samples[i] = ( 4.8 * analogRead(tempPin) * 100.0) / 1024.0; //
conversão matemática para amostra legível de temperatura do LM35 e
armazena resultado de conjunto de amostras. 1024 é a profundidade
de bits (quantização) do Arduino.
// 5 é a voltagem fornecida ao LM35. Alterar apropriadamente para
ter a medida correta. No meu circuito é de 4.8Volts.
// Exibição atual para temperatura em grau Celcius no LCD
simbolotermometro();
lcd.setCursor(0, 0);
lcd.write(2);
lcd.setCursor(1, 0); // set posição do cursor LCD
lcd.print(" Atual: "); // imprime no LCD
112
Depois disso, carregue o seguinte programa, que vai mostrar no display a temperatura atual,
assim como a máxima e a mínima atingidas.
tempC = tempC + samples[i]; // faz a adição de temperatura média
delay(800); // aguarda 800ms
} // FIM de faço FOR
tempC = tempC/8.0; // calculada a média de 8 amostras em grau
Celcius
if(tempC
variavel
if(tempC
variavel
> maxi) {maxi = tempC;} // grava a temperatura maxima na
maxi
< mini) {mini = tempC;} // grava a temperatura minima na
mini
// Envia resultados ao LCD.
lcd.setCursor(0, 0);
lcd.print("Media Max Min");
lcd.setCursor(0, 1); // seta o cursor para a coluna 0, linha 1
lcd.print(tempC); // imprime a temperatura media medida
lcd.setCursor(6, 1);
lcd.print(maxi); // imprime a temperatura maxima
lcd.setCursor(12, 1);
lcd.print(mini); // imprime a temperatura minima
delay(3000); // Aguarde cerca de 3 segundos para exibir os
resultados antes de iniciar o ciclo da sua tela LCD novamente
tempC = 0; // Seta tempC a 0 para que os cálculos possam ser feitos
novamente
} //Fim da rotina principal
void simbolograu()
{
byte grau[8] = { // Cria um array de bytes com o simbolo de grau
B00110,
B01001,
B00110,
B00000,
B00000,
B00000,
B00000,
B00000};
lcd.createChar(1, grau); // Cria o caractere personalizado de grau
} // fim rotina simbolograu
void simbolotermometro()
{
byte termometro[8] = { // Cria um array de bytes com o simbolo de
termometro
B00100,
B01010,
B01010,
B01110,
B01110,
B11111,
B11111,
B01110};
lcd.createChar(2, termometro); // Cria o caractere personalizado 1
(termometro)
} // fim rotina simbolotermometro
113
lcd.setCursor(9, 0);
lcd.print(samples[i]); // imprime amostra da temperatrua atual no
LCD
simbolograu();
lcd.setCursor(14,0);
lcd.write(1);
lcd.print("C");
APLICAÇÃO
O LCD Shield possui um display 16×2 com fundo Azul e letras brancas e um teclado de 5
botões, e seu funcionamento é bem interessante. Os 5 botões são ligados a resistores divisores
de tensão, ou seja, cada botão transmite uma tensão quando pressionado. Sendo assim, os 5
botões são ligados em apenas uma entrada A/D, economizando 5 preciosas I/Os. Vejam a
figura como são ligados:
Dando uma olhada no esquemático você entenderá melhor: Esquemático do SHIELD
114
29 LCD SHIELD COM TECLADO PARA
PARA ARDUINO E EXEMPLO DE
Temos a seguinte disposição de pinos do Arduino e os sinais do display :
Podemos perceber então que não poderemos fazer uso das portas mensionadas para outras
funções enquanto estivermos utilizando o shield com teclado. Observem na imagem abaixo,
que a placa possui furos que permitem a soldagem de uma barra de pinos ou conectores, com
isso podemos usar os pinos que sobraram : 0, 1, 2, 3, 11, 12, 13 (digitais), e A1, A2, A3, A4, A5
(analógicos), além dos pinos de energia (5v, 3.3v, GND). O pino 10 também é utilizado pela
placa para uma função específica, no caso o backlight, e não deve ser utilizado nos programas.
O exemplo abaixo utiliza a biblioteca padrão do Arduino para controlar o shield.
115
O shield utiliza alguns pinos diferentes dos que usamos normalmente nos projetos para ligar
um LCD. Nesse shield teremos que usar a seguinte sequência ao inicializar a biblioteca
LiquidCrystal : LiquidCrystal lcd(8,9,4,5,6,7).
Código Fonte do Projeto
byte pinBotao = 0;
LCD Shield
int valorBotao = 0;
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //RS,E,D4,D5,D6,D7
void setup() {
Serial.begin(9600);
Serial.println("inicio");
lcd.begin(16, 2);
lcd.print("Webtronico.com");
}
void loop() {
valorBotao = analogRead(pinBotao);
//478 esquerda
//129 up
//322 down
//0 right
//720 selecionado
if(valorBotao > 470 && valorBotao < 500){
lcd.setCursor(0, 1);
lcd.print("ESQUERDA");
}else if(valorBotao > 120 && valorBotao < 140){
lcd.setCursor(0, 1);
lcd.print("CIMA ");
}else if(valorBotao > 315 && valorBotao < 400){
lcd.setCursor(0, 1);
lcd.print("BAIXO ");
}else if(valorBotao >=0 && valorBotao < 10){
lcd.setCursor(0, 1);
lcd.print("DIREITA ");
}else if(valorBotao > 700 && valorBotao < 730){
lcd.setCursor(0, 1);
lcd.print("ENTER ");
}
Serial.println(valorBotao);
delay(100);
}
116
Observe que o exemplo envia pela Serial, o valor correspondente a cada valor pressionado.
Para ver os valores basta abrir o Serial Monitor dentro do programa do Arduino
Neste projeto você vai aprender a ligar um relé com botão ao Arduino Uno. Em nosso projeto
o relé acionará um led, mais você poderá acionar qualquer outro dispositivo ao relé, desde que
obedeça a capacidade de corrente máxima do relé. Para acionarmos o relé será acionado uma
chave ou botão tipo push button, onde cada toque na chave será alterado o estado do relé,
permanecendo ligado ou desligando de acordo com um toque no botão. Poderá ser utilizado
qualquer relé com tensão nominal de 5v desde que siga corretamente as ligações das
pinagens.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
1 – LED 5mm (qualquer cor)
1 – Chave push button
1 – Resistor de 220Ω
2 – Resistor de 10kΩ
1 – Transistor NPN BC337/BC338
1 – Diodo 1N4007
1 – Relé de 5V
1 – Protoboard
Fios e jumpers diversos
117
30 LIGANDO RELÉ COM BOTÃO
BOTÃO AO ARDUINO UNO
118
Esquemático de Ligações - Fritzzing
Esquemático de Ligações - Fritzzing
Código Fonte do Projeto
/*
‘***************************************************
‘* Projeto : Ligando relé com botão ao Arduino Uno
‘* Autor : Alessandro Gouvea
‘* Version : v1.0
‘* www.oarduino.com
‘***************************************************
*/
int
int
int
int
rele = 2; //porta a ser utilizada para o acionamento do rele
botao = 3; //porta utilizada para o botão
lebotao; //armazena informações sobre a leitura do botão
statusrele = 0; //armazena o estado do relé (ligado/desligado)
void setup()
{
pinMode(rele, OUTPUT); //Define o pino do rele como saida
pinMode(botao, INPUT); //Define o pino do botão como entrada
}
119
No projeto utilizei um relé com a disposição dos pinos diferente do utilizado no esquemático
fritzing acima. No lugar do led você poderá utilizar uma lâmpada ligada a alimentação de 220v
bastando ligá-los em série a saída do relé como no esquematico abaixo.
120
void loop() // inicio do programa
{
lebotao = digitalRead(botao); // armazena a leitura do botao armazena a informação na variavel
lebotao
if (lebotao != 1)
{
while(digitalRead(botao) != 1)
{
delay(100);
}
statusrele = !statusrele;
digitalWrite(rele, statusrele);
}
}
Lista de Componentes utilizados:
•
•
•
•
•
•
•
- 1 IR receptor LED (fotodiodo com 2 pinos, não o fototransistor com 3 pinos)
- IR emissores LED (tanto quanto você pode obter, mas, pelo menos, 2)
- 100K resistor (marrom, preto, amarelo)
- fios de ligação em ponte
- Breadboard
- Fita isolante
- Buzzer (opcional)
Tenha cuidado para não misturar o receptor de LED com o emissor de LED, todos eles têm a
mesma aparência.
Preparando o sensor
Antes de montá-lo, devemos preparar o receptor LED IR para não receber luz dos lados, de
modo que o sensor é mais direcional. Eu uso fita isolante para fazer isso ou qualquer coisa que
bloqueia a luz dos lados.
Corte um pequeno pedaço de fita isolante e envolvê-la em torno do receptor IR LED, formando
um tubo. Apare a borda com um par de tesouras até que é cerca de 1 cm de comprimento.
Dê uma olhada nas imagens para ver como eu fiz isso com fita isolante.
121
31 SENSOR DE PROXIMIDADE INFRAVERMELHO COM ARDUINO
122
Esquemático de Ligações - Fritzzing
123
Código Fonte do Projeto
// Sensor de proximidade simples usando Infrared
// Descrição: medir a distância até um obstáculo usando a luz
infravermelha emitida pelo LED IR e
// Ler o valor com um fotodiodo IR. A precisão não é perfeito, mas
funciona muito bem
// Com projetos menores.
// Autor: Ricardo Ouviña
// Data: 01/10/2012
// Versão: 1.0
int Irpin = A0; // IR fotodiodo no pino analógico A0
int IRemitter = 2; // IR emissor LED no pino digital 2
int ambientIR; // Variável para armazenar o IR proveniente do
ambiente
int obstacleIR; // Variável para armazenar o IR proveniente do
objecto
valor int [10]; // Variável para armazenar os valores de IR
int distância; // Variável que vai dizer se há um obstáculo ou não
void setup () {
Serial.begin (9600); // Inicializar monitor de Serial
pinMode (IRemitter, OUTPUT); // IR emissor LED no pino digital 2
digitalWrite (IRemitter, LOW); // configuração IR LED como off
pinMode (11, OUTPUT); // Buzzer no pino digital 11
}
void loop () {
readIR int (int vezes) {
para (int x = 0; X <vezes; x ++) { <times;x++){
digitalWrite (IRemitter, LOW); // Transformando os LEDs IR off para
ler o IR proveniente do ambiente
atraso (1); // Atraso mínimo necessário para ler os valores
ambientIR = analogRead (Irpin); // IR armazenar vindo do ambiente
digitalWrite (IRemitter, HIGH); // Transformando o IR LEDs para ler
o IR proveniente do obstáculo
atraso (1); // Atraso mínimo necessário para ler os valores
obstacleIR = analogRead (Irpin); // IR armazenar vindo do
obstáculo
valor [x] = ambientIR-obstacleIR; // Cálculo da variação de valores
de IR e guardá-la por média futuro
}
for (int x = 0; x <vezes; x ++) {// cálculo da média com base na
"precisão"
distância + = valor [x];
}
retorno (educação a distância / tempo); // Retorna o valor final
}
// - Função a soar uma campainha para medições audíveis - //
buzzer void () {
if (distância> 1) {
if (distância> 100) {// som contínuo, se o obstáculo está muito
próximo
digitalWrite (11, HIGH);
}
else {// emite um sinal sonoro mais rápido quando um obstáculo
abordagens
digitalWrite (11, HIGH);
atraso (150-distância); // Ajustar esse valor para sua
conveniência
digitalWrite (11, LOW);
atraso (150-distância); // Ajustar esse valor para sua
conveniência
}
}
else {// off se não houver nenhum obstáculo
digitalWrite (11, LOW);
}
} </times;x++){
Ligue a resistência do pino de 5V para o pino ânodo do receptor LED IR. Todos os ânodos pinos
dos LEDs IR emissores para o pino digital 2. Um fio vai do pino analógico 0 para o pino ânodo
do receptor LED IR. Não se esqueça de ligar todos os pinos de cátodo dos LEDs para o pino
terra.
A campainha é opcional, mas se você estiver usando-o ligar ao pino digital 11 e no chão.
A luz infravermelha não é visível a olho nu, mas você pode vê-lo através de uma câmera digital,
que ajuda a ver se o LED está funcionando ou não.
124
distance = readIR (5); // Chamando a função que irá ler a distância
e passar a "precisão" para ele
Serial.println (à distância); // Escreve o valor lido no monitor
Serial
// Buzzer (); // Retire o comentário para ativar a função buzzer
}
125
Dê uma olhada nas fotos.
Circuito RTC DS1307 e com botões para o ajuste das horas. O relógio é montado com base no
circuito integrado RTC (Real Time Clock) DS1307. Uma bateria CR2032 de 3V, a mesma utilizada
no PC, mantém o DS1307 funcionando mesmo quando o arduino não estiver alimentado. O
circuito também faz uso de um Arduino Uno, um Display LCD 16×2 e possui ainda três botões,
onde um aciona o que vai ser modificado no relógio (dia, mês, ano, hora, minuto ou segundo) e
os outros dois servem para aumentar ou diminuir o valor selecionado. O sistema indica com um
* no canto superior esquerdo da tela que está em modo de atualização da hora e com uma letra
indicando o que está sendo atualizado no momento, além disso o ítem a ser alterado fica
piscando.
Os resistores que fazem ligações aos botões no arduino são na forma de circuito “pull down”, e
podem ser qualquer um de valores entre 1k e 100k, então utilizei os de 10k.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
•
6 resistores de 10k;
3 botões tipo push button;
1 trimpot 10k;
1 display lcd 16×2;
1 c.i. DS1307;
1 bateria CR2032 (3V);
1 cristal de 32,786Khz;
1 Arduino Uno;
1 pront-o-board;
fios diversos.
126
32 RELÓGIO LCD COM RTC DS1307 E ARDUINO
127
Esquemático de Ligações - Fritzzing
/*
‘***************************************************
‘* Projeto : Relógio LCD com RTC DS1307 ajustável
‘* Autor : Alessandro Gouvea
‘* Version : v1.0
‘* www.oarduino.com
‘***************************************************
*/
#include
#include
#include
#include
<LiquidCrystal.h>
<DS1307RTC.h>
<Wire.h>
<Time.h>
// Pinos de comando dos botões do relógio
#define clockSet 7
#define clockUp 9
#define clockDown 8
//Estados de Clock
#define stClockRunning 0
#define stSetDay 1
#define stSetMonth 2
#define stSetYear 3
#define stSetHour 4
#define stSetMinute 5
#define stSetSecond 6
int stat = stClockRunning;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //configuração dos pinos do lcd
void Print(int number)
{
lcd.print(number/10);
lcd.print(number%10);
}
// Preenchimento do display LCD
void printTime()
{
lcd.setCursor(4,1); Print(hour());
lcd.print(":"); Print(minute());
lcd.print(":"); Print(second());
lcd.setCursor(3,0); Print(day());
lcd.print("/"); Print(month());
lcd.print("/"); Print(year());
lcd.setCursor(0,0);
lcd.noCursor(); // Cursor invisível
lcd.noBlink(); // Efeito blink desligado
if (stat != stClockRunning)
lcd.print("*");
else
lcd.print(" ");
simbolorelogio();
lcd.setCursor(1,1);
lcd.write(3);
128
Código Fonte do Projeto
}
// Lê pino usando limiar, como um interruptor, isto é,
// interruptor pressionado primeira vez liga, pela segunda vez desliga
int readPinSwitch(int pin, int threshold)
{
if (digitalRead(pin))
{
unsigned long tt = millis();
while (digitalRead(pin));
if ((millis() - tt) > threshold)
return 1;
else
return 0;
}
else
return 0;
}
//Lê pino usando limiar
int readPin(int pin, int threshold)
{
if (digitalRead(pin))
129
switch(stat)
{
case stSetDay:
lcd.setCursor(1,0);
lcd.print("d ");
lcd.setCursor(4,0);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
break;
case stSetMonth:
lcd.setCursor(1,0);
lcd.print("m ");
lcd.setCursor(7,0);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
break;
case stSetYear:
lcd.setCursor(1,0);
lcd.print("a ");
lcd.setCursor(12,0);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
break;
case stSetHour:
lcd.setCursor(1,0);
lcd.print("h ");
lcd.setCursor(5,1);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
break;
case stSetMinute:
lcd.setCursor(1,0);
lcd.print("M ");
lcd.setCursor(8,1);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
break;
case stSetSecond:
lcd.setCursor(1,0);
lcd.print("s ");
lcd.setCursor(11,1);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
break;
}
}
// obter novo status, se houver
int getStat()
{
if (readPinSwitch(clockSet,300))
if (stat == stSetSecond)
return stClockRunning;
else
return stat+1;
else
return stat;
}
// definir Arduino e tempo do RTC
void setRTCTime(int hour, int minute, int second, int day, int month, int
year)
{
// define tempo do Arduino
setTime(hour,minute,second,day,month,year);
time_t t = now();
// define tempo do RTC
RTC.set(t);
}
void simbolorelogio()
{
byte relogio[8] = {
B00000,
B01110,
B10101,
B10111,
B10001,
B01110,
B00000,
B00000};
lcd.createChar(3, relogio); // Cria o caractere personalizado de um relogio
}
void setup()
{
pinMode(clockUp,INPUT); // configura os pinos dos botões como entrada
pinMode(clockDown,INPUT);
pinMode(clockSet,INPUT);
lcd.begin(16, 2); // Seta o display para 16 colunas and 2 linhas
setSyncProvider(RTC.get); // função para obter o tempo do RTC
if(timeStatus()!= timeSet) // verifica status do RTC e retorna erro
{
lcd.setCursor(0,0);
lcd.print("Erro do RTC:");
lcd.setCursor(0,1);
lcd.print("Ajuste o Relogio");
delay(3000);
lcd.clear();
}
}
130
{
unsigned long tt = millis();
while ((digitalRead(pin) && (millis() - tt) <= threshold));
if (digitalRead(pin))
return 1;
else
return 0;
}
else
return 0;
void loop()
{
int value = 0;
printTime(); // rotina que imprime o tempo no lcd
delay(100);
stat=getStat();
if (stat != oldStat)
{
t=millis();
oldStat = stat;
}
else
if ((stat != stClockRunning) && ((millis() - t) > 30000)) //tempo em
milisegundos que o ajuste do relógio ficará disponível para ser alterado
stat=stClockRunning;
switch(stat)
{
case stClockRunning:
break;
case stSetDay:
// inicializa value
value=day();
//si botao UP (para cima) for pressionado
while(readPin(clockUp,200))
{
value++;
if (value > 31)
value=1;
setRTCTime(hour(),minute(),second(),value,month(),year());
printTime();
}
//si botao DOWN (para baixo) for pressionado
while(readPin(clockDown,200))
{
value--;
if (value < 1)
value=31;
setRTCTime(hour(),minute(),second(),value,month(),year());
printTime();
}
break;
// ver comentários em stSetDay
case stSetMonth:
value=month();
while(readPin(clockUp,200))
{
value++;
if (value > 12)
value=1;
setRTCTime(hour(),minute(),second(),day(),value,year());
printTime();
}
while(readPin(clockDown,200))
{
value--;
if (value < 1)
value=12;
setRTCTime(hour(),minute(),second(),day(),value,year());
printTime();
}
break;
case stSetYear:
value=year();
while(readPin(clockUp,200))
{
131
int oldStat = stat;
unsigned long t=millis();
132
value++;
if (value > 2050)
value=2000;
setRTCTime(hour(),minute(),second(),day(),month(),value);
printTime();
}
while(readPin(clockDown,200))
{
value--;
if (value < 2000)
value=2050;
setRTCTime(hour(),minute(),second(),day(),month(),value);
printTime();
}
break;
case stSetHour:
value=hour();
while(readPin(clockUp,200))
{
value++;
if (value > 23)
value=0;
setRTCTime(value,minute(),second(),day(),month(),year());
printTime();
}
while(readPin(clockDown,200))
{
value--;
if (value < 1)
value=24;
setRTCTime(value,minute(),second(),day(),month(),year());
printTime();
}
break;
case stSetMinute:
value=minute();
while(readPin(clockUp,200))
{
value++;
if (value > 59)
value=0;
setRTCTime(hour(),value,second(),day(),month(),year());
printTime();
}
while(readPin(clockDown,200))
{
value--;
if (value < 0)
value=59;
setRTCTime(hour(),value,second(),day(),month(),year());
printTime();
}
break;
case stSetSecond:
value=minute();
while(readPin(clockUp,200))
{
value++;
if (value > 59)
value=0;
setRTCTime(hour(),minute(),value,day(),month(),year());
printTime();
}
while(readPin(clockDown,200))
{
value--;
if (value < 0)
value=59;
133
setRTCTime(hour(),minute(),value,day(),month(),year());
printTime();
}
}
}
Para utilizarmos o caracter precisamos enviá-lo ao display. Vamos gravar o caracter especial no
display na posição 1:
lcd.createChar(1, coracao); // Grava o caracter heart na posição 1. lcd.write(1); // Escreve o
caracter da posição 1 no display, e tem que ser write(), e não print(). No código do programa
abaixo criamos 3 caracteres especiais.
Neste projeto vamos controlar um display lcd 16×2 com o arduino, escrevendo caracteres,
frases e também criar desenhos. O display utilizado faz uso do chip HD44780, sendo a maioria
encontrado no mercado.
Lista de Componentes utilizados:
•
•
•
•
1 – Protoboard
1 – Display LCD 16X2
1 – Potenciômetro ou trimpot 10k
– Jumpers diversos
134
33 LIGANDO UM DISPLAY LCD
LCD 16X2 AO ARDUINO
No programa é utilizado a biblioteca LiquidCrystal.h. O pino BL (penúltimo pino) que está
ligado à saída 7 do Arduino é o que controla a luz de fundo do display (BL -> backlight). O pino
V0 (3º pino) é o contraste onde vai ligado um potenciômetro ou um trimpot de 10k, ou você
poderá ligá-lo a uma saída PWM do Arduino para controlar o contraste pelo programa.
Todas as funções da biblioteca si encontram neste link.
Criando caracteres personalizados:
Com os displays baseados no HD44780 podemos criar até 8 caracteres customizados! Primeiro
devemos criar um vetor de 8 bytes que representará o nosso caracter. Segue o código
correspondente ao desenho de um coração:
byte heart[8] =
{ 0b00000, 0b01010, 0b11111, 0b11111, 0b01110, 0b00100, 0b00000, 0b00000 };
Graficamente:
135
Esquemático de Ligações - Fritzzing
/*
***************************************************
* Projeto : Ligando Display ao Arduino Uno
* Autor : Alessandro Gouvea
* Version : v1.0
* www.oarduino.com
***************************************************
*/
#include
// declara a utilização da biblioteca LiquidCrystal
#define Luz_Fundo 7
//cria uma saida do "lcd" nos pinos citados:
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
lcd.begin(16, 2); // Iniciando o objeto "lcd" de 2 linhas e 16 colunas
pinMode(Luz_Fundo,OUTPUT); //define o pino como saidda
digitalWrite(Luz_Fundo,HIGH); // Liga a luz do display.
}
void loop()
{
basicoPrintDemo(); // Rotina de impressão básica
displayOnOffDemo(); // Rotina que liga e desliga display
setCursorDemo(); // Rotina que posiciona o cursor na tela
scrollLeftDemo(); // Rotina que rola o texto para a esquerda
scrollRightDemo(); // Rotina que rola o texto para a direita
cursorDemo(); // Rotina que ativa o cursor na tela
createGlyphDemo(); // Rotina de criação de caracteres especiais
}
void basicoPrintDemo() {
lcd.clear(); // Limpa o display
lcd.setCursor(4,0); // envia cursor para coluna 4 e linha 1
lcd.print("OArduino"); // Imprime o texto
lcd.setCursor(0,1); // envia cursor para coluna 0 e linha 2
lcd.print("www.oarduino.com"); // Imprime o texto
delay(4000); // Aguarda 4 segundos
}
void displayOnOffDemo() {
lcd.clear(); // Limpa o display
lcd.setCursor(5,0); // envia cursor para coluna 5 e linha 1
lcd.print("Display"); // Imprime o texto
lcd.setCursor(0,1); // envia cursor para coluna 0 e linha 2
lcd.print("Ligado/Desligado"); // Imprime o texto
for(int x=0; x < 3; x++) { // pisca a mensagem 3 vezes
lcd.noDisplay(); // Apaga o display
delay(1000); // Aguarda 1s
lcd.display(); // Acende-o novamente
delay(1000); } // Aguarda 1s
}
void setCursorDemo() {
lcd.clear(); // Limpa o display
lcd.print("Posicoes do"); // Imprime o texto na primeira linha
136
Código Fonte do Projeto
void scrollLeftDemo() {
lcd.clear(); // Limpa o display
lcd.print("Scroll para");
lcd.setCursor(0,1);
lcd.print("Esquerda:");
delay(2000);
lcd.clear(); // Limpa o display
lcd.setCursor(3,0);
lcd.print(" Rolando ->");
lcd.setCursor(0,1);
lcd.print("OArduino.com");
delay(1000);
for(int x=0; x<16; x++) { // laço de repetição
lcd.scrollDisplayRight(); // Rola o display 16 vezes para a direita
delay(250); }
}
void cursorDemo() {
lcd.clear(); // Limpa o display
lcd.cursor(); // Cursor visível
lcd.print("Cursor");
lcd.setCursor(0,1);
lcd.print("Ligado");
delay(3000);
lcd.clear(); // Limpa o display
lcd.noCursor(); // Cursor invisível
lcd.print("Cursor");
lcd.setCursor(0,1);
lcd.print("Desligado");
delay(3000);
lcd.clear(); // Limpa o display
lcd.print("Cursor");
lcd.setCursor(0,1);
lcd.print("Piscando");
lcd.setCursor(9,1);
lcd.cursor(); // Cursor visível
lcd.blink(); // Cursor piscando
delay(3000); // Aguarda 3s (3000ms)
lcd.noCursor(); // Cursor invisível
lcd.noBlink(); // Efeito blink desligado
}
void createGlyphDemo() {
lcd.clear(); // limpa lcd
byte happy[8] = { // Cria um array de bytes com uma cara feliz
B00000,
B00000,
B10001,
B00000,
B10001,
B01110,
B00000,
B00000};
137
lcd.setCursor(3,1); // envia cursor para coluna 3 e linha 2
lcd.print("Cursor:"); // imprime o texto
delay(2000); // Aguarda 2s
lcd.clear(); // Limpa o display
lcd.setCursor(5,0); // Cursor na coluna 5, linha 1
lcd.print("5,0"); // imprime as coordenadas do cursor no lcd
delay(2000); // aguarda 2s
lcd.setCursor(10,1); // Cursor na coluna 10, linha 2
lcd.print("10,1"); // imprime as coordenadas do cursor no lcd
delay(2000); // aguarda 2s
lcd.setCursor(3,1); // Cursor na coluna 3, linha 2
lcd.print("3,1"); // imprime as coordenadas do cursor no lcd
delay(2000); // aguarda 2s
}
lcd.createChar(3, coracao); // Cria o caractere personalizado 3
for(int x=0; x<5; x++) { // Executa a animação 5 vezes
lcd.setCursor(7,1);
lcd.write(3); // Escreve o caractere personalizado 3
delay(500);
lcd.setCursor(7,1);
lcd.print(" "); // Após 0.5s apaga o coração, assim ele
delay(500); // ficará piscando
}
}
Como criar menus para seus projetos com display
Bom pessoal, aproveitando o circuito de nosso último projeto encontrado aqui, aprenderemos
a montar um menu personalizado para nossos projetos com display no Arduino. O vídeo é do
Mauricio Rivello que mostra como montar os menus através de um vídeo que ele fez no
youtube.
https://www.youtube.com/watch?feature=player_embedded&v=mcuReWQt_oo
// Tutorial de Menu LCD por diagrama de estados
138
byte sad[8] = { // Cria um array de bytes com uma cara triste
B00000,
B00000,
B10001,
B00000,
B01110,
B10001,
B00000,
B00000};
byte coracao[8] = { // vetor de bytes correspondentes ao desenho do coração
B00000,
B01010,
B11111,
B11111,
B01110,
B00100,
B00000,
B00000};
lcd.createChar(1, happy); // Cria o caractere personalizado 1 (carinha
feliz)
lcd.createChar(2, sad); // Cria o caractere personalizado 2 (carinha triste)
lcd.setCursor(0,0);
lcd.print("Carinha");
for(int x=0; x<5; x++) { // Executa a animação 5 vezes
lcd.setCursor(0,1);
lcd.print("Feliz: ");
lcd.setCursor(8,1);
lcd.write(1); // Escreve o caractere personalizado 1
delay(1000);
lcd.setCursor(0,1);
lcd.print("Triste:"); //Imprime o texto
lcd.setCursor(8,1);
lcd.write(2); // Escreve o caractere personalizado 2
delay(1000); } // Aguarda 1s
lcd.clear();
lcd.print("Coracao batendo");
#include <LiquidCrystal.h>
// Definição dos pinos dos botões, luz do display e buzzer
#define Buzzer 6
#define Display 7
#define bMenu A0 // Os pinos analógicos podem ser
#define bChange A1 // usados como digitais, bastando
#define bUp A2 // referenciá-los por A0, A1..
#define bDown A3
#define bMenu0 90 // Valor de referência que a
#define bChange0 91 // função CheckButton() passa
#define bUp0 92 // indicando que um botão foi
#define bDown0 93 // solto
boolean aMenu, aChange, aUp, aDown; // Grava o ultimo valor lidos nos botões.
// Utilizado pela função Checkbutton p/ identificar quando há uma alteração no estado do pino dos
botões
int variavel; // variavel a ser alterada pelo menu
char state=1; // variável que guarda posição atual do menu
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Declaração do objeto tipo lcd
//============================================== SETUP
void setup()
{
lcd.begin(16, 2); // Iniciando a biblioteca do LCD
pinMode(Display,OUTPUT); // Luz de fundo do display
pinMode(Buzzer, OUTPUT); // Buzzer
pinMode(bMenu, INPUT); // Botões
pinMode(bChange,INPUT);
pinMode(bUp, INPUT);
pinMode(bDown, INPUT);
digitalWrite(bMenu, HIGH); // Aciona o pull-up interno
digitalWrite(bChange,HIGH); // dos botões
digitalWrite(bUp, HIGH);
digitalWrite(bDown, HIGH);
digitalWrite(Display,HIGH); // Liga a luz do display.
}
//==============================================
//============================================== LOOP
void loop()
{
switch (state) { // Define checa qual tela atual
case 1:
// executado quando na TELA 1
switch (CheckButton()) {
case bChange:
Feo();
break;
case bUp:
lcd.clear(); Set_state(4); // antes de mudar de tela, é necessário limpar o
break;
// display com a função lcd.clear()
case bDown:
lcd.clear(); Set_state(2);
break;
default: // Caso nenhum botão tenha sido apertado, ela executa a set_state
Set_state(1); // mesmo assim para atualizar o display.
}
139
// Maurício Féo Rivello
// engenheirando.com
// Assista o vídeo sobre:
// http://www.youtube.com/watch?v=mcuReWQt_oo
case 2:
// executado quando na TELA 2
switch (CheckButton()) {
case bChange: // Apita o buzzer quando o botão bChange é pressinado na tela 2
digitalWrite(Buzzer,HIGH);
delay(200);
digitalWrite(Buzzer,LOW);
break;
case bUp:
lcd.clear(); Set_state(1);
break;
case bDown:
lcd.clear(); Set_state(3);
break;
default:
Set_state(2);
}
break;
case 3:
// executado quando na TELA 3
switch (CheckButton()) {
case bChange:
digitalWrite(Display,LOW);
delay(1000);
digitalWrite(Display,HIGH);
break;
case bUp:
lcd.clear(); Set_state(2);
break;
case bDown:
lcd.clear(); Set_state(4);
break;
default:
Set_state(3);
}
break;
case 4:
// executado quando na TELA 4
switch (CheckButton()) {
case bMenu:
lcd.clear(); variavel++;
break;
case bChange:
lcd.clear(); variavel--;
break;
case bUp:
lcd.clear(); Set_state(3);
break;
case bDown:
lcd.clear(); Set_state(1);
break;
default:
Set_state(4);
}
break;
default: ;
}
}
//============================================== FIM da função LOOP
//==============================================
//============================================== CheckButton
char CheckButton() {
if (aMenu!=digitalRead(bMenu)) {
aMenu=!aMenu;
140
break;
//========================================================
//============================================== Set_state
void Set_state(char index) {
state = index; // Atualiza a variável state para a nova tela
switch (state) { // verifica qual a tela atual e exibe o conteúdo correspondente
case 1: //==================== state 1
lcd.setCursor(0,0);
lcd.print("Segundos:");
lcd.setCursor(0,1);
lcd.print( millis()/1000 , DEC); // mostra os segundos na tela
lcd.print(" s");
break;
case 2: //==================== state 2
lcd.setCursor(0,0);
lcd.print("Beep!");
break;
case 3: //==================== state 3
lcd.setCursor(0,0);
lcd.print(" Aperte para");
lcd.setCursor(0,1);
lcd.print(" apagar");
break;
case 4: //==================== state 4
lcd.setCursor(0,0);
lcd.print("Variavel:");
lcd.setCursor(0,1);
lcd.print(variavel, DEC); // mostra o valor de "variavel"
break;
default: ;
}
}
// Função que mostra o nome "Féo" passando na tela.
// Apenas uma assinatura.
//======================================================= Display Feo
void Feo() {
const byte a[2][15][8] = {
{{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00001,0b00001,0b00001,0b00011,0b00011},
{0b00000,0b11111,0b11111,0b11111,0b10000,0b10000,0b10000,0b11111},
{0b00000,0b11111,0b11110,0b11100,0b00000,0b00000,0b00000,0b11000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00001,0b00011,0b00110},
{0b00000,0b00110,0b01100,0b11000,0b00000,0b11100,0b00110,0b00010},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00001,0b00011,0b00110},
{0b00000,0b00000,0b00000,0b00000,0b11000,0b11100,0b00110,0b00011},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
141
if (aMenu) return bMenu0; else return bMenu;
} else
if (aChange!=digitalRead(bChange)) {
aChange=!aChange;
if (aChange) return bChange0; else return bChange;
} else
if (aUp!=digitalRead(bUp)) {
aUp=!aUp;
if (aUp) return bUp0; else return bUp;
} else
if (aDown!=digitalRead(bDown)) {
aDown=!aDown;
if (aDown) return bDown0; else return bDown;
} else
return 0;
}
142
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000}},
{{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00111,0b00111,0b01110,0b01110,0b01100,0b11100,0b11100,0b11000},
{0b11111,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b10000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b01100,0b11111,0b11000,0b11000,0b01100,0b01100,0b00111,0b00001},
{0b00011,0b11100,0b00000,0b00000,0b00010,0b00110,0b11100,0b10000},
{0b01100,0b11000,0b11000,0b11000,0b01100,0b01100,0b00111,0b00011},
{0b00001,0b00001,0b00001,0b00011,0b00110,0b01100,0b11000,0b10000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000},
{0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000,0b00000}}
};
byte b[2][15][8];
int k,i,j;
while (!digitalRead(bChange)) {
lcd.setCursor(12,0);
lcd.write(1);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.setCursor(12,1);
lcd.write(5);
lcd.write(6);
lcd.write(7);
lcd.write(8);
for (k=0; k<2; k++)
for (i=0; i<15; i++)
for (j=0; j<8; j++)
b[k][i][j]=a[k][i][j];
for (j=0; j<55; j++) {
lcd.createChar(1, b[0][0]);
lcd.createChar(2, b[0][1]);
lcd.createChar(3, b[0][2]);
lcd.createChar(4, b[0][3]);
lcd.createChar(5, b[1][0]);
lcd.createChar(6, b[1][1]);
lcd.createChar(7, b[1][2]);
lcd.createChar(8, b[1][3]);
for (i=0; i<15; i++) {
for (k=0; k<8; k++) {
b[0][i][k]=(b[0][i][k]<<1) + ((b[0][i+1][k]>>4)&(1));
}
}
for (i=0; i<15; i++) {
for (k=0; k<8; k++) {
b[1][i][k]=(b[1][i][k]<<1) + ((b[1][i+1][k]>>4)&(1));
}
}
delay(15);
}
}
lcd.clear();
}
como desenvolver o projeto arduino com display LDC, que mede a temperatura através de um
sensor LM35 e mede a luminosidade através de um sensor LDR (do inglêsLight Dependent
Resistor). Além disso você poderá controlar o brilho e contraste do display LDC através de dois
potenciômetros. Este projeto arduino vai te mostrar como trabalhar com displays LDC do tipo
JHD 162A, de 16 colunas e 2 linhas, que é um tipo comum e fácil de encontrar e com um preço
acessível, e te mostrará também como realizar a leitura dos sensores de temperatura e
luminosidade.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
1 Protoboard
um display LDC do tipo JHD 162A de 16 colunas por duas linhas;
um sensor LDR (do inglês Light Dependent Resistor);
um sensor de temperatura LM35;
dois potenciômetros de 10K omhs;
um resistor de 10k ohms;
fios jumper.
Vamos começar conectando os componentes na protoboard, o display ldc, os potenciômetros,
os sensores de luz e temperatura, resistor e fios jumper. O esquema do projeto, logo abaixo, e
que servirá de base durante todo o desenvolvimento do mesmo, te mostra com detalhes todos
os componentes e as conexões entre eles, que serão tratadas com detalhes mais adiante.
143
34 TEMPERATURA E LUMINOSIDADE
LUMINOSIDADE COM DISPLAY LCD
Além do esquema precisamos saber de mais alguns detalhes técnicos sobre essas ligações.
Vamos começar pelo datasheet do display LCD JHD 162A, que mostra a finalidade de cada um
dos pinos do display lcd. Caso o seu display não seja um JHD 162A você poderá procurar na
internet pelo datasheet do mesmo e assim adaptar para esse projeto.
144
Esquemático de Ligações - Fritzzing
•
•
•
•
•
•
•
•
•
•
•
•
pino 1 do LCD ligado ao GND do arduino;
pino 2 do LCD ligado ao 5V do arduino;
pino 3 do LCD ligado ao pino central do primeiro potênciômetro (controle de
contraste);
pino 4 do LCD ligado ao pino digital 9 do arduino;
pino 5 do LCD ligado ao GND do arduino;
pino 6 do LCD ligado ao pino digital 8 do arduino;
pino 11 do LCD ligado ao pino digital 5 do arduino;
pino 12 do LCD ligado ao pino digital 4 do arduino;
pino 13 do LCD ligado ao pino digital 3 do arduino;
pino 14 do LCD ligado ao pino digital 2 do arduino;
pino 15 do LCD ligado ao pino central do segundo potênciômetro (controle do brilho);
pino 16 do LCD ligado ao GND do arduino.
A imagem abaixo mostra um pouco mais das ligações entre o display e os potenciômetro.
145
Segue abaixo a descrição de como deverão ser feitas as ligações entre o display LDC, o arduino,
e os potenciômetros que controlam o brilho e o contrate do LCD.
A conexão será feita da seguinte forma.
•
•
•
pino 5V do LM35 no 5V do arduino;
pino central do LM35 no pino analógico A1 do arduino;
pino GND do LM35 no GND do arduino.
O sensor de luz será ligado da seguinte forma.
•
•
uma perna do sensor de luz LDR no 5V do arduino;
a outra perna do sensor de luz LDR no pino analógico A0 e também no GND do
arduino, a ligação no GND será feita através do resistor. Para detalhes veja o esquema
do projeto.
Após feitas todas as conexões entre arduino, protoboard e componentes, chegou a hora de
programar o seu arduino para que ele assuma as funções propostas neste projeto. Então
146
Agora trataremos do sensor de temperatura LM35. Segue abaixo uma imagem que detalha a
função de cada pino do sensor.
Código Fonte do Projeto
/*
Projeto Arduino com LCD, sensor de luz e de temperatura.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
#include "LiquidCrystal.h"
#include "Limits.h"
const int sensorLuz = 0; //Pino analógico que o sensor de luz está
conectado.
const int sensorTemp = 1; //Pino analógico que o sensor de
temperatura está conectado.
//Variáveis
int valorSensorLuz = 0; //usada para ler o valor do sensor de
luz.
int valorSensorTemp = 0; //usada para ler o valor do sensor de
temperatura.
int menorValorTemp = INT_MAX; //usada para armazenar o menor valor
da temperatura.
//Criando um objeto da classe LiquidCrystal e
//inicializando com os pinos da interface.
LiquidCrystal lcd(9, 8, 5, 4, 3, 2);
void setup() {
//Inicializando o LCD e informando o tamanho de 16 colunas e 2
linhas
//que é o tamanho do LCD JHD 162A usado neste projeto.
lcd.begin(16, 2);
}
void loop() {
//Lendo o valor do sensor de luz
valorSensorLuz = analogRead(sensorLuz);
//Para evitar as grandes variações de leitura do componente
//LM35 são feitas 8 leitura é o menor valor lido prevalece.
menorValorTemp = INT_MAX; //Inicializando com o maior valor int
possível
for (int i = 1; i <= 8; i++) {
//Lendo o valor do sensor de temperatura.
valorSensorTemp = analogRead(sensorTemp);
//Transformando valor lido no sensor de temperatura em graus
celsius aproximados.
valorSensorTemp *= 0.54 ;
//Mantendo sempre a menor temperatura lida
if (valorSensorTemp < menorValorTemp) {
menorValorTemp = valorSensorTemp;
}
delay(150);
147
conecte o seu arduino ao computador através do cabo USB, execute a IDE de programação do
arduino e introduza o código fonte abaixo.
//Exibindo valor da leitura do sensor de temperatura no display
LCD.
lcd.clear(); //limpa o display do LCD.
lcd.print("Temp: "); //imprime a string no display do LCD.
lcd.print(menorValorTemp);
lcd.write(B11011111); //Simbolo de graus celsius
lcd.print("C");
//Exibindo valor da leitura do sensor de luz no display LCD.
lcd.setCursor(0,1); //posiciona o cursor na coluna 0 linha 1 do
LCD.
lcd.print("Luz: "); //imprime a string no display do LCD.
lcd.print(valorSensorLuz);
delay(2000); //aguarda 2 segundos
148
}
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
um Arduino uno ou qualquer outra versão;
uma protoboard;
fios jumper;
um motor cc de 6V;
quatro pilhas pequenas do tipo AA;
suporte para quatro pilhas;
um potenciômetro giratório de 10K;
um diodo 1N4001;
um transistor TIP120;
Esquemático de Ligações - Fritzzing
O primeiro passo é conectar os componentes na protoboard. Neste caso o diodo, o TIP120 e o
potenciômetro. Quero dar uma atenção especial para o diodo, que neste projeto tem a função
de proteger nosso arduino contra a corrente e tensão inversa gerada pelo motor cc. Esteja
149
35 CONTROLANDO A VELOCIDADE
VELOCIDADE DE UM MOTOR CC NO ARDUINO
COM POTENCIÔMETRO.
Posteriormente conete os fios jumper na protoboard.
Conecte os fios jumper no arduino obedecendo o esquema do projeto.
150
também atento a posição do diodo observando a barrinha branca em um dos seus polos e seu
posicionamento no projeto, conforme nostrado na imagem do esquema do projeto. Isso
evitará danos ao arduino.
151
Conecte o motor e as pilhas na protoboard. Apesar de o arduino possuir uma saida de 5V o
motor não será ligado diretamente nele pelo fato de o arduino não ter capacidade de fornecer
corrente suficiente para o funcionamento do motor. Por isso vamos usar pilhas comuns do tipo
AA para alimentar o nosso motor cc. Usei um palito de picolé no motor cc para facilitar a
visualização da rotação do motor. Se você quiser também poderá usar.
Agora chegou a hora de programar o seu arduino. Conecte-o no seu computador através do
cabo USB e abra a IDE do arduino. O código fonte comentado deste projeto segue abaixo.
Depois de inserir o código fonte na IDE, agora é só compilar e fazer o upload do mesmo para o
arduino. Aguarde alguns instantes para a conclusão do upload e logo você poderá girar o
potenciômetro para ambos os lados e ver o seus motor cc aumentar e diminuir a velocidade de
rotação.
/*
Projeto Arduino controlando um motor cc.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//pino analógico onde o potenciômetro está conectado.
int const potenciometro = 0;
//pino digital onde o TIP120 está conectado.
int const transistor = 9;
//armazenará o valor lido no potenciômetro.
int valPotenciometro = 0;
//função setup é executada uma vez quando o arduino é ligado.
void setup() {
//definindo o pino digital 9 como de saída.
pinMode(transistor, OUTPUT);
}
//Função loop é executada repetidamente enquanto
//o arduino estiver ligado.
void loop() {
//lendo o valor do potenciômetro (0 até 1023) e
//dividindo por 4 para obter um valor entre 0 e 255
//que são valores adequados para a base do TIP120.
valPotenciometro = analogRead(potenciometro) / 4;
//atribuindo o valor lido no potenciômetro
//a base do TIP120.
analogWrite(transistor, valPotenciometro);
}
152
Código Fonte do Projeto
VELOCIDADE E SENTIDO DA ROTAÇÃO
Controle de um motor de corrente contínua CC/DC, que permite que você controle a
velocidade de rotação e também o sentido da rotação, horário ou anti-horário. Esse tipo de
mecanismo é a base para a construção de braços robóticos, mini guinchos, mini elevadores e
mais um monte de coisas. Neste projeto arduino iremos usar um componente importante, o
L293D, que é um circuito integrado de ponte H dupla, que vai permitir que tenhamos total
controle de um motor cc/dc e além disso o L293D permite que você controle até dois motores
cc/dc de forma independente. Então vamos iniciar o nosso projeto arduino com ponte H dupla
para controle de velocidade e sentido da rotação de um motor cc/dc.
Para uma visão geral deste projeto arduino, assista o vídeo abaixo que mostra o projeto pronto
em pleno funcionamento.
Para começar é ideal que se conheça o circuito integrado de ponte H dupla L293D. Na imagem
abaixo segue a descrição dos pinos que fazem parte deste componente. Um ponto importante
sobre este componente eletrônico é que ele já possui diodos internamente, por isso o "D" no
final de seu nome, por isso não usaremos diodos externos na protoboard. E observe o chanfro
no topo do componente L293D, parecido com um meio círculo, pois é a partir dele que deverá
ser iniciada a contagem dos pinos. O pino 1 será o primeiro pino no sentido anti-horário
partindo do chanfro.
153
36 MOTOR CC/DC NO ARDUINO E PONTE H DUPLA. CONTROLE DE
•
•
•
•
•
•
•
•
•
•
•
pino 1 - enable 1, 2 - ligado ao pino digital 9 (PWM) do arduino;
pino 2 - input 1 - ligado ao pino digital 3 do arduino;
pino 3 - output 1 - ligado ao motor cc/dc;
pino 4 - GND - ligado ao terra (ground) do arduino;
pino 5 - GND - ligado ao terra (ground) do arduino;
pino 6 - output 2 - ligado ao motor cc/dc;
pino 7 - input 2 - ligado ao pino digital 4 do arduino;
pino 8 - Vcc 2 - ligado ao positivo vindo das pilhas;
pino 12 - GND - ligado ao terra (ground) do arduino;
pino 13 - GND - ligado ao terra (ground) do arduino;
pino 16 - Vcc 1 - ligado ao pino 5V (volts) do arduino;
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
uma protoboard;
um circuito integrado L293D;
fios jumper;
quatro pilhas pequenas;
um motor CC de 6 volts;
um potenciômetro de 10 K ohms;
uma chave liga/desliga;
um resistor de 10 K ohms.
Segue abaixo o esquema do nosso projeto, que servirá de base para o desenvolvimento do
mesmo, e que mostra detalhadamente todas as ligações entre os componentes eletrônicos
que fazem parte deste projeto. O potenciômetro vai controlar a velocidade de rotação do
motor, aumentando ou diminuindo. A chave liga/desliga irá controlar o sentido da rotação do
motor, horário ou anti-horário.
154
No nosso projeto usaremos os seguintes pinos do CI (circuito integrado) L293D:
Vamos começar colocando na protoboard os componentes L293D e o potenciômetro, que
controlará a velocidade de rotação do motor cc/dc.
155
Esquemático de Ligações - Fritzzing
156
Agora faça a ligação da chave liga/desliga, juntamente com o resistor e os fios jumper.
Faça as ligações do potenciômetro, do L293D, das pilhas e do motor cc/dc. Para realizar estas
ligações o melhor é seguir o esquema do início deste post que possui uma forma de
visualização mais detalhada do projeto.
Outro ângulo das ligações entre o arduino e os componentes.
157
Ao finalizar a montagem dos componentes eletrônicos do seu projeto você terá algo parecido
com o projeto da imagem abaixo. Usei uma bateria de 9V para alimentar o arduino, mas
também poderia conectá-lo ao computador através do cabo USB para alimentá-lo.
Agora chegou a grande hora, a hora de programar o seu arduino. Conecte o arduino ao seu
computador com o cabo USB, execute a IDE do arduino, e copie e cole o programa abaixo na
IDE, depois compile o programa e faça o upload para o arduino.
Segue abaixo o código fonte comentado do programa de controle do motor cc/dc com ponte H
dupla para o arduino. Apesar de todos os recursos deste projeto o programa é pequeno e
simples.
/*
Projeto Arduino motor cc com ponte H dupla. Gira
nos dois sentidos e possui controle de potência.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//Chave que muda o sentido da rotação do motor.
#define chaveMudaSentRot 2
//INPUT 1 do L293D.
#define motorCCEnt1 3
//INPUT 2 do L293D.
#define motorCCEnt2 4
//Pino de ativação e controle do L293D.
#define controleL293D 9
//Pino analógico para controle de
//potência/velocidade do motor.
#define controleVelocPot 0
//Variável para armazenar o valor
//lido no potenciômetro.
int potVelPotencia = 0;
void setup() {
//O pino da chave seletora de rotação
//definido como de entrada.
pinMode(chaveMudaSentRot,INPUT);
//Pinos do motor e de ativação do
//L293D definidos como de saída.
pinMode(motorCCEnt1,OUTPUT);
pinMode(motorCCEnt2,OUTPUT);
pinMode(controleL293D,OUTPUT);
}
void loop() {
//Lendo valor do potenciometro para aplicar a
//potência/velocidade ao motor. O valor lido é
//dividido por 4 para se obter valores entre 0 e 255;
potVelPotencia = analogRead(controleVelocPot) / 4;
//Transfere o valor lido de velocidade/potência
//no potenciômetro para o L293D.
analogWrite(controleL293D,potVelPotencia);
//Controlando o sentido de rotação do motor
//pela chave liga/desliga e pelos INPUTs do L293d.
158
Código Fonte do Projeto
}
Após o upload do programa para o arduino seu projeto estará completamente pronto, se você
chegou até aqui meus parabéns! Use o potenciômetro para controlar a velocidade de rotação
do motor e use a chave liga/desliga para mudar o sentido de rotação do motor. Esteja também
sempre atento a temperatura do L293D ele costuma esquentar bastante, se você for deixar
seu projeto ligado por muito tempo use um dissipador de calor no L293D. E abaixo segue o
vídeo do mini guincho feito de palitos de picolé que demonstra uma das milhares de
aplicações de uma ponte H.
159
if (digitalRead(chaveMudaSentRot) == HIGH) {
digitalWrite(motorCCEnt1,LOW);
digitalWrite(motorCCEnt2,HIGH);
} else {
digitalWrite(motorCCEnt1,HIGH);
digitalWrite(motorCCEnt2,LOW);
}
vamos desenvolver um controle de velocidade de rotação para um motor de corrente contínua
e além disso vamos introduzir um medidor da potência aplicada usando leds. Este projeto
arduino funciona assim, a medida que o potenciômetro é girado para um lado a velocidade de
rotação do motor cc aumenta e os leds vão acendendo de acordo com a potência aplicada, se
o motor estiver girando no máximo todos os leds ficarão acesos. Se você girar o potenciômetro
para o outro lado a velocidade de rotação do motor cc vai diminuindo e os leds vão apagando.
O vídeo abaixo mostra este projeto em funcionamento, veja.
Esquemático de Ligações - Fritzzing
160
37 MOTOR CC NO ARDUINO COM CONTROLE DE VELOCIDADE E LEDS
MEDIDORES DE POTÊNCIA
POTÊNCIA.
•
•
•
•
•
•
•
•
•
uma protoboard;
fios jumper;
quatro pilhas pequenas e o suporte para as pilhas;
um motor cc de 6 volts;
três leds, um vermelho, um amarelo e um verde;
três resistores de 100 ohms;
um potenciômetro de 10K ohms;
um TIP120;
um diodo 1N4007.
O primeiro passo é conectar os componentes (potenciômetro, TIP120, diodo, leds e resistores)
na protoboard como na imagem abaixo.
Conecte os fios jumper entre os componentes da protoboard. Veja o esquema do projeto
acima para visualizar os detalhes de cada conexão entre os componentes.
Faça agora as conexões usando os fios jumper entre o arduino e a protoboard. Os pinos
utilizado no arduino foram:
•
•
•
pino analógico A0, foi conectado ao perna central do potenciômetro;
a pernas positivas dos leds foram conectadas aos pinos digitais 2, 3, e 4;
a primeira perna do transistor TIP120, a base, foi conectada ao pino digital 9.
161
Lista de Componentes utilizados:
162
E finalmente conecte o suporte das pilhas e o motor cc na protoboard, conforme o esquema
do projeto no início deste post. O arduino pode ser alimentado por uma bateria de 9 volts ou
pelo cabo USB conectado ao computador.
Agora vamos a melhor parte, que é programar o arduino. Usando o cabo USB conecte o
arduino ao seu computador execute a IDE do arduino, copie e cole o código fonte abaixo na
IDE, compile e faça o upload.
/*
Projeto Arduino controlando a velocidade de um motor cc
com mostrador de leds.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//pino analógico onde o potenciômetro está conectado.
int const potenciometro = 0;
//pino digital onde o TIP120 está conectado.
int const transistor = 9;
//pinos digitais
int const ledVerde = 2;
//led verde está conectado.
int const ledAmarelo = 3; //led amarelo está conectado.
int const ledVermelho = 4; //led vermelho está conectado.
//armazenará o valor lido no potenciômetro.
int valPotenciometro = 0;
//void setup é executada uma vez quando o arduino é ligado.
void setup() {
//definindo o pino digital 9 como de saída.
pinMode(transistor, OUTPUT);
//definindo pinos dos leds como de saída
pinMode(ledVerde, OUTPUT);
pinMode(ledAmarelo, OUTPUT);
pinMode(ledVermelho, OUTPUT);
}
//Função loop é executada repetidamente enquanto
//o arduino estiver ligado.
void loop() {
//lendo o valor do potenciômetro (0 até 1023) e
//dividindo por 4 para obter um valor entre 0 e 255
//que são valores adequados para a base do TIP120.
valPotenciometro = analogRead(potenciometro) / 4;
//atribuindo o valor lido no potenciômetro a
//base do TIP120.
analogWrite(transistor, valPotenciometro);
//acendendo e pagando leds conforme posição do
//potenciômetro
controlarLeds();
}
void controlarLeds() {
//Led verde - acendendo ou apagando conforme
//posição do potenciômetro.
if (valPotenciometro >= 40) {
digitalWrite(ledVerde,HIGH);
} else {
163
Código Fonte do Projeto
//Led amarelo - acendendo ou apagando conforme
//posição do potenciômetro.
if (valPotenciometro >= 125) {
digitalWrite(ledAmarelo,HIGH);
} else {
digitalWrite(ledAmarelo,LOW);
}
//Led vermelho - acendendo ou apagando conforme
//posição do potenciômetro.
if (valPotenciometro >= 210) {
digitalWrite(ledVermelho,HIGH);
} else {
digitalWrite(ledVermelho,LOW);
}
}
164
digitalWrite(ledVerde,LOW);
}
ARDUINO
Controlar um servomotor com um potenciômetro giratório através do arduino. Ao girar o
potenciômetro o braço do servomotor responderá fazendo um movimento proporcional a
velocidade e ao sentido do giro do potenciômetro. O arduino usado neste projeto foi um
arduino uno r3, mas qualquer outra versão poderia ser utilizada. O servomotores são
componentes muito importantes no mundo da robótica, da mecatrônica, e muito usado
também no mundo dos hobbys. Na robótica os servomotores são responsáveis por
movimentar braços, pernas e mãos de robôs. No automodelismo os servomotores são usado
para virar as rodinhas dianteiras dos carrinhos, para esquerda e direita. No aeromodelismo são
usados para controlar os flaps das asas dos aviões. Os servomotores são componentes chave
em muitos projetos, por isso neste post vamos ensinar o conceito básico de controle de um
servomotor, usando um arduino. E ao final deste post veja o vídeo deste projeto em
funcionamento.
Segue abaixo o esquema do projeto, que detalha todas as ligações entre os componentes, a
protoboard e o arduino.
Lista de Componentes utilizados:
•
•
•
•
•
um Arduino;
uma protoboard;
fios jumper;
um potenciômetro de 10K ohms;
um servomotor.
165
38 CONTROLANDO UM SERVOMOTOR
SERVOMOTOR COM POTENCIÔMETRO
POTENCIÔMETRO NO
Começe conectando o potenciômetro na protoboard e depois conecte os fios jumper entre os
componentes da protoboard, o servomotor e o arduino. Para fazer estas conexões
corretamente veja o esquema do projeto, feito em Fritzing, no inicio deste post.
Esquemático de Ligações
Agora vamos programar o arduino para que ele se comporte como desejamos. Então conecte
o arduino ao seu computador com o cabo USB, abra a IDE do arduino e programe o arduino.
Código Fonte do Projeto
/*
Projeto Arduino controlando um servomotor com potenciômetro
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//incluindo biblioteca para controle do servomotor
#include "Servo.h"
//Criando um objeto da classe Servo
Servo servoMotorObj;
//pino analógico onde o potenciômetro está conectado
int const potenciometroPin = 0;
//pino digital associado ao controle do servomotor
int const servoMotorPin
= 3;
166
O servomotor usado neste projeto foi um TG9e da Turnigy, um micro servo que possui um
ótimo custo benefício.
void setup() {
//associando o pino digital ao objeto da classe Servo
servoMotorObj.attach(servoMotorPin);
}
void loop()
{
//lendo o valor do potenciômetro (intervalo entre 0 e 1023)
valPotenciometro = analogRead(potenciometroPin);
//mapeando o valor para a escala do servo (entre 0 e 180)
valPotenciometro = map(valPotenciometro, 0, 1023, 0, 180);
//definindo o valor/posição do servomotor
servoMotorObj.write(valPotenciometro);
delay(15);
}
Após introduzir o código fonte na IDE do arduino, compile-o e depois faça o upload, aguarde
alguns instantes para que a transferência do programa seja realizada, e pronto, você já pode
controlar servomotor através do potenciômetro. Vire o potenciômetro para um lado e veja
que o braço do servomotor vai se mover.
Então é isso pessoal, este projeto trata do princípio básico para o uso de servomotores, que
você poderá aplicar em diversos outros projeto que se movimentam. E logo mais estará
disponível aqui no site ComoFazerAsCoisas.com.br um guincho robótico que usa 3
servomotores e que aplica este princípio.
167
//variável usada para armazenar o valor lido no potenciômetro
int valPotenciometro;
Uma das diferenças de um robô para um aparelho eletrônico comum é que o robô se
movimenta para realizar tarefas. Para se movimentar um robô usa motores de diversos tipos,
como motores de passo, motores de corrente contínua e servomotores. E no projeto arduino
com servomotor robótico e display lcd faremos um servomotor se movimentar e também
trataremos este movimentos exibindo as direções do braço do servomotor no display lcd.
Como um dos nossos objetivo com os projetos em arduino, aqui do site ComoFazerAsCoisas, é
chegar a construção de robôs de diversos tipos, estamos apresentando os princípios básicos,
que quando unidos permitirão a construção de um robô completo.
O projeto arduino com servomotor e display lcd, permite que você controle os movimentos de
um servomotor através de um potenciômetro giratório. Quando você gira o potenciômetro
para um lado ou para o outro o braço do servomotor acompanha estes movimentos e ainda é
mostrado no display lcd em tempo real em que direção o braço do servomotor está, no final
deste post tem o vídeo que mostra este projeto em funcionamento.
Aplicando o princípio deste projeto você poderia por exemplo construir, por exemplo, um
guincho robótico, ou um braço robótico.
Lista de Componentes utilizados:
•
•
•
•
•
uma protoboard;
um servomotor;
um display lcd do tipo JHD162A, de 16 colunas por 2 linhas;
3 potenciômetros de 10 K ohms;
fios jumper.
O servomotor que usamos neste projeto é um microservo TG9E da Turnigy, que é um dos
melhores custo/benefício do mercado. Ele é um servo bem pequeno e leve, tem um preço
camarada, quando comparado a outros servos, e pode ser usado em muitos projetos de
robótica. Este microservo também é muito usado em aeromodelos e carrinhos controle
remoto. Nos potenciômetros desse projeto usei knobs para facilitar na hora de girá-los.
168
39 SERVOMOTOR ROBÓTICO E DISPLAY LC
169
Então vamos começar! Segue abaixo o esquema do projeto, que servirá de base para a ligação
entre todos os componentes e o arduino, e será nossa referência durante o desenvolvimento
do projeto físico.
Esquemático de Ligações - Fritzzing
Segue abaixo o datasheet, detalhando a funcionalidade de cada pino, do display LCD JHD 162A
que foi usado neste projeto.
170
Segue abaixo o detalhamento de como ligar o display LCD ao arduino.
•
•
•
•
•
•
•
•
•
•
•
•
pino 1 do LCD ligado ao GND do arduino;
pino 2 do LCD ligado ao 5V do arduino;
pino 3 do LCD ligado ao pino central do primeiro potênciômetro (controle de
contraste);
pino 4 do LCD ligado ao pino digital 9 do arduino;
pino 5 do LCD ligado ao GND do arduino;
pino 6 do LCD ligado ao pino digital 8 do arduino;
pino 11 do LCD ligado ao pino digital 5 do arduino;
pino 12 do LCD ligado ao pino digital 4 do arduino;
pino 13 do LCD ligado ao pino digital 3 do arduino;
pino 14 do LCD ligado ao pino digital 2 do arduino;
pino 15 do LCD ligado ao pino central do segundo potênciômetro (controle do brilho);
pino 16 do LCD ligado ao GND do arduino.
•
•
•
•
pino central do potenciômetro de controle do servomotor no pino analógico A0 do
arduino;
fio positivo do servomotor no 5V do arduino;
fio negativo do servomotor no GND do arduino;
fio de controle do servomotor no pino digital 12 do arduino.
Lembrando que você poderá verificar o esquema de montagem do projeto no início deste
post, que mostra com detalhes como foram feitas as ligações entre os componentes.
Bem, então depois de fazer todas as ligações entre os componentes, concluindo o projeto
físico, chegou a hora de programar o arduino para que ele faça o controle do servomotor e
também informe a posição do mesmo no display ldc. Então conecte o seu arduino ao
computador, usando o cabo usb, e execute a IDE do arduino. Segue abaixo o código fonte
completo e comentado deste projeto.
171
Segue abaixo o detalhamento da ligação do servomotor e do potenciômetro que irá controlar
o servomotor.
172
Código Fonte do Projeto
/*
Projeto Arduino - servomotor com display lcd.
Por Jota
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
#include "LiquidCrystal.h" //biblioteca para controle de telas LDCs
#include "Servo.h"
//biblioteca para controle de
servomotores
//Criando um objeto da classe LiquidCrystal e
//inicializando com os pinos da interface.
LiquidCrystal lcd(9, 8, 5, 4, 3, 2);
Servo servoMotorObj; //Criando um objeto da classe Servo
//pino analógico onde o potenciômetro está conectado
int const potenciometroPin = 0;
//pino digital associado ao controle do servomotor
int const servoMotorPin = 12;
//usada para armazenar o valor lido no potenciômetro
int valPotenciometro;
void setup() {
//Inicializando o LCD e informando o tamanho de 16 colunas e 2
linhas
//que é o tamanho do LCD JHD 162A usado neste projeto.
lcd.begin(16, 2);
//associando o pino digital ao objeto da classe Servo
servoMotorObj.attach(servoMotorPin);
}
void loop() {
//lendo o valor do
valPotenciometro =
//mapeando o valor
180)
valPotenciometro =
potenciômetro (intervalo entre 0 e 1023)
analogRead(potenciometroPin);
do potenciômetro para a escala do servo (0 e
map(valPotenciometro, 0, 1023, 0, 180);
//definindo o valor/posição do servomotor
servoMotorObj.write(valPotenciometro);
lcd.clear(); //limpa o display do LCD.
lcd.print("Servomotor"); //imprime a string no display do LCD.
lcd.setCursor(0,1); //posiciona o cursor na coluna 0 linha 1 do
LCD.
//Mostrando no lcd a posição do braço do servomotor
if (valPotenciometro < 90) {
lcd.print("Lado direito");
}
if (valPotenciometro == 90) {
lcd.print("Centro");
}
delay(30);
}
173
if (valPotenciometro > 90) {
lcd.print("Lado esquerdo");
}
Se você já pensou em construir um robô, um game, ou um braço robótico usando o arduino
sabemos que um joystick é um componente fundamental, então nesse post vou mostrar como
ligar um joystick em um arduino e ler as posições X, Y e Z do joystick. Tendo o controle sobre as
posições X, Y e Z de um joystick você estará habilitado a controlar diversos outros dispositivos
também ligados ao Arduino, como por exemplo servomotores que controlam e movimentam
um braço robótico. Então vamos lá!
Lista de Componentes utilizados:
•
•
•
uma protoboard;
o joystick;
e fios.
Esse tipo de joystick você encontra fácil em lojas de eletrônica e robótica na internet, inclusive
você pode comprar mais barato direto da china. Nesse projeto eu usei o da direita na imagem
abaixo, mas também poderia usar o da esquerda, a ligação seria a mesma, a diferença entre os
dois é o tamanho e que o joystick da esquerda tem os terminais dentro de um invólucro
plástico.
174
40 JOYSTICK NO ARDUINO E LER AS POSIÇÕES
POSIÇÕES X, Y E Z
175
O esquema de ligação do joystick no Arduino segue abaixo, mas vou transcrevê-lo para facilitar
o entendimento. Nosso joystick tem 9 pinos, da esquerda para a direita temos:
•
•
•
•
•
•
•
•
•
S-Y: pino do eixo Y, ligado ao pino analógico A1 do Arduino através do fio amarelo.
VCC: ligado ao 5v do Arduino através do fio vermelho.
GND: ligado ao GND do Arduino através do fio preto.
S-X: pino do eixo X, ligado ao pino analógico A0 do arduino através do fio azul.
VCC: ligado ao 5v do Arduino através do fio vermelho.
GND: ligado ao GND do Arduino através do fio preto.
S-K: pino do eixo Z, ligado ao pino digital 2 do Arduino através do fio verde.
VCC: ligado ao 5v do Arduino através do fio vermelho.
GND: ligado ao GND do Arduino através do fio preto.
176
Esquemático de Ligações - Fritzzing
/*
Projeto Arduino - Como ligar um joystick no Arduino
-----------------------------------------=<| www.ComoFazerAsCoisas.com.br |>=----------------------------------------*/
//Variável que armazena a posição lida
//nos eixos do joystick
int joystick = 0;
//Atribuindo o pino analógico A0 a variável eixoX
int eixoX = A0;
//Atribuindo o pino analógico A1 a variável eixoY
int eixoY = A1;
//Atribuindo o pino digital 2 a variável eixoZ
int eixoZ = 2;
void setup() {
//Definindo eixoZ como um pino de entrada
pinMode(eixoZ, INPUT);
//Ativando o Serial Monitor que exibirá os
//valores lidos no Joystick
Serial.begin(9600);
}
void loop() {
//Lê o valor do eixoX
joystick = analogRead(eixoX);
//imprime o valor do eixoX
Serial.print(" X=");
Serial.print(joystick);
//Lê o valor do eixoY
joystick = analogRead(eixoY);
//imprime o valor do eixoY
Serial.print("
Y=");
Serial.print(joystick);
//Lê o valor do eixoZ
joystick = digitalRead(eixoZ);
//imprime o valor do eixoZ
Serial.print("
Z=");
Serial.println(joystick);
//espera 200 milisegundos.
//Se vc quiser aumentar a velocidade
//de leitura dos valores do joystick
//diminua o tempo de espera. Ex: delay(100);
delay(200);
}
177
Código Fonte do Projeto
Vamos aprender a montar uma placa controladora para ser usada em conjunto com o Arduino,
com a placa será possivel ativar o relé através de um comando realizado via programação,
podendo realizar a automação a distância de um equipamento, luz, etc.
A placa de relé pode ser comprada pronta, mas com um custo muito baixo será possível
montarmos nossa própria placa.
Lista de Componentes utilizados:
•
•
•
•
•
•
•
•
•
•
1 - Transistor BC548
2 - Resistores 1K 1/8W (marrom-preto-vermelho)
1 - Diodo 1N4004
1 - LED comum (Pode ser usado 3mm ou 5mm) de qualquer cor
2 - Conectores 2 entradas
1 - Conectores 3 entradas
1 - Relé 12V 15A 1 polo 2 posições
1 - Porta fusivel para placa
1 - Fusível.
1 - Placa de circuito impresso 5cm x 10cm
178
41 CONSTRUINDO UM RELÉ SHIELD
O circuito é muito simples, será usado um transistor NPN BC548 polarizado como chave, de
forma a conduzir a corrente entre o emissor e o coletor quando receber o sinal digital do
Arduino. Quando o sinal é recebido, o transistor é saturado, fechando um circuito e acionando
o relé e ligando o led. Para proteção do circuito será usado um fusível no terminal comum do
relé.
179
Entendendo o diagrama:
Placa de circuito impresso com identificação dos componentes:
Placa de circuito impresso face cobreada:
Circuito impresso em uma folha de sulfite:
180
Vamos a construção:
E pronto, nosso primeiro shield já pode ser utilizado:
Conectar a placa Rele SHield e codificar um programa que detecte a luz do ambiente para
acender ou apagar uma luz
Lista de Componentes:
•
•
•
•
•
.
Cabo USB de Programação
ReleShield
LDR
1 Resitor de 10K 1/8W (marrom-preto-laranja)
Fonte 12V
181
Pinagem do transistor BC548:
Entendendo o circuito:
O LDR é um tipo de resistor cuja resistência varia de acordo com a intensidade de
luminosidade, no circuito acima, ele é ligado de forma que a variação da resistência altere a
tensão na entrada A0.
O conversor (A/D) do Arduino tem entrada máxima de 5V. com uma resolução de 10 bits em
valores digitais de 0 a 1023, ele diferencia valores entre 0V e 5V. quando o sinal da entrada
estiver em 5V ele converte para 1023.
Codificando o programa:
A estrutura de um programa do Arduino, também conhecido como Sketch é divido em duas
funções básicas: void setup() e void loop().
A função void setup() é executada quando o Arduino é inicializado, ela deve ser usada para
inicialização de variáveis e configurações que devem ser realizadas no início da execução.
A função void loop() é executada continuamente após a execução da função setup(), e nela
que escrevemos o código do programa.
182
Conectando o ReleShield ao Arduino:
183
184
No começo do programa declaramos três constantes de definição do nosso programa
O método loop é executando continuamente, efetuando a leitura do sinal analógico,
comparando com a constante para acionar ou desligar o ReleShield.
ATENÇÃO – A ilustração abaixo é só para estudo.
A primeira constante define qual pino digital será usado para acionarmos o
ReleShield, se quiser usar outro pino, atribua a constante o valor do pino
desejado
const int shieldRelePin = 13;
A segunda constante define qual pino analógico será usado para leitura do
sinal análogico produzido pelo circuito do LDR
const int sensorLDRPin = A0;
A terceira constante define qual será o valor para disparo do circuito, se
o valor lido for menor que a constante, o ReleShield será acionado.
const int constanteAjuste = 400;
Método de inicialização do Arduino
void setup() {
Método que define que o estado inicial do pino de saida é baixo, para
não acionar o ReleShield
pinMode(shieldRelePin, LOW);
Configuração da comunicação serial do Arduino, ela será usada para envio
do sinal lido para ajuste do programa.
Serial.begin(9600);
}
Método que executa continuamente após execução do método void setup()
void loop() {
variável para armazenar o valor lido da entrada analógica
int leituraSensorLDR = 0;
atribuição na variável do valor lido da entrada analógica
leituraSensorLDR = analogRead(sensorLDRPin);
Se o valor lido for maior ou igual a constante de Ajuste
if (leituraSensorLDR >= constanteAjuste) {
A saída digital enviará sinal baixo para o ReleShield (Desligar
ReleShiel)
digitalWrite(shieldRelePin, LOW);
}
else
{
Senão a saída digital enviará sinal alto para o ReleShield (Ligar
ReleShiled)
digitalWrite(shieldRelePin, HIGH);
}
O Sinal lido é enviado pela porta serial
Serial.println(leituraSensorLDR);
Tempo de espera de 50 milisegundos para transmissão dos dados pela serial
delay(50);
}
185
Análise do programa
CLP Shield, com ele é possível monitorar entradas e acionar saídas de acordo com a lógica
programada, a placa desenvolvida permite conectar diretamente o Arduino Uno, facilitando a
montagem, troca de componentes e conexões.
O projeto foi desenvolvido para uso do Arduino UNO, portando sua quantidade de IOs é
limitada, o uso em conjunto com outro shield como relógio, ethernet, lcd implicará no
funcionamento do circuito e deverá ser adaptado.
186
42 CLP SHIELD PARA ARDUINO
187
Vamos entender o que é uma CLP
O CLP foi idealizado pela necessidade de poder se alterar uma linha de montagem sem que
tenha de fazer grandes modificações mecânicas e elétricas.
O CLP nasceu praticamente dentro da industria automobilística, especificamente na Hydronic
Division da General Motors, em 1968, sob o comando do engenheiro Richard Morley e
seguindo uma especificação que refletia as necessidades de muitas indústrias manufatureiras.
A idéia inicial do CLP foi de um equipamento com seguintes características resumidas:
1. Facilidade de programação;
2. Facilidade de manutenção com conceito plug-in;
3. Alta confiabilidade;
4. Dimensões menores que painéis de Relês, para redução de custos;
Podemos didaticamente dividir os CLP's historicamente de acordo com o sistema de
programação por ele utilizado:
1ª Geração: Os CLP's de primeira geração se caracterizam pela programação intimamente
ligada ao hardware do equipamento. A linguagem utilizada era o Assembly que variava de
acordo com o processador utilizado no projeto do CLP, ou seja, para poder programar era
necessário conhecer a eletrônica do projeto do CLP. Assim a tarefa de programação era
desenvolvida por uma equipe técnica altamente qualificada, gravando-se o programa em
memória EPROM, sendo realizada normalmente no laboratório junto com a construção do
CLP.
2ª Geração: Aparecem as primeiras “Linguagens de Programação” não tão dependentes do
hardware do equipamento, possíveis pela inclusão de um “Programa Monitor “ no CLP, o qual
converte (no jargão técnico, “compila”), as instruções do programa, verifica o estado das
entradas, compara com as instruções do programa do usuário e altera o estados das saídas. Os
Terminais de Programação (ou maletas, como eram conhecidas) eram na verdade
Programadores de Memória EPROM. As memórias depois de programadas eram colocadas no
CLP para que o programa do usuário fosse executado.
3ª Geração: Os CLP's passam a ter uma Entrada de Programação, onde um Teclado ou
Programador Portátil é conectado, podendo alterar, apagar, gravar o programa do usuário,
além de realizar testes (Debug) no equipamento e no programa. A estrutura física também
sofre alterações sendo a tendência para os Sistemas Modulares com Bastidores ou Racks.
4ª Geração: Com a popularização e a diminuição dos preços dos microcomputadores
(normalmente clones do IBM PC), os CLP's passaram a incluir uma entrada para a comunicação
serial. Com o auxílio dos microcomputadores a tarefa de programação passou a ser realizada
nestes. As vantagens eram a utilização de várias representações das linguagens, possibilidade
de simulações e testes, treinamento e ajuda por parte do software de programação,
possibilidade de armazenamento de vários programas no micro, etc.
5ª Geração: Atualmente existe uma preocupação em padronizar protocolos de comunicação
para os CLP's, de modo a proporcionar que o equipamento de um fabricante “converse” com o
equipamento outro fabricante, não só CLP's, como Controladores de Processos, Sistemas
Supervisórios, Redes Internas de Comunicação e etc., proporcionando uma integração a fim de
facilitar a automação, gerenciamento e desenvolvimento de plantas industriais mais flexíveis e
normalizadas, fruto da chamada Globalização. Existem Fundações Mundiais para o
estabelecimento de normas e protocolos de comunicação. A grande dificuldade tem sido uma
padronização por parte dos fabricantes.
188
5. Envio de dados para processamento centralizado;
6. Preço competitivo;
7. Expansão em módulos;
8. Mínimo de 4000 palavras na memória.
Fontes utilizadas para pesquisa:
http://www.ejm.com.br/download/Introducao%20CLP.pdf
http://pt.wikipedia.org/wiki/Controlador_l%C3%B3gico_program%C3%A1vel
Principais recursos:
5 Entradas digitais optoacopladas.
6 Entradas analógicas.
8 Saídas por Relé.
1 Conexão serial .
1 Saída regulada 5V x 1A.
189
Fluxo de funcionamento:
1- Arduino Uno.
5 - Fotoacopladores TIL111 com soquete.
1 - ULN2803 com soquete.
19 - Resistores 1K 1/8W (marrom preto vermelho).
6 - Resistrores 10K 1/8W (marrom preto laranja).
1- Placa de fenolite cobreada face simples 15cm x 15cm.
9 - Leds 5mm (8 para monitoramento das saídas e 1 para indicação de alimentação do circuito.
1- Regulador de tensão LM7809 com dissipador.
1- Regulador de tensão LM7805 com dissipador.
8 - Relés 12V 15A 1 polo 2 posições.
1 - Barra de pinos macho, serão usado 28 pinos.
9 - Bornes de encaixe TC 3 Vias para saída dos relés.
10 - Bornes de encaixe TC 2 Vias para entradas digitais, analógicas e alimentação.
4 - Espaçador de placa ECI-9,4 (opcional).
1 - Fonte de alimentação 12V 1A.
Placa de circuito impresso
190
Lista de Componentes utilizados:
Componentes e conexões:
191
Dependendo da marca do relé, sua largura pode ter uma mínima variação e ficará apertado na
placa, verifique e se necessário, afaste nas placas os relés. Antes da corrosão da placa sugiro
verificar se o tamanho e largura do pinos dos bornes comprados estão alinhados com as ilhas
da placa, se necessário ajustem o alinhamento.
A placa é alimentada por uma fonte de 12V, usa reguladores de tensão para alimentação do
Arduino e para acionamento das entradas analógicas e digitais, No post construindo-um-releshield usamos um transistor para acionamento do relé, como na CLP Shield acionaremos 8
relés, vamos usar um circuito integrado para simplificar nossa montagem, mas nada impediria
de usarmos os transistores. Usaremos optoacopladorers para isolarmos as entradas digitais do
arduino e leds para monitoramento do acionamento das saídas.
Vamos conhecer os principais componentes do circuito.
LM7809
Regulador de tensão com entrada variável.
Saída constante de 9V
Máxima corrente na saída de 1A.
Encapsulamento com dissipador de calor (modelo TO-220).
Funciona de -40 a 125 graus.
Usado no circuito para alimentação do arduino.
1- Alimentação de entrada
2- GND
3- Saída 9V
LM7805
Regulador de tensão com entrada variável.
Saída constante de 5V
Máxima corrente na saída de 1A.
Encapsulamento com dissipador de calor (modelo TO-220).
192
Como funciona:
Usado no circuito para acionamento das entradas analógicas e digitais.
1- Alimentação de entrada
2- GND
3- Saída 5V
ULN7809
O CI ULN2803 tem 8 entradas que podem controlar até 8 saídas, trabalha com correntes
máximas de 500mA e tensão de até 50v. Internamente cada driver é composto por um
transistor Darlington polarizados com resistores e diodos de proteção.
Usado no circuito para acionar os relés.
193
Funciona de -40 a 125 graus.
194
FotoAcoplador TIL111
OptoAcopladores proporcionam a isolação de sinais em uma grande variedade de aplicações.
Eles comutam ou transmitem sinais e informações ao mesmo tempo que isolam diferentes
partes de um circuito.
Para testar a placa vamos usar uma fonte de 12V, um giga de testes de chaves liga desliga e um
shield de LDR, detalhes da ligação do LDR foram apresentados no post testando-nosso-releshield.
Código Fonte do Projeto
/*
Sergio de Miranda e Castro Mokshin
01/02/2013
Todos os direitos reservados
*/
int EntradaDigital1 = 12;
195
Testando a placa
EntradaDigital2
EntradaDigital3
EntradaDigital4
EntradaDigital5
int
int
int
int
int
int
int
int
Saida1
Saida2
Saida3
Saida4
Saida5
Saida6
Saida7
Saida8
=
=
=
=
=
=
=
=
=
=
=
=
11;
10;
9;
8;
196
int
int
int
int
0;
1;
2;
3;
4;
5;
6;
7;
int sensorLDRPin = A0;
int constanteAjuste = 400;
void setup() {
pinMode(EntradaDigital1,
pinMode(EntradaDigital2,
pinMode(EntradaDigital3,
pinMode(EntradaDigital4,
pinMode(EntradaDigital5,
pinMode(Saida1,
pinMode(Saida2,
pinMode(Saida3,
pinMode(Saida4,
pinMode(Saida5,
pinMode(Saida6,
pinMode(Saida7,
pinMode(Saida8,
INPUT);
INPUT);
INPUT);
INPUT);
INPUT);
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
OUTPUT);
digitalWrite(Saida1,
digitalWrite(Saida2,
digitalWrite(Saida3,
digitalWrite(Saida4,
digitalWrite(Saida5,
digitalWrite(Saida6,
digitalWrite(Saida7,
digitalWrite(Saida8,
LOW);
LOW);
LOW);
LOW);
LOW);
LOW);
LOW);
LOW);
}
void loop() {
digitalWrite(Saida1,
digitalWrite(Saida2,
digitalWrite(Saida3,
digitalWrite(Saida4,
digitalWrite(Saida5,
digitalRead(EntradaDigital1));
digitalRead(EntradaDigital2));
digitalRead(EntradaDigital3));
digitalRead(EntradaDigital4));
digitalRead(EntradaDigital5));
int leituraSensorLDR = 0;
leituraSensorLDR = analogRead(sensorLDRPin);
if (leituraSensorLDR >= constanteAjuste) {
digitalWrite(Saida6, LOW);
digitalWrite(Saida7, HIGH);
digitalWrite(Saida8, LOW);
}
else
{
}
}
197
digitalWrite(Saida6, HIGH);
digitalWrite(Saida7, LOW);
digitalWrite(Saida8, HIGH);
Com o Arduino ISP Shield você pode até mesmo gravar o bootloader (uma espécie de BIOS
para os chips Atmega) em um chip ATMEGA com um Arduino. Ideal para pessoas que querem
programar o ATmega328P e transformá-los em chips de bootloader Arduino usando um
esboço AVR-ISP, mas também pode ser usado como programador AVR ISP ‘standalone‘ - de
modo que você possa programar chips virgens, sem um computador! Com esse shield, você
pode simplificar o processo de gravação de vários chips, principalmente pela substituição do
chip devido ao soquete zero in force incluso no projeto.
Lista de Componentes utilizados:
Referencia
Componentes
10k<>120
Header fêmea genérico – 3 pinos
Arduino1
Arduino
ATMEGA328
atmega168 ou 328
C1
Capacitor cerâmico
C2
Capacitor cerâmico
C3
Capacitor cerâmico
C4
Capacitor cerâmico
C4<>dir.
Header fêmea genérico – 3 pinos
C5
Capacitor cerâmico
C6
Capacitor cerâmico
ERR
LED vermelho – 3mm
198
43 ARDUINO ISP SHIELD
Header fêmea genérico – 6 pinos
GND
Header fêmea genérico – 1 pino
HB
LED verde – 3mm
J1
Header fêmea genérico – 14 pinos
J2
Header fêmea genérico – 14 pinos
J5
Header fêmea genérico – 2 pinos
MISO
Header fêmea genérico – 1 pino
MOSI
Header fêmea genérico – 1 pino
PRG
LED amarelo – 3mm
PWR
LED azul – 3mm
R1
120 Ω Resistor
R2
10k Ω Resistor
R3
1k Ω Resistor
R4
1k Ω Resistor
R5
1k Ω Resistor
R6
1k Ω Resistor
RESET
Pushbutton
RESET
Header fêmea genérico – 1 pino
SCK
Header fêmea genérico – 1 pino
Vcc
Header fêmea genérico – 1 pino
XTAL1
Crystal
199
FTDI
Esquemático Elétrico:
200
Esquemático de Ligações - Fritzzing
201
PCB:
Faça o download do projeto no formato Fritzing aqui.
Fonte: fritzing.org
http://www.oarduino.com/downloads/arquivos/isp_shield.rar
Uma Protoboard, ou Breadboard em inglês, é uma placa de ensaio ou matriz de contato, com
furos e conexões condutoras para montagem de circuitos elétricos experimentais. A grande
vantagem da placa de ensaio na montagem de circuitos eletrônicos é a facilidade de inserção de
componentes, uma vez que não necessita soldagem. As placas variam de 800 furos até 6000
furos, tendo conexões verticais e horizontais.
Na superfície de uma matriz de contato há uma base de plástico em que existem centenas de
orifícios onde são encaixados os componentes. Em sua parte inferior são instalados contatos
metálicos que interligam eletricamente os componentes inseridos na placa. Geralmente
suportam correntes entre 1 A e 3 A.
Os contatos metálicos estão em diferentes sentidos na matriz. Como você pode observar na
figura, a placa de montagem possui a matriz principal em seu meio e duas linhas superiores e
duas inferiores em cada matriz (algumas possuem apenas uma linha). Nestes últimos, os
contatos estão na horizontal, enquanto na matriz principal eles estão na vertical. Vamos nos
aprofundar mais no estudo de sua composição e utilização prática.
As protoboards são uma ferramenta fundamental no âmbito da eletrônica. Basicamente, é uma
caixa de plástico com orifícios conectados entre si, que permitem criar um circuito sem
necessidade de soldar os componentes. São excelentes para desenhar e testar circuitos antes
de fabricar uma placa de circuito impresso permanente (PCB).
202
44 PROTOBOARD - HOW TO USE
203
Para que um circuito funcione sobre una protoboard, você somente deve inserir seus
componentes nos pequenos orificios de contacto e uni-los com cabos (pontes ou jumpers). O
melhor de todo o processo é que as protoboards são reutilizáveis. Como os componentes não
estão soldados pode-se alterar o desenho do circuito em projeto de acordo com a necessidade.
Com uma protoboard, pode-se elaborar prototipos de todo tipo de dispositivos, desde circuitos
simples até circuitos tão complexos como um computador, vide os projetos open source Arduino
Standalone ou o Raspberry PI. *Atenção: as protoboards não estão preparadas para conexões
de alta intensidade ou circuitos de alto voltagem.
204
O nome original de breadboard vem do uso que os aficcionados em rádios faziam de tábuas de
(board en inglés) de cortar pão (bread en inglés) para construir prototipos de rádio. Este costume
também era muito utilizado pela resistência na europa durante a segunda guerra mundial, uma
vez que poderiam transportar discretamente componeetes eletrônicos soltos e qualquer técnico
montaria um receptor de rádio usando uma simples tábua de cortar pão. No Brasil, com o boom
da eletrônica de 1970 e a consolidação da Rua Santa Ifigênia no Centro de São Paulo como
fornecedora de produtos eletrônicos incentivaram a criação de um universo não só de técnicos
em eletrônica mas também pessoas que adotaram a eletrônica como hooby. Os técnicos e
projetistas adotaram a breadborad no desenvolvimento de novos projetos visando a reduçao
de custos, antes era necessaário depurar um projeto fabricando várias placas de circuito
impresso e soldando pontes com fios, com a breadboard isso se tornou mais fácil. Aqui no Brasil
chamamos a breadboard de protoboard (project + board).
Existem diversos tipos de protoboards. Umas são grandes, outras pequenas, algunas dispõe de
terminais para alimentação externa, outras incorporam diretamente em seu interior uma fonte
de alimentação, etc... porém todas elas compartilham de uma estrutura muito similar.
Normalmente as protoboards estão marcadas com números e letras para facilitar o máximo a
colocação de cada componente. Estas características não são absolutamente necessárias, mas
muito úteis para utilização com circuitos mais complexos.
205
A protoboard que utilizamos hoje foi inventada em 1971 por Ronald J. Portugal da EI
Instruments.
206
A distância entre os orifícios de uma protoboard de circuitos é de habitualmente de 2,54 mm
(0.1”). (0.1” = 0.1 polegadas). Também chamada de passo (Pitch en inglês).
Alguns modelos incorporan plug´s de encaixe em suas laterais que permitem unir várias
protoboards para formar una superficie de prototipagem única, maior, de acordo com a
necessidade do projeto.
207
Algunas placas possuem uma lamina adesiva em sua parte traseira que permite fixa-las em uma
grande gama de superfícies, de acordo com a necessidade. Isto pode ser realmente útil quando
quieser fixar a protoboard no interior de uma caixa para estudo ou para fixa-la junto a outro
modelo de projeto como o Arduino Standalone ou o Raspberry PI.
No interior de uma protoboard encontramos varias peças de metal condutivo (cobre, estanho,
níquel) que conectam os orifícios exteriores da protoboard entre sí de uma forma prédeterminada (na horizontal e na vertical).
208
Estas peças metálicas no interior da protoboard, estão desenhadas em forma de pinça para
que mantennham os elementos conectados em seu interior.
Uma protoboard típica é formada por 4 seções: 2 seções externas (Buses) e 2 seções internas
(Pistas). Também tem um canal central que divide a protoboard pela metade e impide que a
eletricidade flua entre ambas a metades.
209
As seções externas ou buses são utilizadas para fornecer alimentação ao circuito. São formadas
por duas colunas, uma para voltagem (+) e outra para a conexão do terra (-). A coluna para
voltagem são indicadas por uma linha vermelha e a coluna para terra com uma línha negra ou
azul. Quando se constrói um circuito existe a necessidade de alimentação em diversos pontos,
os buses oferecem muitas opções de alimentação para o circuito em teste em diversos pontos
da placa de prototipagem.
Normalmente, todos os orificios de uma coluna do bus estão conectados entre sí, mas
podemos encontrar placas de prototipagem em que estas colunas estão divididas para
poderem oferecer outras voltagens diferentes (3,3V e 5V). Nesses casos, se queremos uma
voltagem única, será necessário conectar um ou vários cabos de ponte (jumpers em inglês)
para poder alimentar toda a coluna. Sempre é uma boa idéia ter um multímetro para
comprovar a ausencia o presença de corrente eléctrica.
Dois CI´s DIP, um LM358 (acima), muito comum op-amp,
e o ultra popular ATMega328 microcontrolador (abaixo).
(Imagen: Sparkfun)
O habitual nas seções internas é que haja pistas de 5 agrupamentos de cada lado do canal central
aonde os orifícios de cada pista estão interconectados eléctricamente entre sí. Os 5 orifícios do
lado esquerdo do canal central podem estar marcados por colunas com as letras A, B, C, D e E,
e os outros 5 do lado direito marcados com as letras F, G, H, I e J.
Uma protoboard de tamanho standart pode ter entre 56 e 65 filas de pistas. O tamanho de
uma protoboard se define por um número de pontos que somam os orifícios de todos os buses
e pistas.
Para conectar entre si os componentes que são afixados sobre uma protoboard, é necessário
usar cabos de ponte (jumpers em inglês).
210
As seções internas ou pistas são a superfície da protoboard onde se conectam a maioría dos
componentes do circuito em estudo. Esta seção esta dividida em duas partes por um canal
central que separa eletricamente ambos os lados e foi idealizado para poder inserir chip´sen
formato DIP (Dual In-line Package).
211
Conjunto de jumpers para protoboard.
(Imagem: Multilogica-Shop)
No caso de você querer fazer seus próprios cabos de conexão, o tipo de cabo mais adequado
para usar com uma protoboard padrão, é o cabo rígido de 22AWG. (22AWG = 0,325 mm2).
*Atenção: Se for utilizado uma cabo mais grosso, poderá deformar permanentemente as
pinças do interior da protoboard e inutilizar os contatos internos, fazendo com os mesmos
deixem de serem confiáveis.
212
Quando utilizamos um rolo de cabo para conectar nosso circuito é necessário cortar o cabo e
desencapar a ponta da haste. Para realizar esta tarefa com facilidade, podemos utilisar um
alicate de corte que nos permite realizar ambas as operações. (Usar um descascador de fios
também pode ser muito útil para iniciantes, pois fará o desncape do fio na medida desejada).
Uma vez cortado o cabo na medida correta, deve-se desencapar ambas as extremidades.
Cuidado para não desencapar demais, o ideal é algo en torno de 7mm. Um cabo demasiado
desemcapado pode provocar um curto-circuito no projeto, ou realizar o contato indesejado
entre um componenete isolado do projeto e seu vizinho próximo, inviabilizando o circuito como
um todo.
213
Em ciruitos muito grandes, fazer os cabos de conexão um a um pode ser muito improdutivo,
perdendo demasisado tempo, no mercado existem kits de cabos pré-cortados de tamanhos
variados e com terminais rígidos, que facilitam muito a tarefa. Também é muito aconselhável
usar cabos com cores distintas para diferenciar cada conexão no protótipo.
Agora que a estrutura da placa de circuito nos é familiar, vamos fazer um circuito de teste sobre
uma protoboard. Vamos montar um simples circuito que acende um LED, diodo emissor de luz.
Para poder completar este circuito vamos necessitar de uma bateria de 9V, um cabo adaptador
para bateria de 9V com as pontas desencapadas, um LED de 5mm, uma resistência de 300 ohms
e um cabo de ponte.
Temos que alimentar o circuito para energizar a protoboard, usaremos as pontas
desencapadas do terminal de conexão da bateria, conectanto ambas as pontas na protoboard.
Os cabos devem ser conectados nas colunas correspondentes na protoboard. O cabo vermelho
na coluna positiva do bus, coluna com o símbolo positivo (+) e o cabo negro deve ser conectado
214
Primeiro vamos estudar o diagrama do nosso circuito de LED. Um diagrama de circuito (também
chamado de esquema) se usa para planejar e estudar um circuito em um desenho. É uma boa
idéia aprender os símbolos electrônicos que são utilizados habitualmente, para poder desenhar
qualquer circuito. (objeto de um post futuro.)
Muito cuidado com os LED´s. LED´s são polarizados. Isto significa que sua orientação é muito
importante. Ele não funcionará se for ligado invertido, ele simplemente "queimará". Você pode
reconhecer qual é o terminal positivo (anodo) e o negativo (catodo) pelo seu comprimento, ou
pelo chanfro em sua cabeça redonda, o chanfro indica o lado negativo do LED o "catodo" (-).
Insira o LED na protoboard de forma que o anodo (+) esteja inserido dentro do orifício 10E (pista
10 columna E) e o catodo (-) esteja inserido dentro do orificio 9E (pista 9 columna E). Desta
forma, teremos os terminais do LED, em duas pistas diferentes. Se inserir os dois terminais do
LED na mesma pista da protoboard, será produzido um curto-circuito.
Agora é a vez da resistência. A resistência serve para limitar a corriente que passa e atinge o
LED. Neste circuito, se a alimentação de 9v chegar ao LED é provável que ele queime de
imediato. As resistências, diferente dos LED´s, não tem polaridade, assím não importa o lado em
que o mesmo é ligado, mas por padrão em um circuito em que existam diverssos resistores, os
mesmos são alinhados de maneira a facilitar a sua leitura e todos na mesma direção.
215
na coluna negativa do bus, que é a coluna com o símbolo negativo (-). Antes de conctar a bateria
no circuito vamos inserir na protoboard o resto dos componentes...
216
Insira a resistência de forma que um dos terminais esteja conectado na coluna negativa do Bus
e a outra ponta no orifício 9D (pista 9 columna D). Desta forma, teremos o terminal negativo do
LED conectado ao Bus de alimentação (-) por meio da resistência.
Insira um extremo do cabo de ponte no orifício 10D (pista 10 coluna D) e o outro extremo na
coluna positiva do Bus.
Deste modo, teremos o terminal positivo do LED conectado ao Bus de alimentação (+).
Certifique novamente as conexões da bateria e do circuito. Positivo com positivo. Negativo
com negativo.
217
Conectar a bateria de 9V no adaptador que foi colocado ligado ao Bus. Isto é chamado de fonte
de alimetação.
Atenção! Se o LED queimar, revise suas conexões, existe algo errado no circuito.
Circuito complexo montado em uma protoboard. (Imagen: Sparkfun)
Outro uso muito habitual das protoboards é testar diversos componentes, como circuitos
integrados (Chips). Quando quiser averiguar como funciona um componente e tiver que mudar
constantemente conexões e componentes em um projeto de teste, protótipo, você não vai
querer soldar todas as conexões cada vez que fizer uma nova versão do projeto.
218
Se tudo estiver correto o LED acenderá e brilhará, como uma grande idéia em um desenho
animado, isto é um tremedo incentivo para criarmos mais projetos. Na realidade, existem uma
infinidade de maneiras diferentes de montar um mesmo circuito sobre uma protoboard. Isto se
chama depuração, você pode encontrar a maneira que melhor lhe convier, ou a maneira mais
racional a seus olhos, não importa, o que importa é que a cada montagem você estará
aprendendo mais e colocando sua capacidade criativa em evidência.
Resumindo, as protoboards são para a eletrônica o que as calculadoras eletrônicas são para a
matemática. Muitos técnicos rejeitam o seu uso, realmente em muitos casos não é essencial a
sua utilização. Já montei diversos projetos sem placa, mas na minha opinião ajudam muito em
uma solução mais rápida para a analise e depuração de um projeto.
219
Não há a necessidade de placas de circuitos de todos os tamanhos. Com algumas pequenas para
projetos sensíveis, e uma grande você poderá trabalhar em multiplos projetos sem problemas.
Além disso as protoboards podem ser facilmente interconectadas através de seus plug´s,
quando são do mesmo modelo e tamanho, ou através de pontes (jumpers).
O desenvolvimento de circuitos experimentais podem ser facilmente colocados em
funcionamento com a utilização de placas ilhadas universais de fenolite ou fibra de vidro. As
placas de fenolite universais, são desenhadas de tal forma que podemos construir as trilhas do
circuito com pequenas gotas de solda, jumpers ou pequenos cortes realizados com um estilete.
Coloque seus projetos em funcionamento com este modo de montagem utilizando as placas
universais com ilha desligada. As placas universais tipo ilha (desligada) são excelente para se
construir circuitos eletrônicos experimentais, com este tipo de placa podemos alterar facilmente
o circuito e também a ligação de suas trilhas.
O circuito proposto a ser montado é um temporizador que após ativado, manterá o relê ligado
por um determinado tempo. Voltando a se desligar automaticamente e aguardando por um
novo disparo. Este tipo de circuito é muito utilizado em pequenos alarmes, temporizadores para
luz de cortesia em corredores, etc...
Esquema circuito temporizador
Informação adicional: RV1 = 1MΩ ou 2M2Ω
Chave de disparo = Pode ser utilizado uma chave ou um sensor de presença.
220
45 MONTAGEM UTILIZANDO PLACA
PLACA UNIVERSAL
Circuito no papel quadriculado
Verso da placa no papel quadriculado
Além de desenhar os componentes no papel quadriculado, você pode ir traçando as trilhas do
circuito no verso da folha, utilizando como base as linhas do papel quadriculado. Observe que
no cruzamento de cada linha corresponde ao furo da placa.
Não esqueça de conferir atentamente todas as ligações para que o circuito funcione
corretamente.
O tamanho da placa a ser montada é igual a quantidade de cruzamentos utilizados na folha
quadriculada comparado aos furos da placa de fenolite. Aproveite ao máximo os espaços na
folha quadriculada, deste modo você conseguirá montar uma placa de pequenas proporções.
Agora iniciamos o processo de colocação dos componentes na placa universal de acordo com
nossa folha quadriculada.
Furação da placa de fenolite para terminais grossos
Nota importante: alguns componentes podem ter os terminais que não passam nos furos da
placa, ou não coincidem com os furos.
221
Com o esquema do circuito em mãos, o próximo passo é distribuir os componentes do circuito
desenhando-os em uma folha de papel quadriculado comum, simulando a furação da placa
universal. Deste modo podemos encontrar um bom posicionamento para todas as peças que
compõem nosso circuito.
Antes de começar a soldar os componentes, observe se a placa é protegida com verniz e se a
solda pega bem nas ilhas, se a placa não possui verniz, faça uma limpeza na placa com bombril,
deixando-a bem limpa.
Fixação dos componentes no verso da placa
Seguimos colocando os componentes na placa de acordo com a nossa folha quadriculada,
tomando o cuidado de ir fixando-os com uma gota de solda na ilha. Para facilitar o seu trabalho,
começe fixando os componentes de menor altura (jumpers se tiver, depois resistores, diodos,
capacitores), deixe os maiores para o fim. Faça a soldagem dos fios numa última etapa.
Terminado o processo de fixação dos componentes na placa, iniciamos o trabalho de montagem
das trilhas que interligará todos os componentes do circuito. O processo consiste em ligar as
ilhas da placa com uma pequena gota de solda, para isso utilizaremos como guia a folha
quadriculada no lado verso, onde desenhamos somente as trilhas.
Montagem da trilhas na placa universal
Tome o cuidado para não aquecer demais a ilha, utilize um ferro de solda de ponta fina, de 20 a
30 watts de potência. Trilhas longas no circuito, poderão ser contruídas utilizando pequenos
pedaço de fio fino de cobre, geralmente retirados de cabos de rede ou cabos de telefonia.
A grande vantagem em trabalhar com estas placas, está na facilidade de poder alterar o circuito
rapidamente e também as suas trilhas de acordo com a necessidade do novo circuito.
222
Antes de começar a soldar os componentes, devemos preparar a placa para que todos os
componentes sejam inseridos com facilidade. Para isso utilize um broca de 2 mm e refaça os
furos de acordo com o necessário.
Soldagem dos fios
Atenção - Antes de ligar, confira o circuito, observe se não ocorreu curto entre as ilhas, solda
fria ou erro na construção das trilhas.
Circuito em funcionamento
Trabalhando com placas universais, é possível desenvolver e montar rapidamente uma grande
variedade de projetos em eletrônica digital, som e efeitos visuais. Lembre-se que circuitos de
alta frequência, como transmissores e receptores de rádio podem apresentar instabilidades no
seu funcionamento quando utilizamos estes tipos de placas no processo de montagem.
223
Na etapa final, soldamos os fios para chaves, sensores e a fonte de energia. Os fios podem ser
soldados no lado de cima da placa, junto com os componentes ou no lado de baixo diretamente
nas ilhas da placa.
Quando optar em realizar montagens definitivas com placas universais deixe uma área de
margem maior, faça a furação necessária nos cantos com brocas de 4 mm, assim poderá fixar a
placa dentro de gabinetes.
Componentes que trabalham quentes devem ser montados mais distantes da placa para evitar
a queima da placa ou derretimento da solda nos terminais.
Trilhas que conduzem alta corrente, devem ser reforçadas com pedaços de fios de cobre mais
grossos, para evitar o rompimento das trilhas ou da solda.
Comprovado o perfeito funcionamento do projeto, agora é só copia-lo para uma placa de
circuito impresso definitiva.
Atenção - Na foto do circuíto, vemos 5 resistores e também 2 led's. Mas no esquema do circuíto
não vemos estes componentes. Os dois resistores e os dois leds (vermelho e verde) que não
foram incluídos no esquema, tem a função mostrar que o circuito está ligado e funcionando. O
led vermelho indica que o circuito está energizado e o seu resistor é de aproximadamente 1K
ohm, o led verde indica que o relê foi acionado e o valor do resistor limitador para o led é de 1K
ohm. Ambos poderão ser adicionados no circuito para obter uma visualização do funcionamento
e o ponto de montagem é em paralelo com as fontes de alimentação.
224
Algumas dicas adicionais:
PEOPLEWARE Website, http://pplware.sapo.pt/sobre-nos/
COMO FAZER AS COISAS Website, http://www.comofazerascoisas.com.br/
FAZEDORES BLOG Website, http://blog.fazedores.com/
INSTRUCTABLES Website, http://www.instructables.com/tag/type-id/category-technology/
ARDUINO Website, http://arduino.cc/
RASPBERRY PI Website, http://www.raspberrypi.org/
SÊNIOR CONSULTORIA Website, http://seniorcti.com.br/
ROBOHELP Website, http://robohelp.com.br/
225
46 REFERÊNCIAS BIBLIOGRÁFICAS
BIBLIOGRÁFICAS
226
Sobre o Autor
Luiz Henrique Akasaka Ferreira é consultor na área de análise de sistemas, organização e
métodos, especializado em gestão de produção, integração digital de equipamentos de
controle, técnico em eletrônica especializado em CLP para PCP. Estuda as áreas de recursos
naturais para obtenção de energia renovável, é de sua autoria diversos projetos para
implantação de usinas de biodiesel, a cadeia produtiva de insumos pra produção de biodiesel, a
implantação de micro usinas geradoras de energia elétrica com base em células fotovoltaicas e
o estudo e implantação de usinas de energia elétrica com base em células fotovoltaicas para
grande demanda, acima de 11GWh/ano. Como entusiasta da ciência e tecnologia voltada a
eletrônica e tecnologia da informação elaborou este compêndio com informações testadas em
seu dia a dia para auxiliar o inventor iniciante em percorrer seu caminho inicial.
Atualmente, é sócio da Sênior Consultoria e Incorporadora, empresa que desenvolve produtos
para a indústria visando o programa de controle de produção (PCP), a automação da cadeia
produtiva e a assessoria para implantação de sistemas de gestão integrados (ERP).
http://www.seniorcti.com.br
ATENÇÂO
Este estudo faz parte de uma iniciativa da
equipe de desenvolvimento e pesquisas da
Senior Consultoria, todas as informações aqui
contidas estão listadas no item “fonte”, dando crédito ao
seu pesquisador original e colocando-os sob a licença Creative Commons.