WWW.ELETROGATE.

COM 1
 V1.6 – Abril/2025

Olá, Maker!

Parabéns pelo primeiro passo rumo a uma jornada incrível!

Esta apostila foi desenvolvida especialmente para você, servindo como um guia teórico
e prático para o Kit Arduino Big Jack . O kit possui todos os componentes necessários
para os projetos propostos e, assim, permitirá que você tenha uma experiência
completa.

Se você ainda é novo no universo Arduino, não se preocupe! Vamos te guiar desde o
começo, com uma introdução à plataforma, instalação, configuração e o passo a passo
para você dominar todos os recursos da sua placa Arduino. E o melhor: com projetos
práticos que vão te levar da programação à montagem, até ver o seu projeto ganhar
vida!

Mas as oportunidades não param por aí! Com o Kit Arduino Big Jack, as possibilidades
são infinitas. Você poderá criar inúmeros projetos utilizando sensores, motores, shields
e muito mais. Tudo o que você precisa para soltar sua criatividade e inovar está no
nosso Kit.

Então, se você ainda não garantiu o seu, não perca mais tempo! Acesse agora o nosso
site e garanta já o seu Kit Arduino Big Jack para desbloquear todo o seu potencial
criativo!

Prepare-se para uma aventura de aprendizado e criação. Estamos ansiosos para ver
tudo o que você vai criar.

Aproveite bastante e bons estudos!

WWW.ELETROGATE.COM 2
 Sumário

Parte I – Conceitos elétricos, introdução aos componentes e instalação da IDE .. 5

Introdução................................................................................................................ 5
Revisão de circuitos elétricos ................................................................................ 6
Carga e corrente elétrica ..................................................................................... 7
Tensão elétrica..................................................................................................... 8
Potência e energia ............................................................................................... 8
Conversão de níveis lógicos e alimentação correta de circuitos..................... 9
Revisão de componentes eletrônicos ................................................................. 11
Resistores elétricos ........................................................................................... 11
Capacitores ........................................................................................................ 13
Diodos e LEDs ................................................................................................... 15
Transistores ....................................................................................................... 17
Protoboard ......................................................................................................... 20
Parte II – ARDUINO MEGA 2560 CH340 ................................................................... 21
Parte III - Instalando e conhecendo a Arduino IDE ................................................. 26
Parte IV - Seção de Exemplos Práticos ................................................................... 31
Exemplo 1 - Leitura de Sinais Analógicos com Potenciômetro ..................... 31
Exemplo 2 - Divisores de Tensão com Resistores .......................................... 34
Exemplo 3 - Controle de LEDs com Botões ..................................................... 36
Exemplo 4 - Acionamento de buzzer com um botão ....................................... 38
Exemplo 5 - Acionamento de LED conforme do Luz Ambiente...................... 40
Exemplo 6 - Controle de Servo Motor com Potenciômetro ............................ 44
Exemplo 7 - Medindo a Temperatura do Ambiente ......................................... 47
Exemplo 8 - Acionamento de uma Lâmpada com Relé................................... 49
Exemplo 9 - Acendendo um LED com Sensor Reflexivo Infravermelho ........ 53
Exemplo 10 – Efeito fade ................................................................................... 56
Exemplo 11 - Controlando o brilho do LED com potenciômetro.................... 57
Exemplo 12 – Explorando o efeito de persistência da visão (POV) com LED59
Exemplo 13 - Controlando LEDs com funções diferentes sem usar delay() . 60
Exemplo 14 – Diferença entre transistores NPN e PNP na prática................. 63

WWW.ELETROGATE.COM 3
 Exemplo 15 – Acionamento de cargas usando transistores .......................... 65
Exemplo 16 – Semáforo com Arduino .............................................................. 67
Exemplo 17- Acionando displays de 7 segmentos.......................................... 69
Exemplo 18 - Cronômetro Digital com Display LCD........................................ 73
Exemplo 19 - Trena Eletrônica com Sensor Ultrassônico .............................. 77
Exemplo 20 – Controlando um Motor de Passo com Potenciômetro ............ 80
Exemplo 21 – Comunicação sem Fio com Transmissor e Receptor RF ........ 87
Exemplo 22 – Alarme com Buzzer e Sensor de Presença .............................. 93
Exemplo 23 – Ponte H com Módulo Relé de 2 Canais..................................... 98
Exemplo 24 – Acendendo LED's com Controle Remoto Infravermelho....... 102
Exemplo 25 – Relógio Digital de Alta Precisão com Módulo RTC................ 108
Exemplo 26 – Utilizando o Teclado Matricial de 16 Teclas ........................... 112
Exemplo 27 - Medidor de Temperatura e Umidade com DHT11 ................... 116
Exemplo 28 – Utilizando o Módulo MPU-6050 - Acelerômetro e Giroscópio122
Exemplo 29 - Comunicação Bluetooth entre Arduino Mega e Smartphone 128
Parte V - Cálculo do resistor de base dos transistores........................................ 132
Parte VI – Principais comandos do Arduino ......................................................... 134
Considerações finais .......................................................................................... 136

WWW.ELETROGATE.COM 4
 Parte I – Conceitos elétricos, introdução aos
componentes e instalação da IDE

Introdução

A primeira parte da apostila faz uma revisão sobre circuitos elétricos, com destaque para
questões práticas de montagem e segurança que surgem no dia a dia do usuário do Kit
Big Jack para Arduino.

O conteúdo de circuitos elétricos aborda divisores de tensão e corrente, conversão de

níveis lógicos, grandezas analógicas e digitais, níveis de tensão e cuidados práticos de
montagem.
Em relação aos componentes básicos, é feita uma breve discussão sobre resistores
elétricos, capacitores, leds, diodos, chaves e protoboards.

O Arduino Mega é o principal componente do Kit e é discutido e introduzido em uma

seção à parte, na Parte II da apostila.

Todos os conteúdos da Parte I são focados na apostila Arduino Big Jack, tendo em vista
a utilização adequada dos componentes e da realização prática de montagens pelos
usuários. No entanto, recomenda-se a leitura das referências indicadas ao final de cada
seção para maior aprofundamento.

O leitor veterano, já acostumado e conhecedor dos conceitos essenciais de eletrônica e

eletricidade, pode pular a Parte I e ir direto a Parte III, na qual são apresentadas uma
seção de exemplo de montagem para cada sensor ou componente importante da
apostila.

Preparado? Vamos começar!

WWW.ELETROGATE.COM 5
 Revisão de circuitos elétricos

A apostila Big Jack, bem como todas as outras apostilas que tratam de Arduino e
eletrônica em geral, tem como conhecimento de base as teorias de circuitos elétricos e
de eletrônica analógica e digital.

Do ponto de vista da teoria de circuitos elétricos, é importante conhecer os conceitos

de grandezas elétricas: Tensão, corrente, carga, energia potência elétrica. Em todos os
textos sobre Arduino ou qualquer assunto que envolva eletrônica, você sempre terá que
lidar com esses termos. Para o leitor que se inicia nessa seara, recomendamos desde já
que mesmo que a eletrônica não seja sua área de formação, que conheça esses
conceitos básicos.

Vamos começar pela definição de “circuito elétrico”. Um circuito elétrico/eletrônico é

uma interconexão de elementos elétricos/eletrônicos. Essa interconexão pode ser feita
para atender a uma determinada tarefa, como acender uma lâmpada, acionar um
motor, dissipar calor em uma resistência e tantos outras.

O circuito pode estar energizado ou desenergizado. Quando está energizado, é quando

uma fonte de tensão externa ou interna está ligada aos componentes do circuito. Nesse
caso, uma corrente elétrica fluirá entre os condutores do circuito. Quando está
desenergizado, a fonte de tensão não está conectada e não há corrente elétrica fluindo
entre os condutores.

Mas atenção, alguns elementos básicos de circuitos, como os capacitores ou massas

metálicas, são elementos que armazenam energia elétrica. Em alguns casos, mesmo não
havendo fonte de tensão conectada a um circuito, pode ser que um elemento que tenha
energia armazenada descarregue essa energia dando origem a uma corrente elétrica
transitória no circuito. Evitar que elementos do circuito fiquem energizados mesmo sem
uma fonte de tensão, o que pode provocar descargas elétricas posteriores (e em alguns
casos, danificar o circuito ou causar choques elétricos) é um dos motivos dos sistemas
de aterramento em equipamentos como osciloscópios e em instalações residenciais, por
exemplo.

Em todo circuito você vai ouvir falar das grandezas elétricas principais, assim, vamos
aprender o que é cada uma delas.

WWW.ELETROGATE.COM 6
 Carga e corrente elétrica

A grandeza mais básica nos circuitos elétricos é a carga elétrica. Carga é a propriedade
elétrica das partículas atômicas que compõem a matéria (prótons, nêutrons e elétrons),
e é medida em Coulombs.

Do conceito de carga elétrica obtemos o conceito de corrente elétrica, que nada mais
é do que a taxa de variação da carga ao longo do tempo, ou seja, quando você tem um
fluxo de carga em um condutor, a quantidade de carga (Coulomb) que atravessa esse
condutor por unidade de tempo, é chamada de corrente elétrica. A medida utilizada
para corrente é o Ampére(A).

Aqui temos que fazer uma distinção importante. Existem corrente elétrica contínua e
alternada:

 Corrente elétrica contínua (VCC/VDC): É uma corrente que permanece

constante e em uma única direção durante todo o tempo.
 Corrente elétrica alternada (VAC/VCA): É uma corrente que varia de forma
senoidal ao longo do tempo.

Com o Arduino Mega e na maioria dos componentes eletrônicos, lidamos com a

corrente elétrica contínua. É diferente da corrente e tensão elétrica da tomada de sua
casa, que são alternadas.

Outro conceito importante ao falarmos de corrente elétrica é o sentido do fluxo.

Corrente elétrica é o fluxo de carga elétrica através de um condutor, e é transportada
por elétrons em um circuito. Convencionalmente, o sentido da corrente elétrica foi
definido como o fluxo de cargas do lado positivo para o lado negativo. Essa convenção
foi estabelecida antes da descoberta dos elétrons e simplifica a análise de circuitos.

Na realidade, os elétrons, que possuem carga negativa, se movem do polo negativo para
o polo positivo. Isso ocorre porque, em um circuito, o excesso de elétrons em um lado
(polo negativo) cria uma região negativa em relação ao lado com menos elétrons (por
conter menos elétrons, dizemos que essa região está positiva). Essa diferença de
potencial cria uma força que faz com que os elétrons se movam em direção ao lado
positivo.

Quando conectamos os dois polos por meio de uma carga (como um LED, resistor,
motor, por exemplo), a corrente elétrica é gerada e flui devido a essa diferença de

WWW.ELETROGATE.COM 7
 potencial (conceito que será explicado mais adiante). A corrente é a forma como a
energia é transportada e utilizada pelos componentes do circuito.

Tensão elétrica

Para que haja corrente elétrica em um condutor, é preciso que os elétrons se

movimentem por ele em uma determinada direção, ou seja, é necessário “alguém”
para transferir energia para as cargas elétricas para movê-las. Isso é feito por uma
força chamada força eletromotriz (fem.), tipicamente representada por uma bateria.
Outros dois nomes comuns para força eletromotriz são tensão elétrica e diferença de
potencial.

O mais comum é você ver apenas “tensão” nos artigos e exemplos com Arduino.
Assim, definindo formalmente o conceito: Tensão elétrica é a energia necessária para
mover uma unidade de carga através de um condutor, e é medida em Volts (V).

Potência e energia

A tensão e a corrente elétrica são duas grandezas básicas, e juntamente com a potência
e energia, são as grandezas que descrevem qualquer circuito elétrico ou eletrônico. A
potência é definida como a variação de energia (que pode estar sendo liberada ou
consumida) em função do tempo, e é medida em Watts (W). A potência está associada
ao calor que um componente está dissipando e a energia que ele consume.

Nós sabemos da vida prática que uma lâmpada de 100W consome mais energia do que
uma de 60 W. Ou seja, se ambas estiverem ligadas por 1 hora por exemplo, a lâmpada
de 100W vai implicar numa conta de energia mais cara.
A potência se relaciona com a tensão e corrente pela seguinte fórmula:

P=VxI

Essa é a chamada potência instantânea. Com essa fórmula, para saber qual a potência
dissipada em um resistor, por exemplo, basta informar a tensão aplicada nos terminais
do resistor e a corrente que passa por ele. O conceito de potência é importante pois
muitos hobbistas acabam não tendo noção de quais valores de resistência usar, ou
mesmo saber especificar componentes de forma adequada.

WWW.ELETROGATE.COM 8
 Um resistor de 33 ohms de potência igual a 1/4W, por exemplo, não pode ser ligado
diretamente em circuito de 5V, pois nesse caso a potência dissipada nele seria maior
que a que ele pode suportar.

Vamos voltar a esse assunto em breve, por ora, tenha em mente que é importante ter
uma noção da potência dissipada ou consumida pelos elementos do circuito que você
irá montar.

Por fim, a energia elétrica é o somatório da potência elétrica durante todo o tempo em
que o circuito esteve em funcionamento. A energia é dada em Joules (J) ou Wh (watt-
hora). A unidade Wh é interessante pois mostra que a energia é calculada multiplicando-
se a potência pelo tempo (apenas para os casos em que a potência é constante).

Essa primeira parte é um pouco conceitual, mas é importante saber de onde vieram
todas as siglas que você irá encontrar nos manuais e artigos na internet. Na próxima
seção, vamos discutir os componentes básicos que compõem o Kit Big Jack para Arduino.

Conversão de níveis lógicos e alimentação correta de circuitos

É muito comum que hobbistas e projetistas em geral acabem cometendo alguns erros
de vez em quando. Na verdade, mesmo alguns artigos na internet e montagens
amplamente usadas muitas vezes acabam por não utilizar as melhores práticas de forma
rigorosa. Isso acontece frequentemente com situações em que os níveis lógicos dos
sinais usados para integrar o Arduino com outros circuitos não são compatíveis entre si.

Como veremos na seção de apresentação do Arduino Mega, ele é alimentado por um

cabo USB ou uma fonte externa entre 7V e 12V. A placa do Arduino possui reguladores
de tensão que convertem a alimentação de entrada para 5V e para 3,3V. Os sinais lógicos
enviados pelas portas de saída digitais do Arduino operam com sinais de 0V ou 5V.

Isso significa que quando você quiser usar o seu Arduino Mega com um sensor ou CI que
trabalhe com 3.3V, é preciso fazer a adequação dos níveis de tensão, pois se você enviar
um sinal de 5V (saída do Arduino) em um circuito de 3.3V (CI ou sensor), você poderá
queimar o pino daquele componente.
Em geral, sempre que dois circuitos que trabalhem com níveis de tensão diferentes
forem conectados, é preciso fazer a conversão dos níveis lógicos. O mais comum é ter
que abaixar saídas de 5V para 3.3V. Subir os sinais de 3.3V para 5V na maioria das vezes
não é necessário pois o Arduino entende 3.3V como nível lógico alto, isto é, equivalente
a 5V.

WWW.ELETROGATE.COM 9
 Para fazer a conversão de níveis lógicos você tem duas opções:

 Usar um divisor de tensão;

 Usar um CI conversor de níveis lógicos;

O divisor de tensão é a solução mais simples, mas usar um CI conversor é mais elegante
e é o ideal. O divisor de tensão consiste em dois resistores ligados em série (Z1 e Z2), em
que o sinal de 5V é aplicado em um dos terminais de Z1. O segundo terminal de Z2 é
ligado ao GND, e o ponto de conexão entre os dois resistores é a saída do divisor, cuja
tensão é dada pela seguinte relação:

Nessa equação, e Z1 e Z2 são os valores dos resistores da figura abaixo.

Um divisor de tensão muito comum é fazer Z1 igual 1KΩ e Z2 igual 2KΩ. Dessa forma a
saída Vout fica sendo 3.33V. Como o Kit Big Jack para Arduino não contém resistores de
2K, você pode associar dois resistores de 1K ligados em série para formar o resistor Z2.
Fazendo isso, teremos Z1 = 1KΩ e Z2 = (1KΩ + 1KΩ), resultando numa saída de 3.33V
segundo a fórmula mostrada (Vout = (1KΩ + 1KΩ)/(1KΩ+(1KΩ + 1KΩ)) x 5).

Vamos exemplificar como fazer um divisor de tensão como esse na seção de exemplos
da parte II da apostila.

WWW.ELETROGATE.COM 10
 Revisão de componentes eletrônicos

O Kit Big Jack para Arduino possui os seguintes componentes básicos para montagens
de circuitos:

 Buzzer Ativo 5V;

 LED Vermelho/ Verde/ Amarelo;
 Resistor 330Ω/ 1KΩ/ 10KΩ;
 Diodo 1N4007;
 Potenciômetro 10KΩ;
 Capacitor Cerâmico 10 nF/ 100 nF;
 Capacitor Eletrolítico 10uF/ 100uF;
 Chave Táctil (Push-Button);
 Transistor NPN BC548;
 Transistor PNP BC558;
 Display 7 segmentos.

Vamos revisar a função de cada um deles dentro de um circuito eletrônico e

apresentar mais algumas equações fundamentais para ter em mente ao fazer suas
montagens.

Resistores elétricos

Os resistores são componentes que se opõem à passagem de corrente elétrica, ou seja,

oferecem uma resistência elétrica. Dessa forma, quanto maior for o valor de um resistor,
menor será a corrente elétrica que fluirá por ele e pelo condutor a ele conectada. A
unidade de resistência elétrica é o Ohm (Ω), também simbolizado pela letra R maiúscula,
que é a unidade usada para especificar o valor dos resistores.

Os resistores mais comuns do mercado são construídos com fio de carbono e são
vendidos em várias especificações. Os resistores do Kit são os tradicionais de 1/4W e 5%
de tolerância. Isso significa que eles podem dissipar no máximo 1/4W (0,25 watts) e seu
valor de resistência pode variar em até 5% para mais ou para menos, ou seja, o resistor
de 1KΩ pode então ter um valor mínimo de 950Ω e um valor máximo de 1050Ω para ser
considerado em condições de uso.

Em algumas aplicações você pode precisar de resistores com precisão maior, como 1%.
Também há casos em que a precisão não é tão importante, podendo ser utilizados
resistores com tolerância de 10%. Em alguns casos, pode ser necessário usar resistores

WWW.ELETROGATE.COM 11
 com maior potência, como 1W, enquanto em outros a potência pode ser menor, como
1/8W. Essas variações dependem da natureza específica de cada circuito."

Em geral, para as aplicações típicas e montagens de prototipagem que podem ser feitos
com o Kit Big Jack para Arduino, os resistores tradicionais de 1/4W e 5% de tolerância
são mais que suficientes.

Outro ponto importante de se mencionar aqui é a Lei de Ohm, que relaciona as

grandezas de tensão, corrente e resistência elétrica. A lei é dada por:

V=RxI

Ou seja, se você sabe o valor de um resistor e a tensão aplicada em seus terminais, você
pode calcular a corrente elétrica que fluirá por ele. Juntamente com a equação para
calcular potência elétrica, a lei de Ohm é importante para saber se os valores de corrente
e potência que os resistores de seu circuito estão operando estão adequados.

Para fechar, você deve estar se perguntando, como saber o valor de resistência de um
resistor? Você tem duas alternativas: Medir a resistência usando um multímetro ou
determinar o valor por meio do código de cores do resistor.

Se você pegar um dos resistores do seu kit, verá que ele possui algumas faixas coloridas
em seu corpo. Essas faixas são o código de cores do resistor. As duas primeiras faixas
dizem os dois primeiros algarismos decimais. A terceira faixa colorida indica o
multiplicador que devemos usar. A última faixa, que fica um pouco mais afastada, indica
a tolerância.

Figura 1: Faixas coloridas em um resistor

WWW.ELETROGATE.COM 12
 Na figura 2 apresentamos o código de cores para resistores. Cada cor está associada a
um algarismo, um multiplicador e uma tolerância, conforme a tabela. Com a tabela você
pode determinar a resistência de um resistor sem ter que usar o multímetro.

Mas atenção, fazer medições com o multímetro é recomendado, principalmente se o

componente já tiver sido utilizado, pois pode ter sofrido algum dano ou mudança que
não esteja visível.

Figura 2: Código de cores para resistores

Aplicando a tabela da figura 2 na imagem da figura 1, descobrimos que o resistor é de

2,7MΩ (Mega ohms) com tolerância de 5% (relativo à cor dourado da última faixa).

Capacitores

Os capacitores são os elementos mais comuns nos circuitos eletrônicos depois dos
resistores. São elementos que armazenam energia na forma de campos elétricos. Um
capacitor é constituído de dois terminais condutores e um elemento dielétrico entre
esses dois terminais, de forma que quando submetido a uma diferença de potencial, um
campo elétrico surge entre esses terminais, causando o acúmulo de cargas positivas no
terminal negativo e cargas negativas no terminal positivo.

São usados para implementar filtros, estabilizar sinais de tensão, na construção de

fontes retificadores e várias outras aplicações.

O importante que você deve saber para utilizar o Kit é que os capacitores podem ser de
quatro tipos:

WWW.ELETROGATE.COM 13
  Eletrolíticos;
 Cerâmicos;
 Poliéster;
 Tântalo.

Capacitor eletrolítico

As diferenças de cada tipo de capacitor são a tecnologia construtiva e o material

dielétrico utilizado. Capacitores eletrolíticos são feitos de duas longas camadas de
alumínio (terminais) separadas por uma camada de óxido de alumínio (dielétrico).
Devido a sua construção, eles possuem polaridade, o que significa que você
obrigatoriamente deve ligar o terminal positivo (o maior) no polo positivo da fonte de
alimentação, e o terminal negativo (marcado no capacitor por uma faixa com símbolos
de “-”) obrigatoriamente no polo negativo da fonte. Do contrário, o capacitor será
danificado.

Capacitores eletrolíticos costumam ser da ordem de micro Farad, sendo o Farad a

unidade de medida de capacitância, usada diferenciar um capacitor do outro. A Figura
3 ilustra um típico capacitor eletrolítico.

Figura 3: Capacitor eletrolítico 4700 micro Farads / 25 V

Capacitores cerâmicos

Capacitores cerâmicos não possuem polaridade, e são caracterizados por seu tamanho
reduzido e por sua cor característica, um marrom claro um tanto fosco. Possuem
capacitância da ordem de pico Farad. Veja nas imagens abaixo um típico capacitor
cerâmico e sua identificação:

WWW.ELETROGATE.COM 14
 Figura 4: Capacitores cerâmicos

Na imagem da esquerda, os capacitores possuem o valor de 22 nano Farads para a

faixa de tensão de até 500V.

223 = 22 x 1000 = 22.000 pF = 22 nF

Por fim, há também os capacitores de poliéster e de tântalo. No Kit Big Jack para
Arduino, você receberá apenas exemplares de capacitores eletrolíticos e cerâmicos.

Diodos e LEDs

Diodos e LEDs são tratados ao mesmo tempo pois são, na verdade, o mesmo
componente. Diodos são elementos semicondutores que só permitem a passagem de
corrente elétrica em uma direção.

São constituídos de dois terminais, o Anodo(+) e o catodo(-), sendo que para que possa
conduzir corrente elétrica, é preciso conectar o Anodo na parte positiva do circuito, e o
Catodo na parte negativa. Do contrário, o diodo se comporta como um circuito aberto,
bloqueando a passagem dos elétrons.

Figura 4: Diodo e seus terminais

WWW.ELETROGATE.COM 15
 Na figura 4, você pode ver que o componente possui uma faixa indicadora no terminal
catodo, este é o polo negativo. O diodo do Kit Big Jack para Arduino é um modelo
tradicional e que está no mercado há muitos anos, o 1N4007.

O LED é um tipo específico de diodo - Light Emitter Diode, ou seja, um diodo que emite
luz. Trata-se de um diodo que quando polarizado corretamente, emite luz para o
ambiente externo. O Kit Big Jack para Arduino vem acompanhado de LEDs nas cores
vermelha, verde e amarela, as mais tradicionais.

Nesse ponto, é importante você saber que sempre deve ligar um led junto de um
resistor, para que a corrente elétrica que flua pelo led não seja excessiva e acabe por
queimá-lo. Além disso, lembre-se que por ser um diodo, o led só funciona se o Anodo
estiver conectado ao polo positivo do sinal de tensão.

Para identificar o Anodo do Led, basta identificar o terminal mais longo do componente,
como na imagem abaixo:

Figura 5: Terminais de um Led. Créditos: Build-eletronic-circuits.com

WWW.ELETROGATE.COM 16
 Transistores

Os transistores são componentes eletrônicos fundamentais na eletrônica moderna,

podendo atuar como amplificadores ou interruptores. Um transistor é um dispositivo
semicondutor que controla a corrente elétrica em um circuito (chamada corrente de
coletor) através da aplicação de uma corrente em seu terminal de controle (chamada
corrente de base).

Essa corrente é muito pequena em relação à corrente de coletor, graças a um

parâmetro de cada transistor chamado ganho (também chamado Beta (β) ou hFE),
sendo esse o responsável por ditar em quantas vezes a corrente de base será
amplificada dependendo do modo de operação.

O ganho do transistor resulta da divisão entre a corrente de coletor e a corrente de

𝐼𝐼𝐼𝐼
base, representada pela fórmula 𝛽𝛽 = . Isso significa que a corrente de coletor é β
𝐼𝐼𝐼𝐼
vezes maior que a corrente de base.
Vamos começar apresentando os tipos de transistores, que são classificados em duas
categorias:

- Transistores de Efeito de Campo (FET):

Os transistores do tipo FET também se subdividem em dois grupos e possuem
características diferentes dos transistores BJTs, porém não iremos abordá-los nessa
apostila. São subdivididos em:
- Junction FET (JFET): Utiliza um campo elétrico para controlar a condutividade
de um canal.
- Metal-Oxide-Semiconductor FET (MOSFET): Tem um isolamento de óxido que
controla o fluxo de corrente em um canal semicondutor.

- Transistores Bipolares de Junção (BJT):

Os BJTs são o foco dessa apostila e possuem três terminais denominados coletor, base
e emissor. Cada um desses terminais tem uma função específica que varia
dependendo do tipo de transistor. São eles:

 NPN: No transistor NPN, a corrente principal entra pelo coletor e sai pelo
emissor (considerando o sentido convencional da corrente). Para que o
transistor NPN conduza, é necessário aplicar um sinal positivo na base.
Esse sinal permite que a corrente flua do coletor para o emissor, habilitando a
condução do transistor.

WWW.ELETROGATE.COM 17
  PNP: O funcionamento do transistor PNP é oposto ao NPN. Nele, a corrente
principal entra pelo emissor e sai pelo coletor. Entrando em condução ao
aplicarmos um sinal negativo na base. Esse sinal negativo na base permite que
a corrente flua do emissor para o coletor, habilitando a condução do transistor.

Modos de operação

WWW.ELETROGATE.COM 18
 Para facilitar a compreensão do funcionamento do transistor, vamos associar o tipo
NPN a uma torneira. Nesta analogia, o coletor representa a entrada de água na
torneira, o emissor representa a saída de água e, a base, equivale ao registro. Para o
PNP, a analogia é a mesma, diferenciando-se apenas na função do coletor e do
emissor.

Dito isso, vamos explorar os três modos de operação do transistor:

Modo Ativo: Chamamos de região ativa porque o transistor está funcionando como
um amplificador. Neste estado, a corrente de base controla a corrente de coletor, mas
o transistor não está completamente saturado. A corrente de coletor é proporcional à
corrente de base, multiplicada pelo ganho do transistor. Isso faz com que a tensão
entre o coletor e o emissor seja alta o suficiente para permitir essa amplificação.
Associando à torneira, você abre o registro parcialmente, permitindo um fluxo
controlado e proporcional da água. Da mesma forma, no transistor, a corrente de base
controla a quantidade de corrente que flui do coletor (entrada da água) para o emissor
(saída da água).

Modo Saturação: Modo saturação: Nesse modo, o transistor se comporta como um

interruptor fechado (acionado). A base fica "inundada" com elétrons devido à corrente
nela injetada, que é maior que a necessária para o transistor atuar na região ativa.
Como resultado, a resistência entre o coletor e o emissor se torna muito baixa, assim
como a tensão entre esses terminais, significando que o transistor está totalmente
"ligado" e conduzindo a corrente quase sem impedimento.

Embora o ganho (β) do transistor ainda esteja presente, sua influência é menor neste
modo já que existe um excesso de elétrons na base. A corrente de coletor passa a ser
mais influenciada pela configuração do circuito do que pela corrente de base. Na
torneira, é como se o registro estivesse completamente aberto, permitindo o fluxo
máximo de água.

Modo Corte: O transistor está completamente desligado. Não há corrente fluindo

entre o coletor e o emissor, e a tensão entre esses terminais é alta. O transistor atua
como um interruptor aberto, interrompendo a passagem de corrente. Isso ocorre
porque a corrente de base é insuficiente para ativar o transistor, e o ganho do
transistor não tem efeito, pois o transistor está completamente desligado. Esse modo
é equivalente à torneira completamente fechada, bloqueando totalmente o fluxo de
água.

WWW.ELETROGATE.COM 19
 Protoboard

A protoboard é uma ferramenta essencial no desenvolvimento de circuitos eletrônicos,

especialmente em projetos experimentais e de prototipagem. Sua principal vantagem
é a facilidade de montagem e modificação de circuitos sem a necessidade de solda,
permitindo testar e ajustar componentes rapidamente. Na imagem abaixo, mostramos
as ligações internas da protoboard para que você entenda como os pinos são
organizados e onde permitem contato:

Note que, nessa orientação, temos colunas numeradas de 1 a 63, enquanto as linhas
são nomeadas de A a E no segmento inferior e de F a J no segmento superior. A ligação
entre os pinos é bem simples de entender: em cada coluna numérica, as 5 linhas
correspondentes estão interligadas entre si (linhas verdes), mas não há conexão com
as colunas vizinhas (números), nem entre os segmentos superior e inferior (grupos A-E
e F-J).

Já nas linhas de energia, representadas pelas linhas vermelhas e pretas, a ligação é

feita no sentido horizontal, percorrendo toda a largura da protoboard. Essas linhas
geralmente são usadas para fornecer alimentação positiva (VCC) e negativa (GND) aos
componentes do circuito.

Os demais componentes do kit (Buzzer, potenciômetro, display de 7 segmentos e push-

buttons) serão explicados em seções de exemplos, nas quais iremos apresentar um
circuito prático para montagem onde será apresentado o funcionamento de cada um
deles, assim como será feito para os sensores de luz (LDR) e temperatura (NTC). O Micro
Servo 9g SG90 TowerPro também terá uma seção de exemplo dedicada a cada ele.

WWW.ELETROGATE.COM 20
 Parte II – ARDUINO MEGA 2560 CH340
Após o Arduino ter sido lançado em 2005 e ter um grande sucesso no mundo inteiro, a equipe
do Arduino percebeu a necessidade de lançamento de outros modelos. O Arduino Mega foi
lançado em 2010. E em relação à todos os modelos de Arduino, o Mega é o segundo
mais famoso, após o Arduino Mega.

A grande diferença do Arduino Mega é que ele usa um outro Microcontrolador :

ATmega2560, que tem maior quantidade de memória, maior número de pinos e
funções, apesar de usar o mesmo processador e o mesmo clock.

Atmel ATmega2560 datasheet:

https://www.microchip.com/wwwproducts/en/ATmega2560
Características do Microcontrolador ATmega 2560 :
• Processador RISC com até 16 MIPS,
• 256 KBytes de memória Flash (programas),
• 8 KBytes de memória estática SRAM,
• 4 KBytes de memória não-volátil EEPROM,
• 2 Timers/Contadores de 8 bits,
• 2 Timers/Contadores de 16 bits,
• 1 Contador Real Time,
• 1 Conversor ADC de 10 bits com 16 canais,
• Quatro canais PWM de 8 bits e 12 canais PWM de 16 bits,
• Quatro interfaces seriais, uma interface I2C e uma interface SPI.
• e mais alguns outros recursos.

Características do Arduino Mega

A placa Arduino Mega 2560 foi desenvolvida para projetos mais complexos. Com 54
pinos digitais de Entrada / Saída e 16 entradas analógicas, é a placa recomendada para
impressoras 3D e projetos de robótica.
Link oficial do Arduino Mega:
https://store.arduino.cc/usa/arduino-mega-2560-rev3

O Arduino Mega 2560 possui as seguintes características :

• Microcontrolador ATmega 2560 com clock de 16 MHz,
• Regulador de 5V (AMS1117 - 1 A),

WWW.ELETROGATE.COM 21
 • Regulador de 3,3V (LP2985 com apenas 150 mA),
• 4 portas seriais de hardware :
Serial 0 = TX0 (D1) e RX0 (D0)
Serial 1 = TX1 (D18) e RX1 (D19)
Serial 2 = TX2 (D16) e RX2 (D17)
Serial 3 = TX3 (D14) e RX3 (D15)

• Uma porta I2C : I2C : SDA (D20) e SCL (D21)

• Uma porta SPI: MOSI (D51), MISO(D50), SCK(D52) e SS(D53),
• 16 portas analógicas do conversor ADC ( A0 até A15),
• 12 portas PWM de 16 bits (D2 a D13),
• 32 portas Digitais multi-função,
• Um Led para TX0 e um para RX0 (interface serial 0) ,
• Um Led conectado ao pino D13.

A alimentação poderá ser feita através do conector USB ou do conector de energia

(tensão recomendada para a entrada de 7 a 12V). O conector USB é protegido por um
fusível de 500 mA.
O consumo de corrente através da porta USB (alimentação 5V) é de aproximadamente
75 mA (Arduino Mega rodando o programa de exemplo Blink). Cada porta digital do
Arduino Mega pode suportar até 20 mA e ser usada como entrada ou como saída.
A placa tem um botão de RESET e um conector ICSP para gravação de firmware
(opcional).
Observação importante : todos os pinos Digitais e Analógicos funcionam com tensões
de 0 a 5V ! Não use tensões acima de 5V.
A placa tem também um conector ICSP conectado à interface SPI do ATmega2560. Esse
conector poderá ser usado se preferir gravar seu firmware (programas) diretamente no
Microcontrolador.
Comunicação USB-Serial :
Na placa que acompanha o kit, a comunicação entre o PC e Microcontrolador ATmega
2560 é feita através de um outro circuito integrado, o CH340G. Ele é responsável por
coletar os dados vindos da USB do PC e transportá-los para a interface Serial conectada
à Serial 0 do ATmega2560.

Pinout do Arduino Mega

Esse é o diagrama com todos os pinos e conexões do Arduino Mega 2560.
Para uma melhor visualização baixe o PDF :
http://blog.eletrogate.com/wp-content/uploads/2018/08/mega-v3.1-pinout.pdf

WWW.ELETROGATE.COM 22
WWW.ELETROGATE.COM 23
 Instalando o driver da placa
O Arduino Mega R3, em seu projeto oficial, usa o Atmega16U2, que tem seus drivers
(driver é um pequeno programa instalado no seu sistema operacional para que ele saiba
como operar o dispositivo) instalados automaticamente quando você instala a sua
Arduino IDE. Logo, você não necessita instalar driver nenhum para fazer sua placa se
comunicar com o computador.

Já na versão CH340, por utilizar o chip de mesmo nome, é necessário instalar o driver
CH340G. Por sorte, é um processo bem simples, bastando baixar o driver e instalar no
seu computador como se faz com um programa comum.

Para instalá-lo, acesse o site oficial – clicando aqui e faça o download conforme seu
sistema operacional.

Em nosso caso, vamos fazer a instalação da versão para Windows, mas também é
possível instalá-lo no MacOS e no Linux. Clique no link referente ao seu sistema
operacional e aguarde o download ser concluído.
O arquivo baixado será em formato compactado (.zip). Abra-o e dê um duplo clique no
arquivo CH34x_Install_Windows_v3_4.EXE, para executar o instalador. Após, a janela
abaixo será exibida e você só precisa clicar em Install, para iniciar a instalação.

WWW.ELETROGATE.COM 24
 Quando o processo de instalação terminar, a mensagem abaixo será exibida:

Clique em OK e conecte o Arduino ao computador utilizando o cabo USB que

acompanha o kit. Em seguida, clique novamente em Install e aguarde o processo
terminar, sendo exibida a seguinte mensagem:

WWW.ELETROGATE.COM 25
 Com o driver instalado, vamos apenas confirmar se a placa está sendo reconhecida
corretamente pelo computador. Para isso, abra o Gerenciador de Dispositivos do
Windows (basta abrir o menu iniciar e pesquisar por “gerenciador de dispositivos”).
Nele, procure o item “Portas COM e LPT” e veja se a placa está sendo exibida como na
imagem abaixo:

Parte III - Instalando e conhecendo a Arduino IDE

A Arduino IDE é a plataforma oficial para programação do Arduino. Vamos começar
sua instalação fazendo o download do instalador, que pode ser encontrado no site
oficial – clicando aqui.
Recomendamos sempre que você instale a versão estável mais recente disponível para
seu sistema operacional. Como estamos utilizando o Windows 10 em nosso
computador, vamos selecionar a opção Windows Win 10 and newer, 64 bits:

WWW.ELETROGATE.COM 26
 A tela seguinte nos propõe fazer uma contribuição para a plataforma, pode clicar em
“Just Download” – Aqui é de suma importância que seu navegador não traduza a
página, pois essa opção não é exibida quando traduzida.

Na tela seguinte, clique novamente em “Just Download”.

WWW.ELETROGATE.COM 27
 Após esses passos, o download irá iniciar automaticamente. Quando terminar, execute
o arquivo baixado e clique em “Eu concordo” na janela exibida.

WWW.ELETROGATE.COM 28
 Nas telas seguintes, basta clicar em “Próximo” e “Instalar”. Ao término, clique em
concluir para abrir a IDE.

Com a IDE instalada e aberta, vamos conhecer os recursos que serão úteis nessa
apostila. Primeiramente, vamos fazer uma pequena configuração, que será útil
futuramente. Clique em “Arquivo”, na parte superior e vá em “Preferências”. A tela
abaixo será exibida:

WWW.ELETROGATE.COM 29
 Nela, marque as caixinhas “compilar” e “enviar”. Elas são responsáveis por exibir logs e
possíveis erros quando começarmos a programar o Arduino. Você também pode alterar
o idioma, ativar o modo escuro e alterar a fonte, conforme sua preferência. Clique em
“OK” para salvar as alterações.

Abaixo, você encontra as principais funções da IDE que serão usados ao longo dessa
apostila:

Azul: Botão “Upload”, usado para enviar o código para o Arduino;

Vermelho: Aqui você visualiza todas as placas conectadas ao computador. Selecione a
que for correspondente ao seu Arduino;
Verde: Botão para abrir o monitor serial.

WWW.ELETROGATE.COM 30
 Se tudo foi instalado corretamente, você está pronto para iniciar a montagem e
programação dos exemplos!

Parte IV - Seção de Exemplos Práticos

Agora vamos entrar nas seções de exemplos em si. Os conceitos da Parte I são
importantes caso você esteja começando a trabalhar com eletrônica. No entanto,
devido ao aspecto prático da montagem, não necessariamente você precisa de ler toda
a parte introdutória para montar os circuitos abaixo, mas recomendamos que estude os
componentes e suas particularidades para complementar seu conhecimento.

Em cada exemplo vamos apresentar os materiais utilizados, o diagrama, o código e mais:

em um exemplo específico, deixamos um desafio para que você complete o
funcionamento do projeto com base nos conhecimentos adquiridos.

Vamos começar!

Exemplo 1 - Leitura de Sinais Analógicos com Potenciômetro

O potenciômetro nada mais do que um resistor cujo valor de resistência pode ser
ajustado de forma manual. Existem potenciômetros slides e giratórios. Na figura abaixo
mostramos um potenciômetro giratório dos mais comumente encontrados no mercado.

Em ambos, ao variar a posição da chave manual, seja ela giratória ou slide, o valor da
resistência entre o terminal de saída e um dos outros terminais se altera. O símbolo do
potenciômetro é o mostrado na imagem a seguir:

WWW.ELETROGATE.COM 31
 Nesse exemplo, vamos conectar a saída de um potenciômetro a uma entrada
analógica da Arduino Mega. Dessa forma, vamos ler o valor de tensão na saída do
potenciômetro e vê-la variando de 0 a 1023. Mas, como assim, 0 a 1023?

Isso ocorre da seguinte maneira: ao aplicarmos uma tensão de 5V nos terminais do

potenciômetro, a entrada analógica do Arduino converte esse sinal de tensão externo
em um valor digital. Esse valor é representado por um número inteiro que varia de 0 a
1023, resultado da resolução do conversor analógico-digital (ADC) do Arduino, que
trabalha com 10 bits. Em sistemas digitais, a base é 2 porque os dados são representados
em binário, com dois estados possíveis: 0 e 1. Com 10 bits, o ADC pode representar 1024
níveis diferentes. Assim, o intervalo vai de 0 a 1023, totalizando 1024 possíveis valores.
Esse total de 1024 resulta da potência 210 , onde 2 é a base do sistema binário e 10 é o
número de bits de resolução do ADC.

Resumindo, o Arduino divide o valor de tensão de referência (5V) em 1024 unidades (0

a 1023), totalizando 0,00488 volts por unidade. Assim, se a tensão lida na entrada
analógica for de 2,5V, o valor capturado pelo Arduino será dado por 2,5/0,00488, que
resulta em 512. Se for 0V, será 0, e ser for 5V, será 1023, e assim proporcionalmente
para todos os valores. Assim, digamos que um valor de tensão fictício é dado por V. O
valor que o Arduino vai te mostrar será o resultado da divisão de V por 5 (tensão de
referência) multiplicado por 1024 (resolução do ADC). Você pode conferir a fórmula a
seguir:
Valor = (V/5)*1024

Em nosso código, queremos saber o valor de tensão na saída do potenciômetro, e não

um número entre 0 e 1023. Para isso, podemos rearranjar a equação da seguinte forma:

Tensão = Valor*(5/1024)

Bacana, né? Agora, vamos à montagem em si.

WWW.ELETROGATE.COM 32
 Lista de materiais:

Para esse exemplo você vai precisar de:

 Arduino Mega;
 Protoboard;
 Potenciômetro 10K;
 Jumpers.

Diagrama de circuito

Monte o circuito conforme diagrama abaixo e carregue o código de exemplo:

O Potenciômetro possui 3 terminais, sendo que o do meio é o que possui resistência

variável. A ligação consiste em ligar os dois terminais fixos a uma tensão de 5V. Assim, o
terminal intermediário do potenciômetro terá um valor que varia de 0 a 5V à medida
que você gira seu knob.

O terminal intermediário é ligado diretamente a uma entrada analógica do Arduino (A0).

Como a tensão é de no máximo 5V, então não há problema em ligar direto.

WWW.ELETROGATE.COM 33
 Carregue o código abaixo no Arduino e você verá as leituras no Monitor serial da IDE.

// Exemplo 1 - Usando potenciômetro para fazer leituras analógicas

// Apostila Eletrogate - KIT BIG JACK

#define sensorPin A0 // define entrada analógica A0

int sensorValue = 0; // variável inteiro igual a zero

float voltage; // variável número fracionário

void setup(){
Serial.begin(9600); // monitor serial - velocidade 9600 Bps
delay(100); // atraso de 100 milissegundos
}

void loop(){
sensorValue = analogRead(sensorPin); // leitura da entrada analógica A0
voltage = sensorValue * (5.0 / 1024); // cálculo da tensão

Serial.print("Tensão do potenciômetro: "); // imprime no monitor serial

Serial.print(voltage); // imprime a tensão
Serial.print(" Valor: "); // imprime no monitor serial
Serial.println(sensorValue); // imprime o valor
delay(500); // atraso de 500 milissegundos
}

No código, nós declaramos a variável sensorValue para armazenar as leituras da entrada

analógica A0 e a variável Voltage para armazenar o valor lido convertido para tensão.
Declaramos como sendo do tipo float pois precisamos trabalhar com casas decimais, o
que não é permitido no tipo int.

Na função void setup(), nós inicializamos o terminal serial com uma taxa de transmissão
de 9600 bits por segundo. Na função void loop(), primeiro faz-se a leitura da entrada
analógica A0 com a função analogRead(SensorPin) e armazenamos a mesma na variável
sensorValue. Em seguida, aplicamos a fórmula para converter a leitura (que é um
número entre 0 e 1023) para o valor de tensão correspondente. O resultado é
armazenado na variável Voltage e em seguido mostrado na interface serial da IDE
Arduino.

Exemplo 2 - Divisores de Tensão com Resistores

Esse exemplo é para ilustrar como usar um divisor de tensão. Sempre que você precisar
abaixar um sinal lógico de 5V para 3.3V você pode usar esse circuito. Explicamos o divisor
de tensão na seção de introdução, mais especificamente, quando conversamos sobre
conversão de níveis lógicos.

WWW.ELETROGATE.COM 34
 Esse circuito será útil sempre que você tiver que abaixar as saídas do Arduino de 5V para
3.3V.

Lista de materiais:

Para esse exemplo você vai precisar:

 5 resistores de 1KΩ;
 1 Arduino Mega;
 Protoboard;
 Jumpers.

Diagrama de circuito:

Esse é um diagrama com dois divisores de tensão. O primeiro é composto por três
resistores, sendo cada um de 330R. Assim, o resistor Z1 é de 330R e o resistor Z2 é
formado pela associação em série dos outros dois, resultando numa resistência
equivalente de 660R.

Dessa forma, a tensão de saída do divisor é:

((1000+1000) / 1000 + (1000+1000) ) * 5 = 3,33V

O segundo divisor é formado por dois resistores de 1K, dessa forma, a tensão de saída
é a tensão de entrada dividida pela metade:

(1000/ (1000 + 1000)) * 5 = 2,5 V

WWW.ELETROGATE.COM 35
 O código para o exemplo 2 é uma extensão do código usada na seção anterior para ler
valores de tensão do potenciômetro. Nesse caso, nós fazemos a leitura de dois canais
analógicos (A0 e A1), fazemos as conversões para as tensões e mostramos os resultados
de cada divisor na interface serial.

Carregue o código abaixo e observe os dois valores no Monitor Serial da IDE Arduino.

// Exemplo 2 - Divisor de tensão

// Apostila Eletrogate - KIT BIG JACK

#define sensorPin1 A0 // define entrada analógica A0

#define sensorPin2 A1 // define entrada analógica A1

int sensorValue1 = 0; // variável inteiro igual a zero

int sensorValue2 = 0; // variável inteiro igual a zero
float voltage1; // variável número fracionário
float voltage2; // variável número fracionário

void setup()
{
Serial.begin(9600); // monitor serial - velocidade 9600 Bps
delay(100); // atraso de 100 milissegundos
}

void loop()
{
sensorValue1 = analogRead(sensorPin1); // leitura da entrada analógica A0
sensorValue2 = analogRead(sensorPin2); // leitura da entrada analógica A1
voltage1 = sensorValue1 * (5.0 / 1024); // cálculo da tensão 1
voltage2 = sensorValue2 * (5.0 / 1024); // cálculo da tensão 2
Serial.print("Tensão do divisor 1: "); // imprime no monitor serial
Serial.print(voltage1); // imprime a tensão 1
Serial.print(" Tensão do divisor 2: "); // imprime no monitor serial
Serial.println(voltage2); // imprime a tensão 2
delay(500); // atraso de 500 milissegundos
}

Exemplo 3 - Controle de LEDs com Botões

Os push-buttons (chaves botão) e LEDs são elementos presentes em praticamente

qualquer circuito eletrônico. As chaves são usadas para enviar comandos para o Arduino
e os LEDs são elementos de sinalização luminosa.

Esses dois componentes são trabalhados por meio das entradas e saídas digitais do
Arduino. Neste exemplo vamos fazer uma aplicação básica que você provavelmente vai
repetir muitas vezes. Vamos ler o estado de um push-button e usá-la para acender ou
apagar um LED.

WWW.ELETROGATE.COM 36
 Lista de materiais:

Para esse exemplo você vai precisar:

 Resistor de 330Ω;
 Resistor de 1KΩ;
 LED vermelho (ou de outra cor de sua preferência);
 Push-button (chave botão);
 Arduino Mega;
 Protoboard;
 Jumpers.

Diagrama de circuito:

Esse pequeno código abaixo mostra como ler entradas digitais e como acionar as
saídas digitais. Na função void setup(), é preciso configurar qual pino será usado como
saída e qual será usado como entrada.

Depois de configurar os pinos, para acioná-los basta chamar a função digitalWrite(pino,

HIGH). A função digitalWrite() liga ou desliga um pino digital dependendo do valor
passado no argumento. Se for “HIGH”, o pino é ativado. Se for “LOW”, o pino é
desativado.

Na função void loop(), fizemos um if no qual a função digitalRead é usada para saber se
o push-button está acionado ou não. Caso ele esteja acionado, nós acendemos o LED,
caso ele esteja desligado, nós desligamos o LED.

WWW.ELETROGATE.COM 37
 Carregue o código abaixo e pressione o botão para acender o LED.

// Exemplo 3 - Entradas e saídas digitais - push-button + led

// Apostila Eletrogate - KIT BIG JACK

#define PinButton 6 // define pino digital D6

#define ledPin 7 // define pino digital D7

void setup()
{
pinMode(PinButton, INPUT); // configura D8 como entrada digital
pinMode(ledPin, OUTPUT); // configura D7 como saída digital
Serial.begin(9600); // monitor serial - velocidade 9600 Bps
delay(100); // atraso de 100 milissegundos
}

void loop()
{
if (digitalRead(PinButton) == HIGH) // se chave = nível alto
{
digitalWrite(ledPin, HIGH); // liga LED com 5V
Serial.println("Acendendo LED"); // imprime no monitor serial
}
else // senão chave = nível baixo
{
digitalWrite(ledPin, LOW); // desliga LED com 0V
Serial.println("Desligando LED"); // imprime no monitor serial
}
delay(100); // atraso de 100 milissegundos
}

Exemplo 4 - Acionamento de buzzer com um botão

O buzzer é um dispositivo eletrônico que que transforma energia elétrica em som,
através da vibração de uma membrana interna. Essa vibração é feita por um circuito
chamado oscilador, que pode ser interno (quando presente no corpo do buzzer,
recebendo o nome de buzzers ativos) ou externo, quando é necessário que esse
circuito seja conectado ao buzzer (recebendo o nome de buzzers passivos).

Os buzzers ativos diferenciam-se dos passivos também na frequência do som emitido,

já que, por conter internamente o circuito oscilador, geralmente não é possível variar a
frequência em que esse circuito oscila. Já nos buzzers passivos, como o oscilador é
externo ao componente, temos total controle das frequências emitidas, sendo esse o
modelo ideal para projetos em que necessitamos emitir sons específicos.

WWW.ELETROGATE.COM 38
 Buzzer passivo e buzzer ativo, respectivamente

Repare que o circuito do buzzer ativo não é acessível, estando coberto com resina. Já o
buzzer passivo você pode visualizar uma pequena placa de circuito interna, onde os
terminais estão conectados.

Nosso kit traz o buzzer ativo de 5V, que é mais fácil de acionar e desenvolver projetos,
já que, para emitir som, precisa apenas ser energizado. No projeto a seguir, vamos
utilizar o Arduino e um botão para fazer o acionamento desse buzzer.

Lista de materiais:

• Arduino Mega;
• Protoboard;
• Push Button;
• Jumpers.

Diagrama de circuito:

WWW.ELETROGATE.COM 39
 Carregue o código abaixo em seu Arduino:

//Exemplo 4 - Acionamento de buzzer com um botão

//Apostila Eletrogate - KIT BIG JACK

#define BUTTON 3
#define BUZZER 4

void setup(){
pinMode(BUTTON, INPUT_PULLUP);
pinMode(BUZZER, OUTPUT);
Serial.begin(9600);
delay(100);
}

void loop(){
if (digitalRead(BUTTON) == LOW){
digitalWrite(BUZZER, HIGH);
} else {
digitalWrite(BUZZER, LOW);
}
delay(100);
}

Exemplo 5 - Acionamento de LED conforme do Luz Ambiente

O sensor LDR é um sensor de luminosidade. LDR é a sigla para Light Dependent Resistor,
ou seja, um resistor cuja resistência varia com a quantidade de luz que incide sobre ele.
Esse é seu princípio de funcionamento.

Quanto maior a luminosidade em um ambiente, menor a resistência do LDR. Essa

variação na resistência é medida através da queda de tensão no sensor, que varia
proporcionalmente (de acordo com a lei Ohm, lembra?) com a queda na resistência
elétrica.

A imagem abaixo mostra o sensor em mais detalhes:

Foto resistor (LDR)

WWW.ELETROGATE.COM 40
 É importante considerar a potência máxima do sensor, que é de 100 mW. Ou seja, com
uma tensão de operação de 5V, a corrente máxima que pode passar por ele é de 20 mA.
Felizmente, com 8KΩ (que medimos experimentalmente com o ambiente bem
iluminado), que é a resistência mínima, a corrente ainda está longe disso, sendo
0,625mA. Dessa forma, podemos conectar o sensor diretamente ao Arduino.

*Nota: Em suas medições, pode ser que encontre um valor de resistência mínimo
diferente, pois depende da iluminação local e da própria fabricação do componente em
si.

Este sensor de luminosidade pode ser utilizado em projetos com o Arduino e outros
microcontroladores para diversas aplicações, como alarmes, automação residencial,
sensores de presença e vários outros.

Nesse exemplo, vamos usar uma entrada analógica do Arduino para ler a variação de
tensão no LDR e, consequentemente, saber como a luminosidade ambiente está se
comportando. Veja na especificação que, com muita luz, a resistência fica em torno de
10-20KΩ, enquanto no escuro pode chegar a 1MΩ.

Para podermos ler as variações de tensão resultantes da variação da resistência do LDR,

vamos usar o sensor como parte de um divisor de tensão. Assim, a saída do divisor será
dependente apenas da resistência do sensor, pois a tensão de entrada e a outra
resistência são valores conhecidos. Em nosso caso, vamos usar um resistor de 10K e uma
tensão de operação de 5V. Assim, o sinal que vamos ler no Arduino terá uma variação
de 2,2V (quando o LDR for 8KΩ) e 5V (quando o LDR tiver resistências muito maiores
que o resistor de 10KΩ).

Lista de materiais:

Para esse exemplo você vai precisar:

 LDR;
 Resistor de 10KΩ;
 1 Arduino Mega;
 Protoboard;
 Jumpers.

WWW.ELETROGATE.COM 41
 Diagrama de circuito:

No diagrama, o sensor é ligado como parte de um divisor de tensão no pino analógico

A0, de forma que a tensão de saída do divisor varia de acordo com a variação da
resistência do sensor. Assim, vamos identificar as variações na intensidade de luz pelas
variações na tensão do sensor.

Quanto maior a intensidade de luz, menor a resistência do sensor e, consequentemente,

menor a tensão de saída.

WWW.ELETROGATE.COM 42
 Carregue o código abaixo e varie a luminosidade sobre o LDR.

// Exemplo 5 - Sensor de luz LDR

// Apostila Eletrogate - KIT BIG JACK

#define AnalogLDR A0 // define pino analógico A0

#define Limiar 1.5 // define constante igual a 1.5
#define ledPin 13 // define pino digital D13

int Leitura = 0; // variável inteiro igual a zero

float VoltageLDR; // variável número fracionário
float ResLDR; // variável número fracionário

void setup()
{
pinMode(ledPin, OUTPUT); // configura D13 como saída digital
Serial.begin(9600); // monitor serial - velocidade 9600 Bps
delay(100); // atraso de 100 milissegundos
}

void loop()
{
Leitura = analogRead(AnalogLDR); // leitura da tensão no pino analógico
A0
VoltageLDR = Leitura * (5.0/1024); // cálculo da tensão no LDR
Serial.print("Leitura sensor LDR = "); // imprime no monitor serial
Serial.println(VoltageLDR); // imprime a tensão do LDR

if (VoltageLDR > Limiar) // se a tensão LDR maior do que limiar

digitalWrite(ledPin, HIGH); // liga LED com 5V
else // senão a tensão LDR < limiar
digitalWrite(ledPin, LOW); // desliga LED com 0V
delay(500); // atraso de 500 milissegundos
}

No código acima usamos funcionalidades de todos os exemplos anteriores. Como o

sensor é um elemento de um divisor de tensão, efetuamos sua leitura do mesmo modo
que nos exemplos do potenciômetro e divisor de tensão.

Nesse caso, definimos uma tensão de limiar, a partir da qual desligamos ou ligamos um
LED para indicar que a intensidade da luz ultrapassou determinado valor. Esse limiar
pode ser ajustado por você para desligar o led em intensidades diferentes de luz
ambiente.

É importante que o sensor esteja exposto à iluminação ambiente e não sofra

interferência de fontes luminosas próximas, que não sejam parte do ambiente.

WWW.ELETROGATE.COM 43
 Exemplo 6 - Controle de Servo Motor com Potenciômetro

Um servomotor é um equipamento eletromecânico que possui um encoder e um

controlador acoplado. Diferentemente de motores tradicionais, como os de corrente
contínua, o servo motor apresenta movimento rotativo proporcional a um comando de
forma a atualizar sua posição. Ao invés de girar continuamente como os motores de
corrente contínua convencionais, o servo, ao receber um comando, gira até a posição
especificada pelo comando recebido.

Ou seja, o servo motor é um atuador rotativo para controle de posição, que atua com
precisão e velocidade controlada em malha fechada. De acordo com a largura do pulso
aplicado no pino de controle PWM, a posição do rotor é definida (0 a 180 graus) . Os
pulsos devem variar entre 0,5 ms. e 2,5 ms.

Posição do Servo de acordo com a largura do pulso

Fonte : electronics.stackexchange.com

Existem dois tipos de Servomotores :

• Servomotor analógico
• Servomotor digital

Servomotores analógicos são os mais comuns e mais baratos. O controle da posição do

rotor utiliza um método analógico através da leitura de tensão sobre um potenciômetro
interno.

No caso dos servomotores digitais, mais caros e mais precisos, o controle da posição do
rotor utiliza um encoder digital.

A figura abaixo mostra um típico servo motor analógico. Trata-se do Micro Servo Tower
Pro SG90 9G que acompanha o Kit Big Jack para Arduino.

WWW.ELETROGATE.COM 44
 Os Servos são acionados por meio de três fios, dois para alimentação e um
correspondente ao sinal de controle para determinar a posição. Em geral, os três fios
são:
• Marrom ou preto: GND;
• Vermelho: Alimentação positiva;
• Laranja ou branco: Sinal de controle PWM.

Lista de materiais:

Inicialmente, vamos separar os componentes que precisamos para montar o

servomotor junto com o Arduino. A nossa lista de componentes é a seguinte:

 Micro Servo 9g SG90 TowerPro;

 Arduino Mega + cabo USB;
 Potenciômetro de 10KΩ;
 Jumpers para conexão na protoboard;
 Push-button.

A montagem é simples. O servomotor em si deve ser ligado à alimentação conforme as

cores apresentadas na introdução. Para esse exemplo específico não é necessário
utilizar nenhuma fonte externa para alimentar o servo, no entanto, é de suma
importância que a utilize em aplicações que demandam movimentações mais
complexas ou que exijam que o servo permaneça ligado por muito tempo. Nesse caso,
basta conectar o positivo da fonte no fio vermelho do servo e o GND da fonte no fio
marrom/preto do servo e no GND do Arduino.

WWW.ELETROGATE.COM 45
 Diagrama de circuito

A montagem para uma aplicação de controle do servo em qualquer posição, fica da

seguinte forma:

Carregue o código a seguir e gire o potenciômetro para o Servo motor girar:

// Exemplo 6 - Acionando o Micro Servo TowerPro

// Apostila Eletrogate - KIT BIG JACK

#include <Servo.h> // usando biblioteca Servo

Servo myservo; // cria o objeto myservo

#define potpin A0 // define pino analógico A0

int val; // variável inteiro

void setup()
{
myservo.attach(6); // configura pino D6 - controle do Servo
}

void loop()
{
val = analogRead(potpin); // leitura da tensão no pino A0
val = map(val, 0, 1023, 0, 179); // converte a leitura em números (0-179)
myservo.write(val); // controle PWM do servo
delay(15); // atraso de 15 milissegundos
}

WWW.ELETROGATE.COM 46
 O aspecto mais importante desse software é a utilização da biblioteca servo.h.
Bibliotecas nada mais são que conjuntos de código prontos para facilitar a
programação, e essa possui as funções necessárias para posicionar a servo para a
posição desejada. Na função Void Setup() nós associamos o objeto servomotor, do
tipo Servo, a um pino do Arduino. Na mesma função, nós inicializamos o servo na
posição 0º, utilizando o método write do objeto que acabamos de criar.

Na função Void Loop(), o procedimento consiste em ler o valor do potenciômetro e usá-

lo como referência para atualizar a posição do servo. A leitura analógica do
potenciômetro retorna um valor entre 0 e 1023. Para controlar o servo nós usamos
valores de 0 a 179, correspondendo ao meio giro de 180º do mesmo. Assim, é necessário
usar a função Map() para traduzir a escala de 0-1023 para a escala de 0-179. Dessa
forma, os valores lidos do potenciômetro podem ser usados como referência para
determinar a posição do servomotor.

Para atualizar a posição do servo a cada contagem do loop, nós chamamos o método
write() do objeto servomotor, passando como parâmetro o valor lido do potenciômetro
traduzido para a escala de 0-179. Assim, sempre que mexermos no potenciômetro, o
servo motor irá atuar e atualizar a sua posição.

Exemplo 7 - Medindo a Temperatura do Ambiente

O sensor de temperatura NTC pertence a uma classe de sensores chamada de

Termistores. São componentes cuja resistência é dependente da temperatura. Para
cada valor de temperatura absoluta há um valor de resistência.

Assim, o princípio para medir o sinal de um termistor é o mesmo que usamos para medir
o sinal do LDR. Vamos medir na verdade, a queda de tensão provocada na resistência
do sensor.

Existem dois tipos básicos de termistores:

 PTC (Positive temperature coeficient): Nesse sensor, a resistência elétrica

aumenta à medida que a temperatura aumenta;

 NTC (Negative Temperature Coeficient): Nesse sensor, a resistência elétrica

diminui à medida que a temperatura aumenta.

WWW.ELETROGATE.COM 47
 O termistor que acompanha o kit é do tipo NTC, como o próprio nome diz. Esse é o tipo
mais comum do mercado.

O grande problema dos termistores é que é necessária fazer uma função de calibração,
pois a relação entre temperatura e resistência elétrica não é linear. Existe uma equação,
chamada equação de Stein Hart-Hart que é usada para descrever essa relação (vide
referências).

O código que vamos usar nesse exemplo utiliza a equação de Stein-Hart conforme a
referência 1.

Lista de materiais:

 1 Sensor de temperatura NTC;

 Arduino Mega + cabo USB;
 1 resistor de 10KΩ;
 Protoboard;
 Jumpers para conexão no protoboard.

Diagrama de circuito:

WWW.ELETROGATE.COM 48
 Carregue o código abaixo e meça a temperatura com o NTC:

// Exemplo 7 - Sensor de temperatura NTC

// Apostila Eletrogate - KIT BIG JACK

#define Vin 5.0 // define a tensão de entrada igual a 5.0

#define T0 298.15 // define constante igual a 298.15 Kelvin
#define Rt 10000 // Resistor do divisor de tensão
#define R0 10000 // Valor da resistência inicial do NTC
#define T1 273.15 // [K] in datasheet 0º C
#define T2 373.15 // [K] in datasheet 100° C
#define RT1 35563 // [ohms] Resistência in T1
#define RT2 549 // [ohms] Resistência in T2
float beta = 0.0; // parâmetros iniciais [K]
float Rinf = 0.0; // parâmetros iniciais [ohm]
float TempKelvin = 0.0; // variable output
float TempCelsius = 0.0; // variable output
float Vout = 0.0; // Vout in A0
float Rout = 0.0; // Rout in A0

void setup(){
Serial.begin(9600); // monitor serial - velocidade 9600 Bps
beta = (log(RT1 / RT2)) / ((1 / T1) - (1 / T2)); // cálculo de beta
Rinf = R0 * exp(-beta / T0); // cálculo de Rinf
delay(100); // atraso de 100 milissegundos
}

void loop(){
Vout = Vin * ((float)(analogRead(0)) / 1024.0); // cálculo de V0 e leitura de A0
Rout = (Rt * Vout / (Vin - Vout)); // cálculo de Rout
TempKelvin = (beta / log(Rout / Rinf)); // cálculo da temp. em Kelvins
TempCelsius = TempKelvin - 273.15; // cálculo da temp. em Celsius
Serial.print("Temperatura em Celsius: "); // imprime no monitor serial
Serial.print(TempCelsius); // imprime temperatura Celsius
Serial.print(" Temperatura em Kelvin: "); // imprime no monitor serial
Serial.println(TempKelvin); // imprime temperatura Kelvins
delay(500); // atraso de 500 milissegundos
}

Exemplo 8 - Acionamento de uma Lâmpada com Relé

O Módulo Relé nada mais é do que um ou mais relés acionados por sinais digitais de 5V.
Esse componente é indicado para acionar cargas que utilizam correntes maiores do que
a suportada pelo Arduino, ou então uma carga de um circuito de corrente alternada
(rede elétrica).

O módulo de relé pode ser usado para vários tipos de aplicações:

• ativação de eletroímãs,

WWW.ELETROGATE.COM 49
 • ativação de motores CC,
• ativação de motores CA,
• ligar/desligar lâmpadas.

O terminal de controle do relé (bobina) é ligado a um dos pinos

digitais do Arduino. O outro terminal da carga é ligado ao outro
terminal da tomada (ou ao outro terminal da bateria).

Uma das aplicações mais comuns dos módulos relés para Arduino
é no acendimento de lâmpadas em sistemas de automação
residencial. O módulo funciona exatamente da mesma forma que
uma chave ou interruptor. Ao lado temos a pinagem de um relé comum:

• C - Terminal Comum
• NA - Contato Normalmente Aberto
• NF - Contato Normalmente Fechado

O terminal C é o Comum do Contato. Os outros dois terminais usamos para ligar ou

desligar a carga. Se ligamos a carga no terminal NA, a carga será acionada quando
enviarmos um sinal. Se ligarmos a carga no pino NF, ela será ativada setando o pino de
controle do Arduino para nível baixo, e desligada setando o pino de controle para nível
alto.
A capacidade corrente em cada contato é de 10 A. Não ultrapasse esse valor, para não
danificar o seu relé.
Os outros dois terminais são para alimentação da bobina do relé – no caso 5V . O
terminal de controle do Módulo está conectado nessa bobina. O consumo de corrente
da bobina do relé é de aproximadamente 60 mA, quando energizada.
No mercado você pode encontrar módulos de 1 , 2, 4 e 8 canais. Cada canal corresponde
a um relé montado no módulo. Ou seja, um módulo relé de 5V e 8 canais, é um conjunto
de 8 relés acionados por sinais separados de 5V. Um módulo relé de 12V e 4 canais, nada
mais do que um conjunto de 4 relés, cada qual acionado por sinais de 12V.
Na imagem abaixo temos como exemplo um relé de 4 canais.

WWW.ELETROGATE.COM 50
 Repare que cada relé possui os três terminais que explicamos mais acima. Além deles,
há outros 6 pinos usados para interfacear o módulo com o Arduino. São eles:
 GND,
 IN1,
 IN2,
 IN3,
 IN4,
 VCC.

Cada pino INx serve para acionar um dos relés. VCC e GND são os pinos de alimentação
do Módulo do relé : VCC deve ser conectado no +5V e o GND no negativo, ambos da
fonte. O GND do Módulo Relé deve estar conectado também no GND do Arduino !

Lista de Materiais:
Para este exemplo você vai precisar:
 Protoboard,
 Arduino Mega,
 Jumpers de ligação,
 Módulo relé de 1 canal,
 Uma chave táctil (push-button),
 1 resistor de 10K.

IMPORTANTE: se você não tem conhecimentos em montagens de circuitos elétricos

CA, procure uma pessoa especializada para montar para você. Risco de choque
elétrico ! Verifique todas as ligações, antes de energizar o circuito ! A Eletrogate não
se responsabilizará por danos materiais ou pessoais no caso de acidentes.

Diagrama de circuito:

WWW.ELETROGATE.COM 51
 Código para acionar o Relé com uma chave táctil:

// Exemplo 8 - Módulo Relé 1 Canal

// Apostila Eletrogate - KIT BIG JACK

int buttonPin = 3; // pino D3 para botao

int ledPin = 13; // LED na placa Arduino

int IN1 = 2; // pino D2 para controle do rele

int ledState = LOW; // estado do LED = LOW

int buttonState; // variavel do estado do botao

int lastButtonState = LOW; // estado previo do botao = LOW

unsigned long lastDebounceTime = 0; // ultimo tempo de debounce

unsigned long debounceDelay = 50; // timer do debounce 50 ms

void setup(){

pinMode(ledPin, OUTPUT); // pino do LED = saida

pinMode(buttonPin, INPUT); // pino do botao = entrada

pinMode(IN1, OUTPUT); // pino de controle do rele = saida

digitalWrite(ledPin, ledState); // apaga o LED

digitalWrite(IN1, ledState); // desliga o rele

void loop(){

int reading = digitalRead(buttonPin); // le o estado do botao

if (reading != lastButtonState){ // se o estado for diferente do anterior

lastDebounceTime = millis(); // reset do timer debouncing

if ((millis() - lastDebounceTime) > debounceDelay) {

// se o tempo do botao pressionado for maior do que debounce

if (reading != buttonState){ // se o estado do botao for diferente do anterior

buttonState = reading; // muda o estado do botao

if (buttonState == HIGH){ // se o botao esta no nivel High

ledState = !ledState; // muda o estado do LED

digitalWrite(ledPin, ledState); // seta o LED

digitalWrite(IN1, ledState); // seta o estado do rele 1

lastButtonState = reading; // salva a leitura do botao

}
WWW.ELETROGATE.COM 52
 H com módulo relé 2 canais

Exemplo 9 - Acendendo um LED com Sensor Reflexivo Infravermelho

O sensor ótico reflexivo TCRT5000 é um dos mais populares para utilização em projetos
com Arduino. Trata-se de um sensor reflexivo que possui um emissor infravermelho e
um fototransistor. O emissor é um led infravermelho que emite um sinal nessa faixa do
espectro. Já o fototransistor é o receptor que faz a leitura do sinal refletido.
Ou seja, o led emite um feixe infravermelho que pode ou não ser refletido por um
objeto. Caso o feixe seja refletido, o fototransistor identifica o sinal refletido e gera um
pulso em sua saída.
A distância máxima de detecção não é grande, ficando em torno de 25 mm (dois
centímetros e meio), o que pode limitar um pouco a sua aplicação. O fototransistor vem
com um filtro de luz ambiente, o que maximiza a identificação do feixe infravermelho
refletido.

Sensor TCRT5000 visto por cima Fonte: Vishay

Lista de materiais:

 Arduino Mega R3;

 Protoboard;
 Sensor TCRT5000;
 Led vermelho 5mm;
 Resistor de 330;
 Resistor de 10K;
 Jumpers para ligação no protoboard;

WWW.ELETROGATE.COM 53
 Diagrama de Circuito:

O terminal Anodo (A) positivo do LED infravermelho está ligado por meio de um resistor
de 330R ao VCC (5V) e o seu terminal catodo (K) negativo está ligado em GND. O Coletor
(C) do fototransistor está ligado ao resistor de 10K (que está conectado no VCC) e
também na entrada digital D7 do Arduino. Essa entrada é que vamos usar para
identificar se o sensor percebeu algum objeto ou não. O Emissor (E) do fototransistor
está ligado ao GND.
O LED vermelho para indicação do Sensor, tem o terminal Anodo (A) positivo conectado
à um resistor de 330R que está conectado à porta digital D8 do Arduino. O terminal
catodo (K) negativo está ligado ao GND.

WWW.ELETROGATE.COM 54
 Código:

// Exemplo 9 - Sensor Ótico Reflexivo TCRT5000

// Apostila Eletrogate - KIT BIG JACK

int leituraSensor; // variavel de leitura do sensor

int led = 8; // led indicador = D8 do Arduino

int fotoTransistor = 7; // coletor do fototransistor = D7 do Arduino

void setup(){

pinMode(led, OUTPUT); // pino do led indicador = saida

pinMode(fotoTransistor, INPUT); // pino do coletor do fototransistor =
entrada

void loop(){
leituraSensor = digitalRead(fotoTransistor); // leitura do sensor TCRT5000

if (leituraSensor == 0 ){ // se o led refletir a luz

digitalWrite(led, HIGH); // acende LED indicador

}
else { // senão

digitalWrite(led, LOW); // apaga LED indicador

delay(500); // atraso de 0,5 segundos
}
}

O código para utilização do sensor TCRT5000 é bem simples. Com o circuito montado,
basta monitorar o estado do pino no qual a saída do sensor (coletor do fototransistor)
está ligada. Se esse pino estiver em nível baixo, é porque algum objeto está presente
dentro do raio de medição do sensor ( a luz infra-vermelha do LED esta sendo
refletida) . Se o pino estiver em nível alto, então não há objeto nenhum no raio de
medição do sensor.
Nesse exemplo, a presença do sensor é identificada pelo acionamento de um led, ou
seja, sempre que um objeto for identificado pelo sensor, o led ficará aceso.

WWW.ELETROGATE.COM 55
 Exemplo 10 – Efeito fade

Este projeto demonstra como criar um efeito de fade no LED, onde seu brilho aumenta
e diminui gradativamente e de forma automática.

Lista de materiais:
• Arduino Mega + cabo;
• LED;
• Resistor de 330Ω;
• Protoboard;
• Jumpers.

Diagrama de circuito:

Carregue o código a seguir:

WWW.ELETROGATE.COM 56
 // Exemplo 10 - Efeito fade
// Apostila Eletrogate - KIT BIG JACK

#define LED 3 //nomeia o pino 3

void setup(){
pinMode(LED, OUTPUT); //seta o pino 3 como saída
}

void loop(){
for(int i=0; i<255; i++){ //incrementa os valores de 0 até 255
analogWrite(LED, i); //liga o LED proporcionalmente a i
delay(10); //aguarda 10 milissegundos
}
for(int i=255; i>0; i--){ //decrementa os valores de 255 até 0
analogWrite(LED, i); //liga o LED proporcionalmente a i
delay(10); //aguarda 10 milissegundos
}
}

Seu funcionamento é simples e pode ser explicado usando o conceito de iteração. Na

programação, chamamos de iteração o processo de executar um conjunto de
instruções várias vezes dentro de um laço de repetição (também chamado de loop),
até que a condição de verificação deste seja falsa.

Nesse exemplo, usamos o laço for() para iniciar uma iteração. O laço inicia a variável ‘i’
em zero e incrementa seu valor de 1 em 1 até que a condição “i < 255” seja falsa. A
cada iteração, o brilho do LED é ajustado conforme o valor de ‘i’ e o programa aguarda
10 milissegundos antes de fazer o próximo incremento. Esse processo aumenta o
brilho do LED de forma gradativa no primeiro for() e diminui, também gradativamente,
no segundo for().

Exemplo 11 - Controlando o brilho do LED com potenciômetro

Vamos repetir os conceitos apresentados no exemplo 5 e utilizar um potenciômetro

para variar o brilho de um LED. O princípio de funcionamento é o mesmo, com a
diferença de que o comando map(), para o servo, vai de 0 a 180 por referenciar o
ângulo de atuação, dado em graus. No caso do LED, vamos variar o valor de 0 a 255,
sendo esse o intervalo válido para o controle de brilho através do sinal de PWM gerado
pelo Arduino.

Lista de materiais:

• Arduino Mega + cabo;

WWW.ELETROGATE.COM 57
 • Potenciômetro 10KΩ;
• 1 LED;
• 1 Resistor de 330Ω
• Protoboard;
• Jumpers.

Diagrama de circuito

O código para esse projeto é simples, como podemos conferir abaixo:

// Exemplo 11 - Controlando o brilho do LED com potenciômetro

// Apostila Eletrogate - KIT BIG JACK

#define LED 3 //nomeia o pino do LED

#define POT A0 //nomeia o pino do potenciômetro

void setup(){
pinMode(LED, OUTPUT); //configura o pino do led como saída
}

void loop(){
int brilho = map(analogRead(POT), 0, 1023, 0, 255); //conversão de valores
analogWrite(LED, brilho); //varia o brilho do LED
}

WWW.ELETROGATE.COM 58
 Faça o upload do código após as conexões e gire o eixo do potenciômetro para variar o
brilho do LED.

Exemplo 12 – Explorando o efeito de persistência da visão (POV) com

LED

Nesse exemplo, vamos explorar o efeito POV, sigla em inglês para Persistência da
Visão. Esse efeito se resume a uma ilusão de óptica, na qual nosso olho continua a ver
uma imagem mesmo após a fonte de luz cessar.

Lista de materiais:

• Arduino Mega + cabo;

• Potenciômetro 10KΩ;
• 1 LED;
• 1 Resistor de 330Ω
• Protoboard;
• Jumpers.

Diagrama de circuito

WWW.ELETROGATE.COM 59
 Carregue o código abaixo em seu Arduino:

//Exemplo 12 - Controlando LEDs com funções diferentes sem usar delay()

// Apostila Eletrogate - KIT BIG JACK

//Definição dos pinos

#define ledPin 3 // Pino do LED

int intervalo; // Intervalo em milissegundos para o piscar do LED

void setup() {
pinMode(ledPin, OUTPUT); // Configura o pino do LED como saída
}

void loop() {
int leituraPotenciometro = analogRead(A0); // Lê o valor do potenciômetro

// Mapeia a leitura do potenciômetro para um intervalo de 10 ms a 1000 ms

intervalo = map(leituraPotenciometro, 0, 1023, 10, 1000);

// Alterna o estado do LED com base no intervalo

digitalWrite(ledPin, HIGH);
delay(intervalo); // Espera o intervalo em milissegundos
digitalWrite(ledPin, LOW);
delay(intervalo); // Espera o intervalo em milissegundos
}

Repare que, conforme você gira o potenciômetro, a frequência em que o LED pisca
aumenta ou diminui. Configuramos para que consiga variar de 1Hz (1x por segundo)
até 100Hz (100x por segundo), de modo que, quanto mais próximo de 100Hz menos
percepção do LED piscando você irá ter, graças ao efeito de persistência da visão.
Legal, né?

Exemplo 13 - Controlando LEDs com funções diferentes sem usar delay()

Em projetos anteriores, utilizamos a função delay() para pausar a execução do código

por um tempo determinado. No entanto, essa abordagem interrompe a execução do
programa, o que pode não ser ideal para projetos onde várias ações precisam
acontecer simultaneamente. Neste exemplo, vamos ensinar como controlar o brilho
de um LED usando um potenciômetro ao mesmo tempo em que um segundo LED pisca
de forma intermitente, sem interferir no primeiro.

WWW.ELETROGATE.COM 60
 Para isso, utilizaremos a função millis(), que atua como um contador interno do
Arduino e começa a ser incrementado a partir do momento em que o
microcontrolador é energizado ou resetado, funcionando independentemente do
código em execução.

Essa função nos permite medir o tempo decorrido e gerenciar essas ações de forma
eficiente, sem interromper o fluxo do programa.

Lista de materiais:
• Arduino Mega;
• Protoboard;
• Potenciômetro 10KΩ;
• 2 LEDs;
• 2 Resistores de 330Ω;
• Jumpers.

Diagrama de circuito

A lógica de funcionamento do código é bem simples. Primeiro, vamos atribuir os

valores enviados pelo potenciômetro e já convertidos num intervalo entre 0 e 255 à
variável brilho, em seguida usamos o comando analogWrite() para acionar o LED
conforme atribuímos a função millis() à variável millisPisca, que é declarada como
unsigned long porque precisamos armazenar valores muito grandes (já que a

WWW.ELETROGATE.COM 61
 contagem ocorre em milissegundos) e sabemos que não usaremos números negativos
— daí o uso do termo unsigned, que significa 'sem sinal'.

No loop, fazemos duas verificações para saber quanto tempo passou. Primeiro,
verificamos se a diferença entre o valor atual de millis() e o valor armazenado em
millisPisca é menor que o intervalo definido para o LED piscar. Se essa condição for
verdadeira, o LED é ligado. Se for falsa, o LED será desligado e o valor de millisPisca é
atualizado, recebendo a contagem atual de millis(), reiniciando o ciclo.

Carregue o código abaixo em seu Arduino e manipule o potenciômetro para observar o

funcionamento descrito:

//Exemplo 13 - Controlando LEDs com funções diferentes sem usar delay()

// Apostila Eletrogate - KIT BIG JACK

//Definição dos pinos

#define LED_BRILHO 3
#define LED_PISCA 4
#define POT A0

#define tempoLED_PISCA 250 //Intervalo desejado para o LED piscar

unsigned long millisPisca = millis(); //Recebe o valor inicial de millis()

void setup(){
//Definindo ambos os pinos dos LEDs como saída
pinMode(LED_BRILHO, OUTPUT);
pinMode(LED_PISCA, OUTPUT);

void loop (){

int brilho = map(analogRead(POT), 0, 1023, 0, 255); //conversão de valores
analogWrite(LED_BRILHO, brilho); //varia o brilho do LED

//Se a diferença entre o valor atual de millis e o valor armazenado for menor que
o intervalo desejado:
if((millis() - millisPisca) < tempoLED_PISCA){
digitalWrite(LED_PISCA, HIGH); //Ligue o LED
} else {
digitalWrite(LED_PISCA, LOW); //Senão, desligue o LED
if ((millis() - millisPisca) >= 2 * tempoLED_PISCA) { // Se um ciclo foi
completo:
millisPisca = millis(); //atualiza millisPisca com o valor atual de millis()
}
}
}

WWW.ELETROGATE.COM 62
 Exemplo 14 – Diferença entre transistores NPN e PNP na prática
Como vimos anteriormente, existem dois tipos de transistores, os NPN e os PNP. Nesse
exemplo, vamos mostrar na prática as diferenças na conexão com a carga (em nosso
caso, um LED) e as mudanças no código para o acionamento de cada um.

Lista de materiais:

• Arduino Mega;
• Protoboard;
• 2 LEDs;
• 2 Resistores de 330Ω;
• 2 resistores de 10KΩ;
• Transistor BC548;
• Transistor BC558;
• Jumpers.

Diagrama de circuito

No diagrama acima, podemos observar a diferença na conexão dos LEDs dependendo

do tipo de transistor usado. Embora os transistores NPN (BC548) e PNP (BC558)

WWW.ELETROGATE.COM 63
 tenham a mesma disposição de terminais (Coletor – Base – Emissor), a forma como a
corrente flui através deles é diferente - reveja o esquemático dos transistores, lá na
página 17.

No transistor NPN (BC548), o emissor está conectado ao negativo (GND) do Arduino e

o coletor ao terminal negativo do LED. Nesse caso, considerando o sentido
convencional da corrente elétrica, os elétrons fluem do positivo (coletor) para o
negativo, que está conectado ao emissor. Assim, a corrente elétrica passa primeiro
pelo LED e seu resistor e depois pelo transistor, antes de chegar ao polo negativo.

No transistor PNP (BC558), o emissor está conectado ao positivo do Arduino (+5V) e o

coletor ao terminal positivo do LED através do resistor. Nesse caso, os elétrons fluem
do LED para o coletor do transistor e, em seguida, do emissor para o polo positivo.
Para que o transistor PNP conduza, o emissor precisa estar mais positivo que a base —
por isso, utilizamos o comando digitalWrite(PNP, LOW) para ativá-lo. Quando
aplicamos um sinal negativo à base, a corrente flui do emissor para o coletor, ativando
o LED.

Em ambos os casos, o fluxo da corrente é controlado pela base do transistor, que

recebe um sinal do Arduino. No transistor NPN, aplicamos um sinal positivo à base
(digitalWrite(NPN, HIGH)) para que os elétrons possam fluir do coletor para o emissor.
No transistor PNP, aplicamos um sinal negativo à base para permitir que os elétrons
fluam do emissor para o coletor. Isso faz com que os transistores NPN e PNP trabalhem
de forma invertida no circuito.

Uma forma bem simples de entender como a corrente flui pelo transistor é observar a
setinha presente no emissor, na simbologia do componente. Note que, no transistor
NPN, essa seta está saindo do transistor, indicando que a corrente entra no transistor
pelo coletor e sai pelo emissor.

Já no PNP, a seta está entrando no transistor, indicando que a corrente entra no

transistor pelo emissor e sai pelo coletor.

WWW.ELETROGATE.COM 64
 Com esses conceitos em mente, carregue o código no Arduino e veja o funcionamento
do circuito:

//Exemplo 14 - Diferença entre transistores NPN e PNP na prática

//Apostila Eletrogate - KIT BIG JACK

//Definição dos pinos

#define PNP 5
#define NPN 6

void setup() {
//Configura os pinos como saída
pinMode(NPN, OUTPUT);
pinMode(PNP, OUTPUT);
}

void loop() {
//Envia um sinal de nível lógico alto aos transistores
digitalWrite(NPN, HIGH);
digitalWrite(PNP, HIGH);

delay(1000); // Aguarda 1 segundo

// Envia um sinal de nível lógico baixo aos transistores

digitalWrite(NPN, LOW);
digitalWrite(PNP, LOW);

delay(1000); //Aguarda 1 segundo

}

Exemplo 15 – Acionamento de cargas usando transistores

Nesse exemplo, vamos abordar o uso dos transistores como drivers, utilizando o
BC548. A principal vantagem dessa configuração é permitir ao Arduino controlar cargas
de maior corrente sem sobrecarregar seus pinos digitais (que fornecem somente 40mA
cada). Para ilustrar isso, vamos usar o transistor para acionar 10 LEDs ao mesmo
tempo, totalizando cerca de 75mA (conforme nossas medições).

Lista de materiais:
• Arduino Mega;
• Protoboard;
• 10 LEDs;
• 10 Resistores de 330Ω;
• 1 Resistor de 10KΩ;
• Transistor BC548;
• Jumpers.

WWW.ELETROGATE.COM 65
 Diagrama de circuito:

Carregue o código abaixo em seu Arduino:

//Exemplo 15 - Acionamento de cargas usando transistores

//Apostila Eletrogate - KIT BIG JACK

//Definição dos pinos

#define NPN 4

void setup() {
//Configura os pinos como saída
pinMode(NPN, OUTPUT);
}

void loop() {
//Envia um sinal de nível lógico alto aos transistores
digitalWrite(NPN, HIGH);
delay(1000); // Aguarda 1 segundo
// Envia um sinal de nível lógico baixo aos transistores
digitalWrite(NPN, LOW);
delay(1000); //Aguarda 1 segundo
}

Por ser uma pessoa interessada em aprender, você pode estar se perguntando:

WWW.ELETROGATE.COM 66
 “Mas como chegaram a esses valores para o resistor de base nos exemplos 11 e 12?”

Ao final da apostila, deixamos uma explicação completa de como calcular esse resistor,
juntamente com exemplos de cálculo para que você aprenda a dimensioná-lo
corretamente.

Exemplo 16 – Semáforo com Arduino

Nesse projeto, vamos definir as regras que queremos que nosso código siga. Dessa
forma, você pode associar o que a descrição da regra pede que seja feito com os
comandos, ajudando na compreensão do funcionamento do código. Acompanhe:

Lista de materiais:

• Arduino Mega;
• Protoboard;
• 2 LEDs vermelhos;
• 2 LEDs verdes;
• 1 LED amarelo;
• 5 Resistores de 330Ω;
• Jumpers.

Diagrama de circuito

WWW.ELETROGATE.COM 67
 O código deverá satisfazer as seguintes situações:

1- O semáforo de veículos deve permanecer verde por 8s, desligando em seguida;

2- O LED amarelo acende por 3s, apaga e depois o LED vermelho dos veículos e o
LED verde dos pedestres acendem;
3- O semáforo de pedestres fica aberto por 7s;
4- Após 4s, o LED vermelho pisca e permanece aceso enquanto o semáforo de
veículos está verde.

O resultado é o código abaixo. Carregue-o em seu Arduino e confirme o

funcionamento descrito.

WWW.ELETROGATE.COM 68
 //Exemplo 16 - Semáforo com Arduino
// Apostila Eletrogate - KIT BIG JACK

//Definições dos pinos onde os LEDs dos pedestres e veículos estão

conectados
#define VERDE_PED 3
#define VERMELHO_PED 4
#define VERDE_VEI 5
#define AMARELO_VEI 6
#define VERMELHO_VEI 7

void setup() {
pinMode(VERDE_PED, OUTPUT);
pinMode(VERMELHO_PED, OUTPUT);
pinMode(VERDE_VEI, OUTPUT);
pinMode(AMARELO_VEI, OUTPUT);
pinMode(VERMELHO_VEI, OUTPUT);
}

void loop() {
digitalWrite(VERMELHO_VEI, LOW); //Desliga o LED vermelho dos veículos
digitalWrite(VERDE_VEI, HIGH); //Liga o LED verde dos veículos
digitalWrite(VERMELHO_PED, HIGH); //Liga o LED vermelho dos pedestres
delay(8000);
digitalWrite(VERDE_VEI, LOW); //Desliga o LED verde dos veículos
digitalWrite(AMARELO_VEI, HIGH); //Liga o LED amarelo do veículos
delay(3000);
digitalWrite(AMARELO_VEI, LOW); //Desliga o LED amarelo dos veículos
digitalWrite(VERMELHO_PED, LOW); //Desliga o LED vermelho dos pedestres
digitalWrite(VERMELHO_VEI, HIGH); //Liga o LED vermelho dos veículos
digitalWrite(VERDE_PED, HIGH); //Liga o LED verde dos pedestres
delay(5000);
digitalWrite(VERDE_PED, LOW); //Desliga o LED verde dos pedestres

//Laço para piscar o LED vermelho dos pedestres

for (int i = 0; i < 4; i++) {
digitalWrite(VERMELHO_PED, HIGH);
delay(250);
digitalWrite(VERMELHO_PED, LOW);
delay(250);
}
}

Exemplo 17- Acionando displays de 7 segmentos

Os displays de 7 segmentos surgiram a partir da evolução dos LEDs. Um LED é um diodo
semicondutor que emite luz quando uma corrente elétrica o atravessa. Para evitar que
ele queime, é essencial limitar a corrente, por isso um resistor em série deve ser utilizado
ao energizá-lo.
Cada segmento do display é, na verdade, um LED individual. Ao acionar os segmentos,
podemos formar números e letras (com algumas limitações). Os segmentos são
identificados por letras de A a G, além do ponto decimal, rotulado como DP.

WWW.ELETROGATE.COM 69
 Existem dois tipos de displays: catodo comum e anodo comum. No display de catodo
comum, os negativos de todos os segmentos estão conectados a um único pino. No
display de anodo comum, os positivos são os pinos interligados entre si, resultando em
um acionamento invertido em relação ao catodo comum.
Neste projeto, utilizamos um display de 7 segmentos de catodo comum. Os pinos
marcados com bolinhas pretas representam os pinos comuns dos catodos. Utilize
apenas um desses pinos, pois ambos estão interligados internamente. Os demais devem
ser conectados ao Arduino através de um resistor para limitar a corrente.

Lista de componentes

• Arduino;
• Protoboard;
• 8 resistores de 330Ω;
• Display de 7 segmentos;
• Jumpers.

Diagrama de montagem

WWW.ELETROGATE.COM 70
 Em nosso código, vamos explorar dois novos recursos da programação: arrays e
funções. Começando com os arrays, para ilustrar, imagine uma gaveta que guarda um
único parafuso – esta representa uma variável. Agora, pense em uma segunda gaveta
com divisórias, onde cada compartimento contém um parafuso de tamanho diferente.
Isso é o que chamamos de array.

Por exemplo, um array chamado tamanhoParafuso[3] pode armazenar três valores:

tamanhoParafuso[0] = 25, tamanhoParafuso[1] = 30, tamanhoParafuso[2] = 20. Cada
tamanho ocupa uma posição específica, chamada índice, que começa em 0,
permitindo acesso individual sem afetar os demais.

Quanto às funções, elas nos permitem nomear um conjunto de instruções que podem
ser reutilizadas em outras partes do código. Por exemplo, ao fazer um LED piscar com
o Arduino, em vez de repetir os comandos de ligar, aguardar e desligar, você pode criar
uma função chamada piscaLED(). Dentro dessa função, reunimos todos os comandos
necessários para realizar a tarefa de piscar o LED. Assim, sempre que precisar que o
LED pisque, em vez de repetir os quatro comandos, você simplesmente chama
piscaLED(), trazendo organização, praticidade e legibilidade ao seu código, facilitando
seu entendimento e manutenção.

WWW.ELETROGATE.COM 71
 Tendo isso em mente, carregue o código abaixo em seu Arduino:
//Exemplo 17 - Acionando displays de 7 segmentos
//Apostila Eletrogate - KIT BIG JACK

int pinos[8] = {2, 3, 4, 5, 6, 7, 8, 9};

int N0[8] = {0, 0, 0, 1, 0, 0, 0, 1};
int N1[8] = {1, 0, 0, 1, 1, 1, 1, 1};
int N2[8] = {0, 0, 1, 1, 0, 0, 1, 0};
int N3[8] = {0, 0, 0, 1, 0, 1, 1, 0};
int N4[8] = {1, 0, 0, 1, 1, 1, 0, 0};
int N5[8] = {0, 1, 0, 1, 0, 1, 0, 0};
int N6[8] = {0, 1, 0, 1, 0, 0, 0, 0};
int N7[8] = {0, 0, 0, 1, 1, 1, 1, 1};
int N8[8] = {0, 0, 0, 1, 0, 0, 0, 0};
int N9[8] = {0, 0, 0, 1, 0, 1, 0, 0};

void reset7Seg() {
for (int i = 0; i < 8; i++) {
digitalWrite(pinos[i], HIGH);
}
}

void exibir(int caractere) {

reset7Seg(); //Limpar o display
switch (caractere) {
case 0:
for (int i = 0; i < 8; i++) {
if (N0[i] == 1) {
digitalWrite(pinos[i], HIGH);
} else {
digitalWrite(pinos[i], LOW);
}
}
break;
case 1:
for (int i = 0; i < 8; i++) {
if (N1[i] == 1) {
digitalWrite(pinos[i], HIGH);
} else {
digitalWrite(pinos[i], LOW);
}
}
break;
case 2:
for (int i = 0; i < 8; i++) {
if (N2[i] == 1) {
digitalWrite(pinos[i], HIGH);
} else {
digitalWrite(pinos[i], LOW);
}
}
break;
}
}

void setup() {
for (int i = 0; i < 8; i++) {
pinMode(pinos[i], OUTPUT);
}
}

void loop() {
for (int i = 0; i < 3; i++) { // Mude o limite para o número total de caracteres
configurados no switch + 1
exibir(i);
delay(1000); // Esperar 1 segundo entre os caracteres
}
}

WWW.ELETROGATE.COM 72
 Seu funcionamento é bem simples: criamos um array com 8 posições para armazenar
os pinos do Arduino onde os LEDs do display estão conectados. Também criamos
arrays de mesmo tamanho contendo os pinos que devem estar ligados ou desligados
para formar cada caractere. No setup, configuramos os pinos utilizando um laço for e o
comando pinMode(i, OUTPUT), que interpreta o valor em cada índice do array como
sendo o número do pino e o configura como saída.

Para manter a organização e evitar repetições, implementamos as funções reset7Seg(),

que desliga todos os LEDs antes de exibir um novo caractere, e exibir(), que faz o
acionamento do display. Para isso, informamos como parâmetro um número que pode
ir de 0 até a quantidade de arrays de caracteres, utilizando o comando switch para
atribuir cada número à leitura do respectivo array (veja a parte V, onde explicamos
cada comando do Arduino). No loop, criamos um laço for que conta de zero até 2,
fornecendo o parâmetro necessário para a função exibir() e definindo um tempo de 1
segundo entre a exibição de cada caractere.

Na prática, nosso código conta de 0 a 2, somente, mas isso tem um objetivo:

desafiarmos você a implementar a contagem de 0 a 9 e criar arrays para exibir
também as letras “a”, “b”, “c”, “d”, “e”, “f”, “g”, “h”, “L”, “p” e “u”, que são as
possíveis de serem formadas/exibidas num display de 7 segmentos.

Fazendo isso, você colocará à prova todo o seu aprendizado até aqui ao mesmo tempo
que o coloca em prática, desenvolvendo habilidades essenciais para a programação do
Arduino.

Exemplo 18 - Cronômetro Digital com Display LCD

O display 16×2 é um dispositivo que possui interface para comunicação e controle

padronizada. Esses displays são fáceis de serem controlados e graças à essa
padronização é possível trocar um display 16×2 de um fabricante por outro diferente
sem maiores problemas.
A tecnologia utilizada nos displays tradicionais é LCD (Liquid Crystal Display). Mais
recentemente, modelos mais modernos com tecnologia O-Leds , os LEDS orgânicos, já
estão sendo encontrados também.
A grande vantagem e razão pela qual até hoje é componente popular, é o seu preço e a
facilidade de implementação em projetos eletrônicos. Antes dos displays LCD, a
interface gráfica usada para mostrar caracteres alfa numéricos era os displays a LED de
x segmentos (os mais comuns eram de 7, 14 ou 16 segmentos).

WWW.ELETROGATE.COM 73
 Esses componentes mais antigos utilizavam vários leds (7,14 ou 16) dispostos em
segmentos, de forma que dependendo de qual conjunto de leds fosse aceso, um
determinado caractere seria mostrado.

LCD 16x2. Créditos: Eletrogate

Na hora de comprar um display LCD, você vai encontrar diversas opções, além do mais
tradicional 16×2. A especificação é dada em relação ao número de caracteres por linha
e o número de linhas. Assim, 16×2 significa que o display pode exibir 16 caracteres em
cada linha, e possui 2 linhas. Alguns valores típicos para essas especificações são:
 Quantidade de caracteres padrão de mercado: 8, 12, 16, 20, 24 e 40;
 Quantidade de linhas mais comuns: 2 e 4;
 Cores de fundo (backlight): Azul ou verde;

O display que vamos trabalhar é de 16 colunas e 2 linhas (16×2), backlight (luz de fundo)
azul e caracteres brancos. A interface com Arduino é feita por meio de um barramento
de 16 pinos. Em geral apenas 12 são utilizados de fato. Os pinos do LCD são:

WWW.ELETROGATE.COM 74
 LCD 16x2 pinagem – foto Gustavo Murta
 Pino de register select (RS): Controle em que parte da memória (do LCD) o
usuário está escrevendo os dados. São duas opções, você pode escrever um
dado para ser mostrado no display, ou uma instrução no MCU do display;
 Pino de Read/Write (R/W): Seleciona se está em modo de leitura ou de escrita;
 Pino de Enable: Habilita a escrita de dados nos registradores;
 8 pinos de dados (D0 -D7). Os estados de cada pino desses corresponde aos
bits que você está enviando para display ou os valores lidos, quando está no
modo de leitura.
 Pinos de alimentação VCC e GND do LCD e do LED Backlight (A-anodo/K-
catodo);
 Pino V0 de ajuste de contraste;

Vamos conferir em nosso exemplo como usar o LCD 16x2:

Lista de materiais:
 1 Arduino Mega;
 1 Protoboard;
 Jumpers para ligação no protoboard;
 Display LCD 16x2;
 Potenciômetro 10K;

WWW.ELETROGATE.COM 75
 Diagrama de circuito:

No diagrama acima, o potenciômetro é usado para controlar o contraste do LCD, e deve

ser ajustado sempre que você ligar o display para poder visualizar bem cada caractere.
As demais ligações são padrão.
No código abaixo, os pinos do Arduino são configurados de acordo com a ligação acima.

// Exemplo 18 - Display LCD 16x2

// Apostila Eletrogate - KIT BIG JACK

#include <LiquidCrystal.h> // biblioteca Liquid Crystal

LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // pinos do LCD - RS E D4 D5 D6 D7

int contador = 0; // variável contador

void setup(){

lcd.begin(16, 2); // inicializa LCD 16x2

delay(500); // atraso de 0,5 segundos

void loop(){

lcd.clear(); // limpa tela do LCD

lcd.setCursor(0, 0); // selecionando coluna 0 e linha 0

lcd.print("Exemplo LCD !"); // mostra no LCD

lcd.setCursor(1, 1); // selecionando coluna 1 e linha 1

lcd.print(contador); // mostra no LCD a contagem

contador++; // incrementa contador

if (contador == 60) // se contador = 60

contador = 0; // zera o contador

delay(1000); // atraso de 1 segundo

WWW.ELETROGATE.COM 76
 No código, é mostrado na primeira linha (0) do display, a mensagem “Exemplo LCD !“.
Na segunda linha (1) será mostrado um contador que é incrementado de 1 em 1
segundo. Para usar o LCD é preciso incluir a biblioteca LiquidCrystal.h, que é nativa da
IDE arduino. Essa biblioteca possui as seguintes funções:
 lcd.clear() - Limpa a tela do display
 lcd.SetCursor(0,0) - Posiciona o cursor a partir de onde os caracteres serão
escritos
 lcd.print() - Imprime caracteres no display

Exemplo 19 - Trena Eletrônica com Sensor Ultrassônico

O princípio de funcionamento do Sensor HC-SR04 consiste na emissão de sinais
ultrassônicos e na leitura do sinal de retorno (reflexo/eco) desse mesmo sinal. A
distância entre o sensor e o objeto que refletiu o sinal é calculada com base no tempo
entre o envio e leitura de retorno.
“Sinais Ultrassônicos são ondas mecânicas (ondas de som) com frequência acima de
40 KHz, imperceptíveis ao ouvido humano.“

Como ouvido humano só consegue identificar ondas mecânicas até a frequência de

20KHz, os sinais emitidos pelo sensor Ultrassônico não podem ser escutados por nós.

O sensor HC-SR04 é composto de três partes principais:

 Transmissor Ultrassônico – Emite as ondas ultrassônicas que serão refletidas
pelos obstáculos;
 Um receptor – Identifica o eco do sinal emitido pelo transmissor;
 Circuito de controle – Controla o conjunto transmissor/receptor, calcula o
tempo entre a emissão e recepção do sinal;

Seu funcionamento consiste em três etapas:

1. O circuito externo (Arduino) envia um pulso de trigger de pelo menos 10us em
nível alto;
2. Ao receber o sinal de trigger, o sensor envia 8 pulsos de 40khz e detecta se há
algum sinal de retorno ou não;
3. Se algum sinal de retorno for identificado pelo receptor, o sensor gera um sinal
de nível alto no pino de saída cujo tempo de duração é igual ao tempo calculado
entre o envio e o retorno do sinal ultrassônico;

WWW.ELETROGATE.COM 77
 Por meio desse pulso de saída cujo tempo é igual a duração entre emissão e recepção,
nós calculamos a distância entre o sensor e o objeto/obstáculo, por meio da seguinte
equação:
(𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇_𝑑𝑑𝑑𝑑_𝑑𝑑𝑑𝑑𝑑𝑑𝑑𝑑çã𝑜𝑜_𝑑𝑑𝑑𝑑_𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠_𝑑𝑑𝑑𝑑_𝑠𝑠𝑠𝑠í𝑑𝑑𝑑𝑑 ∗ 𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣𝑣_𝑑𝑑𝑑𝑑_𝑠𝑠𝑠𝑠𝑠𝑠 )
𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷 =
2
Nela, o tempo de duração do sinal de saída é o tempo no qual o sinal de output
permanece em nível alto e a velocidade do som = 340 m/s;
Repare que as unidades devem estar coerentes para o resultado da conta ser correto.
Assim, se a velocidade do som é dada em metros/segundo, o tempo de duração do sinal
de saída deve estar em segundos para que possamos encontrar a distância em metros.

Lista de Materiais:
Para este exemplo você vai usar os seguintes componentes:

 Protoboard;
 Jumpers de ligação;
 Sensor ultrassônico HCSR-04.

Diagrama de circuito:

WWW.ELETROGATE.COM 78
 Copie e cole o código a seguir em sua IDE:

// Exemplo 19 - Sensor de Distância Ultrassônico HC-SR04

// Apostila Eletrogate - KIT BIG JACK

int PinTrigger = 2; // pino usado para disparar os pulsos do sensor

int PinEcho = 3; // pino usado para ler a saida do sensor

float TempoEcho = 0; // variável tempo do eco

const float velocidadeSom_mps = 340; // em metros por segundo

const float velocidadeSom_mpus = 0.000340; // em metros por microsegundo

void setup(){

pinMode(PinTrigger, OUTPUT); // configura pino Trigger como saída

digitalWrite(PinTrigger, LOW); // pino trigger - nível baixo

pinMode(PinEcho, INPUT); // configura pino ECHO como entrada

Serial.begin(9600); // inicializa monitor serial 9600 Bps

delay(100); // atraso de 100 milisegundos

void loop(){

DisparaPulsoUltrassonico(); // dispara pulso ultrassonico

TempoEcho = pulseIn(PinEcho, HIGH); // mede duração do pulso HIGH de eco em

microsegundos

Serial.print("Distancia em metros: "); // mostra no monitor serial

Serial.println(CalculaDistancia(TempoEcho)); // mostra o calculo de distancia em metros

Serial.print("Distancia em centimentros: "); // mostra no monitor serial

Serial.println(CalculaDistancia(TempoEcho) * 100); // mostra o calculo de distancia em cm

delay(2000); // atraso de 2 segundos

void DisparaPulsoUltrassonico(){

digitalWrite(PinTrigger, HIGH); // pulso alto de Trigger

delayMicroseconds(10); // atraso de 10 milissegundos

digitalWrite(PinTrigger, LOW); // pulso baixo de Trigger

float CalculaDistancia(float tempo_us){

return ((tempo_us * velocidadeSom_mpus) / 2 ); // calcula distancia em metros

WWW.ELETROGATE.COM 79
 Explicando, as variáveis declaradas são para determinar os pinos de trigger (pino 2) e de
leitura do sensor (pino 3). Temos três variáveis do tipo float utilizadas para medir o
tempo do pulso no output do sensor e calcular a distância. Na função void setup(),
inicializamos o pino 2 como saída e o 3 com entrada. Além disso, configuramos a
comunicação serial para 9600 bits/segundo.
Na função void loop(), onde o programa será executado continuamente, executa-se três
passos básicos:
1. Enviar pulso de 10us (microssegundos) para o pino de trigger do sensor. Isto é
feito com a função DisparaPulsoUltrassonico();

2. Ler o pino de saída do sensor e medir o tempo de duração do pulso utilizando a

função pulseIn. Esta função retorna o tempo de duração do pulso em
microssegundos para que ele seja armazenado em uma variável;

3. Por fim, chamamos a função CalculaDistancia (tempo) passando como

parâmetro o tempo lido com a função pulseIn. Esta função calcula a distância
entre o sensor e o obstáculo. Nós chamamos esta função de dentro da função
Serial.println(), de forma que o resultado já é impresso diretamente no terminal
serial;

A função DisparaPulsoUltrassonico() apenas ativa o pino 2 em nível alto, espera 10

microsegundos e volta a setar o pino para nível baixo. Lembre-se que 10 us é o tempo
mínimo que o pulso deve perdurar para disparar o sensor HC-SR04.
A função CalculaDistancia() recebe como parâmetro o tempo do pulso no pino Echo do
sensor. Com esse tempo nós usamos a equação, para calcular a distância entre o sensor
e o obstáculo.

Exemplo 20 – Controlando um Motor de Passo com Potenciômetro

O Motor de passo é um motor elétrico que não possui escovas ou comutadores,

permitindo assim uma vida longa sem tantos desgastes. O rotor (parte móvel) constitui-
se de um ou mais imãs permanentes. No estator (parte fixa) encontram-se duas ou mais
bobinas, dependendo do tipo de motor. O controle do motor é feito por um circuito
eletrônico que aciona repetidamente as bobinas numa sequência que permite o giro do
rotor. Cada pulso enviado para o circuito, faz com que o motor avance um passo. O
sentido de rotação do motor é controlado também pela sequência e pela polarização

WWW.ELETROGATE.COM 80
 das bobinas. A velocidade que o rotor gira é determinada pela frequência dos pulsos
do circuito de controle. Quanto maior a frequência, maior será o RPM.
Informações sobre o Motor de Passo 28BYJ-48:
Esse motor é Unipolar pois possui 4 enrolamentos que chamamos de fases. Em uma das
pontas das fases, todas estão conectadas juntas (fio comum). Portanto, esse
motor não pode ser usado em Drivers para motores Bipolares (com duas fases somente).
Interessante, que ele pode ser alimentado com 5V e consome baixa corrente, o que
facilita a montagem.

Algumas características do motor:

• Tensão de operação : 5V CC
• Número de fases : 4
• Razão da variação de velocidade : 1/64 (mecanismo de redução)
• Angulo do passo : 5,625 graus => 64 passos/volta (360/64=5,625)
• Resistência CC : 23 ohms
• Frequência : 100 Hz
• Torque de tração: > 34,3 mN.m

OBS: a resistência medida nas bobinas do motor foi de 23 ohms. Assim podemos
deduzir o consumo estático de corrente em cada bobina :
I = V / R -> 5V / 23 ohms -> 217 mA
Nesse tipo de motor, cada fase é energizada por um circuito driver num único sentido
de corrente. Isto é, uma extremidade do enrolamento será sempre positiva e a outra
sempre negativa. A desvantagem do motor unipolar é que tem menos torque do que o
bipolar similar, pois sempre terá no máximo, a metade das fases energizadas. Daí
pode-se concluir que tem 50% da eficiência em relação ao bipolar.

Esse motor tem uma caixa de engrenagens para redução da rotação do eixo, mas que
permite um aumento no torque. Veja abaixo a caixa de engrenagens desmontada. A
relação de redução é de 63,68:1 , isto é, para cada giro do eixo de saída, são
necessárias 63,68 voltas do eixo interno do motor. Como esse motor de passo precisa

WWW.ELETROGATE.COM 81
 de 64 passos para dar uma volta, são necessários 64 x 63,68 = 4075 passos (pulsos)
aproximadamente para um giro do eixo de saída.

Informações sobre o Módulo Driver ULN2003:

O único chip no módulo é o ULN2003. Esse chip possui um conjunto de sete drivers de
transistores Darlington que permitem o acionamento de cargas indutivas. Todas as
saídas tem o coletor aberto e diodos de supressão (Clamp) . Os transistores suportam
tensões de até 50V e correntes de até 500 mA. Todas as entradas IN1, IN2,IN3 e IN4
são compatíveis com sinais limitados a tensões de até 5V.
Pinos do Módulo ULN2003 :

O pino mais à esquerda (-) no módulo é o terra (veja foto acima). Esse terra tem que ser
conectado ao terra da fonte e ao terra do Arduino. O pino (+) no caso do Motor 28BYJ-
48, tem que ser conectado ao positivo de uma fonte de 5V (preferencialmente de 1
Ampére). Não recomendo que conecte no 5V do Arduino, pois poderá sobrecarregar o

WWW.ELETROGATE.COM 82
 regulador de tensão do mesmo. O jumper Power ON/OFF é usado para ligar ou desligar
o motor. Os quatro leds vermelhos (A,B,C e D) são usados para indicar o acionamento
de cada um dos drivers (fases do motor).
IMPORTANTE: Muita atenção ao conectar a alimentação nos pinos. Uma ligação
incorreta poderá danificar o driver ou o motor.
Modos de operação:
Para um motor de Passo Unipolar, temos alguns modos de operação. Temos o modo
Passo completo com alto torque (Full step), o modo Passo completo com baixo torque
( Wave Step), o modo Meio Passo (half step) e Micro-passo (Micro stepping).
No caso do Micro passo, a corrente nos enrolamentos deve ser alterada. Como o nosso
circuito não permite o controle da corrente, esse modo de operação não se aplica para
esse driver.
Passo completo com alto torque ( Full step): - Duas Fases são acionadas ao mesmo tempo,
nessa ordem:

Passo completo com baixo torque ( Wave Step): - Somente uma Fase acionada de cada vez,
nessa ordem:

Meio Passo (half step): - Na sequência de oito passos, em alguns passos temos somente uma
fase acionada e em outros passos, temos duas fases acionadas, nessa ordem:

WWW.ELETROGATE.COM 83
 Lista de materiais:

• Motor de passo 28BYJ-48 + Driver ULN2003;

• Arduino Mega R3 + Cabo;
• Protoboard;
• Potenciômetro;
• Adaptador para fonte;
• Jumpers.

Diagrama do circuito :

WWW.ELETROGATE.COM 84
 Para esse projeto, nosso código fará uso de uma biblioteca chamada AccelStepper.
Diferente das outras que utilizamos ao longo dessa apostila, a AccelStepper não é uma
biblioteca nativa da Arduino IDE, portanto, precisamos instalá-la manualmente. Para
isso, siga os passos abaixo:
1º - Abra o Gerenciador de Bibliotecas da Arduino IDE clicando no botão mostrado
abaixo:

2º - Com o gerenciador aberto, digite o nome da biblioteca e tecle Enter:

WWW.ELETROGATE.COM 85
 3º - Vamos instalar a versão destacada acima, desenvolvida por Mike McCauley. Basta
clicar em “Instalar” e aguardar a mensagem abaixo:

Com a biblioteca instalada e o circuito montado, basta carregar o código abaixo em seu
Arduino e girar o potenciômetro para observar o funcionamento do motor:

Esse é o Sketch da aplicação:

// Exemplo 20 - Motor de passo unipolar 28BYJ-48 + Driver ULN2003

// Apostila Eletrogate - KIT BIG JACK
// Baseado em AccelStepper/ProportionalControl_8pde-example

#include <AccelStepper.h> // biblioteca AccelStepper

#define ANALOG_PIN A0 // pino A0 para leitura da tensão do Potenciometro

AccelStepper motorPasso (AccelStepper::FULL4WIRE, 8, 10, 9, 11); // Passo completo

void setup()
{
motorPasso.setMaxSpeed(500); // maxima velocidade = 500 pulsos/seg
}

void loop()
{
int analog_in = analogRead(ANALOG_PIN); // lendo a tensão do pino A0 do Arduino
motorPasso.moveTo(analog_in); // gira o eixo do motor X pulsos
motorPasso.setSpeed(100); // velocidade = 100 pulsos por segundo
motorPasso.runSpeedToPosition(); // gira o eixo para a posição definida
}

WWW.ELETROGATE.COM 86
 Exemplo 21 – Comunicação sem Fio com Transmissor e Receptor RF

Esse conjunto de Módulos de transmissão(TX) e recepção(RX) de RF 433 MHz serve

para o envio de dados digitais entre dois Arduinos (ou outro tipo de Microcontrolador).
A comunicação é unidirecional , isto é, os dados são enviados pelo transmissor e
recebidos pelo receptor.
A tipo de modulação da portadora de Rádio Frequência é o ASK (amplitude shift
keying) - modulação por chaveamento de amplitude. Isto é, quando existe o Bit 1 a
portadora transmite o sinal de 433 MHz. Quando o Bit é zero, nenhum sinal é
transmitido.

Referência : http://blog.eletrogate.com/wp-content/uploads/2018/09/ASKnFSK.pdf
Essas são algumas aplicações para esses módulos RF 433 MHz :
• transmissão de dados à curta distância,
• controle remoto,
• automação residencial,
• sistema de segurança - Alarme,
• Registro remoto de dados (Log).

Pinagem dos Módulos TX /RX de 433 MHz :

Modulo Transmissor - pinagem:

1. Data - pino de transmissão de dados

2. VCC - pino de alimentação : 3 a 12 V

3. GND - terra

WWW.ELETROGATE.COM 87
 Módulo Receptor - pinagem :
1. VCC - pino de alimentação : 5V
2. Data - pino de recepção de dados
3. Data - idem - conectado ao pino 2
4. GND – terra

Especificações dos Módulos TX /RX de 433 MHz :

Módulo Transmissor 433 MHz (FS1000A) :

Corrente de operação : 20 a 28 mA
Frequencia de operação : 433,92 MHz
Potência de saída: 10mW
Taxa de transferência < 4Kbps
Tensão de operação : 3 a 12 V
Alcance da transmissão < 100 m (com antena, sem obstáculos)
Antena externa : fio com 17,3 cm

Módulo Receptor 433 MHz (XY-MK-5V) :

Tensão de operação : 5 V (somente)
Frequencia de operação : 433,92 MHz
Corrente de operação : 4 mA
Sensibilidade de recepção : -105DB
Antena externa : fio com 17,3 cm

Sobre as Antenas dos Módulos TX e RX :

Para um perfeito funcionamento dos módulos de RF 433 MHz, é necessário a
instalação das antenas tanto no transmissor quanto no receptor. Sabendo-se que a
frequência da portadora é de 433,92 MHz e a velocidade da onda eletromagnética no
espaço é de 3 x 108 m/s , o comprimento de onda é :
λ = v/f = 300.000.000 / 433.920.000 = 0,69 metros
Usando uma antena com 1/4 do comprimento de onda :
D = 0,69 m / 4 = 17,28 cm

WWW.ELETROGATE.COM 88
 Portanto solde fios rígidos de aproximadamente 17,3 cm nos locais indicados na foto
dos módulos. Uma antena para o transmissor e outra para o receptor, ambas com o
mesmo tamanho.

Transmitindo dados entre dois Arduinos :

Os primeiros tutoriais que descobri na WEB sobre o uso desses módulos TX/RX RF 433
MHz , usavam a biblioteca VirtualWire. Mas no site do idealizador dessa Biblioteca, ele
indica outra biblioteca mais recente - a RadioHead, que permite o uso de vários tipos
de módulos de comunicação.
https://github.com/adafruit/RadioHead
https://github.com/adafruit/RadioHead

Para esse projeto, faremos uso de uma biblioteca chamada RadioHead, que será
responsável por simplificar o envio dos dados. Como ela não foi publicada na Arduino
IDE, precisamos fazer a instalação através de um arquivo compactado (.zip). Comece
baixando-a através do link abaixo:
http://blog.eletrogate.com/wp-content/uploads/2018/09/RadioHead-master.zip

Em seguida, na Arduino IDE, clique em Sketch > Incluir Biblioteca > Adicionar
biblioteca.zip e localize o arquivo RadioHead-master.zip que você acabou de baixar,
clicando em abrir na sequência.

Bem interessante essa biblioteca, e funcionou perfeitamente nos meus testes. Ela
poderá ser adaptada para a sua aplicação, enviando dados entre dois Arduinos.
Usando os módulos com antenas, o alcance poderá ser expressivo. Lembrando que
quanto maior a tensão de alimentação do módulo transmissor, maior será a potência
de RF a ser transmitida e portanto maior alcance (limite : 12V).

WWW.ELETROGATE.COM 89
 Como visto nas especificações do módulo TX, a taxa de transmissão de dados é
relativamente baixa (< 4000 bps). Mas para aplicações como o envio de dados de um
sensor, por exemplo, essa biblioteca poderá ser usada.
Montagem do Módulo Transmissor RF 433 MHz:

O Módulo Transmissor poderá ser montado com um Arduino Mega ou Mega. A

alimentação do módulo Transmissor poderá ser de até 12V, para um maior alcance.
Esse é o Sketch para ser gravado no Arduino conectado ao Módulo Transmissor. Uma
mensagem de teste será enviada à cada meio segundo.
http://blog.eletrogate.com/wp-content/uploads/2018/09/RF433askTX.ino

Módulo Transmissor RF 433 Mhz

Sketch do Módulo Transmissor :

WWW.ELETROGATE.COM 90
 // Exemplo 21 – Módulos RF – Transmissor e Receptor – 433 MHz
// Apostila Eletrogate - KIT BIG JACK
// Arduino Transmissor

#include <RHReliableDatagram.h> // biblioteca Radiohead reliableDatagram

#include <RH_ASK.h> // biblioteca Radiohead ASK
#include <SPI.h> // biblioteca SPI

#define TX_ADDRESS 1 // endereço do transmissor

#define RX_ADDRESS 2 // endereço do recept

RH_ASK driver; // instância RH ASK

RHReliableDatagram gerente(driver, TX_ADDRESS); // configurando o gerenciador

uint8_t count = 1; // contador

uint8_t data[] = "Mensagem de teste"; // mensagem a ser enviada
uint8_t buf[RH_ASK_MAX_MESSAGE_LEN]; // buffer da mensagem

void setup()
{
Serial.begin(9600); // inicializa console serial 9600 bps
if (!gerente.init()) // se a inicialização do gerenciador falhar
Serial.println("Falha na inicializacao"); // print na console serial
}

void loop()
{
Serial.print("Transmitindo mensagem n. "); // print na console serial
Serial.println(count); // print do contador
if (!gerente.sendtoWait(data, sizeof(data), RX_ADDRESS)) // se gerenciador enviar mensagem
{
count++; // incrementa contador
}
delay(500); // atraso 0,5 segundos
}

Montagem do Módulo Receptor RF 433 MHz:

O Módulo Receptor pode ser montado com um Arduino Mega ou Mega.

WWW.ELETROGATE.COM 91
 Esse é o Sketch para ser gravado no Arduino conectado ao Módulo Receptor. Uma
mensagem de teste será recebida à cada meio segundo.
Durante os testes iniciais, coloque o transmissor perto do Receptor. Depois faça o
teste distante um do outro. Obstáculos como paredes maciças, portões metálicos
poderão prejudicar a recepção. Uma transmissão ao ar livre poderá ter um alcance
bem maior.

http://blog.eletrogate.com/wp-content/uploads/2018/09/RF433askRX.ino.ino
Sketch do Modulo Receptor:

// Exemplo 21 – Módulos RF – Transmissor e Receptor – 433 MHz

// Apostila Eletrogate - KIT BIG JACK
// Arduino Receptor

#include <RHReliableDatagram.h> // biblioteca Radiohead reliableDatagram

#include <RH_ASK.h> // biblioteca Radiohead ASK
#include <SPI.h> // biblioteca SPI

#define TX_ADDRESS 1 // endereço do transmissor

#define RX_ADDRESS 2 // endereço do receptor

uint8_t count = 0; // contador

uint8_t buf[RH_ASK_MAX_MESSAGE_LEN]; // buffer da mensagem
uint8_t tamanho; // tamanho da mensagem
uint8_t from; // endereço de quem transmite

RH_ASK driver; // instância RH ASK

RHReliableDatagram gerente(driver, RX_ADDRESS); // configurando o gerenciador

void setup()
{
Serial.begin(9600); // inicializa console serial 9600 bps
if (!gerente.init()) // se a inicialização do gerenciador falhar
Serial.println("Falha na inicializacao"); // print na console serial
}

void loop()
{
if (gerente.available()) // se gerenciador estiver ativo
{
tamanho = sizeof(buf); // determina o tamanho do buffer
if (gerente.recvfromAck(buf, &tamanho, &from)) // se o gerenciador receber mensagem
{
Serial.print("Recebido de: 0x"); // print na console serial
Serial.print(from, HEX); // print do endereço do transmissor em
Hexadecimal
Serial.print(": "); // print na console serial
Serial.println((char*)buf); // print da mensagem recebida
}
}
}

WWW.ELETROGATE.COM 92
 Essa é a tela da Console Serial da IDE do Arduino Receptor (9600 bps), com as
mensagens recebidas:

Exemplo 22 – Alarme com Buzzer e Sensor de Presença

O Módulo Sensor de presença usa um componente eletrônico piroelétrico passivo,

sensível às variações de luz de raios infravermelhos – PIR (passive infrared). Sabemos
que todos seres vivos emitem radiações de infravermelho, imperceptíveis ao olho
humano. Dessa forma, esse sensor é capaz de detectar a presença de pessoas ou animais
dentro de um ambiente.

https://en.wikipedia.org/wiki/Passive_infrared_sensor

Sob o sensor PIR existe uma lente de Fresnel que amplia a luz infravermelha recebida.
Quando o ser vivo monitorado está em movimento, algumas variações na intensidade
da luz são percebidas pelo circuito do módulo. Ao atingirem um determinado nível pré-
configurado, o circuito dispara o sensor.

https://pt.wikipedia.org/wiki/Lente_de_Fresnel

WWW.ELETROGATE.COM 93
 Especificações do Módulo PIR DYP-ME003:

• Sensibilidade e tempo ajustáveis

• Ângulo máximo de detecção = 110 °
• Tensão de Operação VCC : 4,5-20V
• Corrente estática: 50 uA
• Tensão de dados OUT: 3,3V (Alto) e 0V (Baixo)
• Distância detectável: 3-7m (Ajustável)
• Tempo de Atraso: 5 a 300seg (Default: 5seg)
• Tempo de Bloqueio: 2,5seg (Default)
• Dimensões: 3,2 x 2,4 x 1,8cm

https://www.elecfreaks.com/wiki/index.php?title=PIR_Motion_Sensor_Module:DYP-
ME003

Aplicações sugeridas para o Módulo PIR:

• Sistemas de alarme de presença ou movimento,

• Disparo automáticos de câmera fotográfica – Camera Trap,
• Automação residencial – acionamento de lâmpadas,

WWW.ELETROGATE.COM 94
 Modulo PIR DYP-ME003

OBS: alguns fabricantes podem inverter os pinos VCC com GND. Veja a identificação na
placa.

• Potenciômetro para ajuste do Tempo de atraso do disparo

- Tempo de atraso mínimo de 5 segundos e máximo de 300 segundos
• Potenciômetro para ajuste de sensibilidade (distância)
- A distância poderá ser ajustada entre 3 e 7 metros
• Jumper modo de disparo:
- modo de disparo simples (posição L)
- modo de disparo repetitivo (posição H = default)

Como funciona o Módulo PIR:

O sensor Piroelétrico possui duas áreas de “visão”, sensíveis às radiações

infravermelhas. As lentes de Fresnel focalizam as ondas de radiações para sobre o
sensor. Quando o sensor está ocioso, ambas áreas sensíveis detectam a mesma
quantidade de radiação. Quando um corpo quente como um ser humano ou animal
passa na frente do sensor, variações nas quantidades de energia são percebidas pelo
mesmo. Essas variações fazem o circuito disparar a saída OUT com um nível de tensão
de 3,3V. A duração do pulso positivo nessa saída pode ser ajustada no potenciômetro
TEMPO, entre 5 e 300 segundos. No potenciômetro de DISTÂNCIA ou sensibilidade,
pode-se ajustar a distância entre o sensor e a pessoa, entre 3 e 7 metros. No modo
simples, a partir de um disparo a saída se mantem alta durante o tempo ajustado. No
modo repetitivo, os disparos se sobrepõem e assim a duração do pulso de saída será
maior.

WWW.ELETROGATE.COM 95
 Montagem do Módulo PIR com Arduino:

WWW.ELETROGATE.COM 96
 // Exemplo 13 – Modulo Sensor de Presença PIR
// Apostila Eletrogate - KIT BIG JACK

int sensorPIR = 2; // Pino ligado ao sensor PIR

int buzzer = 8; // Pino ligado a sirene Buzzer
int disparo; // Variavel de disparo do sensor
int frequencia = 4000; // Frequencia do apito em Hertz
int duracao = 500; // Duração do apito em milisegundos

void setup()
{
pinMode(LED_BUILTIN, OUTPUT); // Define LED embutido D13 como saída
pinMode(sensorPIR, INPUT); // Define pino do sensor PIR D2 como entrada
pinMode(buzzer, OUTPUT); // define pino da sirene buzzer D8 como saída
delay(5000); // tempo necessário para o módulo PIR se inicializar 5 segundos
}

void loop()
{
disparo = digitalRead(sensorPIR); // Le o valor da saída do sensor PIR
if (disparo == LOW) // Se saída tem nível baixo
{
digitalWrite(LED_BUILTIN, LOW); // LED embutido permanece apagado
}
else // Se a saída tem nível alto
{
digitalWrite(LED_BUILTIN, HIGH); // LED embutido acende
tone(buzzer, frequencia, duracao); // Buzzer apita
}
}

Para o funcionamento do circuito, ajuste os potenciômetros de Tempo e Distancia para

a posição mínima (gire tudo para o sentido anti-horário). Dessa forma o tempo de
duração será de aproximadamente 5 segundos e a distância de percepção será de 3
metros. Insira o jumper de modo para a posição H, para que o sensor fique mais
perceptível. Despois dos testes, faça as suas modificações.
Quando o sensor perceber a presença de alguém, o LED embutido no Arduino (D13)
acenderá e a sirene Buzzer apitará na frequência de 4000 Hz.

Com essa montagem, usando o relé do exemplo 8 poderá implementar um sistema de

alarme ou automação residencial.

WWW.ELETROGATE.COM 97
 Exemplo 23 – Ponte H com Módulo Relé de 2 Canais

O Módulo Relé nada mais é do que um ou mais relés acionados por sinais digitais de 5V.
Esse componente é indicado para acionar cargas que utilizam correntes contínuas
maiores do que a suportada pelo Arduino, ou então uma carga de um circuito de
corrente alternada (rede elétrica).
O módulo de relé pode ser usado para vários tipos de aplicações:

• ativação de eletroímãs,
• ativação de motores CC,
• ativação de motores CA,
• ligar/desligar lâmpadas.

No mercado você pode encontrar módulos de 1, 2, 4 e 8 canais. Cada canal corresponde

a um relé montado no módulo. Ou seja, um módulo relé de 5V e 8 canais, é um conjunto
de 8 relés acionados por sinais separados de 5V. Um módulo relé de 12V e 4 canais, nada
mais do que um conjunto de 4 relés, cada qual acionado por sinais de 12V.
O módulo com 2 Relés tem um circuito de controle através de acopladores óticos. Isso
é usado para isolar as portas do microcontrolador, do circuito de acionamento dos relés.
As portas de controle dos relés são os pinos IN1 e IN2. Por exemplo, para acionar o relé
K1, a porta do microcontrolador conectada no pino IN1 deverá estar no nível baixo
(LOW). Para controlar o relé K2, use o pino IN2.
O módulo funciona exatamente da mesma forma que uma
chave ou interruptor. Esse é o diagrama de um dos relés
SONGLE SRD-05VDC-SL-C:

• NA - Contato Normalmente Aberto

• C - Terminal Comum
• NF - Contato Normalmente Fechado

Existe um Led em série com cada entrada do acoplador ótico. Portanto quando a porta
é ativada, o Led acende. A alimentação do módulo tem que ser 5 V (pino +5V). Não use
uma tensão maior ou menor do que 5 V, pois poderá queimar o relé (tensão maior) ou
então o relé não poderá ser acionado (tensão menor). Se quiser usar relés com 12 V,

WWW.ELETROGATE.COM 98
 procure um outro módulo de relé. Não se esqueça de conectar o pino terra (GND) do
módulo com o GND do Arduino. Mantenha o jumper entre os pinos JD-VCC e VCC. Dessa
forma, a alimentação dos relés será de 5 V através do pino +5V. A capacidade corrente
em cada contato é de 10 A. Não ultrapasse esse valor, para não danificar o seu relé. O
consumo de corrente da bobina de cada relé é de aproximadamente 70 mA, quando
energizada.
Na imagem abaixo temos o Módulo Relé 2 canais com a identificação das conexões:

Módulo relé de 2 canais

Os pinos dos contatos dos Relés são NA (normalmente aberto), COM (comum) e NF
(normalmente fechado.). Isto é, enquanto o relé estiver desativado, a ponta comum
estará conectada no contato NF. Quando o relé for acionado, a ponta comum será
conectada no contato NA.
Cada pino INX serve para acionar um dos relés. VCC e GND são os pinos de alimentação
do Módulo do relé: VCC deve ser conectado no +5V e o GND no pino terra, ambos da
fonte. O pino terra (GND) do Módulo Relé deve estar conectado também no Terra
(GND) do Arduino!

Ponte H com Arduino

Ponte H é um tipo de circuito eletrônico muito usado para controlar um motor elétrico
CC (corrente contínua). Através das portas de controle, pode-se ligar e desligar a energia
do motor. E mais, alterar o sentido de rotação do motor.
Atualmente existem inúmeros módulos de Ponte H que usam chips dedicados. Mas um
inconveniente é que para circuitos com maior corrente, os módulos são bem mais caros.

WWW.ELETROGATE.COM 99
 Por isso criei esse tutorial para montagem de uma Ponte H com relés. A ponte H desse
tutorial pode controlar motores CC com escova (Brushed) com corrente de até 10
amperes.
Uma limitação da Ponte H com relé, é que não suporta o controle de velocidade (PWM)
do motor. Não é possível ficar chaveando um relé com uma frequência de pulsos. Isso
danificaria os relés!
Para entender como uma ponte H funciona, recomendo a leitura do meu tutorial no
Blog da Eletrogate:
http://blog.eletrogate.com/arduino-ponte-h-com-rele/

Lista de Materiais:
Para este exemplo você vai precisar:

 Protoboard,
 Arduino MEGA,
 Jumpers de ligação,
 Módulo relé 2 canais,
 Motor CC,
 Fonte de alimentação.

O circuito abaixo é uma montagem de uma Ponte H básica com o Módulo 2 Relés. Veja
que nessa montagem estou alimentando o motor com uma fonte externa CC. Verifique
as especificações do seu motor, para saber qual é a tensão de alimentação e a corrente
necessárias para o mesmo. Importante: a corrente de operação da fonte de
alimentação precisa suportar a corrente do motor! Os relés suportam no máximo 10 A.

Para efeito didático, usaremos o Motor CC do Kit. Ele poderá ser alimentado com o
+5V do Arduino, pois o consumo de corrente dele é bem baixo – aproximadamente 10
mA.
Conecte o GND do conector ao GND do Arduino e o +VCC do conector ao +5V do
Arduino. Não use motores CC com correntes maiores do que 50 mA, para não queimar
o regulador 5V do Arduino.

WWW.ELETROGATE.COM 100
 Diagrama do circuito:

Esse é o programa de controle da Ponte H. O Arduino aciona um relé de cada vez,

durante 3 segundos. Portanto o motor gira num sentido e depois gira no sentido
inverso, sucessivamente. Essa montagem poderá ser aplicada em vários outros tipos
de projetos, que necessitam o controle de acionamento de um motor CC. Sugiro que
implemente botões para acionamento dos motores e chaves de limite de movimento
(backstop) para desligar o motor, quando a parte móvel chegar no destino.

Código Arduino – Ponte H com módulo relé 2 canais

WWW.ELETROGATE.COM 101
 // Exemplo 23 - Ponte H com modulo 2 relés
// Apostila Eletrogate - KIT BIG JACK
// Gustavo Murta

int IN1 = 4; // pino IN1 conectado porta D4 Arduino

int IN2 = 5; // pino IN2 conectado porta D5 Arduino

void setup()
{
Serial.begin(9600); // console serial 9600 Bps
pinMode(IN1, OUTPUT); // definições das portas como portas de saidas
pinMode(IN2, OUTPUT);
digitalWrite(IN1, HIGH); // desativa porta IN1
digitalWrite(IN2, HIGH); // desativa porta IN2
}

void loop()
{
digitalWrite(IN2, HIGH); // desativa porta IN2
digitalWrite(IN1, LOW); // acionamento relé K1
Serial.println("Rele K1 acionado"); // print mensagem
delay (3000); // atraso de 3 segundos
digitalWrite(IN1, HIGH); // desativa porta IN1
digitalWrite(IN2, LOW); // acionamento relé K2
Serial.println("Rele K2 acionado"); // print mensagem
delay (3000); // atraso de 3 segundos
}

Exemplo 24 – Acendendo LED's com Controle Remoto Infravermelho

O controle Remoto IR (infrared, ou infravermelho em português) de aparelhos

eletrônicos consiste em um pequeno dispositivo que contém um chip de
microcontrolador, um ou mais LEDs emissores de infravermelho e um teclado
acoplado. Quando o usuário pressiona uma das teclas do controle, uma sequência de
pulsos de luz infravermelha é transmitida pelos LEDs. Esses pulsos formam um código
que é único para cada tecla acionada.

O chip do Microcontrolador do Controle Remoto Transmissor, já vem programado com

um protocolo definido pelo fabricante do aparelho.

Os pulsos de dados (código) são enviados do transmissor através de outros pulsos

numa frequência bem maior, modulando o sinal a ser transmitido. Alguns trabalham
com frequências diferentes de modulação, mas a mais comum atualmente é a
frequência de 38 KHz. Na figura abaixo, pode-se perceber que quando o pulso de dado
é 1, a frequência é transmitida e quando o pulso é 0, nenhuma frequência é
transmitida. Esse tipo de modulação chama-se PCM (modulação codificada de pulsos).

WWW.ELETROGATE.COM 102
 Com esse tipo de modulação, impede-se que a luz externa interfira na transmissão dos
dados.

O circuito Receptor IR que fica internamente no aparelho a ser controlado, consiste

basicamente de um descodificador dos pulsos recebidos do transmissor. Interpretando
o código de cada tecla pressionada, o aparelho pode executar vários tipos de
operações, como por exemplo, desligar, aumentar volume e mudar o canal no caso de
uma Televisão.

Hoje com a integração cada vez maior dos circuitos, existem receptores de controle
remoto IR que já contém o foto-sensor e todos os outros circuitos necessários para
demodular os pulsos de controle, como amplificadores de sinal, filtros, demodulador,
integrador e comparador.
O diagrama de blocos abaixo contém os vários circuitos que estão integrados no
pequeno receptor. Após a demodulação dos pulsos, esses são descodificados por um
outro Microcontrolador, para que o aparelho possa entender que tipo de operação
deverá ser realizada.

Receptor de Infravermelho AX-1838HS

Esse é foto-receptor IR usado nesse exemplo. Ele é amplamente utilizado em
aparelhos para permitir o controle remoto. Pode ser encontrado em TVs, rádios,
aparelhos de multimídia e até em aparelhos de ar condicionado.

WWW.ELETROGATE.COM 103
 Ele pode trabalhar com tensões de 2,1V a 5,5V. O consumo de energia é bem baixo,
com uma corrente de aproximadamente 1,5 mA. A frequência de modulação dos
pulsos de dados é de 38 KHz. E o comprimento de onda da luz infravermelha percebida
é de 940 nm. O ângulo de visão é de aproximadamente 90 graus. A vantagem do uso
desse foto-receptor IR é que ele já tem todo o circuito integrado necessário para
demodular os pulsos.

Folha de especificações (Datasheet) do AX-1838HS:

http://blog.eletrogate.com/wp-content/uploads/2018/12/IR-Receiver-AX-1838HS.pdf

Sensor AX-1838HS - pinagem

Controle Remoto Infravermelho:

O controle remoto IR (transmissor) é o da KEYES com 17 botões. Ele funciona com uma
pilha botão CR2025. Antes de usá-lo, retire a proteção de plástico transparente que
fica dentro do suporte da bateria. Para trocar a pilha, pressione a trava para o lado e
puxe o suporte da pilha. Veja o diagrama na parte debaixo do controle remoto. Esse
controle remoto usa o protocolo de codificação da NEC.

WWW.ELETROGATE.COM 104
 Controle Remoto IR com Arduino:
Usando um circuito de Controle Remoto IR com o Arduino, poderá implementar
inúmeras aplicações bem interessantes como:

• Controle remoto de lâmpadas (liga/desliga ou até controle de brilho),

• Acionamento remoto de aparelhos,
• Controle remoto de alarmes,
• Controle remoto de câmera fotográfica.

A montagem do circuito é bem simples, interligando um sensor Receptor IR AX-1838Hs

ao Arduino. A alimentação do sensor é fornecida pelo 5V do Arduino. E o pino de saída
dos pulsos do Receptor é conectado ao pino D11 do Arduino. O Led verde está
conectado no pino D05, o Led azul no pino D06 e o Led vermelho no pino D07 do
Arduino. Todos Leds tem um resistor de 330 ohms em série com as ligações. O lado
chanfrado do Led é o catodo, que deve ser conectado ao pino terra (GND).
Diagrama do Controle Remoto IR para Arduino:

WWW.ELETROGATE.COM 105
 Para que o código funcione, também precisaremos instalar uma biblioteca. Dessa vez,
faremos uso da biblioteca IRremote, desenvolvida por Shirriff, Z3t0 e ArminJo. Siga o
mesmo passo a passo demonstrado nos Exemplos 19 e 21 dessa apostila.

Falando do sketch em si, desenvolvemos um exemplo bem interessante, pois, com o

uso do controle remoto, você poderá ligar ou desligar os LEDs coloridos. Se quiser
acionar um equipamento, poderá substituir os LEDs por um módulo de relé – e
inclusive, te desafiamos a isso! Implemente o módulo relé que acompanha o kit nesse
projeto como forma de praticar os conhecimentos adquiridos.

No código, configuramos as seguintes teclas:

• Tecla 1 controla Led Verde - pino 5

• Tecla 2 controla Led Amarelo - pino 6
• Tecla 3 controla Led Vermelho - pino 7

WWW.ELETROGATE.COM 106
 Código Controle Remoto IR - LEDs coloridos:

// Exemplo 24 – Controle Remoto IR - LEDs coloridos

// Apostila Eletrogate - KIT BIG JACK
// Gustavo Murta

#include <IRremote.h> // Biblioteca IRemote

int RECV_PIN = 11; // Arduino pino D11 conectado no
Receptor IR
IRrecv irrecv(RECV_PIN); // criando a instância
decode_results results; // declarando os resultados
bool LED5, LED6, LED7 = false; // estado dos LEDs
int atraso = 250; // atraso após ligar LED

void setup()
{
pinMode(7, OUTPUT); // LED vermelho no pino D07
pinMode(6, OUTPUT); // LED azul no pino D06
pinMode(5, OUTPUT); // LED verde no pino D05
irrecv.enableIRIn(); // Inicializa a recepção de
códigos
}

void loop()
{
results.value = 0; // zera os registradores
if (irrecv.decode(&results)) // se algum código for recebido
{
irrecv.resume(); // reinicializa o receptor
}
if (results.value == 0xFFB04F) // pressione tecla 3 para
controlar LED vermelho (D07)
{
LED7 = !LED7; // alterna o estado do LED D07
digitalWrite(7, LED7); // acende ou apaga LED vermelho
(D07)
delay(atraso); // atraso de 250 ms
}

if (results.value == 0xFF9867) // pressione tecla 2 para

controlar LED azul (D06)
{
LED6 = !LED6; // alterna o estado do LED D06
digitalWrite(6, LED6); // acende ou apaga LED vermelho
(D07)
delay(atraso); // atraso de 250 ms
}

if (results.value == 0xFF6897) // pressione tecla 1 para

controlar LED verde (D05)
{
LED5 = !LED5; // alterna o estado do LED D05
digitalWrite(5, LED5); // acende ou apaga LED verde (D05)
delay(atraso); // atraso de 250 ms
}
}

WWW.ELETROGATE.COM 107
 Exemplo 25 – Relógio Digital de Alta Precisão com Módulo RTC

Módulo RTC DS1307:

Esse módulo serve como relógio para projetos com Arduino que precisam do controle
do tempo. Pode ser usado como alarme despertador, controle automatizado de
operações temporizadas, e claro como um relógio comum com horas e minutos. O
módulo tem o chip DS1307 que é o relógio, uma EEPROM 24C32, um cristal de 32,768
KHz e uma pilha CR2032.

O chip DS1307 RTC (Real-Time Clock) é um relógio / calendário de baixa potência com
codificação binária completa (BCD) mais 56 bytes de NV SRAM (memória estática RAM
não-volátil). Os endereços e os dados são transferidos em série por meio do
barramento bidirecional da interface I2C. O relógio / calendário fornece informações
sobre segundos, minutos, horas, dia, data, mês e ano. O relógio funciona no formato
de 24 ou 12 horas com o indicador AM / PM. O DS1307 possui um circuito de detecção
de falha de energia que alterna automaticamente a alimentação para a pilha CR2032
(3V), na ausência de energia da fonte. A contagem de tempo do relógio é baseada no
oscilador do cristal de 32,768 KHz.

A memória EEPROM 24C32 permite o armazenamento de até 4096 K Bytes e ela é não
volátil, isto é, mesmo sem energia ela armazena os dados gravados. Para a
comunicação com o microcontrolador ela também usa a interface I2C.

Na placa do circuito do módulo, existe um espaço onde um sensor de temperatura DS18B20

poderá ser soldado. Esse sensor é opcional e não vem com o KIT.
A alimentação do módulo RTC DS1307 é feita em 5V. A tensão mínima de alimentação
do chip DS1307 é de 4,5V. Portanto esse módulo não pode ser alimentado com 3,3V.
A tensão da bateria (pilha de Lítio) deverá variar com o uso. Quando a pilha está nova,
a tensão é de 3,2V aproximadamente.
Lista de Materiais:
Para este exemplo você usará os seguintes componentes:
• Arduino Mega,
• Protoboard,
• Jumpers de ligação,
• Módulo RTC DS1307.

WWW.ELETROGATE.COM 108
 Diagrama de montagem

Novamente, faremos a instalação de uma biblioteca. Usaremos a RTClib, desenvolvida

pela Adafruit. Sua instalação é idêntica à biblioteca do sensor DHT11, que mostramos
no Exemplo 19.

Ao término da instalação, você receberá a seguinte mensagem de confirmação:

WWW.ELETROGATE.COM 109
 Em seguida, carregue o código abaixo em seu Arduino e abar o monitor serial:

WWW.ELETROGATE.COM 110
 Código Arduino – Módulo RTC DS1307:

// Exemplo 25 – Modulo RTC DS1307 com Arduino Mega

// Apostila Eletrogate - KIT BIG JACK
// Gustavo Murta
// https://github.com/adafruit/RTClib/blob/master/examples/ds1307/ds1307.ino

#include "RTClib.h" // biblioteca RTClib

RTC_DS1307 rtc; // criando a instância RTC

char diasDaSemana[7][12] = {"Domingo", "Segunda", "Terca", "Quarta", "Quinta", "Sexta", "Sabado"};

void setup ()
{
Serial.begin(9600); // monitor da console serial 9600 bps
if (! rtc.begin()) // se o RTC não foi inicializado
{
Serial.println("RTC nao pode ser encontrado!"); // imprime mensagem
while (1);
}

if (! rtc.isrunning()) // se o RTC não estiver rodando

{
Serial.println("RTC nao esta funcionando!"); // imprime mensagem
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // ajusta relógio com o relógio do seu PC
}
}

void loop ()
{
DateTime now = rtc.now(); // faz a leitura dos dados do RTC
Serial.print(now.day(), DEC); // imprime o dia do mês
Serial.print('/');
Serial.print(now.month(), DEC); // imprime o mês
Serial.print('/');
Serial.print(now.year(), DEC); // imprime o ano
Serial.print(" (");
Serial.print(diasDaSemana[now.dayOfTheWeek()]); // imprime o dia da semana
Serial.print(") ");
Serial.print(now.hour(), DEC); // imprime horas
Serial.print(':');
Serial.print(now.minute(), DEC); // imprime minutos
Serial.print(':');
Serial.print(now.second(), DEC); // imprime segundos
Serial.println(); // imprime uma linha
delay(2000); // atraso de 2 segundos
}

Esse programa foi traduzido e adaptado do exemplo DS1307 da biblioteca RTClib. Ele
acerta a data e as horas com o relógio do seu computador e atualiza a data e hora no
monitor serial a cada 2 segundos. Esse exemplo é para você entender basicamente como
o relógio RTC pode ser usado.
No monitor serial, a saída será semelhante a essa:

WWW.ELETROGATE.COM 111
 Exemplo 26 – Utilizando o Teclado Matricial de 16 Teclas

Para alguns tipos de aplicações dos Microcontroladores é necessária uma interface de

entrada de dados, que permita a comunicação entre o homem e a máquina. E a
interface mais usada é o teclado. Através de um teclado, o usuário da “máquina” pode
selecionar e alterar funções ou operações.
Os teclados de membrana são muito usados ainda, pois eles têm baixo custo, boa
durabilidade e boa confiabilidade nas operações. Todos os celulares usam os teclados
de membrana. Os smartphones mais antigos usavam também, mas atualmente os
teclados são capacitivos e montados sobre a tela. Os teclados de laptops e desktops
usam o mesmo princípio de teclado matricial, mas no lugar das membranas são usadas
teclas.
Esse teclado de membrana é montado como uma matriz de teclas. Por isso também é
chamado de matricial. Mas o nome mais usado em inglês é Keypad, devido ao
pequeno tamanho. Veja a identificação dos pinos do conector (L = linhas e C =
colunas). Essa foto foi editada para diminuir o tamanho do cabo.

WWW.ELETROGATE.COM 112
 Montagem Arduino com o teclado de membrana:
Logo abaixo temos o diagrama da montagem. O keypad foi conectado nos pinos D4 até
D11, onde as colunas estão ligadas nos pinos D4, D5, D6 e D7, enquanto as linhas estão
ligadas nos pinos D8, D9, D10 e D11.

Lista de Materiais:
Para este exemplo você vai usar os seguintes componentes:

 Arduino MEGA,
 Protoboard,
 Jumpers de ligação,
 Teclado de membrana,
 Resistor 330 ohms,
 Display 7 segmentos – anodo comum.

Diagrama do teclado:

WWW.ELETROGATE.COM 113
 Código Arduino - Teclado de membrana:
O primeiro passo para dar início à programação desse exemplo é instalar a biblioteca
Keypad. Para isso, siga os passos de instalação dos exemplos anteriores e pesquise
pela biblioteca “Keypad”. Vamos instalar a versão desenvolvida por Mark Stanley e
Alexander Breving, conforme mostrado na imagem abaixo:

WWW.ELETROGATE.COM 114
 Código:

// Exemplo 26 – Display de 7 segmentos + Teclado de membrana

// Apostila Eletrogate - KIT BIG JACK
// Gustavo Murta

#include <Keypad.h> // biblioteca Keypad

const byte ROWS = 4; // Keypad 4 linhas

const byte COLS = 4; // Keypad 4 colunas

char hexaKeys[ROWS][COLS] = { // definição dos caracteres do Keypad

{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'} };

byte rowPins[ROWS] = {11, 10, 9, 8}; // portas D11 a D8 => linhas do Keypad
byte colPins[COLS] = {7, 6, 5, 4}; // portas D7 a D4 => colunas do Keypad

Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

void setup() {
Serial.begin(9600); // console serial 9600 Bps
}

void loop() {
char customKey = customKeypad.getKey(); // leitura da tecla pressionada
int number = customKey - 48; // converte o caracter em um número

if ((number > 16) && (number < 23)) number = number - 7;

// se numero for entre 17 e 22 subtraia 7 (numeros hexadecimais)

if (customKey) // se tecla for pressionada

Serial.println(number); // imprime o numero na console serial
}

WWW.ELETROGATE.COM 115
 Exemplo 27 - Medidor de Temperatura e Umidade com DHT11

O sensor DHT11 é um dispositivo de baixo custo usado para medição de umidade e

temperatura do ar. O sensor de umidade é capacitivo e o sensor de temperatura é um
termistor NTC, isto é um resistor sensível às variações de temperatura. Dentro do sensor
existe um microcontrolador que faz as medições e transmite as medições no formato
digital através de um pino de saída. Segundo o fabricante, a transmissão digital pode ser
realizada através de um cabo de até 20 metros.
OBS = longa exposição do sensor ao sol, poderá afetar a performance do mesmo.

Especificações do sensor DHT11 (esses valores podem variar dependendo do

fabricante):

• Faixa de umidade relativa = de 20 a 80 %

• Precisão na umidade = ± 5 % RH
• Resolução de umidade = 5 % RH
• Faixa de temperatura = 0 a 50 °C
• Precisão na temperatura = ± 2 % °C
• Tempo de resposta = 2 segundos
• Alimentação = de 3,5 V a 5 V
• Consumo máximo de corrente = 2,5 mA

Sensor DHT11 - pinagem

• VCC = 3,5 a 5V
• DATA = comunicação de dados
• NC = sem conexão
• GND = terra

WWW.ELETROGATE.COM 116
 Interface com o Sensor DHT11Após a alimentação de tensão do Sensor DHT11, aguarde cinco
segundos para o circuito se estabilizar. Um capacitor de 100 nF é recomendado entre o pino VCC
e o GND, se a fiação for longa. No pino de saída, deve ser usado também um resistor de pullup
-10 K ohms. Resistor Pullup é o resistor que fica conectado entre o pino de saída e o 5V.

A comunicação dos dados no barramento serial (único pino) ocorre nos dois sentidos, isto é, do
sensor para o Arduino e vice-versa.

O protocolo de comunicação pode ser dividido em três partes:

• Requisição: para o sensor enviar os dados, ele deverá ser requisitado,

• Resposta: o sensor envia uma resposta depois de requisitado,

• Leitura de dados: após a resposta do sensor, os dados são enviados em 5

segmentos de 8 bits (40 bits).

Se quiser saber mais sobre o sensor e o protocolo de comunicação, sugiro a leitura do

documento abaixo:

Módulo sensor DHT11:

http://blog.eletrogate.com/wp-content/uploads/2018/12/DHT11-DFRobot.pdf

Lista de materiais:
 Arduino MEGA,
 Protoboard,
 Sensor DHT11,
 Resistor de 10K,
 Jumpers para ligação no protoboard.

Diagrama do Circuito:

WWW.ELETROGATE.COM 117
 Para esse projeto, nosso código fará uso de uma biblioteca chamada DHT sensor
library. Diferente das outras que utilizamos ao longo dessa apostila, a biblioteca do
DHT 11 não é nativa da Arduino IDE, portanto, precisamos instalá-la manualmente.
Para isso, siga os passos abaixo:
1º - Abra o Gerenciador de Bibliotecas da Arduino IDE clicando no botão mostrado
abaixo:

2º - Com o gerenciador aberto, digite o nome da biblioteca e tecle Enter:

WWW.ELETROGATE.COM 118
 3º - Vamos instalar a versão destacada acima, desenvolvida pela Adafruit. Após clicar
em “Instalar”, no caso específico das bibliotecas da Adafruit, a seguinte mensagem será
exibida (caso seja a primeira vez que instala uma biblioteca da Adafruit):

Nela, clique em “INSTALAR TODAS” para dar sequência à instalação e aguarde a

mensagem abaixo ser exibida, indicando a finalização:

WWW.ELETROGATE.COM 119
 O programa também é bem simples. Ele faz com que o Arduino se comunique com o
Sensor DHT, para realizar as leituras de umidade e temperatura. Traduzimos o exemplo
da Biblioteca da Adafruit, para facilitar o entendimento.

WWW.ELETROGATE.COM 120
 Código Arduino – Sensor DHT11 – Umidade e Temperatura:

// Exemplo 17 - Arduino - Sensor DHT11 - Umidade e Temperatura

// Apostila Eletrogate - KIT BIG JACK
// Gustavo Murta

#include <Adafruit_Sensor.h> // Biblioteca DHT Sensor Adafruit

#include <DHT.h>
#include <DHT_U.h>

#define DHTTYPE DHT11 // Sensor DHT11

#define DHTPIN 2 // Pino do Arduino no Sensor (Data)

DHT_Unified dht(DHTPIN, DHTTYPE); // configurando o Sensor DHT - pino e tipo
uint32_t delayMS = 500; // variável para atraso no tempo

void setup()
{
Serial.begin(9600); // monitor serial 9600 bps
dht.begin(); // inicializa a função
Serial.println("Usando o Sensor DHT");
sensor_t sensor;
}

void loop()
{
delay(delayMS); // atraso entre as medições
sensors_event_t event; // inicializa o evento da Temperatura
dht.temperature().getEvent(&event); // faz a leitura da Temperatura
if (isnan(event.temperature)) // se algum erro na leitura
{
Serial.println("Erro na leitura da Temperatura!");
}
else // senão
{
Serial.print("Temperatura: "); // imprime a Temperatura
Serial.print(event.temperature);
Serial.println(" *C");
}
dht.humidity().getEvent(&event); // faz a leitura de umidade
if (isnan(event.relative_humidity)) // se algum erro na leitura
{
Serial.println("Erro na leitura da Umidade!");
}
else // senão
{
Serial.print("Umidade: "); // imprime a Umidade
Serial.print(event.relative_humidity);
Serial.println("%");
}
}

WWW.ELETROGATE.COM 121
 A saída esperada pode ser conferida na imagem abaixo:

Exemplo 28 – Utilizando o Módulo MPU-6050 - Acelerômetro e

Giroscópio

Este módulo, é um acelerômetro de 3 eixos com um giroscópio de 3 eixos integrado.

A principal função de um acelerômetro é calcular a aceleração linear do módulo na
direção X, Y ou Z, seguindo um plano cartesiano, e com essa informação você pode
calcular a velocidade ou a posição do módulo.

WWW.ELETROGATE.COM 122
 Créditos: https://en.wikipedia.org/wiki/Cartesian_coordinate_system#/media/File:Coord_system_CA_0.svg

Já o giroscópio é capaz de calcular a velocidade angular do módulo, isso é, a

aceleração com que o o módulo rotacional em um determinado eixo. Com esse dado
da aceleração, você é capaz de calcular a posição que o eixo está, que é uma
informação bem relevante para algumas aplicações.

Datasheet do módulo: http://datasheets.eletrogate.com/MPU-6000.pdf

WWW.ELETROGATE.COM 123
 Sobre este módulo para Arduino, ele se chama GY-521. onde ele já vem com um
regulador de tensão, que permite o módulo ser usado de 3-5V e com a opção de soldar
pinos que se encaixam em protoboard. Os pinos presentes são

• VCC: A alimentação positiva, que pode ser de 3 até 5V

• GND: A o pino de alimentação neutra da fonte.
• SCL: Pino de Clock da comunicação I2C.
• SDA: Pino de Dados da comunicação I2C.
• XDA: Pino de Dados para I2C auxiliar (não usado)
• XCL: Pino de Clock para I2C auxiliar (não usado)
• AD0: Pino para troca de endereço I2C de acordo com a tensão, podendo usar
mais de um do mesmo módulo simultaneamente.
• INT: Pino de interrupção

Interface com o Sensor MPU-6050

O sensor funcionará medindo os dados das acelerações linear e angular, irá utilizar o
seu conversor ADC interno para transformar este dado em um dado digital, e enviará
para o Arduino através da comunicação I2C.

Aqui neste projeto nós faremos uso de uma biblioteca, que facilitará a comunicação,
interpretação das informações, assim como a localização do sensor.

Sensor MPU-6050 com Arduino:

Para fazer a ligação do sensor com o Arduino iremos precisar de:

Lista de materiais:

• Arduino Mega 2560

• Sensor acelerômetro de 3 eixos MPU-6050
• Protoboard 830 pontos
• Jumpers de ligação

WWW.ELETROGATE.COM 124
 Diagrama do Circuito:

Instalando a Biblioteca Adafruit MPU6050:

Para instalar a Biblioteca Adafruit MPU6050 na Arduino IDE, clique em:

Sketch > Incluir Biblioteca > Gerenciar Bibliotecas

Após abrir a janela do Gerenciador de Biblioteca, refine a busca digitando “MPU6050”.

Na biblioteca da Adafruit, clique em More Info e depois em Instalar. Após alguns
segundos, ela será automaticamente instalada. Lembre-se que o seu computador
precisa estar conectado na internet, para poder baixar a biblioteca. Após a instalação
da Biblioteca, é necessário que feche e abra novamente o programa da Arduino IDE.

WWW.ELETROGATE.COM 125
 Sketch Arduino – Acelerômetro MPU-6050

A Sketch que apresentaremos é uma adaptação da Sketch de exemplo da própria

biblioteca, onde os dados podem ser vistos no monitor serial. Não esqueça de mudar a
taxa de comunicação para 115200.

WWW.ELETROGATE.COM 126
 // Exemplo 18 - Arduino - Sensor MPU-6050 - Acelerômetro e Giroscopio
// Apostila Eletrogate - KIT BIG JACK

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>

Adafruit_MPU6050 mpu; // Inicia um objeto do tipo sensor MPU6050, chamado mpu

void setup(void) {
Serial.begin(115200);
while (!Serial)
delay(10); // Fará uma pausa até que a comunicação serial se inicie corretamente.

Serial.println("MPU6050 teste!");

// Tentando inicializar
if (!mpu.begin()) { // Se caso o sensor não iniciar
Serial.println("A inicialização sensor MPU-6050 falhou");
while (1) {} // Se a inicialização falhar, o programa irá travar aqui
}
Serial.println("MPU6050 encontrado!");

mpu.setAccelerometerRange(MPU6050_RANGE_8_G); // Definindo o range de ação do acelerometro.

mpu.setGyroRange(MPU6050_RANGE_500_DEG); // Definindo o range de ação do giroscopio.
mpu.setFilterBandwidth(MPU6050_BAND_21_HZ); // Configurando a largura da banda do filtro

Serial.println(""); // Fim das configuracoes iniciais

delay(100);
}

void loop() {

/* Capturando dados de evento do sensor através das variáveis personalizadas.*/

sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);

/* Imprimindo no monitor Serial os valores capturados */

Serial.print("Aceleracao em X: ");
Serial.print(a.acceleration.x);
Serial.print(", Y: ");
Serial.print(a.acceleration.y);
Serial.print(", Z: ");
Serial.print(a.acceleration.z);
Serial.println(" m/s^2");

Serial.print("Rotacao em X: ");
Serial.print(g.gyro.x);
Serial.print(", Y: ");
Serial.print(g.gyro.y);
Serial.print(", Z: ");
Serial.print(g.gyro.z);
Serial.println(" rad/s");

Serial.print("Temperature: ");
Serial.print(temp.temperature);
Serial.println(" oC");

Serial.println("");
delay(500);
}

WWW.ELETROGATE.COM 127
 Os dados podem ser visualizados no monitor serial.

Referências:

• https://playground.arduino.cc/Main/MPU-6050/
• https://www.instructables.com/id/MPU-6050-Tutorial-How-to-Program-MPU-
6050-With-Ard/
• http://www.ime.eb.br/~moniz/dinamica/desafio_01.pdf

Exemplo 29 - Comunicação Bluetooth entre Arduino Mega e Smartphone

A tecnologia Bluetooth consiste em um protocolo para comunicação de rádio para uso

pessoal, isto é, é uma especificação de rede sem fio classificada como PAN (Personal
Area Network). Foi desenvolvida inicialmente em 1994 pela Ericsson como uma
alternativa sem fio ao protocolo RS-232. A faixa de frequência utilizada pelo Bluetooth
é de 2.4 a 2.485 GHz.

Um grupo de empresas e centros de desenvolvimento chamado de Bluetooth Special

Interest Group é responsável por escrever as especificações do protocolo e lançar
versões atualizadas e novas funcionalidades.

WWW.ELETROGATE.COM 128
 O protocolo é licenciado e para que um produto possa estampar o emblema da
comunicação bluetooth é preciso estar de acordo com todas as especificações do
protocolo. Para cada versão do Bluetooth existem testes de qualificação pelos quais
um produto deve passar para poder ser certificado como um equipamento que utiliza
comunicação Bluetooth.

O Arduino vem sendo amplamente utilizado em projetos em que é preciso fazer a

comunicação sem fio de sensores, controladores e processadores. A comunicação
bluetooth, já popularizada e usada em diversos equipamentos como Smartphones,
tablets, Headsets, notebooks e outros, é uma das melhores opções para implementar
redes sem fio com Arduino.

O módulo HC-06 consegue operar como um dispositivo escravo, isto é, ele não
consegue se comunicar a outros dispositivos procurando a conexão, ele só é capaz de
receber a solicitação de comunicação e se comunicar.

WWW.ELETROGATE.COM 129
 Pinout do módulo HC-06:

• VCC – Alimentação positiva do módulo (3.6V – 6V)

• GND – Alimentação neutra
• TXD – Pino de transmissão da comunicação serial (3.3V)
• RXD – Pino de recebimento de dados da comunicação serial (3.3V)

Vale ressaltar que para realizar a comunicação serial com o Arduino Mega deve ser
feita ligando o TXD (Bluetooth) ligando diretamente ao RX (Arduino) e RXD (Bluetooth)
passando por um divisor de tensão e ligando ao TX (Arduino).

Lista de Materiais:

Para este exemplo você precisará dos seguintes componentes:

• Arduino Mega
• Protoboard
• Bluetooth HC-06
• 2 resistores de 10K
• Jumpers de ligação
• Aplicativo Bluetooth Serial (não compatível com IOS)

Montagem do Modulo HC-06 com Arduino:

WWW.ELETROGATE.COM 130
 Instale o aplicativo abaixo, pareie o módulo Bluetooth ao seu celular.

Vá em “Devices” e selecione o módulo HC-06.

Após isso você pode poderá enviar mensagens ao módulo bluetooth.

Lendo as mensagens

Carregue o código abaixo.

// Exemplo 19 - Arduino - Modulo HC-06 Bluetooth

// Apostila Eletrogate - KIT BIG JACK

void setup() {
Serial.begin(9600); // Inicia o monitor serial
Serial1.begin(9600); // inicia a porta serial 1, do Bluetooth
}

void loop() {
if(Serial1.available()){ // Lendo os caracteres enviados
Serial.print((char)Serial1.read());
}
}

Abra o monitor serial e selecione a velocidade como 9600

O monitor serial irá exibir as mensagens enviadas pelo seu celular.

WWW.ELETROGATE.COM 131
 Parte V - Cálculo do resistor de base dos
transistores
Vamos abordar aqui como o cálculo do resistor de base deve ser feito. É de suma
importância dimensioná-lo corretamente pois, como visto anteriormente, esse resistor
é o responsável por controlar a corrente que fluirá pelo transistor.
O primeiro passo é calcular a corrente de base usando a fórmula
𝐼𝐼𝐼𝐼
𝐼𝐼𝐼𝐼 = , onde:
𝛽𝛽

Ib representa o valor da corrente de base, Ic é o valor da corrente que fluirá pelo

coletor (dada em Ampères) e β é o ganho do transistor.

Com o valor de Ib em mãos, vamos utilizar a lei de Ohm para encontrar o valor da
resistência através da seguinte fórmula:
𝑉𝑉𝑉𝑉−𝑉𝑉𝑉𝑉𝑉𝑉
𝑅𝑅𝑅𝑅 = , onde:
𝐼𝐼𝐼𝐼
Rb representa o valor do resistor de base em ohms, Vb é valor da tensão aplicada na
base (no caso de uma aplicação com o Arduino, esse valor será de 5V) e Vbe é o valor
da tensão entre base e emissor do transistor quando este está ligado (considere como
sendo tipicamente 0,7V). Ib, como dito anteriormente, é o valor da corrente de base.

IMPORTANTE: O valor de ganho é encontrado no datasheet do componente (você

encontra facilmente na internet). Abaixo, retiramos um trecho do datasheet do
transistor BC548B para exemplificarmos essa questão:

WWW.ELETROGATE.COM 132
 Se utilizarmos qualquer valor de ganho dentro da faixa especificada, o transistor
funcionará na região ativa. Para que o transistor em opere em modo saturação, o
ganho utilizado no cálculo deve ser muito inferior ao ganho mínimo (nesse caso, a 200),
sendo comum utilizar apenas 10% desse valor.

Outros parâmetros também são importantes ao dimensionar um transistor para seu

circuito, como corrente de coletor máxima suportada, tensão máxima etc., ambos
presentes no datasheet. Não abordaremos esses detalhes nessa apostila.

Dito isso, vamos considerar o exemplo 12 da apostila como modelo de cálculo. Nele,
nós temos que:

• O transistor opera como chave (em modo saturação - lembre-se, utilize 10% do
ganho mínimo especificado nessa situação);
• A corrente de coletor é 75mA (equivalente a 0,075A - para converter mA em A,
basta dividir por 1000);
• A tensão de base é 5V;
• O modelo do transistor é o BC548B.
Com esses dados em mãos, vamos aos cálculos. Primeiramente, encontramos o valor
da corrente de base:
𝐼𝐼𝐼𝐼 0,075
𝐼𝐼𝐼𝐼 = → 𝐼𝐼𝐼𝐼 = → 𝐼𝐼𝐼𝐼 = 0,00375
𝛽𝛽 20

Com o valor de Ib encontrado, vamos para a segunda fórmula. Nela, temos que:

• Vb equivale a 5V;
• Vbe equivale a 0,7V;
• Ib equivale a 0,00375A
Substituindo:
𝑉𝑉𝑉𝑉−𝑉𝑉𝑉𝑉𝑉𝑉 5−0,7 4,3
𝑅𝑅𝑅𝑅 = → 𝑅𝑅𝑅𝑅 = → 𝑅𝑅𝑅𝑅 = → 𝑅𝑅𝑅𝑅 = 1.146,66
𝐼𝐼𝐼𝐼 0,00375 0,00375
Veja que o valor encontrado para Rb é de 1.146Ω, porém não encontramos esse
resistor comercialmente. O valor mais próximo disponível no Kit Big Jack é de 1KΩ

WWW.ELETROGATE.COM 133
 (1000Ω), portanto esse deve ser o resistor utilizado na base do transistor no exemplo
12.
E aí, já consegue confirmar o valor dos resistores de base para o exemplo 11?
Deixaremos essa tarefa como exercício para você!

Parte VI – Principais comandos do Arduino

Nesta seção, trazemos um resumo dos comandos da Arduino IDE utilizados ao longo
dos exemplos. Essas referências são ferramentas valiosas para esclarecer suas dúvidas
sobre a sintaxe (a estrutura dos comandos) e, mais importante, para desvendar o
funcionamento de cada um deles. Aproveite esta oportunidade para aprofundar seu
conhecimento e dominar a programação no Arduino!

• #include <biblioteca>: Tem por função permitir a importação de bibliotecas

externas, como a Servo.h.
• #define: Define constantes que serão usadas ao longo do código, como um
pino do Arduino.
• pinMode(pino, modo): Comando usado para configurar um pino como entrada
(INPUT), saída (OUTPUT) ou ainda como um tipo especial de entrada que
dispensa o uso de resistores para acionar botões (INPUT_PULLUP).
• digitalWrite(pino, valor): Define se o pino configurado estará ligado (HIGH) ou
desligado (LOW).
• digitalRead(pino): Faz a leitura de um pino digital, verificando se está ligado ou
desligado.
• analogRead(pino): Faz a leitura de um pino analógico, retornando valores
entre 0 e 1023.
• analogWrite(pino, valor): Envia um sinal PWM para os pinos digitais
compatíveis.
• delay(x): Pausa a execução do código por x milissegundos.

WWW.ELETROGATE.COM 134
 • millis(): Retorna o número de milissegundos desde que o Arduino começou a
rodar o código.
• map(fonte, in_min, in_max, out_min, out_max): Converte um intervalo inicial
proveniente de uma (como uma entrada analógica) para outro, de maneira
proporcional.
• Serial.begin(velocidade): Inicializa a comunicação serial com uma velocidade
específica em bits por segundo.
• Serial.print() e Serial.println(): Imprimem dados no monitor serial. O segundo,
acrescido de uma quebra de linha.
• if (condição) / else: Laço condicional (Se condição, execute y, senão, execute z).
• for (inicialização; condição; incremento): Laço de repetição que itera sobre um
bloco de código um número definido de vezes (x recebe y, enquanto x for
menor que z, incremente x).
• switch (variável)/ case possível valor / break: estrutura usada para selecionar
um bloco de código a ser executado com base no valor da variável. As
possibilidades são listadas com o comando “case” e encerradas com o
comando “break”.
• int: Usado para iniciar uma variável ou array do tipo inteiro, que trabalha
somente com números inteiros (sem casas decimais).
• float: Usada para criar variáveis e arrays que precisam receber números com
ponto flutuante (números com casas decimais).
• unsigned long: Usado para criar variáveis que precisam armazenar grandes
números positivos, como os fornecidos pela função millis().
• void: Usado para criar funções que não retornam nenhum tipo de valor.
• Servo / attach / write: comandos dedicados da biblioteca Servo.h, usados para
criar o objeto que receberá as funções da biblioteca, configurar o pino em que
o servo está conectado e enviar os pulsos de forma correta.

Sugerimos que, além de consultar esse pequeno resumo, acesse a documentação

oficial do Arduino e estude os demais comandos e sua sintaxe através do link a seguir:

• https://www.arduino.cc/reference/pt/

WWW.ELETROGATE.COM 135
 Considerações finais
Essa apostila tem por objetivo apresentar alguns exemplos básicos sobre como utilizar
os componentes do Kit Big Jack para Arduino, a partir dos quais você pode combinar e
fazer projetos mais elaborados por sua própria conta.

Nas referências finais, também tentamos indicar boas fontes de conteúdo objetivo e
com projetos interessantes. Sobre esse ponto, que consideramos fundamental,
gostaríamos de destacar algumas fontes de conhecimento que se destacam por sua
qualidade.

O fórum oficial Arduino possui muitas discussões e exemplos muito bons. A comunidade
de desenvolvedores é bastante ativa e certamente pode te ajudar em seus projetos. No
Project Hub poderá encontrar milhares de projetos com Arduino.

 Fórum oficial Arduino: https://forum.arduino.cc/

 Project Hub Arduino: https://create.arduino.cc/projecthub

O Instructables é a ótima referência do mundo maker atual. Pessoas que buscam

construir suas próprias coisas e projetos encontram referências e compartilham suas
experiências no site.

 Instructables: https://www.instructables.com/

O Maker Pro é outro site referência no mundo em relação aos projetos com Arduino. Há
uma infinidade de projetos, todos bem explicados e com bom conteúdo.

WWW.ELETROGATE.COM 136
  Maker pro: https://maker.pro/projects/arduino

Em relação à eletrônica, teoria de circuitos e componentes eletrônicos em geral,

deixamos alguns livros essenciais na seção finais de referências. O leitor que quer se
aprofundar no mundo da eletrônica certamente precisará de um livro basilar e de bons
conhecimentos em circuitos eletroeletrônicos.

No mais, esperamos que essa apostila seja apenas o início de vários outros projetos e,
quem sabe, a adoção de Kits mais avançados, como os de Robótica e Arduino Big Jack.
Qualquer dúvida, sugestão, correção ou crítica a esse material, fique à vontade para
relatar em nosso blog oficial: http://blog.eletrogate.com/

Referências gerais

1. Fundamentos de Circuitos Elétricos. Charles K. Alexander; Matthew N. O.

Sadiku. Editora McGraw-Hill.
2. Circuitos elétricos. James W. Nilsson, Susan A. Riedel. Editora: Pearson; Edição:
8.
3. Microeletrônica - 5ª Ed. - Volume Único (Cód.: 1970232). Sedra, Adel S. Editora
Pearson.
4. Fundamentals of Microelectronics. Behzad Razavi. Editora John Wiley & Sons;
Edição: 2nd Edition (24 de dezembro de 2012).

Abraços e até a próxima!

WWW.ELETROGATE.COM 137
WWW.ELETROGATE.COM 138