Apostila IOT Versão Final

QI ESCOLAS E FACULDADES
CURSOS TÉCNICOS – EIXO TECNOLOGIA DA INFORMAÇÃO
Internet Das
Coisas
Desenvolvido por: Prof. Rodrigo M. Barreto

( rodrigo.barreto@qi.edu.br )
Pág.
Coordenação Pedagógica – Cursos Técnicos 1
SUMÁRIO
UNIDADE 1 – INTERNET DAS COISAS ............................................................................ 6

1 ENTENDENDO O IOT ................................................................................................... 6
1.1 Requisitos do IOT ...................................................................................................... 7
1.2 Áreas principais do IoT .............................................................................................. 9
1.2.1 Domótica ............................................................................................................................ 9
1.2.2 Indústria 4.0 .................................................................................................................... 11
1.2.3 Agrotech ........................................................................................................................... 12
1.2.4 Smart Cities ..................................................................................................................... 13
1.3 Cultura Maker......................................................................................................... 14
1.3.1 O Manifesto Maker ........................................................................................................... 15
1.3.2 Os Makerspaces............................................................................................................... 17
1.3.3 Placas de Prototipagem .................................................................................................... 19
UNIDADE 2 - TÓPICOS BÁSICOS DE ELETRÔNICA ANALÓGICA ................................. 20

2 O QUE É ELETRÔNICA? ............................................................................................ 20
2.1 Energia elétrica, fluxo de elétrons e observações iniciais ......................................... 20
2.2 Exemplificando Tensão x Corrente e Resistência ..................................................... 24
2.3 Formalização das observações sobre Tensão, Corrente e Resistência ....................... 26
2.3.1 Representação formal de um circuito eletrônico básico ................................................... 27
2.3.2 Primeira Lei de Ohm......................................................................................................... 27
2.3.3 Segunda Lei de Ohm ........................................................................................................ 28
2.4 Associação de fontes de energia............................................................................... 30
2.5 Associação de Resistências ...................................................................................... 31
2.5.1 Associação de resistências em série ................................................................................ 31
2.5.2 Associação de resistências em paralelo........................................................................... 33
2.6 Potência elétrica ...................................................................................................... 35
3 PRINCIPAIS COMPONENTES ELETRÔNICOS ............................................................. 36
3.1 Resistores ............................................................................................................... 37
3.1.1 Resistores fixos ................................................................................................................ 37
3.1.2 Resistores variáveis ......................................................................................................... 38
3.2 Capacitores ............................................................................................................. 39
3.2.1 Capacitor como temporizador ........................................................................................... 41
3.2.2 Capacitor como estabilizador de tensão .......................................................................... 41
3.2.3 Capacitor como amplificador de corrente e de tensão ..................................................... 41
3.2.4 Capacitores como disparadores de alta tensão ou alta corrente ..................................... 43
3.3 Diodos ..................................................................................................................... 43
3.3.1 Ligação inversa ................................................................................................................ 44
3.3.2 Ligação direta .................................................................................................................. 44
3.3.3 Outros tipos de diodos especiais ..................................................................................... 45
Pág.
3.4 Transistores ............................................................................................................ 46
3.4.1 Esquematização de um transistor NPN ............................................................................ 48
3.4.2 Exemplo de circuito com transistor como chave de disparo ............................................. 50
3.4.3 Transistores Reguladores de Tensão Fixos e Variáveis................................................... 53
4 ELETRÔNICA DO DIA A DIA ...................................................................................... 56
4.1 Tomadas, padrões e tipos de ligação........................................................................ 56
4.2 Dimensionamento de tomadas e fios ....................................................................... 58
4.3 Disjuntores e dimensionamento da rede .................................................................. 60
UNIDADE 3 – INTRODUÇÃO AO ARDUINO ................................................................... 64

5 ARDUINO – ASPECTOS INICIAIS ............................................................................... 64
5.1 Principais tipos de Arduino ..................................................................................... 64
5.1.1 Arduino Uno ..................................................................................................................... 65
5.1.2 Arduino Mega ................................................................................................................... 65
5.1.3 Arduino Nano ................................................................................................................... 65
5.1.4 Arduino Pro Mini .............................................................................................................. 66
5.1.5 Arduino LilyPad ............................................................................................................... 66
5.1.6 Arduino Leonardo ............................................................................................................ 66
5.1.7 Arduino Due ..................................................................................................................... 67
5.1.8 Arduino Esplora ............................................................................................................... 67
5.1.9 Arduino Romeo ................................................................................................................. 68
5.1.10 Tabela comparativa de especificações técnicas ............................................................. 68
5.2 Portas do Arduino ................................................................................................... 69
5.2.1 Portas Digitais .................................................................................................................. 69
5.2.2 Portas PWM ...................................................................................................................... 70
5.2.3 Portas analógicas ............................................................................................................. 70
5.2.4 Portas de alimentação...................................................................................................... 71
5.2.5 Porta Reset ....................................................................................................................... 71
5.2.6 Porta RX e TX ................................................................................................................... 71
5.2.7 Portas de Interrupção ....................................................................................................... 72
5.2.8 Portas I2C (SDA e SCL) .................................................................................................... 72
5.2.9 Portas SPI ......................................................................................................................... 72
5.2.10 Portas AVR ..................................................................................................................... 73
5.3 Programando com a Arduino IDE ............................................................................ 73
5.3.1 Instalando e configurando o ambiente de trabalho ......................................................... 73
5.3.2 Configurações iniciais ...................................................................................................... 76
5.3.3 Testando a compilação, o upload e a execução do código ............................................... 78
5.4 Iniciando com a programação Arduino .................................................................... 82
5.4.1 Configurando as portas digitais como entrada ou saída ................................................. 82
5.4.2 Escrevendo o estado de saída da porta digital convencional .......................................... 83
5.4.3 Escrevendo o estado de saída da porta digital PWM....................................................... 83
5.4.4 Criando paradas temporizadas ....................................................................................... 84
5.4.5 Escrevendo nosso código e entendendo o setup e o loop ................................................. 84
5.4.6 Exemplo 1: ligando e desligando leds .............................................................................. 85
5.4.7 Exemplo 2: ligando o led e regulando a intensidade com PWM ....................................... 88
Pág.
UNIDADE 4 - SENSORES .............................................................................................. 89
6 TRABALHANDO COM SENSORES .............................................................................. 89
6.1 Leitura de sensores digitais de resposta binária ...................................................... 91
6.1.1 Sensor de proximidade PIR: Exemplo detalhado ............................................................. 91
6.1.2 Sensor de som.................................................................................................................. 93
6.1.3 Sensor de chama ............................................................................................................. 93
6.1.4 Sensor de vibração........................................................................................................... 93
6.1.5 Sensor de inclinação (TILT) .............................................................................................. 94
6.1.6 Chave magnética (reed-switch) ........................................................................................ 94
6.1.7 Sensor magnético de proximidade ................................................................................... 95
6.1.8 Push button ...................................................................................................................... 95
6.1.9 Chave tátil capacitiva ...................................................................................................... 95
6.1.10 Chave de 2 estados ....................................................................................................... 96
6.1.11 Chave de fim de curso ................................................................................................... 96
6.1.12 Encoder ótico e encoder magnético ................................................................................ 96
6.1.13 Sensor de vazão ............................................................................................................. 97
6.2 Leitura de sensores de resposta binária com uso de interrupções ........................... 97
6.2.1 Sensor encoder: exemplo detalhado com uso de interrupções ......................................... 99
6.2.2 Sensor de vazão: exemplo detalhado com uso de interrupções ..................................... 101
6.3 Leitura de sensores analógicos .............................................................................. 103
6.3.1 Mapping de valores ........................................................................................................ 104
6.3.2 Sensor LDR: exemplo detalhado de captura direta de valor .......................................... 105
6.3.3 Sensor de gás ................................................................................................................ 107
6.3.4 Sensor óptico reflexivo ................................................................................................... 108
6.3.5 Sensor Joystick .............................................................................................................. 109
6.3.6 Sensor de temperatura LM35 – Exemplo detalhado de mapping de valor..................... 111
6.3.7 Potenciômetro ................................................................................................................. 113
6.3.8 Sensor de umidade do solo ............................................................................................ 115
6.3.9 Sensor de respingos ....................................................................................................... 117
6.4 Leitura de sensores especiais ................................................................................ 118
6.4.1 Sensor ultrassônico de distância (HC-SR04) ................................................................. 120
6.4.2 Sensor de cor RGB (TCS230).......................................................................................... 123
6.4.3 Sensor de umidade e temperatura (DHT11) .................................................................. 127
6.4.4 Sensor RFID (RC522) ..................................................................................................... 128
6.4.5 Sensor acelerômetro e giroscópio (MPU6050) ................................................................. 131
6.4.6 Sensor de carga com amplificador (HX711) ................................................................... 133
6.4.7 Sensor de gestos (APDS-9960) ....................................................................................... 134
6.4.8 Sensor de reconhecimento de voz (V3) ........................................................................... 134
6.4.9 Sensor de batimentos cardíacos (KY-039) ..................................................................... 135
6.4.10 Sensor GPS (Neo-6M) ................................................................................................... 136
UNIDADE 5 – ATUADORES ......................................................................................... 136

7 TRABALHANDO COM ATUADORES ......................................................................... 136
7.1 Atuadores de ativação simples com até 5V ............................................................ 137
7.1.1 Leds ............................................................................................................................... 137
7.1.2 Emissor laser ................................................................................................................. 137
7.1.3 Vibracall ......................................................................................................................... 138
7.1.4 Buzzer ............................................................................................................................ 138
7.1.5 Relé ................................................................................................................................ 141
Pág.
7.2 Atuadores de ativação simples com tensões superiores à 5V ................................. 143
7.2.1 Solenoide........................................................................................................................ 144
7.2.2 Válvula solenoide ........................................................................................................... 144
7.2.3 Trava solenoide .............................................................................................................. 145
7.2.4 Bomba submersa ........................................................................................................... 145
7.2.5 Bomba de ar .................................................................................................................. 145
7.3 Displays ................................................................................................................ 146
7.3.1 Display de 7 segmentos ................................................................................................. 146
7.3.2 Display LCD ................................................................................................................... 149
7.3.3 Display OLED ................................................................................................................. 154
7.4 Motores ................................................................................................................. 154
7.4.1 Motor DC + Ponte H ........................................................................................................ 155
7.4.2 Motor de passo ............................................................................................................... 158
7.4.3 Servomotor ..................................................................................................................... 160
7.5 Emissor Infravermelho .......................................................................................... 162
7.5.1 Clonando o controle remoto para controlar o Arduino .................................................... 164
7.5.2 Clonando o controle remoto para controlar equipamentos ............................................. 167
UNIDADE 6 – TÓPICOS AVANÇADOS ......................................................................... 170

8 MÓDULOS ESPECIAIS E COMUNICAÇÃO................................................................ 170
8.1 Módulo de Cartão MicroSD.................................................................................... 170
8.1.1 Principais métodos para trabalhar com arquivos e MicroSD.......................................... 171
8.1.2 Esquema eletrônico de ligação do leitor ......................................................................... 171
8.1.3 Exemplo prático: histórico de temperaturas de um forno de pizza ................................ 172
8.2 Módulo Bluetooth .................................................................................................. 175
8.2.1 Principais métodos para trabalhar com o módulo HC .................................................... 176
8.2.2 Ligação eletrônica .......................................................................................................... 177
8.2.3 Pareamento do HC com um Smartphone Android .......................................................... 178
8.2.4 Descoberta do Mac Address do módulo HC ................................................................... 179
8.2.5 Exemplo prático: criando app em Android integrado com Arduino ................................ 180
8.3 Módulo WiFi (ESP-8266) ....................................................................................... 188
8.3.1 Principais métodos para trabalhar com o módulo ESP-8266 ......................................... 189
8.3.2 Ligação eletrônica .......................................................................................................... 192
8.3.3 Exemplo prático: comunicação e controle com webpage através do WiFi ...................... 194
8.3.4 Adaptando o exemplo para redes cabeadas com a biblioteca Ethernet.h ..................... 199
Pág.
UNIDADE 1 – INTERNET DAS COISAS
1 ENTENDENDO O IOT
O termo IoT (Internet of Things, ou

Internet das Coisas, em português),
foi criado por Kevin Aston e
apareceu pela primeira vez em uma
apresentação sua sobre as novas
tecnologias na empresa Procter &
Gamble, no ano de 1999. Porém,
passou a ser mais difundido a
partir de 2005 e popularizou-se a
partir de 2010.
Chamamos de IoT uma rede composta pelos mais diversos dispositivos que possuem a
capacidade de se comunicar, trocando informações em tempo real e tomando decisões a
partir daí (sejam esses dispositivos desde simples sensores até complexos assistentes de
voz). Uma característica importante é que eles não devem ter a comunicação e
funcionamento restritos a um conjunto limitado que compõe uma linha comercial ou uma
determinada marca. Um Chromecast aceita transmissões vindas de smartphones Android
mas também de iOS; a Alexa controla lâmpadas inteligentes da Amazon mas também de
outras marcas; um sensor de umidade do solo pode ser lido tanto por um Arduino, quanto
por um ESP32 ou um Raspberry PI; uma geladeira inteligente da LG pode se comunicar
com uma televisão inteligente da Samsung sugerindo a execução de vídeos de receitas com
algum dos ingredientes retirados dela pelo usuário. Quando falamos de IoT, falamos de
ampliar as possibilidades e não de limitá-las.
Essa troca de informações e as decisões tomadas, podem envolver tanto hardware

como software (Alexa, Siri, Google Lens, firmwares de controle de eletroeletrônicos
inteligentes, aplicações de smartphone para controle ou exibição de dados coletados). Tudo
isso tem como objetivo principal a automatização de tarefas (nas mais diversas áreas), mas
também a segurança e o lazer.
Pág.
1.1 Requisitos do IOT
É impossível listar todos os componentes,

dispositivos e tecnologias que podem ser aplicadas quando
falamos de Internet das Coisas. Porém, o sucesso do IoT
está relacionado com 4 fatores principais, mostrados no
esquema ao lado:
Sensores de baixo custo: você sabe o valor do sensor

acelerômetro que equipa um caríssimo iPhone 12 e que
captura todos os movimentos realizados pelo telefone
(permitindo desde o controle de jogos, o ajuste de
conteúdos na tela de acordo com a posição e mesmo alertas ao perceber por
micromovimentos da sua caminhada que a pisada está errada)? Em torno de 2 reais. Ou
então um sensor que detecta respingos, acionando o fechamento automático de uma janela
quando perceber o início das primeiras gotas de uma chuva? Menos de 50 centavos. Por
mais elaborados e tecnológicos que sejam os usos
dos sensores, geralmente eles são muito baratos e
acessíveis. Nos últimos anos, popularizaram-se os
sensores de baixo custo e de fácil uso, permitindo
que mesmo entusiastas sem muito conhecimento
técnico possam utilizá-los em projetos que chamam
atenção e que não seriam possíveis anos atrás. E empresas também se beneficiaram,
agregando funcionalidades atraentes em dispositivos cada vez mais tecnológicos e sem
necessariamente um aumento significativo no preço.
Conectividade: IoT não seria possível sem a comunicação entre os dispositivos (para a
troca de informações, dados capturados, alertas, decisões). Então, a conectividade é um
ponto fundamental, criando condições para que essa comunicação aconteça de forma
eficiente. A conectividade é dada através de três fatores importantes: protocolos de
comunicação, rede e segurança. Os protocolos de comunicação são formas padronizadas
de como informações podem ser enviadas de um dispositivo A para um dispositivo B
(através de pacotes direcionados ou em broadcast) e interpretadas no momento em que
forem recebidas. Podemos entendê-los como uma “língua” que permitirá aos dispositivos,
Pág.
com base nas mesmas regras, conversar. Entre os mais comuns em IoT temos TCP/IP,
HTTP, Serial e I2C. Já a rede é quem garante um meio para que essa comunicação possa
acontecer e as informações (pacotes) possam trafegar de um dispositivo para o outro. Essas
redes podem ser físicas (cabeadas ou por
pontes de contatos) ou não físicas (como o
WiFI, Bluetooh, NFC, RFid, LoRa e ZigBee).
Por último, a segurança é a garantia de que a
comunicação, utilizando a rede escolhida e no
protocolo escolhido, vai acontecer de forma
segura. Porém, como “forma segura” não
estamos falando somente da segurança dos
dados trafegados (por criptografia, por
exemplo), mas também da garantia da sua
transmissão e a proteção para evitar a sua perda. Infelizmente segurança de dados é um
ponto crítico do IoT, pois muitas vezes é dada a preferência por redes e protocolos mais
simples e leves, focando em otimização e velocidade em detrimento da privacidade; outras,
o serviço é oferecido gratuitamente e a coleta intencional de dados (e seu posterior uso ou
venda) é o objetivo e o que vai garantir a monetização do negócio.
Inteligência: sistemas IoT capturam, compartilham e utilizam dados. Seja através dos
sensores, dos aplicativos, dos serviços ou das plataformas, a massa de informações
geradas é muito grande. Um dos maiores
méritos do sucesso do IoT é justamente saber
fazer bom uso destes dados, seja para tomar
decisões a partir deles em favor do usuário,
seja para utilizar esses dados contra o
próprio usuário sem o seu conhecimento. A
implementação de inteligência em sistemas
desse tipo, pode ter relação com alguns aspectos importantes: mineração e processamento
de dados (saber selecionar quais dados de uma massa gigantesca de dados utilizar),
aprendizagem sobre esses dados (conseguir aprender ou encontrar padrões em cima dos
dados selecionados) e ação sobre o aprendizado (saber agir baseado dos aprendizados e
padrões obtidos). Ou seja, a inteligência tem a ver diretamente com ferramentas de três
áreas principais: data science, inteligência artificial e o desenvolvimento de softwares
(lógica, restrições e implementação de regras de negócio).
Pág.
Serviços: os serviços são duplamente importantes quando pensamos em IoT. São eles que
permitem desenvolver sistemas mais robustos e flexíveis com uso de tecnologias
disponibilizadas para fins específicos e que podem ser incorporados ao projeto
(processamento e armazenamento na nuvem,
por exemplo). Mas diversos sistemas de IoT
são planejados para funcionarem também
como um serviço disponibilizado para o
usuário, de forma gratuita (monetizando
sobre dados, publicidade, propagandas
direcionadas, etc) ou paga (com cobrança de
licenças ou mensalidades). Um termo muito
aderente ao IoT é o SaaS (Software as a
Service, ou Software como um Serviço). O software geralmente deixa de ser o foco e passa
a ser “transparente” pois o serviço oferecido é mais visível e agrega uma maior percepção
de valor ao usuário. Por trás, do serviço temos uma infraestrutura também transparente
e que serve de plataforma para o armazenamento de dados, interpretação dos códigos-
fonte, hospedagem do software e de websites, execução de aplicativos ou de serviços para
aplicativos (webservices).
1.2 Áreas principais do IoT
O IoT pode ser aplicado nas mais diversas áreas e sua variedade de possibilidades
permite o fácil encontro de usos práticos em que ele agregue. Porém, existem 4 áreas onde
ele aparece com mais força: domótica, indústria 4.0, agrotech e smart cities.
1.2.1 Domótica
Talvez este seja o grande exponencial do uso
de IoT e o primeiro contato da maioria das pessoas
com o conceito e com suas tecnologias. A Domótica
(junção da palavra grega Domus que significa
“casa” com a palavra robótica) é a automatização
residencial, onde o IoT é fundamental na coleta de
informações, análise da rotina, sensoriamento e
uso dessas informações para tornar o ambiente mais agradável, seguro, prático e moderno.
A domótica se divide em 5 grandes áreas e em todos o IoT pode trazer ganhos:
Automação e Controle: é o controle dos dispositivos que compõe o sistema inteligente da

casa (e como controle podemos entender as ações de ligar/desligar, abrir/fechar, mover e
Pág.
ajustar) e a automação que permite a execução de tarefas de forma mais fácil ou até mesmo
automática.
Segurança e Vigilância: é a implementação de segurança através dos sistemas

inteligentes. Como segurança, podemos derivar segurança patrimonial (alarmes, sistemas
de monitoramento, identificação e acesso), segurança ambiental (detector de gás, fumaça
ou fogo, monitoramento de condições ambientais) e segurança pessoal (controle de quedas,
integração com órgãos de segurança, monitoramento de sinais vitais).
Comunicações: é a implementação de comunicação e troca de informações entre diversos

dispositivos (conectividade) e entre o morador e o sistema (ou vice-versa). Aqui podemos
considerar a comunicação direta (por voz, vídeo e imagem), o controle por voz (assistentes),
feedbacks (sonoros, visuais ou hápticos) e apresentação de informações (tanto dos
sensores e dispositivos da casa como de recomendações, notícias e notificações buscadas
com base no perfil do usuário).
Serviços e entretenimento: é a implementação do acesso a serviços e a entretenimento

de forma mais fácil e automatizada. Um exemplo de serviço seria a realização automática
de compras (por uma geladeira que monitora os produtos em seu interior, por um
assistente que sugere opções de tele entrega de acordo com a rotina do morador, entre
outros). Já em entretenimento, temos tudo que tem a ver com diversão e com multimídia.
Produtividade: é a implementação de inteligência em qualquer uma das 4 áreas anteriores

de modo a se conseguir uma maior produtividade e aproveitamento do tempo. Aqui,
podemos considerar a produtividade pessoal, a produtividade social e a produtividade
profissional (pois muitas pessoas, principalmente a partir da pandemia, aderiram ao
regime home office ou possuem um espaço onde possam produzir fora de suas empresas).
Um exemplo seria o controle de condições ambientais para potencializar a capacidade de
produção ou de concentração (como a temperatura, som ambiente, luz com ajuste de
claridade e coloração visando influenciar determinados sentidos, etc).
Pág.
1.2.2 Indústria 4.0

A indústria sempre foi um destaque quando o
assunto é inovação e a responsável direta por
grandes revoluções que transformaram (e ainda
transformam) profundamente a nossa sociedade. As
evoluções impulsionadas pelo capital e pela busca
da máxima produtividade, fazem da indústria um
celeiro de novas tecnologias, tendência e modelos. A
forte automatização, principalmente nas linhas de montagem e na logística, é essencial e
estratégica. A indústria 4.0, resumidamente, é a integração da forte automatização (já
existente) com diferentes tecnologias atuais de modo a tornar mais digitais as atividades
industriais, buscando ainda mais produtividade, modernização nos processos e até mesmo
uma maior proximidade e engajamento do cliente. Segundo o SENAI, o IoT é apenas uma
das onze tecnologias que compõe a chamada “integração total”, porém, encontra-se
presente em muitas delas.
Inteligência artificial: busca de padrões, aprendizagem automática, tomada de decisões

e sistemas autônomos;
Computação em nuvem: uso da nuvem para armazenamento, acesso e compartilhamento

de dados, serviços de hospedagem de aplicações e de webservices, máquinas de
processamento remoto, entre outros;
Big data: data science, análise de grandes massas de dados, busca de padrões em
conjunto com IA, sintetização e categorização automática, extração de informações
estratégicas para tomadas de decisões (como o Businness Inteligence);
Cyber segurança: segurança e privacidade dos dados e informações críticas aos negócios,
aos processos, ao dia a dia da empresa e mesmo dos clientes (principalmente após criação
da Lei Geral de Proteção de Dados – LGPD);
Robótica avançada: interação com humanos, auto ajuste de processos, tomadas de

decisões de forma semi-supervisionada e não supervisionada (com base em sensores,
aprendizagem, análise de dados e até mesmo análise comportamental dos funcionários);
Manufatura digital: incorporação de ferramentas para manufatura com base em sistemas

de modelagem 3D, transformação automática de desenhos vetoriais em comandos para as
máquinas (tornos, fresas, robôs), simulação e realidade aumentada;
Pág.
Manufatura aditiva: tecnologias de produção com base na sobreposição de matérias em
camadas ou através da ligação de pequenas partículas, como as impressoras 3D
(sobreposição de camadas de plástico), impressoras de alimentos (sobreposição de
camadas de materiais orgânicos) ou mesmo impressoras de tecidos humanos
(sobreposição de proteínas);
Sistemas de simulação: sistemas para simulações variadas, que podem ir desde

treinamentos de processos perigosos por imersão em realidade virtual (um curso de solda
em tanques de navios petroleiros ou outro ambiente insalubre) até a simulação para
validação de peças, produtos e processos. Temos hoje sistemas que simulam o
comportamento eletrônico (montando circuitos de prova de forma digital para testagem
para só depois o primeiro protótipo eletrônico real ser criado), o comportamento mecânico
(movimento de uma peça, temperatura em cada parte dela, nível de trepidação, resistência
mecânica, etc) e até o comportamento químico e biológico (simulação de organismos vivos
ou a interação de medicações com as proteínas de um vírus para buscar indicativos de
sua eficácia).
Integração de sistemas: integração das múltiplas tecnologias entre si de forma otimizada,

assertiva e inteligente, organizando as trocas e o uso das várias informações relevantes
produzidas por cada um;
Digitalização: transformação digital e modernização de processos internos, fabris,

culturais e a criação de serviços digitais para os clientes (criando facilidade e engajamento).
1.2.3 Agrotech
O Brasil é um dos maiores produtores mundiais e uma parcela considerável do PIB
do país vem da agricultura e da pecuária. De forma inacreditável, somente nos últimos
anos vemos uma modernização mais consistente nos processos de produção,
plantio/colheita, armazenagem e logística (geralmente limitada aos grandes produtores
com alta capacidade de investimento) e muitas
vezes com o uso de soluções estrangeiras. Até
alguns anos atrás, IoT na agropecuária era
sinônimo de sistemas de monitoramento RFID
para controle de gado ou outros animais
através de tags ativas ou passivas. O cenário
vem mudando e cada vez mais os produtores
percebem as múltiplas possibilidades que o
Pág.
IoT oferece para o meio rural. Hoje contamos com sistemas de pulverização e controle de
pragas com drones, sistemas para rastreamento de produtos desde a origem, silos
automatizados que controlam fatores ambientais (umidade, temperatura e composição do
ar) para maior durabilidade dos grãos e até silos conectados a bolsas de valores e sistemas
de regulagem de preços para informar a melhor hora de escoar a produção e o valor total
recebido com base no volume do silo (também automaticamente calculado por sensores).
E, felizmente, algumas tecnologias de baixo custo começaram a chegar no pequeno
produtor e no produtor familiar, como sistemas de rega automática (através de decisões
baseadas no tipo de planta e no monitoramento climático), controle de volume de lençóis
freáticos (para autorregular o gasto hídrico garantindo água por um maior período),
sistemas de detecção de pragas por imagem (inclusive apps para smartphone com esse
recurso), plataformas de compra automática de insumos, entre outros. Mas chama atenção
os dados da pesquisa da AgTechGarage que aponta que mesmo com aproximadamente
13.000 startups registradas no
Brasil, menos de 300 são voltadas
à tecnologia no setor agro. Ao
mesmo tempo, esse gap gera uma
área com inúmeras oportunidades
e a exploração, desenvolvimento e
implantação de tecnologias no
campo é uma das tendências nos
negócios nos próximos 10 anos.
Essas startups dividem-se entre
mais ou menos 20 áreas de atuação dentro do agronegócio, conforme o gráfico apresentado
na mesma pesquisa. Com isso, fica claro quanto o uso do IoT ainda tem a crescer no Brasil.
1.2.4 Smart Cities

E se aplicarmos todos esses recursos
da domótica, da indústria 4.0 e do agrotech
para melhorar as nossas vidas na cidade?
Esse é o conceito por traz das Smart Cities:
cidades inteligentes planejadas para fazer uso
das mais diversas tecnologias buscando a
desburocratização, agilidade na tomada de
decisões, eficiência energética, segurança,
saúde, bem-estar dos cidadãos e economia criando um ecossistema forte para as
Pág.
empresas. Assim, as tecnologias são planejadas e aplicadas para garantir impacto nas
seguintes áreas:
Sociedade e bem-estar: formas de garantir um bom nível social, educacional econômico

e cultural dos seus cidadãos, além da boa convivência e o respeito a diferentes crenças,
costumes e individualidades.
Economia e negócios: formas de garantir o desenvolvimento econômico através da criação

de ambientes inovadores e criativos, ótima infraestrutura, qualificação dos profissionais,
modernização das práticas e criação de novos modelos de negócio.
Meio ambiente e urbanismo: formas de garantir a proteção ao meio ambiente (controle

de fatores ambientais, ações de reversão do impacto ambiental, monitoramento da
poluição, reciclagem e reaproveitamento dos resíduos orgânicos, sólidos e eletrônicos),
eficiência energética (novas formas de produção de energias limpas e maior aproveitamento
da distribuição e uso da energia produzida) e urbanismo em todo o seu planejamento.
Mobilidade: formas de garantir o deslocamento eficiente pela cidade (de pessoas, veículos
e cargas) mas também na ampliação e acesso aos serviços necessários por pessoas e
empresas, principalmente na migração dos mesmos para plataformas digitais.
1.3 Cultura Maker
Se o IoT tem um grande responsável por

torná-lo popular e próximo às pessoas, esse
responsável é com certeza o movimento maker
e o DIY (Do it yourself, ou Faça você mesmo). A
cultura maker criada através deles tem a ver
com mostrar às pessoas que, mesmo sem
conhecimentos técnicos e com pouco dinheiro,
qualquer um tem a capacidade de inventar,
reproduzir, construir, modificar ou consertar objetos, dispositivos ou sistemas. A diferença
entre eles é que o DIY tem um propósito mais geral: artesanato, decoração, construção em
madeira, bricolagem, etc. Já o movimento Maker adiciona como principal ingrediente o
desenvolvimento, o entendimento, o compartilhamento e a aplicação de tecnologias,
principalmente as de baixo custo, no desenvolvimento de projetos diversificados.
A cultura maker humaniza o uso das tecnologias e ajuda com que elas se tornem
familiares, mostrando que não são tão distantes e inacessíveis como muitas pessoas
Pág.
imaginam (e nem tão caras, permitindo a criação de muitos dispositivos e sistemas de
forma muito mais barata do que os equivalentes comerciais, tornando-os mais acessíveis).
E isso cria mais três movimentos interessantes e com grande potencial de impacto,
principalmente na educação: a cultura da colaboração e compartilhamento do
conhecimento, o autodidatismo e a criação de soluções com impacto social.
1.3.1 O Manifesto Maker

Uma excelente forma de conhecer melhor o movimento é a leitura do livro “The
Maker Movement Manifesto: Rules for Innovation in the New World of Crafters, Hackers, and
Tinkerers” (O Manifesto do Movimento Maker: Regras para Inovação no Novo Mundo dos
Artesãos, Hackers e Reformadores), escrito em 2013 por Mark Hatch, um dos gurus e
grandes responsáveis pela difusão do conceito. Abaixo, parte do texto de um artigo
publicado na revista Educação na versão online (www.revistaeducacao.com.br), com um
resumo dos principais pontos deste manifesto.
Pág.
O MANIFESTO MAKER
Fazer – Algo fundamental para o significado do ser

humano. Devemos fazer, criar e nos expressar para nos
sentirmos inteiros. Há algo único em fazer coisas físicas.
Elas são como pequenos pedaços de nós e parecem
incorporar porções de nossas almas.
Compartilhar – O sentimento total de plenitude de um

criador ou inventor só é alcançado quando ele compartilha
o que fez e “sabe sobre o fazer” com os outros. Fazer e não
compartilhar é inviável e anacrônico.
Presentear – Há poucas coisas mais altruístas e

satisfatórias do que dar algo que você fez. O ato de fazer
coloca um pequeno pedaço de você no objeto. Dar isso
para outra pessoa é como doar um pequeno pedaço de si
mesmo. Tais coisas muitas vezes são nossos itens mais
estimados.
Aprender – Você deve aprender a fazer. Sempre procurar aprender mais sobre sua criação. Você pode
se tornar um viajante ou mestre artesão, mas ainda aprenderá, desejará aprender e impulsionará o
aprendizado de novas técnicas, materiais e processos. Construir um caminho de aprendizagem garante
uma vida rica e recompensadora e, mais importante, permite compartilhar.
Equipamentos – Você deve ter acesso às ferramentas certas para cada projeto. Invista e desenvolva
acesso local às ferramentas de que você precisa para fazer o desejado. As ferramentas jamais foram
tão baratas, poderosas e fáceis de usar.
Divirta-se – Tenha bom humor diante do que está fazendo, e ficará surpreso, animado e orgulhoso do
que descobrir.
Participe – Junte-se ao Movimento Maker e alcance os que estão por perto. Juntos, vocês irão trocar
experiência, conhecimento e descobrirão a alegria de fazer. Realizem encontros, seminários, festas,
eventos, dias de fabricante, feiras, exposições, aulas e jantares com e para os outros makers em sua
comunidade.
Apoie – Isso é um movimento. Requer apoio emocional, intelectual, financeiro, político e institucional.
Apoie no que for ao seu alcance. A melhor esperança de melhorar o mundo está em nós mesmos.
Somos responsáveis por isso fazendo um futuro melhor.
Mude – Aceite e abrace as mudanças que se apresentarão e ocorrerão naturalmente em sua trajetória
maker. Você se tornará uma versão mais completa de você mesmo (no espírito maker, sugiro
fortemente que você pegue esse manifesto, faça mudanças nele se for o caso, e trilhe o seu próprio
caminho. Esse é o ponto no fazer).
Pág.
1.3.2 Os Makerspaces
Provavelmente o movimento maker não teria tanta penetração na sociedade e não
seria acessível a tantas pessoas (independentemente de classe social), se não fossem os
makerspaces (espaços makers). Eles são espaços especialmente desenvolvidos e com toda
a infraestrutura necessária para que qualquer pessoa possa desenvolver os seus projetos.
São equipados com computadores, softwares para desenvolvimento, desenho e
modelagem, os mais diversos tipos de ferramentas, acessórios, materiais, maquinários
fabris básicos (tornos e fresas por exemplo) além
de modernos equipamentos como impressoras
3D e máquinas de corte à laser. E o mais incrível:
são espaços abertos ao público, gratuitos e que
contam com monitores e voluntários capacitados
a auxiliar nas dúvidas, orientar, ensinar e
compartilhar conhecimentos. Basta levar o seu
material e o limite é a criatividade (aliás, muitos
destes espaços possuem diversos materiais gratuitos que poder ser utilizados pelos
usuários e levados para casa após construído o projeto, como placas de madeira e acrílico,
ferragens diversas e até mesmo alguns componentes eletrônicos).
Os makerspaces, mesmo sendo iniciativas que partiram de hobistas e entusiastas,

são considerados hoje, parte fundamental dos ecossistemas de inovação e criatividade das
cidades. Encontramos espaços deste tipo mantidos tanto por parcerias colaborativas,
quanto por iniciativas públicas, privadas ou PPPs (parcerias público-privadas). Eles estão
presentes no mundo todo, em todos os 193 países e no Brasil em todas as principais
cidades. Entre todas as iniciativas de incentivo, promoção e qualificação dos Makerspaces,
a mais conhecida é o FabLab, do Massachusetts Institute of Technology (MIT). Qualquer
makerspace pode se filiar à rede FabLab de forma gratuita, desde que cumpra alguns
requisitos mínimos (que vão desde as ferramentas que devem possuir até o número mínimo
de horas aberto para a comunidade). Assim que ingressos na rede recebem, também de
forma gratuita, acompanhamento, treinamentos, licenças de software do MIT e parceiros
e mentorias em relação à marketing, captação de recursos, divulgação e parcerias
estratégicas. O infográfico abaixo, desenvolvido pelo FabLab de Nuremberg, na Alemanha,
esquematiza o funcionamento dos espaços makers em geral.
Pág.
Pág.
1.3.3 Placas de Prototipagem

Se a popularização do IoT se deu através dos
makerspaces, a popularização da eletrônica se deu nos
makerspaces, escolas e universidades, nos últimos
anos, através das chamadas “Placas de Prototipagem”
(também conhecidas como placas de ensaio). As placas
de prototipagem são placas eletrônicas que encapsulam
funcionalidades de um microprocessador, dentro de
uma montagem que torne simples o acesso às funcionalidades do chip e às suas portas
(permitindo facilmente incorporar sensores e atuadores dos mais diversos tipos), fazendo
uso de interfaces práticas que permitem facilmente a sua programação. Podemos
programar placas de prototipagem para ligar e desligar componentes e aparelhos, capturar
informações do mundo externo, controlar atuadores para executarem ações e realizar a
comunicação com outras placas, smartphones, tablets, consoles, computadores e etc.
Como dito, a sua facilidade de uso é o grande diferencial, mas um segundo atrativo,
fundamental para a sua ascensão e popularização, é o preço. Com menos de 50 reais temos
em mãos, por exemplo, um Arduino, utilizando uma tecnologia eficiente e de baixo custo
para realizar todo esse controle citado. Aliás, algumas
destas placas são tão completas e tão potentes que
podem ser utilizadas inclusive como computadores
pessoais (com entrada para TV, mouse, teclado,
joystick e mídias de armazenamento externas) para
rotinas do dia a dia ou mesmo como consoles para emulação de jogos (como a Raspeberry
Pi Zero, à esquerda, que ficou conhecida como o computador de 5 dólares). Outras, contam
com microchips adicionais que agregam funcionalidades
extras que as tornam mais interessantes para projetos
mais específicos (como o Esp32, à direita, dotado de um
processador multicore que permite multithreads reais
além de possuir comunicação wifi e bluetooth já
encapsuladas e nativas). Essas placas variam em características e utilizaremos uma delas
(o Arduino Uno), nesta disciplina para a construção de projetos eletrônicos dos mais
diversos tipos, que possam ser aplicados no nosso dia a dia e mesmo na resolução de
diversos problemas detectados em nossa comunidade, escola ou cidade. Mas para isso
precisamos entender um pouco de eletrônica...
Pág.
UNIDADE 2 - TÓPICOS BÁSICOS DE ELETRÔNICA ANALÓGICA
2 O QUE É ELETRÔNICA?
Se você realizar uma busca pelo termo “eletrônica”, certamente irá se deparar com
uma infinidade de conceitos distintos, alguns bastante técnicos, que tentam explicar e
definir esta importante área do conhecimento (considerada a terceira revolução tecnológica
da humanidade). Para simplificar, podemos dizer que “eletrônica” é a ciência que estuda
como controlar e como utilizar a energia elétrica em baixas correntes, aproveitando o
fluxo de elétrons para gerar fenômenos desejados em um dispositivo (através da
associação de componentes que possuem propriedades conhecidas). Estas palavras em
destaque serão importantes na compreensão dos conceitos posteriormente apresentados.
Observação: Não é intensão deste material e nem desta disciplina o aprofundamento nos
conceitos físicos que regem as leis da eletrônica, porém o entendimento básico dos mesmos
nos dá maiores condições de entendimento e contextualização. Portanto, nos permitiremos
aqui algumas simplificações, sacrificando o rigor técnico em favor da didática.
2.1 Energia elétrica, fluxo de elétrons e observações iniciais
Os átomos são formados de 3 partículas essenciais: os nêutrons e prótons (que

compõe o seu núcleo) e os elétrons (que orbitam a chamada eletrosfera ao redor deste
núcleo). Os nêutrons não possuem carga elétrica (são neutros), enquanto os prótons
apresentam uma carga elétrica positiva e os
elétrons apresentam uma carga elétrica
negativa. Essa carga elétrica acaba induzindo à
uma interação eletromagnética entre estas
partículas, provocando repulsão entre as de
mesma carga (nêutrons com nêutrons, elétrons
com elétrons) e atração entre os de carga oposta
(nêutrons com elétrons). Essas propriedades
são importantes e ajudam a compreender
alguns comportamentos que são fundamentais
para o entendimento da eletrônica e para o seu
uso através do controle destes fenômenos:
Pág.
Movimento dos elétrons e órbita ao redor do núcleo: por terem a mesma carga elétrica
(negativa) os elétrons estão em constante repulsão entre si, mas em constante atração em
relação ao núcleo por conta da carga positiva dos prótons presentes nele. Esta atração tem
força suficiente para manter os elétrons na eletrosfera, mas não é forte suficiente para
atraí-los para o núcleo. A interação destas forças mantém a composição do átomo e cria o
movimento orbital dos elétrons.
Núcleo forte, eletrosfera frágil: a força de atração que mantém as partículas do núcleo
unidas é muito maior do que a força de atração que o núcleo exerce sobre os elétrons.
Deste modo, quanto mais longe do núcleo um elétron está, mais facilmente ele pode ser
atraído pela força do núcleo de outro átomo.
Carga do átomo e busca pela neutralidade: os átomos sempre buscam o equilíbrio de

cargas e para que isso aconteça, o número de prótons e elétrons deve ser igual. Quando
um átomo está desequilibrado, podemos chamá-lo de Íon. Caso perca elétrons, o
excedente de prótons faz do átomo um íon positivo (chamado de cátion) e cuja tendência é
atrair elétrons ou ligar-se com outro átomo de carga negativa para compartilhar com ele
esses elétrons. Caso ganhe elétrons, o excedente dos mesmos faz do átomo um íon negativo
(chamado de ânion) e cuja tendência é ceder/repelir elétrons ou ligar-se com outro átomo
de carga positiva para que esses elétrons excedentes sejam compartilhados.
Desequilíbrio leva ao movimento e movimento leva à corrente: quando o desequilíbrio

ocorre, os cátions querem atrair elétrons ao mesmo tempo em que os ânions querem ceder
elétrons. Isso pode levar ou à uma ligação iônica (amplamente estudada na química e que
explica a combinação dos átomos para a formação dos mais diversos materiais) ou a um
fluxo de elétrons movimentando-se entre os átomos. Quando este fluxo de elétrons ocorre
de forma ordenada e constante, obedecendo um sentido dentro de um determinado período
Pág.
de tempo, recebe o nome de “Corrente Elétrica”. Este fenômeno é obtido através de uma
reação em cadeia, representada abaixo:
Os 3 átomos têm carga total

neutra e estão em equilíbrio,
tanto na sua composição
interna quanto em relação aos
átomos em sua volta.
Remover 3 elétrons do átomo à

direita, cria um forte
desequilíbrio interno (cátion
com carga +3) e seu núcleo
exerce forte atração aos
elétrons mais externos do
átomo à sua esquerda
O átomo do meio, ao perder 2

elétrons, também fica em
desequilíbrio interno (cátion
com carga +2) e seu núcleo
exerce forte atração aos
elétrons mais externos do
átomo à sua esquerda
O átomo mais à esquerda ao

perder 2 elétrons, também fica
em desequilíbrio interno (cátion
com carga +1) mas seu núcleo
não tem força suficiente para
atrair elétrons dos outros
átomos. Neste momento,
mesmo com desequilíbrio
interno nos 3 átomos (que
viraram cátions com carga +1),
o conjunto está equilibrado
entre si
Ordenando o movimento dos elétrons e forçando uma corrente: como ilustrado no

processo acima, a remoção de elétrons de um átomo provoca um desequilíbrio que pode
levar à uma reação em cadeia que culmina em uma movimentação dos elétrons para os
átomos à volta. E este processo de remoção de elétrons (ou o processo contrário, de
saturação de elétrons), dada a fraca atração dos mais externos pelo seu núcleo, é
relativamente simples e necessita de pouca energia para acontecer.
Pág.
Isso é conseguido através do uso de reações
químicas sobre determinados elementos. O zinco,
por exemplo, ao sofrer oxidação perde elétrons
com facilidade dando origem a uma substância
rica nestas partículas. Já o cobre, sofre facilmente
reações químicas dando origem a uma substância
com deficiência de elétrons. O lado rico em cátions
recebe o nome de cátodo. Já o lado rico em ânions
recebe o nome de ânodo. Deste modo, se unirmos os dois “lados” através de um material
condutor, os elétrons provenientes do ânodo serão atraídos pelo cátodo, movendo-se em
direção ao mesmo. Esse movimento gera um campo magnético que cria uma força igual
no sentido inverso. Essa força é a Corrente Elétrica.
E o que podemos fazer com esse conhecimento: uma pilha (ou, mais genericamente,
uma bateria) nada mais é do que um componente formado por um cátodo e por um ânodo
(isolados entre si) que ao serem conectados por um condutor (fio, por exemplo), encontram
um caminho para que os elétrons movam-se do
material rico em ânions para o material rico em
cátions, gerando assim um fluxo ordenado. É
interessante notar que na imagem ao lado, o
fluxo da corrente é representado em dois
sentidos opostos. Como já vimos, o sentido real
do fluxo de elétrons é sempre do ânodo (-) para
o cátodo (+). Mas popularmente, o cátodo (+) é
encarado por muitas pessoas como o “mais
carregado”, criando uma conclusão cultural de
que a corrente flui de forma oposta (do positivo
para o negativo). A composição química das pilhas (materiais e compostos utilizados no
ânodo e cátodo) e suas dimensões (que permitem uma maior ou menor quantidade destes
materiais e compostos), influenciam na chamada “voltagem” (termo não correto, como
veremos adiante), na intensidade da
corrente e na autonomia. Podemos ter desde
as amplamente difundidas baterias de íon-
lítio (de 3,0V a 3,5V) até mesmo uma bateria
feita de batata com a penetração de uma
haste de cobre e uma haste de zinco (em
torno de 0,6V à 0,9V).
Pág.
2.2 Exemplificando Tensão x Corrente e Resistência
Através das observações iniciais sobre o comportamento das partículas

elementares, carga dos átomos e como isso pode ser utilizado de forma controlada para
criar um fluxo ordenado de elétrons, já conseguimos observar e compreender de forma
mais fácil as duas grandezas físicas fundamentais da eletrônica (a tensão elétrica e a
corrente elétrica) e uma das principais propriedades dos materiais (a resistência elétrica).
• Tensão Elétrica é a força que move os elétrons dentro de um circuito, gerada

através da diferença de cargas entre dois pontos do mesmo. Por esse motivo,
também é chamada de ddp (diferença de potencial elétrico) e é medida em Volts (V).
• Corrente Elétrica é a quantidade de elétrons que passa por um ponto do circuito
dentro de um determinado tempo, em um fluxo ordenado provocado por uma
diferença de potencial. Quando mais elétrons por segundo, mais intenso o fluxo.
Por esse motivo, também é chamada de intensidade de corrente e é medida em
Amperes (A).
• Resistência Elétrica é uma oposição à corrente elétrica, impondo uma maior
dificuldade para a passagem dos elétrons no ponto onde existe, funcionando como
um obstáculo para os mesmos. É medida em Ohms ().
Para melhor compreender, vamos nos permitir a utilização de dois exemplos com
uma simplificação que abstrai conceitos físicos e unidades formais:
Pág.
Exemplo 1) Imagine que uma pilha A tem um ânodo com 10 elétrons excedentes (-10) e
um cátodo que tem uma deficiência de 10 elétrons (+10). Podemos dizer que a diferença
de potencial entre os dois pontos é de 20. Agora imagine uma pilha B que tem um ânodo
com 10 elétrons excedentes (-10) e um cátodo que tem uma deficiência de 40 elétrons
(+40). Podemos dizer que a diferença de potencial entre os dois pontos é de 50.
O que podemos avaliar dos dois exemplos?
• Ambas as pilhas transferirão uma carga máxima de 10 elétrons do ânodo para o

cátodo.
• Na primeira pilha, com o passar do tempo, o sistema vai entrando em equilíbrio de

carga pois os 10 elétrons excedentes do ânodo vão reduzindo a deficiência inicial de
elétrons do cátodo até que ele entre em equilíbrio. Isso faz com que os últimos
elétrons sejam atraídos por uma força muito fraca, pois a diferença de potencial vai
se aproximando de 0.
• Na segunda pilha, com o passar do tempo, por mais que os 10 elétrons do ânodo
vão compensando a deficiência do cátodo, eles não são suficientes para o equilíbrio
do mesmo visto que a deficiência inicial era muito grande e muito maior do que o
total de elétrons que o ânodo pode fornecer. Isso faz com que os últimos elétrons
ainda sejam atraídos por uma força muito grande.
• Claramente na segunda pilha, dada a força de atração (diferença de potencial) muito

maior (e que se mantém alta até o final), os elétrons serão movidos muito mais
rápido do ânodo para o cátodo. Assim, podemos dizer que a corrente elétrica é maior
no segundo exemplo pois são movidos mais elétrons por segundo do que no primeiro
exemplo. Percebemos, assim, que quanto maior a diferença de potencial elétrico,
maior é a capacidade de mover elétrons e, consequentemente, maior a corrente
elétrica possível.
Pág.
Exemplo 2) Imagine agora duas pilhas iguais (pilha C e pilha D), com ânodos contendo
30 elétrons excedentes e cátodos com deficiência de 40 elétrons. A única diferença é que
no condutor da pilha D existe um obstáculo que dificulta a passagem dos elétrons.
O que podemos avaliar dos dois exemplos?
• A força inicial de atração dos elétrons pelo cátodo é igual na pilha C e na pilha D
(dada a igual carga de +40), assim como o total de elétrons livres (-30). Portanto,
ambas possuem a mesma diferença de potencial elétrico de 70.
• Apesar da mesma força (ddp), o obstáculo da pilha D vai fazer com que os elétrons
demorem mais tempo para moverem-se do ânodo para o cátodo. Deste modo, a
resistência que o obstáculo exerce sobre a passagem dos elétrons vai diminuir a
velocidade dos mesmos e a quantidade movida por segundo, criando uma corrente
elétrica menor apesar da mesma força (tensão) aplicada.
2.3 Formalização das observações sobre Tensão, Corrente e Resistência
Observações similares a essa serviram de base para a formulação de leis que

pudessem representar os fenômenos observados em um circuito elétrico, padronizando o
comportamento das duas grandezas físicas observáveis (tensão e corrente) e a sua relação
com as características dos materiais envolvidos (principalmente a resistência).
Pág.
2.3.1 Representação formal de um circuito eletrônico básico

Pensando em padronizar esquemas eletrônicos para que qualquer circuito pudesse
ser lido e compreendido universalmente, foram criadas representação tanto para as
grandezas eletrônicas, quanto para os componentes e até mesmo para propriedades
específicas destes componentes (como a resistência). Inicialmente, para nossos primeiros
exemplos, vamos analisar o esquema a seguir. Nele, a tensão elétrica é representada
formalmente pela letra U (podendo também ser V) e no
diagrama por duas barras paralelas com tamanhos distintos,
representando uma diferença de potencial (barra maior é o
cátodo, barra menor é o ânodo). A corrente é representada
formalmente pela letra I (por ser a intensidade do fluxo de
elétrons) e no diagrama por uma seta (do cátodo para o
ânodo, com o sentido convencional que é o que utilizaremos). A resistência é representada
formalmente pela letra R e no diagrama por um segmento em “zig-zag”, para expressar um
obstáculo que fará com que os elétrons demorem mais para passar por ali.
2.3.2 Primeira Lei de Ohm

A primeira Lei de Ohm diz que em um circuito que possua uma resistência de valor
fixo, a corrente é diretamente proporcional à diferença de potencial (tensão) estabelecida.
Porém, para uma mesma tensão, a corrente é inversamente proporcional à resistência do
circuito. Colocando isso em uma fórmula, temos as seguintes variações:
U=I.R I=U/R R=U/I
Claramente vemos que se soubermos o valor de quaisquer duas variáveis,

conseguimos descobrir o valor da outra. Vamos a três exemplos simples.
Exemplo 1: O filamento da lâmpada de um determinado modelo de

lanterna tem uma resistência conhecida de 20 . Verificando as
especificações técnicas da mesma, descobrimos que a intensidade de
corrente máxima suportada é de 0,15 A. Qual a tensão deve ser
fornecida pelas pilhas para que a lâmpada ela funcione corretamente?
Aqui, queremos descobrir a tensão, logo: U = I . R → U = 0,15 . 20 → U=3V
Pág.
Exemplo 2: Um led convencional alimentado por uma saída de uma

placa Arduino com tensão de 3,3 V, suporta uma corrente máxima de
30 mA (0,03 A). Para que ele não queime e funcione em uma situação
ideal, qual a resistência necessária no circuito?
Aqui, queremos descobrir a resistência, logo: R = U / I → R = 3,3 / 0,03 → R = 110 
Exemplo 3: A trava elétrica de um determinado automóvel é alimentada

pela bateria do veículo (tensão de 12 V) e ao ser acionada oferece uma
resistência de 5  à passagem da corrente elétrica. A qual corrente
elétrica a trava é submetida durante o seu funcionamento?
Aqui, queremos descobrir a corrente, logo: I = U / R → I = 12 / 5 → I = 2,4 A
2.3.3 Segunda Lei de Ohm

A segunda Lei de Ohm diz que a resistência de um determinado condutor elétrico é
relacionada à sua forma e à característica do material do qual é composto, atribuindo a
ele uma propriedade importante chamada de resistividade (resistência equivalente por
metro). Para condutores com a mesma resistividade, a resistência total é diretamente
proporcional ao comprimento do condutor e inversamente proporcional à sua área de
secção transversal (a popular “bitola”). Colocando isso em uma fórmula temos:
𝜌.𝐿 Onde:  = resistividade do material (.m)

𝑅= 𝐴 L = comprimento (m)
A = área transversal (m2)
Resistividade de alguns materiais condutores típicos:
Prata 1.6 × 10-8 .m2 → 0.000000016 .m2

Cobre 1.7 × 10-8 .m2 → 0.000000017 .m2
Ouro 2.3 × 10-8 .m2 → 0.000000023 .m2
Alumínio 2.7 × 10-8 .m2 → 0.000000027 .m2
Tungstênio 5.5 × 10-8 .m2 → 0.000000055 .m2
Zinco 6.3 × 10-8 .m2 → 0.000000063 .m2
Bronze 6.7 × 10-8 .m2 → 0.000000067 .m2
Latão 6.7 × 10-8 .m2 → 0.000000067 .m2
Platina 9.5 × 10-8 .m2 → 0.000000095 .m2
Pág.
Níquel 1.0 x 10-7 .m2 → 0.000000100 .m2
Estanho 1.3 x 10-7 .m2 → 0.000000130 .m2
Ferro 1.5 x 10-7 .m2 → 0.000000150 .m2
Chumbo 2.0 x 10-7 .m2 → 0.000000200 .m2
Mercúrio 9.0 x 10-7 .m2 → 0.000000900 .m2
Grafite 1.3 × 10-7 .m2 → 0.000013000 .m2
Carbono 3.5 × 10-7 .m2 → 0.000035000 .m2
Exemplo: Ao acampar, um grupo de amigos resolveu ligar frigobar de 12V na bateria de

um carro, distante 10 metros do local desejado. Esse frigobar ao trabalhar na potência
máxima, pode chegar a necessitar de uma corrente de 20 A. Paulo trouxe uma extensão
de 30 metros com fio de cobre com seção transversal de 1,0 mm2 (0,000001 m2). Luís
trouxe uma extensão de 30 metros com fio de cobre com seção transversal de 2,5 mm2
(0,0000025 m2). Lucas trouxe uma extensão de 100 metros com seção transversal de 2,5
mm2 (0,0000025 m2). Quais as resistências elétricas de cada extensão e a corrente máxima
possível em cada uma delas? Todas elas poderão garantir o funcionamento do frigobar em
potência máxima?
• Extensão do Paulo
 .L 0,000000017 . 30 U 12
𝑹= = = 0,51  𝑰= = = 23,5 A
𝐴 0,000001 𝑅 0,51
• Extensão do Luís
 .L 0,000000017 . 30 U 12
𝑹= = = 0,20  𝑰= = = 60,0 A
𝐴 0,0000025 𝑅 0,20
• Extensão do Lucas
 .L 0,000000017 . 100 U 12
𝑹= = = 0,68  𝑰= = = 17,7 A
𝐴 0,0000025 𝑅 0,68
Como podemos perceber, a extensão de Lucas (terceira), permite uma corrente

máxima de 17,7 A, não sendo suficiente para a potência máxima de funcionamento do
frigobar e provocando uma perigosa sobrecarga.
Pág.
2.4 Associação de fontes de energia
Quando falamos em “fontes de energia”, falamos em

qualquer componente que possa nos fornecer uma diferença
de potencial que leve à uma corrente elétrica. Essas fontes
podem ser uma pilha, uma bateria, a tomada, etc. E a
associação de múltiplas fontes é relativamente comum e
muito útil em algumas situações. Um exemplo muito simples e corriqueiro diz respeito ao
uso de pilhas. Muitos dispositivos eletrônicos (controle remoto, rádio, lanterna,
brinquedos) necessitam de tensões superiores à 1,5 V (tensão típica de uma pilha) e para
isso, várias pilhas são associadas (como na figura do controle do Xbox One acima). Essa
associação pode acontecer com as baterias em série (positivo de um ligado ao negativo da
outra) ou em paralelo (positivos ligados entre si e negativos ligados entre si). Cada uma
destas associações traz características próprias, como podemos ver no esquema abaixo:
Observação importante: a ligação de baterias em paralelo, além de pouco convencional,

é NÃO RECOMENDADA. Caso as fontes tenham tensões diferentes (ou as tensões se
tornem diferentes ao longo do uso por desgaste ou flutuações), aparecerão no circuito
fluxos reversos (um cátodo mais saturado de elétrons alimentando um cátodo com maior
deficiência de elétrons). Além do maior (e desnecessário) consumo, isso pode levar a altas
correntes capazes de danificar as fontes e até provocar um curto-circuito no sistema.
Pág.
2.5 Associação de Resistências
A associação de resistências dentro de um circuito (seja pelas características dos

materiais que o compõe, seja pela inclusão proposital de resistores), dá ao circuito
características bem importantes e úteis que permitem o melhor ajuste das tensões e
correntes em múltiplos pontos ao longo de si.
2.5.1 Associação de resistências em série

Quando associamos resistências em série em um circuito (ou subcircuito dentro
dele), a corrente permanece a mesma, mas a tensão se divide, criando diferenças de
potenciais elétricos distintas em pontos diferentes dele. Por isso mesmo, esse tipo de
associação recebe o nome especial de “Divisor de Tensão”. Um divisor de tensão é muito
útil quando possuímos no circuito componentes que trabalham com diferentes tensões e
precisamos alimentá-los com a mesma fonte. Para formalizar e calcular as características
da associação em série das resistências, podemos utilizar as seguintes convenções:
1) A corrente que circulará pelo circuito é a mesma em todos os pontos,

independentemente da quantidade e dos valores das resistências. Para calculá-la,
precisamos descobrir a resistência equivalente do circuito (explicada abaixo) para
multiplicarmos pela tensão, usando a fórmula da Primeira Lei de Ohm:
I = U / Req
2) A resistência equivalente do circuito é a resistência total que causará oposição à

passagem da corrente. Quando as resistências estão em série, um elétron passa por
todas elas para se mover do ânodo até o cátodo. Deste modo, a resistência total pela
qual todos os elétrons serão submetidos é a soma das resistências em série do
circuito:
Req = R1 + R2 + R3 + ... + Rn
3) Para calcular a tensão (diferença de potencial elétrico) entre as extremidades de

qualquer uma das resistências do circuito, basta utilizarmos a fórmula da Primeira
Lei de Ohm, pois se já sabemos a corrente e a mesma não se altera ao longo desse
circuito, tendo a resistência, chegamos na tensão:
URn = I . Rn
Pág.
Exemplo: temos um circuito eletrônico alimentado com

uma fonte de tensão de 12 V e neste circuito existem 3
resistências em série: 10 , 20  e 30 . Calcule a
resistência equivalente, a corrente do circuito e as tensões
em cada uma das 3 resistências.
Passo 1) Primeiramente, devemos calcular a resistência equivalente para, com ela,

podermos calcular a corrente do circuito:
Req = R1 + R2 + R3 = 10 + 20 + 30 = 60 
Passo 2) Tendo a resistência e a tensão do circuito (12 V) podemos com a Primeira

Lei de Ohm descobrir a corrente:
I = U / Req = 12 / 60 = 0,2 A
Passo 3) Agora sabemos a corrente e como na associação em série de resistências a

corrente não se altera ao longo do circuito, podemos também com a Primeira Lei de
Ohm descobrir a tensão de cada um dos resistores usando a mesma corrente:
UR1 = I . R1 = 0,2 . 10 = 2,0 V
UR2 = I . R2 = 0,2 . 20 = 4,0 V
UR3 = I . R3 = 0,2 . 30 = 6,0 V
Concluindo: Assim, teremos as seguintes características no circuito:
Pág.
2.5.2 Associação de resistências em paralelo

Quando associamos resistências em paralelo em um circuito (ou subcircuito dentro
dele), ocorre o oposto à associação em série: a tensão permanece a mesma (pois todos as
resistências estarão sujeitas à mesma diferença de potencial elétrico), mas a corrente se
divide, pois os elétrons agora possuem mais de um caminho entre o ânodo e o cátodo
(sendo que mais elétrons escolherão o caminho com menor resistência, passando por ali a
maior corrente). Por isso mesmo, esse tipo de associação recebe o nome especial de “Divisor
de Corrente”. Um divisor de corrente é muito útil quando possuímos no circuito
componentes que suportam diferentes correntes máximas. Para formalizar e calcular as
características da associação em paralelo das resistências, podemos utilizar as seguintes
convenções:
1) A corrente se distribuirá proporcionalmente às resistências através dos

múltiplos caminhos formados pela associação em paralelo, sendo mais intensa
(passando mais elétrons) naquele caminho com menos resistência e sendo
menos intensa (passando menos elétrons) naquele caminho com mais
resistência. Como a tensão será a mesma em qualquer ponto do circuito (pois
um lado de todas as resistências é paralelo ao mesmo ânodo e o outro é paralelo
ao mesmo cátodo), obtemos a corrente em cada resistência:
In = U / R n
2) Mesmo que os elétrons se dividam, a corrente total do circuito não se altera,

sendo, portanto, a soma das correntes individuais. Outra forma de calcular a
corrente total do circuito é encontrando a resistência equivalente (explicada
abaixo) e utilizando a Primeira Lei de Ohm, caso se saiba a tensão do circuito:
Itotal = I1 + I2 + I3 + ... + In OU Itotal = U / Req
3) A resistência equivalente do circuito acaba sendo sempre menor do que qualquer

uma das resistências individuais em paralelo pois agora a corrente se dividirá e
a oposição individual desvia elétrons para outros caminhos possíveis. Observou-
se que, na prática, o inverso da resistência equivalente é igual a soma do inverso
de cada uma das resistências individuais:
𝟏 𝟏 𝟏 𝟏 𝟏
= + + + ⋯+
𝑹𝒆𝒒 𝑹𝟏 𝑹𝟐 𝑹𝟑 𝑹𝒏
Pág.
Exemplo: temos um circuito eletrônico alimentado

com uma fonte de tensão de 12 V e neste circuito
existem 3 resistências em paralelo: 10 , 20  e 30
. Calcule a resistência equivalente, as correntes
em cada resistência e a corrente total do circuito.
Passo 1) Primeiramente, podemos calcular as correntes individuais de cada

resistência através da Primeira Lei de Ohm, pois a tensão é exatamente a mesma
para todas elas:
I1 = U / R1 = 12 / 10 = 1,2 A
I2 = U / R2 = 12 / 20 = 0,6 A
I3 = U / R3 = 12 / 30 = 0,4 A
Passo 2) Tendo as correntes individuais, podemos calcular a corrente total do

circuito através da soma:
Itotal = I1 + I2 + I3 = 1,2 + 0,6 + 0,4 = 2,2 A
Passo 3) Outra forma de chegar à corrente total é descobrir a resistência equivalente

e após aplicar a Primeira Lei de Ohm:
𝟏 𝟏 𝟏 𝟏 1 1 1
= + + = + + = 0,1 + 0,05 + 0,033 = 0,183
𝑹𝒆𝒒 𝑹𝟏 𝑹𝟐 𝑹𝟑 10 20 30
1 1
= 0,183 1 = 0,183 . 𝑅𝑒𝑞 𝑅𝑒𝑞 = = 5,46 
𝑅𝑒𝑞 0,183
Aplicando a Primeira Lei de Ohm, temos:
Itotal = U / Req = 12 / 5,46 = 2,2 A
Concluindo: Assim, teremos as seguintes características no circuito:
Pág.
2.6 Potência elétrica
Sendo a principal e mais útil relação entre as duas grandezas da eletrônica, a

potência elétrica é a quantidade de energia consumida por um circuito em um determinado
intervalo de tempo. Essa quantidade de energia fluindo pelo circuito para alimentá-lo e
fazê-lo funcionar (chamado formalmente de trabalho) tem relação direta com a tensão
(força que movimenta os elétrons) e a corrente (fluxo ordenado de elétrons movimentado
por influência da tensão e dependente da resistência do circuito). O aumento da tensão ou
o aumento da corrente provocam um aumento proporcional da potência. Podemos dizer,
então, que quanto maior a potência elétrica, maior a força que faz o circuito funcionar.
Esta potência é medida em Watts (W). Formalmente, temos:
P=I.U e reordenando, temos também I=P/U e U=P/I
Se você reparar, todos os seus equipamentos eletroeletrônicos possuem a indicação

de sua potência de funcionamento. Aqueles com potência maior realizam um trabalho que
necessita de mais força. Aqueles com potência menor realizam um trabalho que necessita
de menos força. E aqui é importante observar que como a potência tem a ver com a corrente
deslocada pela diferença de potencial em uma unidade de tempo, quanto maior a potência,
maior é o gasto energético.
Exemplo 1: Um determinado motor utilizado em uma bomba

d’água foi projetado para trabalhar com tensão de 110 V, para
operar de forma otimizada com uma corrente máxima de 25 A.
Qual é a sua potência, considerando estas informações?
Aqui queremos descobrir diretamente a potência, logo: P = I . U = 25 * 110 = 2750 W
Exemplo 2: Um casal deseja comprar uma máquina de lavar roupas para a

sua casa. A ideia é poder instalá-la na área de serviço, que possui apenas
uma tomada de 10 A (com tensão 220 V). Para evitar sobrecarga, qual deverá
ser a potência máxima da máquina de lavar escolhida pelo casal?
Aqui também queremos descobrir a potência, logo: P = I . U = 220 . 10 = 2200 W
Pág.
Exemplo 3: Um cliente viu o anúncio de dois chuveiros elétricos

similares, ambos de tensão 220 V, mas o primeiro com potência de
4800 W e o segundo com potência de 5600 W. Qual a corrente de
funcionamento de ambos?
Aqui queremos descobrir a corrente, sendo que temos a potência e a tensão, logo:
Chuveiro 1: I = P / U = 4800 / 220 = 21,8 A

Chuveiro 2: I = P / U = 5600 / 220 = 25,5 A
Exemplo 4: Um mecânico encontrou em um ferro velho uma trava

elétrica com sua etiqueta parcialmente ilegível, inviabilizando a leitura
da tensão de funcionamento. Porém, foi possível identificar a
indicação de uma potência 180 W e corrente máxima de 15 A. Com
base nessas informações, qual a tensão de funcionamento da bomba?
Aqui queremos descobrir a tensão, tendo a corrente e tendo a potência, logo: U = P / I =

180 / 15 = 12 V
3 PRINCIPAIS COMPONENTES ELETRÔNICOS
Agora que já vimos os principais conceitos sobre eletrônica, as grandezas físicas

importantes e a dinâmica da corrente elétrica, temos maiores condições de entender o
funcionamento e a aplicação dos componentes eletrônicos clássicos que compõe um
circuito. Cada componente pertence a uma família, possui características próprias e
agrega uma “funcionalidade” ao nosso circuito por conta de fenômenos característicos
conhecidos. Nesta disciplina não vamos nos aprofundar nos componentes, o que
necessitaria de meses de estudo dada a variedade e a até a complexidade de uso e
entendimento de alguns deles. Nosso intuito é, porém, conhecer suas principais
características e compreender qual a sua importância em um circuito eletrônico, nos
dando condições de poder fazer um uso básico dos mesmos, agregando características
desejadas aos nossos sistemas de IOT, vistos a partir da próxima unidade deste material.
Pág.
3.1 Resistores
Falamos bastante até agora de resistência elétrica, que é um obstáculo que impõe
dificuldade à passagem dos elétrons e, portanto, da corrente elétrica. Essa resistência pode
ser natural e intrínseca ao circuito (por causa das características dos materiais que os
compõe, como a resistividade dos condutores, por exemplo) ou pode ser planejada,
incorporando ao circuito componentes que tenham uma resistência conhecida. Esses
componentes, são os resistores. Existem resistores fixos (cuja resistência não varia dentro
de certos parâmetros de funcionamento) e resistores variáveis (cuja resistência varia de
acordo com a variação de alguma característica). Ambos se utilizam do chamado Efeito
Joule, onde a resistência se dá pela conversão de parte da energia elétrica em energia
térmica (ao seja, resistores esquentam e esse deve ser um cuidado na hora de utilizar).
3.1.1 Resistores fixos

Os resistores mais utilizados (verdadeiros coringas dentro do mundo da eletrônica)
são os fixos, básicos para realizar o controle e o planejamento das tensões e correntes do
circuito. Esses resistores fixos (que podem ser feitos de diferentes materiais como carbono,
filmes de metal, óxidos, entre outros), utilizam um sistema de cores para identificar a sua
resistência (em Ohms) e a sua tolerância (como se fosse uma margem de erro para cima
ou para baixo).
Os resistores fixos comuns

são identificados com 4 faixas
(três juntas que representam a
resistência e uma separada que
representa a tolerância). Já os
resistores fixos de precisão (com
uma tolerância muito menor e,
consequentemente, mais caros)
são identificados com 5 faixas
(quatro juntas que representam a
resistência e uma separada que
representa a tolerância).
Pág.
Exemplo: identificar o valor da resistência (em Ohms) e a tolerância dos resistores fixos
comuns mostrados abaixo:
3.1.2 Resistores variáveis

Os resistores variáveis são componentes muito interessantes pela possibilidade da
variação da resistência, dada as suas características. Essa variação sempre ocorre atrelada
(de forma mecânica ou automática) à mudança de outra característica e propriedade e são
elas que dão nomes especiais a estes resistores.
Potenciômetros: os potenciômetros têm suas resistências modificadas

de forma manual através do uso de um eixo que pode ser girado ou de
uma alavanca / chave que pode ser deslizada. São construídos de modo
a serem melhor aplicados para produzir variações na tensão.
Trimpots: muito similares aos potenciômetros, mas menores, com

mecanismos mais simples (muitas vezes com posições limitadas e não
lineares) e construídos para serem utilizados internamente nos circuitos,
sem acesso direto do usuário do dispositivo.
Reostatos: muito similares aos potenciômetros, mas geralmente

utilizados em circuitos de grande corrente (AC principalmente) por serem
construídos de modo a terem um comportamento mais estável na
produção de variações de corrente.
Pág.
Varistores: os varistores tem suas resistências modificadas de acordo

com a tensão aplicada a eles. Quanto maior a tensão, menor a
resistência oferecida. Deste modo, é importante observar que varistores
são resistência que não respeitam a Lei de Ohm.
LDRs: Os LDRs (Light Dependent Resistores) têm suas resistências

modificadas de acordo com a intensidade da radiação da luz que incide
sobre eles, diminuindo com o aumento dessa luminosidade. Aceitam
luzes visíveis (natural, laser) e não visíveis (como a infravermelha).
Termistores: os termistores tem suas resistências modificadas com a

temperatura. Podem ser NTC (Negative Temperature Coefficient, onde a
resistência diminui com o aumento da temperatura), PTC (Positive
Temperature Coefficient, onde a resistência aumenta com o aumento da
temperatura) e CTR (Critical Temperature Resistor, onde a resistência
aumenta abruptamente ao atingir uma temperatura limite).
3.2 Capacitores
Os capacitores são componentes eletrônicos

capazes de, quando submetidos a uma tensão,
carregar-se eletricamente e armazenar essa energia.
Ao contrário, se carregados, no momento que não
forem mais submetidos a uma tensão, passam a
liberar a energia armazenada, funcionando como
pequenas baterias. Apesar dessa semelhança, os
capacitores têm características diferentes das
baterias: armazenam cargas muito pequenas,
porém carregam-se muito rapidamente e podem liberar essa energia também rapidamente
(ou mais lentamente em associação com resistores que criem resistência em oposição à
corrente, se assim desejado). Isso é conseguido através do uso de duas placas condutoras
separadas por um material isolante (chamado de dielétrico). Quando energizado, o
capacitor carrega as placas com cargas opostas, que vão crescendo ao longo do tempo
(quanto maiores as placas, maior a carga possível). Em dado momento, as cargas opostas
estão tão altas que o material isolante cria um campo elétrico que permite a sua passagem.
Neste momento, dizemos que o capacitor está totalmente carregado, ou seja, suas cargas
estão tão saturadas que possibilitam que a energia elétrica flua por entre as placas através
do campo elétrico criado no dielétrico.
Pág.
Deste modo, enquanto estão sendo carregados, os capacitores criam uma abertura
no circuito, interrompendo o fluxo da corrente. Ao atingirem sua carga máxima, os elétrons
começam a escapar da placa que está funcionando como ânodo, atravessando o dielétrico
e entrando novamente no circuito através da outra placa e do seu terminal, voltando a
permitir que a corrente (oposta) circule no circuito. Já quando carregado (totalmente ou
parcialmente), caso a tensão à qual está submetido varie ou seja interrompida, o capacitor
passa a funcionar como bateria liberando esta carga no circuito. Quanto maiores as placas
(também conhecidas como armaduras), maior é a carga possível de ser acumulada.
Essa capacidade de armazenar carga é conhecida como Capacitância e é medida em

Farads (F), mas geralmente é apresentada com valores baixos, sendo mais comum
encontrar submúltiplos (mF, µF, nF, etc). Apesar de serem propriedades importantes, a
compreensão da carga elétrica (medida em Coulombs), da capacitância e do impacto delas
em relação à tensão e à corrente, são conhecimentos mais complexos, que aprofundam no
campo da física e que fogem do escopo dos nossos estudos. Porém, de forma prática, alguns
dos fenômenos citados anteriormente, nos interessam pelas suas aplicações práticas,
principalmente em circuitos CC.
Pág.
3.2.1 Capacitor como temporizador

Através da informação da capacitância (C) é possível, através do ajuste de uma
resistência (R) em série com o capacitor, definir o seu tempo total de carregamento ou
descarregamento. Assim, sabemos quanto tempo ele irá demorar para permitir a passagem
de corrente a partir do momento que foi energizado (tensão aplicada nos seus terminais)
ou o tempo que irá demorar para descarregar a partir do momento que não for mais
energizado (sem tensão aplicada nos seus terminais). Esse tipo de associação capacitor +
resistor recebe o nome de “Circuito RC”. Nele, o capacitor pode funcionar como uma chave
temporizada que liga, desliga ou envia um pulso para o circuito ou um subcircuito. Para
calcular esse tempo (T), utilizamos a fórmula:
T = (R . C) . 5 (com T em segundos, R em Ohms e C em Farads)
Exemplo: Se temos um capacitor com capacitância de

1000μF (1mF ou 0,001F) ligado em série com um resistor
de 2k (2000), formando um circuito RC, teremos que:
T = (2000.0,001) . 5 = 10 segundos para carga ou descarga
3.2.2 Capacitor como estabilizador de tensão

Quando associamos capacitores em série, a tensão aplicada causa um desequilíbrio
em cadeia durante o carregamento até que todos os capacitores entrem em equilíbrio de
carga (pois elétrons excedentes em um, são “puxados” pelos demais). Quando esse
equilíbrio é atingido, a tensão se divide entre os terminais, sendo a tensão total igual a
soma das tensões individuais e igual (ou muito próxima) à tensão aplicada. Quando a fonte
de tensão é interrompida ou sofre uma variação para baixo, os capacitores passam a
fornecer energia para o sistema, funcionando como baterias que mantém a tensão inicial
à qual foram submetidas, devolvendo-a ao sistema. Deste modo, variações na tensão são
compensadas e temos uma estabilização.
3.2.3 Capacitor como amplificador de corrente e de tensão

Quando associamos capacitores em paralelo, todos eles estão sujeitos à mesma
diferença de potencial elétrico e, por terem capacitâncias diferentes e não acontecer o
equilíbrio da associação em série (provocado pelo fenômeno eletrostático), cada capacitor
acaba se carregando com uma quantidade de carga diferente (de acordo com suas
Pág.
características) e com a mesma tensão recebida. Quando a tensão aplicada nos seus
terminais é interrompida ou varia, eles passam a funcionar como baterias em paralelo: a
tensão é limita pelo capacitor de menor tensão (apesar de iniciarem a descarga com tensão
igual e o sistema tender ao equilíbrio, mantendo uma maior paridade), porém todos eles
liberam a energia acumulada ao mesmo tempo, aumentando a corrente total do sistema
que se iguala à soma das suas correntes individuais. Deste modo, conseguimos com os
capacitores em paralelo criar um amplificador de corrente, muito útil em diversas
aplicações.
Nesta mesma configuração em paralelo, os capacitores se carregaram com cargas

diferentes, mas todos manterão a mesma diferença de potencial ao qual foram submetidos.
Se após carregados mudarmos a configuração da ligação dos seus terminais de paralelo
para em série (por chaveamento manual ou automático) e interrompermos a tensão dos
seus terminais, eles passam a se comportar como baterias em série, cuja tensão total é
igual a soma das suas tensões. Deste modo amplificamos a tensão. Esse chaveamento de
paralelo (até o carregamento) e em série (ao liberar a energia) é fundamental pois se os
capacitores já estivessem em série (como visto no uso dos capacitores como estabilizadores
de tensão), a tensão aplicada se dividiria nos seus terminais e ao ser liberada daria origem
à mesma tensão original (soma das tensões individuais).
Pág.
3.2.4 Capacitores como disparadores de alta tensão ou alta corrente

Em todas as situações acima, tanto na associação em série quanto em paralelo, os
capacitores acumulam carga e dão origem a tensões em seus terminais. Este carregamento
pode ocorrer lentamente ou rapidamente dependendo da resistência que estiver em série
com ele e com a sua capacidade, como já visto. Mas ao descarregar, podemos reduzir ou
remover a resistência do circuito e isso fará com que a intensidade seja muito alta pela
rápida evacuação dos elétrons. Esse é o princípio utilizado, por exemplo, nos flashs, como
no circuito simplificado da figura ao lado.
3.3 Diodos
Um dos mais importantes componentes eletrônicos, os diodos

são formados de materiais semicondutores e possuem uma
característica importante: somente permitem a passagem da
corrente em um sentido, desde que aplicada uma tensão mínima
para que isso ocorra. Para entender este funcionamento,
precisamos entender um pouco sobre como um diodo é
construído e os dois lados que o compõe:
Lado N (negativo): é composto de um material semicondutor

formado por átomos que possuem 1 elétron excedente (efeito obtido
através de um processo chamado de dopagem). Mesmo com esses
elétrons sobrando, pela natureza do material, existe uma
dificuldade para que eles possam se movimentar livremente.
Lado P (positivo): é composto de um material semicondutor formado por átomos com

déficit de elétrons, o que os obriga a compartilhar alguns, em equilíbrio frágil. Desse modo,
sua tendência é atrair elétrons para que se completem, dando origem a uma ligação forte
em lugar do equilíbrio frágil.
Pág.
Quando estes dois lados são unidos, em uma junção chamada PN, no centro da
junção, haverá um equilíbrio entre as cargas. Já as cargas mais distantes não possuem
força de atração suficiente. Porém, quando uma tensão é aplicada, dependendo da
polaridade, podem acontecer dois fenômenos diferentes.
3.3.1 Ligação inversa

O cátodo da fonte atrairá os elétrons do lado N enquanto os prótons do lado P serão
atraídos pelo ânodo da fonte. Com isso, a concentração das cargas se dará nas
extremidades do diodo e será criada no seu centro uma região neutra, chamada de “Zona
de Depleção”. Claramente neste caso, como pode ser observado na figura abaixo, isso cria
um isolamento e a corrente não circula através do diodo. O mesmo funciona, então como
um isolante, de alta resistência. Existe um ponto, porém, onde a concentração de cargas
está tão grande que o componente entra em curto-circuito, podendo ser danificado.
3.3.2 Ligação direta

O cátodo da fonte provocará uma repulsão nos prótons do lado P do diodo, do
mesmo modo que o ânodo da fonte provocará uma repulsão nos elétrons do lado N do
diodo. Assim quanto maior a tensão, maior a força que agirá repelindo as cargas cada vez
mais para o centro e diminuindo a região de depleção. Chegará um momento em que essa
região será inexistente e a proximidade entre os prótons e os elétrons será tão grande que
possibilitará que os elétrons pulem de um lado para o outro, permitindo assim a passagem
da corrente. Veja o exemplo abaixo de um diodo típico de silício, onde o desaparecimento
da zona de depleção (que permite um ponto de contato entre as duas cargas e a
consequente passagem de corrente) ocorre a aproximadamente 0,7 V. É importante frisar
que ao utilizar diodos dentro do circuito, ocorre uma queda de tensão, consumida por ele.
Pág.
3.3.3 Outros tipos de diodos especiais

Partindo deste princípio básico de funcionamento, os diodos podem ser construídos
a partir de diversos materiais e com diferentes configurações que podem lhes dar uma
infinidade de características diferentes que sejam úteis e encontrem aplicabilidade. Entre
os principais tipos de diodo, temos:
Diodo retificador: é o diodo mais comum, com comportamento igual ao

explicado anteriormente. Esse diodo possui especificação quanto a
tensão máxima aceita na polarização direta (chamada de Vf) e a tensão
máxima aceita na polarização reversa (chamada de Vbr). São muito úteis
na conversão de corrente AC em CC (pois só permitem a passagem da
corrente em um sentido, bloqueando o outro), na filtragem de pequenas
flutuações de tensão e no controle de polaridade de um circuito,
impedindo sua queima se a fonte CC for ligada de forma invertida.
Diodo Schottky: são diodos bastante comuns e com o mesmo princípio

básico de funcionamento. A maior diferença é que enquanto os diodos
retificadores são construídos a partir de cristais silício e germânio
(operando com tensão a partir de 0,3 V à 0,8 V na polarização direta), os
diodos Schottky são construídos a partir de metais, com zonas de
depleção muito menores e que permitem a passagem de corrente a partir
de tensões mais baixas (geralmente entre 0,1 V e 0,45 V). Além disso,
suportam uma corrente máxima maior na polarização reversa.
Diodo Zener: é um diodo especial que quando recebe polarização

reversa, provoca um efeito muito importante: permite a passagem da
corrente, mas de tal forma que mantém uma determinada tensão
constante entre seus terminais. Por exemplo, um diodo zener de 5,1 V e
com potência de 1,3 W suporta uma corrente de até 250 mA entre seus
terminais, independente da tensão recebida. Porém, se esta tensão for
ultrapassada, o diodo tende a ser danificado provocando uma abertura
no sistema (que pode ser ou não intencional, como um fusível).
Pág.
Diodo Emissor de Luz: é um fotodiodo construído para dissipar parte

de sua tensão de queda em forma de luz (e não só calor). O exemplo mais
comum é chamado de Led. Aliás, por ser um componente polarizado
temos que ter cuidado ao ligar seus terminais (sendo o mais longo deles,
o cátodo). Já um Led RGB é composto por 3 diodos que emitem, cada
um, uma cor primária da luz. Outro exemplo deste tipo de diodo é o
emissor de infravermelho, muito utilizado em controles remotos para
enviar sequências distintas para aparelhos que querem controlar.
Diodo Receptor de Luz: é um fotodiodo igual ou similar a um diodo

emissor de luz, mas capaz de captar luz. Os fótons recebidos provocam
um deslocamento dos elétrons e acabam criando um desequilíbrio entre
as camadas, o que gera uma corrente elétrica. Estes diodos são o
princípio utilizado na confecção das chamadas células fotovoltaicas,
principais componentes dos painéis solares que convertem a luz solar
em energia elétrica. Ou exemplo, são os receptores de luz infravermelha,
comuns em aparelhos operados por controles remotos.
3.4 Transistores
Os transistores são considerados, sem dúvida, como os

mais importantes componentes eletrônicos de todos os
tempos, sendo um dos grandes responsáveis por
impulsionar a tecnologia que hoje nos cerca. A sua
flexibilidade, variedade de montagens e possibilidades
de aplicação, o tornam um componente bem difícil de
ser dominado e conhecido dentro de todo seu potencial.
Nesta disciplina, nosso objetivo é entender o funcionamento geral do tipo mais comum (e
mais utilizado) de transistor (chamado de NPN) e aprender a utilizá-lo como uma chave
eletrônica, dimensionando nosso circuito para isso. Além disso, outros dois transistores
especiais (chamados de reguladores de tensão) serão vistos, também pensando em sua
aplicação prática em nossos circuitos. Para isso, começamos com os conceitos mais gerais
sobre o seu funcionamento, aprofundando somente naquilo que nos é útil.
Basicamente, um transistor é a
associação de junções PN. O tipo mais
comum de transistor (que recebe o nome
de BJT, ou Bipolar Junction Transistor),
associa duas dessas junções, unindo
seus lados iguais. Quando a união se dá
Pág.
pelos seus lados P, temos um transistor NPN; ao contrário, quando a união se dá pelos
seus lados N, temos um transistor PNP. O lado unido (central à montagem) é chamado de
Base e os outros 2 lados iguais são chamados de Coletor e Emissor.
Na prática, este tipo de transistor funciona de forma similar à associação de dois

diodos, possibilitando a criação de duas áreas de depleção entre o emissor e o coletor,
ligados a uma fonte. Quando uma corrente é aplicada à base (entrando por ela no tipo NPN
ou saindo por ela no tipo PNP), é provocada uma diminuição na área de depleção. Pelas
características dos seus materiais, essa diminuição já permite que uma corrente flua entre
os elementos iguais (do coletor para o emissor em transistores NPN e do emissor para o
coletor em transistores PNP). Quando maior a corrente da Base, maior é a “abertura” (como
uma válvula de água) para a passagem da corrente entre coletor e emissor. Deste modo,
os transistores do tipo BJT, podem estar em 3 estados distintos:
• Estado de corte: o estado de corte ocorre quando não existe corrente na Base (ou
existe e esta é insuficiente). Deste modo, a passagem da corrente entre emissor e
condutor está interrompida.
• Estado de saturação: o estado de saturação ocorre quando a corrente da Base atinge
um valor determinado que “abre” totalmente a passagem da corrente entre emissor
de condutor.
• Estado ativo: o estado ativo ocorre quando na base existe uma corrente nem tão
baixa para o estado de corte e nem tão alta para o estado de saturação, permitindo
uma passagem apenas parcial da corrente entre emissor e condutor.
Para melhor compreensão, podemos uma analogia desenvolvida pela Sparkfun

(www.sparhfun.com), relacionando-o com uma válvula de água. Esta válvula (base), para
abrir ou fechar, deve receber uma força (no caso do transistor uma corrente) e de acordo
com sua abertura controla o fluxo da água que passará por ela, percorrendo o cano:
Os transistores têm outra característica importante que os tornam ainda mais

únicos e interessantes: o HFE (também conhecido como “ganho” e representado pelo
símbolo β). Ele funciona como um multiplicador, fazendo com que uma pequena corrente
Pág.
na base gere a liberação de uma grande corrente no coletor, amplificando o sinal. É como
se, mantendo a analogia com a válvula de água, a mesma fosse ligada a um sistema de
esforço hidráulico que permitisse girá-la aplicando uma força mínima para isso, muito
menor do que em uma válvula de água comum.
3.4.1 Esquematização de um transistor NPN

Para facilitar nossa exemplificação, iremos nos ater ao tipo NPN (mais comum e de
mais fácil entendimento), e transformar essas observações iniciais e alguns outros
conceitos importantes em um esquema que facilite a compreensão do seu funcionamento
real em um circuito eletrônico:
• À esquerda do transistor, temos um circuito ligado a ele através da Base (por onde
entrará a corrente de controle que ajustará a corrente permitida do lado direito entre
o Coletor e o Emissor);
• Entre a fonte de tensão deste circuito de controle e a Base do transistor temos um
resistor RB que é utilizado para regular a corrente de entrada da Base. Se sabemos
a tensão da fonte do circuito de controle (VB), ajustamos a resistência para gerar a
corrente de entrada desejada.
• Para o cálculo do valor do resistor que nos entregará a corrente de base desejada,
podemos utilizar a Primeira Lei de Ohm, I = U / R. Porém, o transistor se comporta
como um diodo e alimentação da base vai consumir parte desta tensão (algo em
Pág.
torno de 0,3 V e 0,8 V). Esse valor, chamado de VBE, varia para cada transistor e é
informado nas especificações do modelo. Assim, a tensão que consideramos para
qualquer cálculo desejado deste lado do circuito de controle deve descontar esse
valor. A partir de todas essas informações, temos que, IB = (VB – VBE) / RB.
• O transistor possui um ganho (𝛽) e, deste modo, a corrente de entrada da Base será
amplificada (multiplicada) por ele, liberando uma corrente muito mais forte no
Emissor (IE) e, indiretamente, no coletor (IC) que tentará acompanhá-la.
• Com isso, a corrente no emissor (IE) será a soma da corrente recebida do coletor (IC)
com a corrente recebida da base (IB), já amplificada. Desde modo, podemos dizer
que IE = IC + (IB . β). Como a corrente do coletor (IC) será drenada para acompanhar
a corrente que está fluindo pelo Emissor (IE), acaba sendo muito próxima a ela até
o estado de saturação. Com isso, podemos substituí-la na fórmula original e teremos
que IE = IB + (IB . β).
• Já a corrente da Base (IB) deve ser dimensionada para, após sua amplificação, gerar
no emissor uma corrente suficiente para induzir no Coletor o que ele necessita para
os componentes que estiver alimentando (se a corrente na base aumenta, a corrente
no coletor aumenta para acompanhá-la). Deste modo, se sabemos a corrente total
que precisamos no coletor, podemos calcular a corrente que devemos aplicar na
Base para induzir essa liberação. Assim, temos que IB = IC / β.
• O que será alimentado pela corrente entre coletor e emissor, deverá ser posicionado
entre o terminal do coletor e o positivo da fonte do circuito principal. Essa corrente
que passa pelo Coletor (IC) virá da fonte e atravessará esses componentes neste
caminho.
• A corrente da Base (B), entra no circuito principal e se soma à corrente do emissor
pois tem que fluir para algum lugar. Caso ela seja muito alta e gere uma corrente
no emissor superior à corrente máxima que o coletor pode fornecer, dizemos que o
transistor está saturado (ou seja, a corrente máxima que pode estar sendo fornecida
pelo coletor, está sendo). Neste momento, o equilíbrio típico do estado ativo deixa
de existir.
• Se a corrente gerada no coletor for maior do que aquela suportada pelos
componentes alimentados por ele, poderá haver dano a estes componentes. Desde
modo, geralmente utilizamos um resistor para limitar a corrente no coletor,
mantendo um nível controlado mesmo quando a corrente da base for alta e liberar
uma grande passagem ao fluxo.
• Como temos a corrente suportada pelos componentes posicionados entre o coletor
e a fonte de tensão do circuito principal e sabemos a tensão nesta fonte (V C),
Pág.
podemos calcular o valor do resistor necessário para garantir essa corrente máxima
desejada. Porém, assim como no cálculo do resistor da base, devemos considerar
que parte da tensão da fonte será consumida pelo transistor quando entrar no
coletor. Deste modo, para qualquer cálculo no circuito principal, devemos
desconsiderar esta perda, chamada de VCE (e também informada nas especificações
do transistor). Assim, IC = (VC – VBC) / RC.
Apoiados nestas informações e em posse das fórmulas apresentadas, já temos

condições de dimensionar um circuito que utilize o transistor como uma chave disparadora
que, através da base, induza entre o coletor e o emissor exatamente a corrente necessária
para alimentar os componentes desejados.
3.4.2 Exemplo de circuito com transistor como chave de disparo

Um pequeno produtor rural resolveu desenvolver
um sistema de rega que pudesse ser acionado à
distância através de um botão. Para isso, possui
uma válvula de água solenoide, alimentada por
9V e que ao ser acionada para liberar a passagem
da água, necessita de uma corrente máxima de
até 0,5 A. Sabendo que o produtor possui apenas
duas fontes de tensão (uma de 12V e outra de
5V), desenhe e dimensione um circuito para ativar e desativar essa válvula com o uso do
transistor BC-548A (do tipo NPN).
Passo a passo para a solução
1) Montar o circuito baseado no esquema de uso do transistor NPN: utilizando o

esquema base, nossa única modificação estrutural é a inclusão da válvula solenoide
que queremos controlar (entre o coletor e a fonte do coletor) e um botão que ao ser
clicado permite a entrada da corrente na Base (entre ela e o positivo da fonte que a
alimenta). Além disso, já devemos incluir no esquema os valores das fontes. Como
só possuímos uma fonte de 12V e outra de 5V, claramente a de 12V deve ser a que
alimentará a válvula (que trabalha com 9V). Assim, a fonte de 5V pode ser utilizada
no circuito de controle da Base. Além disso, esta válvula necessita de uma corrente
máxima de 0,5 A que deverá ser fornecida pelo coletor. Assim, a corrente do coletor
deverá ser também de 0,5 A.
Pág.
2) Buscar as especificações do transistor: todo componente eletrônico possui um

datasheet, que contém seus detalhes técnicos e características descritas. Entre
todas as informações do transistor, três são fundamentais para nós: o ganho
(identificado como ou β ou HCE), a queda de tensão na base (identificada como VBE)
e a queda de tensão no coletor (identificada como VCE). Perceba que no trecho abaixo
retirado do datasheet do transistor BC-548A, os valores são informados não de
forma precisa, mas dentro de uma faixa de operação que possui uma margem de
erro aceitável e conhecida.
Como regra, quando trabalhamos com circuitos eletrônicos de baixas correntes,

consideramos o ganho mínimo e as quedas de tensões mínimas. Esses valores
chegam perto ao máximo quando o transistor opera em situações mais extremas, o
que não é nosso caso. Então, nosso 𝜷 = 110, VBE = 0,58 V e VCE = 0,25 V.
Pág.
3) Calcular a corrente da Base (IB): podemos iniciar nossos cálculos descobrindo qual
a corrente devemos aplicar na base para conseguir estimular a corrente total
necessária pelo coletor para o acionamento da válvula solenoide. Como já sabemos
o β do transistor e a corrente necessária ao coletor (0,5 A), podemos usar a fórmula:
IB = IC / β = 0,5 / 110 = 0,0045 A (ou 4,5 mA).
4) Calcular o resistor de controle da corrente da Base (RB): Agora temos todas as

informações que necessitamos para calcular o resistor
necessário no circuito de controle para garantir essa
corrente de 0,0045 A na base. Aqui, como explicado
anteriormente, devemos considerar que parte da tensão
será dissipada pela base e o valor dessa queda (VBE) já
descobrimos no datasheet do transistor (0,58 V). Com isso:
IB = (VB – VBE) / RB, onde devemos isolar RB (o que queremos calcular). Então:
RB = (VB – VBE) / IB = (5 – 0,58) / 0,0045 = 4,42 / 0,0045 = 982,2 
Como não existe um resistor com esse valor, devemos buscar o resistor comercial
com o valor mais próximo. Neste caso, será o de 1000 (1k).
5) Calcular o resistor de controle da corrente do Coletor (IC): também já temos

todas as informações que necessitamos para calcular o
resistor necessário entre a fonte do circuito principal e
o coletor (RC) para garantir a limitação da corrente que
passará pela válvula solenoide. Parte da tensão desta
fonte será dissipada pelo transistor ao entrar pelo
coletor e também já buscamos do datasheet esta queda
chamada de VCE. Assim, temos:
IC = (VC – VCE) / RC, onde devemos isolar RC (o que queremos calcular). Então:
RC = (VC – VCE) / IC = (12 – 0,25) / 0,5 = 11,75 / 0,25 = 47 
Existe um resistor comercial com esse valor, portanto RC será exatamente 47 .

Caso não existisse, por segurança, deveríamos procurar o resistor com valor
Pág.
comercial mais próximo e MAIOR do que o que calculamos, pois escolher um
resistor com valor menor, permitiria uma corrente superior à máxima suportada.
6) Calcular a corrente do emissor: somente para complementar o dimensionamento

e as informações no nosso circuito, a única informação que está faltando é a
corrente que atravessará o emissor (IE). Como ela é a soma das correntes do coletor
(IC) e da corrente da base já amplificada (IB . β), temos:
IE = IB + (IB . β) = 0,0045 + (0,0045 * 110) = 0,0045 + 0,495 = 0,5 A (arredondando).
7) Anotar todas as informações no circuito: nosso circuito já está totalmente

dimensionado e toda vez que o botão for pressionado, uma corrente de 4,5mA na
base irá liberar uma corrente de 0,5 A no coletor, acionando a válvula solenoide e
liberando o fluxo de água que fará a rega da horta. Vamos então, finalmente, anotar
todas os valores calculados ao nosso esquema:
3.4.3 Transistores Reguladores de Tensão Fixos e Variáveis

Existem algumas categorias de transistores que são especialmente úteis pois
aproveitam-se de suas características de duplo diodo para conseguir regular e garantir
uma determinada tensão de saída, independentemente da tensão de entrada. Apesar de
podermos fazer o mesmo com resistores em série (divisor de tensão, sem filtro de
flutuações) e com diodos, estes transistores são muito mais fáceis de usar, seguros (com
proteção interna) e estáveis (estabilizando a tensão). Veremos então dois desses
transistores de regulação de tensão, sendo um deles fixo e o outro regulável.
Pág.
Regulador de tensão fixo com o LM78xx
Essa família de transistores reguladores é a mais comum e barata

do mercado, contando com proteção contra curto-circuito em sua
saída. Possui tensão de saída fixa (sendo mais inflexível), porém
não necessita de nenhum outro componente adicional. O valor
dessa tensão de saída dá origem aos dois últimos números do
nome ao transistor: LM7805 (5 V), LM7806 (6 V), LM7808 (8 V),
LM7812 (12 V), LM7815 (15 V), LM7818 (18 V), LM7824 (24 V). O
seu uso é muito simples: basta conectar ao pino 1 a tensão a ser
regulada e o pino 2 ao terra (GND). Assim, automaticamente a tensão de saída do pino 3
será a indicada pelo transistor da família LM78xx escolhido. Para que tudo funcione de
forma segura e sem surpresas, precisamos ter alguns cuidados:
• Tensão máxima de entrada a ser regulada: máximo de 35 V (com exceção do

transistor LM7824 que suporta até 40 V na entrada).
• Para a tensão de saída ser garantida, a tensão de entrada deve ser no mínimo 3 V
maior do que ela.
• A corrente máxima utilizada pelo subcircuito que utiliza a tensão de saída deve ser
limitada à 1 A.
• A potência dissipada deve ser calculada e se o seu valor superar 1W, o transistor
deverá utilizar um dissipador de calor. Para esse cálculo, P = (Ventrada – Vsaída) / Isaída.
Transistor regulador de tensão LM317 (variável): o transistor

LM317 é também um regulador de tensão, com uso um pouco
mais difícil do que os da família LM78xx, porém com uma grande
vantagem: através da combinação de 2 resistores é possível
regular a tensão de saída desejada. Para o seu uso, também é
suportada uma tensão de entrada de até 40 V, com tensão de
saída entre 3 e 37 V (pela queda de tensão dissipada) e corrente
máxima de 1 A. Quanto ao seu uso, o LM317 pode compor
diversas montagens diferentes que variam a sua aplicação. Porém, para ser utilizado como
um regulador de tensão variável (seu principal propósito), devemos reproduzir o circuito
abaixo:
Pág.
Nesta configuração, independente de qual for a tensão de

entrada (desde que seja até 40 V), a tensão de saída é definida
pela combinação dos resistores R1 e R2.
Uajustada = 1,25 . (1 + R2/R1)
Também podemos isolar os resistores para descobrir quais

valores devem possuir para chegar à tensão de saída desejada:
R1 = R2 / ( (Vajustada/1,25) – 1)
R2 = ( (Vajustada/1,25) – 1) . R1
Na prática, escolhemos o valor de um dos resistores (com um chute ou alguma

estimativa caso se precise limitar uma corrente) e assim calculamos o outro resistor que
em conjunto garante a tensão. Outro cuidado importante é descobrir a potência dos
resistores a serem utilizados (comercialmente temos resistores na casa dos mW até os W)
e se o transistor vai atingir a potência de 1W, a partir da qual o mesmo deve ser associado
a um dissipador de calor que impeça a queima do componente. Para isso, usamos as
seguintes fórmulas:
PR1 = 1,25 . 1,25 / R1
PR2 = (Vajustada – 1.25) . (Vajustada – 1.25) / R2
Plm317 = PR1 + PR2
Exemplo: Imagine que precisamos obter uma tensão de saída de 10 V com o LM317. A
primeira observação é que a tensão de entrada pode variar entre qualquer valor entre 13
V (por conta dos 3 V de perda) e 40 V (tensão máxima suportada na entrada). Para os
resistores, vamos “chutar” um valor para o R1 (240 , por exemplo) e a partir daí podemos
encontrar o R2:
R2 = ( (Vajustada/1,25) – 1) . R1 = ( (10/1,25) – 1) . 240 = 7 . 240 = 1680  = 1,680 K
Assim, utilizando o transistor LM317 associado a um resistor de 240  com um

resistor de 1,6 K (o comercial mais próximo), garantimos uma tensão de 10V regulada na
saída. Porém, precisamos verificar a potência dos resistores e do transistor para garantir
a segurança da operação:
Pág.
PR1 = 1,25 . 1,25 / R1 = 1,25 . 1,25 / 240 = 1,5625 / 240 = 0,0065 W (ou 6,5 mW)
PR2 = (Vajustada – 1.25) . (Vajustada – 1.25) / R2 = (10 – 1,25) . (10-1,25) / 1600

= 8,75 . 8,75 / 1600 = 0,0478 W = 47,8 mW
Plm317 = PR1 + PR2 = 0,0065 + 0,0478 = 0,0543 W (ou 54,3 mW)
Assim, verificamos que o transistor não necessita de um dissipador (pois não atingiu
o limite de 1W) e que resistores de 1/8 W (os mais comuns no mercado) atendem com uma
boa margem de segurança.
4 ELETRÔNICA DO DIA A DIA
Os conceitos básicos de elétrica e eletrônica são importantes não somente para a

sua aplicação técnica e profissional, mas também no nosso dia a dia. Esse tópico é uma
miscelânea de aplicações práticas do conhecimento adquirido até aqui.
4.1 Tomadas, padrões e tipos de ligação
O chamado novo padrão brasileiro de

tomadas e plugs foi uma forma de padronizar o uso
através de um modelo universal a qualquer
equipamento, substituindo cerca de 6 padrões
diferentes que eram utilizados simultaneamente.
Além disso, o novo padrão busca segurança, visto
que conta com um pino terra (para aterramento) e
os pinos do plug ficam escondidos no interior da
tomada, protegendo contra choques acidentais. O
pino central é o terra, que deve ser aterrado para evitar pequenas descargas e choques e
para proteção em situações de sobrecarga (raios por exemplo). Já o pino à esquerda do
pino terra (com ele voltado para baixo) é o pino da fase, sendo o pino à direita o neutro ou,
em caso de redes bifásicas, a segunda fase. Apesar da rede elétrica ser alternada (ou seja,
alterna o sentido de entrada e saída da corrente) e, na prática, a tomada funcionar
normalmente se o fase e o neutro forem invertidos, os equipamentos eletroeletrônicos são
construídos de modo a ter uma proteção contra sobretensão e sobrecorrente na entrada
deste pino. Com isso, perde-se essa proteção se os lados não forem respeitados. Ao
desmontar uma tomada e ter acesso aos fios que descem internamente pela parede, ou
Pág.
mesmo ao puxar uma extensão de outra tomada, é
importante descobrir qual dos dois é o fase para que a
montagem seja correta. Para isso podemos usar uma
chave teste, encontrada em qualquer ferragem. Existem
vários modelos, desde os mais simples com um led que
acende ao tocar o fase, quanto eletrônicos mais
elaborados que indicam inclusive a tensão. Caso se deseje
instalar uma tomada nova a partir dos cabos internos da
parede, as cores já são um indicativo (apesar de o teste ser
sempre recomendado para evitar acidentes caso o padrão de
cores não tiver sido respeitado pelo eletricista que criou a rede elétrica do local).
Com esses cuidados, a montagem de uma

tomada simples torna-se segura e fácil de
fazer. Porém, podem surgir algumas dúvidas
quando uma tomada dupla for montada. A
regra aqui, é que os pinos de mesmo tipo
devem ficar paralelos entre si (fase com fase
e neutro com neutro). Para isso, basta
utilizar um fio ligando os dois fios fase (e que
deve ser ligado ao fio fase da instalação
elétrica) e um outro fio diferente ligando os
dois neutros (e que deve ser ligado ao fio neutro da instalação elétrica). Na imagem acima
temos uma exemplificação de como os fios devem ligar-se aos pinos na
parte interna da tomada. Perceba que foram apresentados dois
padrões: o invertido (ou cruzado) e o linear. As tomadas duplas fixas já
são vendidas no padrão cruzado e recomenda-se o mesmo padrão ao
montar uma tomada modular. Carregadores e fontes de energia tem o
seu corpo voltado para a horizontal em relação aos pinos ou então
vertical, mas com o corpo voltado para o sentido do pino terra. Caso
nossa tomada seja linear, será impossível conectar dois deste tipo nela.
Pág.
4.2 Dimensionamento de tomadas e fios
As tomadas do novo padrão brasileiro são classificadas em dois tipos: 10 A e 20 A.

Isto se deve à corrente máxima suportada por elas. Visualmente, a diferença é no diâmetro
dos furos. A de 10 A possui furos menores e só aceita plugs de 10 A. Já a de 20 A possui
furos maiores e aceita tanto plugs de 10
A quanto plugs de 20 A. Obviamente, as
tomadas de 20 A são melhores
(suportam maior carga) mas mais caras.
Em casa, são poucos os equipamentos eletroeletrônicos que necessitam de uma

tomada de 20 A, entre eles os mais comuns são: secador de cabelo, chapinha elétrica,
forno elétrico, forno microondas, cafeteira de cápsulas, aquecedor, secadora de roupas,
máquina de lavar e ferro de passar. Se vamos utilizar esses equipamentos na tomada,
necessariamente ela deve ser de 20 A. Porém, mesmo que seja para uso somente com
equipamentos de baixa ou média potência, talvez a tomada de
20 A também seja necessária. Para isso, necessitamos descobrir
a corrente de cada equipamento, através da tensão (que
sabemos) e da potência (informada através de etiquetas) com a
fórmula I = P / U. O mesmo cuidado que vale para a tomada,
vale para os fios utilizados para conectá-la à rede elétrica (ou
para criar uma extensão conectada a ela). Quanto aos fios, existe
uma relação entre a sua seção transversal e a corrente máxima
suportada. Essa relação é mostrada na figura à direita e deve ser
consultada para auxiliar na escolha.
Exemplo: Precisamos construir um espaço para um pequeno escritório particular,

utilizando uma parte da sala de estar. Porém, neste espaço
não existe tomada. Nosso objetivo é instalar uma nova
tomada simples, de tensão 110 V. Ela será posicionada
próxima a uma bancada, onde deverá ser montada uma
extensão (com entrada para 6 equipamentos) a ser conectada nela. Então é necessário
dimensionar a tomada, o fio da tomada que à ligará à rede elétrica e o fio da extensão. Para
este exemplo, vamos imaginar dois cenários, com equipamentos similares, mas de
potências diferentes.
Pág.
• Situação 1:
Carregador de 15 W → I = 15 / 110 = 0,14 A
Desktop com fonte de 300 W → I = 300 / 110 = 2,73 A
Monitor 21’ de 28 W → I = 28 / 110 = 0,25 A
Televisão 32’ de 65 W → I = 65 / 110 = 0,59 A
Playstation 3 de 55 W → I = 55 / 110 = 0,50 A
Ventilador pequeno de 40 W → I = 40 / 110 = 0,36 A
Nesta situação, a soma das correntes chega a um valor de 4,6 A. Deste modo, a
tomada de 10 A será suficiente para suportar a carga necessária, e com uma boa
margem de segurança, operando longe do seu limite máximo. A corrente máxima
que passará pela tomada (e pela extensão consequentemente), permitiria o uso de
um fio com seção transversal a partir de 0,5mm (que suporta até 6 A) tanto na
tomada quanto na extensão. Porém, mesmo que a corrente máxima não vá ser
atingida, geralmente dimensionamos como se fosse. Nesse caso, tomada e extensão
deveriam suportar 10 A e assim necessitam utilizar um fio de seção transversal a
partir de 0,75mm (que suporta exatamente 10 A, mas estaria no limite) ou um fio
com seção transversal a partir de 1,0mm (que suporta 12 A, tendo então uma folga).
• Situação 2:
Carregador turbo power de 55 W → I = 55 / 110 = 0,5 A
Desktop gamer com fonte de 500 W → I = 500 / 110 = 4,5 A
Monitor 29’ de 68 W → I = 68 / 110 = 0,6 A
Televisão 58’ de 200 W → I = 200 / 110 = 1,8 A
Playstation 4 de 250 W → I = 250 / 110 = 2,3 A
Ventilador grande de 108 W → I = 108 / 110 = 1,0 A
Já nesta situação, mesmo com equipamentos “similares”, a soma das correntes

chega a um valor de 10,7 A. Deste modo, a tomada de 10 A será insuficiente para
suportar a carga necessária, sob risco de superaquecimento, derretimento e curto
circuito. Obviamente a escolha deverá ser pela tomada de 20 A. De forma análoga
ao exemplo anterior, se olharmos para a corrente máxima consumida pelos
equipamentos, seria necessário um fio com seção transversal mínima de 1,0mm
(suportando até 12 A, perto do limite de 10,7 A necessários) ou com seção
transversal mínima de 1,5mm (suportando até 15,5 A, com uma folga). Já se
Pág.
olharmos para os 20 A da tomada e quisermos um dimensionamento mais seguro
que permita a ela trabalhar com carga máxima (caso os equipamentos sejam
substituídos por similares ainda mais potentes no futuro), seria necessário um fio
com seção transversal mínima de 2,5 mm (suportando até 21 A, perto do limite de
20 A necessários em carga máxima) ou com seção transversal mínima de 4,0mm
(suportando até 28 A, com uma folga).
4.3 Disjuntores e dimensionamento da rede
Os disjuntores são chaves de proteção que ao receberem na entrada uma corrente

maior do que a dimensionada para suportarem, desarmam (abrem) e interrompem essa
corrente. Eles são fundamentais para proteger a rede elétrica de sobrecargas e servem
como uma interface entre a entrada da rede elétrica e nossos equipamentos
eletroeletrônicos. Os disjuntores são instalados no QDC (Quadro de Distribuição de
Circuitos), a nossa famosa “Caixa dos disjuntores”. A partir dela, são ligados em paralelo
à rede principal e cada um dá origem a uma rede independente à qual controla. Não nos
interessa aqui explicar como um disjuntor é instalado pois para isso é necessário um
conhecimento técnico aprimorado (número de fases, tipo de rede, características
desejadas, etc) e qualquer erro pode levar a sérios problemas, como curto circuitos e
incêndios. Porém, conhecer como funcionam e saber os seus valores nos ajudam a
dimensionar as tomadas e, consequentemente, os aparelhos que podemos conectar em
cada segmento. Vamos observar a rede abaixo, com 3 disjuntores já instalados em nossa
QDC, cada um controlando um segmento diferente de nossa rede.
Pág.
O primeiro disjuntor suporta 40 A e controla três tomadas ligadas ao segmento A. O

segundo disjuntor suporta 20 A e controla apenas um ar condicionado ligado ao segmento
B. O terceiro disjuntor suporta 30 A e controla um chuveiro e uma tomada ligados ao
segmento C. Para entender o uso destes disjuntores e o dimensionamento da rede e dos
nossos equipamentos, vamos refletir sobre algumas perguntas:
1) No disjuntor do segmento A, as três tomadas podem ser de 20 A?
Sim e não. Não é a tomada a responsável pela corrente que circulará pelo segmento
e sim os equipamentos conectados a ela. Imagine que em cada uma colocamos uma
extensão onde mais 5 equipamentos podem ser ligados. Se, por exemplo, a soma da
corrente na primeira tomada (já vimos anteriormente como calcular a corrente
máxima através das potências dos equipamentos) ficar em 12 A, a da segunda em
6 A e a da terceira em 8 A, a corrente total no segmento A será de 26 A, suportada
pelos disjuntores. Porém, se colocamos as três tomadas de 20 A, abrimos a
possibilidade de termos, em todas elas, equipamentos de média ou alta potência.
Imagine que em uma toma temos um aquecedor necessita de 15 A, em outra tomada
uma torneira elétrica que necessita de 12 A e na outra tomada um micro-ondas que
necessita de 14 A. Se olharmos individualmente, nenhum desses equipamentos
ultrapassa os 20 A suportados pelas suas respectivas tomadas. Porém, a corrente
total gerada será de 41 A, superior à suportada pelo disjuntor. Então, toda vez que
os 3 equipamentos forem ligados juntos, uma sobrecarga será gerada no disjuntor
e o mesmo irá desarmar para evitar danos à rede. Já se tivéssemos uma tomada de
20 A e duas de 10 A, somente na primeira poderíamos ligar equipamentos de média
ou alta potência, pois nas de 10 A os plugs nem entram. Assim, mesmo que todas
trabalhassem na carga máxima suportada, ainda assim a soma das correntes seria
de 40 A, a mesma suportada pelo disjuntor. Assim, temos um melhor
dimensionamento no segmento.
2) Se o segmento B for de 110V, qual seria a potência máxima recomendada para

o ar-condicionado?
Primeiramente, devemos consultar a potência do ar-condicionado que desejamos,

pois, todos equipamentos eletroeletrônicos possuem essa informação. Para fins de
exemplo, vamos uma a tabela abaixo que estima a potência média comercial de
acordo com a potência de refrigeração (dada em BTU):
Pág.
Ar-condicionado 7.500 BTU  1000 W

Com a potência e a tensão, chegamos à corrente. Vamos calculá-la então com a

fórmula I = P / U. Com isso, descobriremos que o ar-condicionado escolhido deverá
ser de no máximo 12000 BTU, pois os demais ultrapassam a corrente de 20 A
suportada pelo disjuntos que projete o segmento B.
Corrente do Ar-condicionado de 7500 BTU = 1000 / 110 = 9,1 A

3) Se o segmento C for de 110 V e o chuveiro tiver potência de 3200 W,

poderemos ligar outro equipamento eletroeletrônico na tomada do segmento?
Sim, mas desde que ele nunca seja ligado enquanto o chuveiro está sendo utilizado!
Pela mesma lógica do exemplo do ar-condicionado, a corrente do chuveiro seria de
3200 / 110 = 29,1 A. Assim, o chuveiro em potência máxima consome quase o limite
de corrente suportada pelo disjuntor. Se quisermos ligar um secador de cabelo de
250 W, o mesmo irá necessitar de 250 / 110 = 2,3 A. Então, com os dois ligados, a
corrente no segmento chegará à 32,2 A e o disjuntor desarmará.
4) Podemos resolver esse problema aumentando o disjuntor para 60 A?
NÃO! A proteção dos disjuntores está justamente no fato de eles limitarem a corrente
em um segmento. Uma das coisas mais perigosas que se pode fazer (e acredite, é
mais comum do que se imagina) é, incomodado por um disjuntor que desarma toda
hora, alguém substituí-lo por outro de maior capacidade. Isso permitirá correntes
muito altas que podem incendiar os fios do segmento sem que o disjuntor desarme.
Muitas vezes, o disjuntor é dimensionado justamente pensando na máxima corrente
que os fios utilizados no segmento suportam.
Pág.
5) Como dimensionar um disjuntor com base na seção transversal dos fios
utilizados no segmento?
Simples! Basta consultar a mesma tabela apresentada quando falamos em corrente

máxima suportada por cada seção transversal de fio no dimensionamento de
tomadas. Se o segmento utiliza fios de 4mm, então o disjuntor do segmento deve
ser de no máximo 28 A (preferencialmente um pouco menos para que eles não
trabalhem no limite).
6) Se quisermos instalar um chuveiro de 7500 W em uma rede 220 V, qual deverá

ser o disjuntor escolhido e o fio a ser utilizado no segmento?
Primeiramente vamos descobrir a corrente que o chuveiro necessita. I = 7500 / 220

= 34 A. Assim, um disjuntor de 40 A estaria adequado, com uma folga de 4 A para
situações de sobrecarga. Já o fio com seção transversal mais próximo de suportar
essa corrente é o de 6mm. Apesar de ser suficiente, cobrindo os 34 A necessários,
como o disjuntor permite a passagem de 40 A em situações de sobrecarga, se esta
situação acontecer, os fios derreterão antes do disjuntor desarmar. Então, por
segurança, o ideal seria utilizar um fio com maior seção transversal. O mais próximo
é o de 10mm que suporta 50 A. Mas isso não nos traria um problema em caso de
sobrecarga já que o fio deixaria passar 50 A? Não, pois se isso acontecer o disjuntor
irá desarmar ao atingir 40 A. Assim, temos um sistema bem dimensionado, com
disjuntor suportando corrente próxima a do chuveiro (e com uma margem de
segurança) e com um fio que não será danificado em caso de sobrecarga antes do
disjuntor desarmar.
Pág.
UNIDADE 3 – INTRODUÇÃO AO ARDUINO
5 ARDUINO – ASPECTOS INICIAIS
O Arduino é a placa de prototipagem mais conhecida do

mundo, sendo uma das primeiras a levar ao extremo o
conceito de simplificar e popularizar a eletrônica. Foi
criada em 2005 na Itália por 5 pesquisadores: Massimo
Banzi, David Cuartilles, Tom Igoe, David Mellis e Gianluca
Martino. Seus principais objetivos era ser barata,
funcional, simples de programar e simples de conectar a outros dispositivos, como
sensores e atuadores. Para isso, utilizaram um microcontrolador Atmel, muito popular na
época por possuir portas analógicas e digitais, portas de tensão, portas de comunicação e
uma série de outras portas especiais, porém extremamente difícil de programar com as
plataformas comumente utilizadas (como linguagem Basic ou mesmo Assembly). Então se
apresentavam dois problemas a serem resolvidos: facilitar o acesso às portas (geralmente
era necessário soldar fios e componentes diretamente nas portas do microcontrolador ou
criar uma placa de circuito) e facilitar a programação e o envio do programa ao chip.
Aproveitando-se de uma IDE desenvolvida por um colega de Massimo (Casey Reis), o
Processing (que tornava muito fácil a criação de descrições visuais e com uma linguagem
de alto nível muito simples de aprender), foi desenvolvido o Wiring. Hernando Barragán,
desenvolvedor do Processing, trabalhou ativamente com o time do Arduino para modificar
a sua linguagem e dar origem a uma interface simples, amigável e poderosa. A mesma era
capaz de trabalhar com C e C++ (as linguagens mais populares e utilizadas no mundo até
hoje) e ao mesmo tempo com bibliotecas especialmente desenvolvidas para oferecer
métodos simples de acesso às funcionalidades do microchip Atmel. Após algumas
melhorias e ajustes (como a incorporação de uma interface USB com a placa para o fácil
upload dos programas), nascia em 2005 a primeira das muitas placas Arduino.
5.1 Principais tipos de Arduino
A popularização do Arduino fez com que a placa tivesse uma série de variantes
diferentes, com características diferentes que tornassem o uso de uma ou de outra mais
adequado a diferentes tipos de projetos. Essa flexibilidade foi um dos motivos que ajudo
ainda mais na popularização da plataforma e na sua incorporação em massa em projetos
tanto acadêmicos, quanto do mundo Maker.
Pág.
5.1.1 Arduino Uno

O primeiro Arduino comercial e, sem dúvida alguma, o mais popular. O Arduino Uno alia
a simplicidade de uso com um dimensionamento que o torna adequado à maioria dos
projetos, sendo, ao mesmo tempo, um dos mais baratos e
acessíveis de toda a família. Utiliza um microcontrolador
Atmega328 possuindo 14 portas digitais (sendo 6 delas PWM) e
6 portas analógicas, além de contar com portas de comunicação
I2C (SDA e SLC) e outras portas especiais. A alimentação
recomendável via USB é 5 V e via entrada de energia entre 7 V
e 12 V (sendo suas saídas de 5 V).
5.1.2 Arduino Mega

Desenvolvido para grandes projetos que necessitem da conexão de um grande número de
sensores e atuadores. Oferece, entre todos os Arduinos, o maior número de portas
analógicas e digitais. Utiliza um microcontrolador Atmega2560
e possui 54 portas digitais (sendo 15 delas PWM) e 16 portas
analógicas, além de contar com portas de comunicação I2C
(SDA e SLC) e outras portas especiais. A alimentação é idêntica
ao Arduino Uno com saídas também de 5 V. Outra diferença é
a grande memória interna em comparação com o modelo
anterior (256 KB contra 32 KB).
5.1.3 Arduino Nano

De um Arduino gigante, vamos diretamente para um Arduino compacto. O Arduino Nano
foi uma das primeiras tentativas de desenvolver uma placa que primasse pelas pequenas
dimensões, de modo a ser utilizada em projetos que necessitassem acomodar a própria
placa e o circuito eletrônico do entorno, em um encapsulamento
relativamente pequeno (inclusive, conectado diretamente em
uma protoboard, facilitando ainda mais o uso). Podemos dizer
que ele é uma versão em miniatura do Arduino Uno pois utiliza
o mesmo microcontrolador e possui as mesmas características
Pág.
dele, com exceção da conexão USB do tipo micro para acompanhar o seu tamanho enxuto.
5.1.4 Arduino Pro Mini

Ainda dentro das placas enxutas, o Arduino Pro Mini foi desenvolvido para ser o menor da
família e o mais adequado para projetos compactos e que necessitem de um número de
portas não superior ao suportado pelo Nano (e consequentemente pelo Uno). Porém esta
redução de tamanho cobrou um preço: ele perdeu sua porta de comunicação USB e o seu
bootloader, sendo necessário conectá-lo através dos pinos RX e TX a outro Arduino para
permitir o upload do código na placa. Outra perda foi da porta
de alimentação, necessitando-se soldar o negativo da fonte a
um dos seus GND e o positivo à sua porta Vin. Utiliza
microcontrolador Atmega168 e possui uma versão com saídas
de 5 V e outra versão com saídas de 3,3 V.
5.1.5 Arduino LilyPad

O mais fino e um dos mais diferentes Arduinos, o LilyPad foi especialmente desenvolvido
para o desenvolvimento de projetos para wearables (vestíveis), permitindo a sua fácil
incorporação sem fazer volume, de modo a ser facilmente escondido. Em formato circular,
a disposição dos seus pinos visa facilitar as saídas em todas as direções, utilizando como
substituto aos fios, uma linha especial composta por finíssimos fios de cobre, muito
flexível, resistente e fina o suficiente para ser costurada à placa e à roupa. Utiliza
microcontrolador Atmega328P, contando com 14 portas digitais (6 deles PWM) e 6 portas
analógicas, operando com uma alimentação entre 2,7 V e 5,5 V
(e saídas 3,3 V), possuindo ainda um pino especial para a
ligação de baterias de Íon-Lítio para sua alimentação. Também
não conta com interface USB (sendo necessária sua ligação à
outra placa ou a uma interface FTDI para upload do seu código).
5.1.6 Arduino Leonardo

O primeiro Arduino a utilizar o microcontrolador ATmega32u4, que dá a ele uma
característica especial: pode ser reconhecido pelo dispositivo ao qual está conectado via
USB como um mouse, teclado ou joystick. Isto permite que a placa envie sequências
Pág.
binárias interpretadas como caracteres, como comandos ou como
ordens de movimentação do ponteiro do mouse, o que, na prática,
possibilita o controle do dispositivo ao qual está conectado.
Imagine o Leonardo ligado em um Windows que necessitamos
enviar um sinal de desligamento quando determinada situação
ocorrer, ou escrever diretamente em um documento do Word, ou
então controlar o mouse permitindo realizar interações com a
interface. As possibilidades são expandidas com o uso do chip ATmega32uA. Quanto a
portas, alimentação e saídas, ele se equipara ao Arduino Uno.
5.1.7 Arduino Due

Esta é a primeira placa da família Arduino a ser equipada com um microcontrolador ARM
(no caso, um ARM Cortex-M3), sendo, até o momento, o mais rápido e com maior poder de
processamento pelo seu chip de 32 bits. Isso o torna especialmente útil em projetos onde
necessitamos de rapidez, processamento poderoso e tomada de decisões rápidas. Além
disso, em tamanho, se equipara a um Arduino Mega,
possuindo 54 postas digitais (12 delas PWM), 12 portas
analógicas, 4 portas seriais adicionais, além de 2 portas 2TWI
que são compatíveis com o padrão de comunicação I2C
porém com mais recursos. Apesar de tensões típicas de
entrada da maioria dos Arduinos maiores (7 V à 12 V), suas
saídas são de 3,3 V.
5.1.8 Arduino Esplora

Este Arduino foi desenvolvido para agradar os entusiastas do movimento maker, amantes
de games e pessoas que necessitam do desenvolvimento de interfaces de controle (de
hardware ou software) usando o Arduino. Esta placa foi pensada para possuir integrados
ao seu encapsulamento, componentes de controle, como por exemplo um joystick
analógico, acelerômetro para captura de movimentos, push buttons, botões de ajuste,
conectores, além de led RGB, buzzer e motor de
vibração. Também possui uma interface de conexão que
permite a fácil associação de displays coloridos. Assim,
este Arduino torna-se um controle completo. Utilizando
microcontrolador ATmega32u4, pode ser reconhecido
Pág.
facilmente como um dispositivo USB e simular para o sistema operacional ao qual está
conectado, ser um joystick, um teclado ou um mouse.
5.1.9 Arduino Romeo

Ainda nos Arduinos de uso mais específico, o Arduino Romeo foi especialmente projetado
para o desenvolvimento de robôs e projetos de automação com atuadores mecânicos. O
microcontrolador ATmega32u4 (que permite a integração com dispositivos externos via
USB e realizar controles no mesmo) é montado em um encapsulamento que oferece uma
placa com até 4 controladores lógicos para motores de passo ou servo motores, 3 pontes
H para inversão polarizada em motores DC, conexão para
módulo de comunicação via bluetooth ou rádio FM, entre
outros. Conta com 20 portas digitais (sendo 7 delas PWM), 12
portas analógicas e algumas portas especiais para facilitar
tarefas de automação. Além disso, suporta tensões de entrada
de até 20 V com saídas de 5 V.
5.1.10 Tabela comparativa de especificações técnicas

Contamos hoje com mais de 20 modelos de Arduino diferentes, cada um com suas
peculiaridades e especificidades que os tornam mais adequados a diferentes situações.
Para servir com um guia rápido, apresentamos uma tabela comparativa entre os modelos.
Pág.
5.2 Portas do Arduino
Como visto até aqui, os Arduinos possuem uma série de portas diferentes, cada uma
dedicada a um determinado fim e em números diferentes. Ao planejar um projeto, conhecer
essas portas é fundamental para dimensionar nosso circuito, verificar a oferta das portas
necessárias e, principalmente, saber fazer o melhor uso possível de cada uma. Nesta
disciplina, utilizaremos o Arduino Uno R3 e por isso analisar a sua pinagem (Pinout) é
fundamental. Então, vamos analisar o esquemático abaixo e a partir dele falar um pouco
sobre as principais portas.
5.2.1 Portas Digitais

As portas digitais do Arduino, como o próprio nome demonstra, trabalham com sinal
digital, tanto para leitura quanto para escrita. Resumidamente, elas têm a capacidade de
trabalhar com uso do sistema binário, onde um bit 0 é a porta não energizada e o bit 1 é
a porta energizada (no caso do Arduino Uno, com uma tensão aproximada de 5 V). No caso
da porta atuando como uma entrada (recebendo sinais de sensores e outros dispositivos),
Pág.
de tempos em tempos é realizada uma leitura dessa tensão e a presença ou ausência da
mesma é convertida em um conjunto de 0 e 1. De forma análoga, o mesmo ocorre quando
as portas digitais funcionam com portas de saída, escrevendo na porta 0 ou 1 (ou seja,
sem tensão ou com tensão) de tempos em tempos. Estas portas são indicadas para
trabalhar com sensores e atuadores que também utilizem sinal digital, mas também como
portas de controle, ligando e desligando dispositivos externos (seja um led, seja um relé).
Na leitura de dados (de um sensor, por exemplo) é possível receber diretamente o valor
exato da grandeza medida de forma binária.
5.2.2 Portas PWM

As portas PWM (Pulse Width Modulation) são portas digitais especiais com a
capacidade de transformar sinais digitais em modularizações de sinal que permitam, na
prática, regular a saída modificando a sua tensão (e consequentemente a sua corrente).
Imaginando um led ligado a uma porta digital normal, o máximo que podermos fazer com
ele é liga-lo ou desligá-lo. Porém, se essa porta digital for uma PWM, podemos regular a
sua saída e, deste modo, alterar a luminosidade do led, fazendo que o mesmo brilhe mais
forte ou mais fraco.
5.2.3 Portas analógicas

Diferentemente das portas digitais, as portas analógicas trabalham com sinais que
podem variar entre 0 e 5 V, assumindo diversos valores diferentes. Assim, um sensor
analógico é especialmente desenvolvido para, ao medir a grandeza ou o fenômeno desejado,
variar a tensão emitida. Por exemplo, um sensor de temperatura analógico que mede
temperaturas entre 0 e 100 graus celsius, é construído para ao medir 0ºC (o primeiro valor
possível) gerar uma tensão de 0 V e ao medir uma temperatura de 100ºC (o último valor
possível) gerar uma tensão de 5 V. Qualquer temperatura acima de 0ºC e abaixo de 100°C,
irá gerar uma tensão diferente (acima de 0 V e abaixo de 5 V). Estes sensores são
geralmente mais baratos e rápidos que os digitais (por não necessitam de conversões
binárias para devolver o valor final pronto) mas, por isso mesmo, têm uma maior
dificuldade no uso, já que sempre necessitamos fazer um mapeamento entre a tensão
medida e o quanto ela representa dentro da grandeza medida.
Pág.
5.2.4 Portas de alimentação

O Arduino Uno pode ser alimentado de 3 formas diferentes: pela sua porta USB
(com uma entrada de 5V), pelo seu conector de alimentação (permitindo carregadores ou
pilhas com uma tensão recomendada entre 7V e 12V) e pela sua porta Vin (soldando uma
fonte ou bateria com entrada também entre 7V e 12V). Alimentada a placa, ela garante
uma saída de 5V nas suas portas digitais e de até 5 V nas suas portas analógicas. Porém,
para isso, teríamos que configurar as portas (via código) como portas de saída e escrever
na sua saída que estão em estado alto (como se fosse um estado “ligado”). Para simplificar
então a alimentação de sensores, atuadores e outros dispositivos externos, o Arduino Uno
oferece algumas portas com tensão fixa e que estão sempre ativas: uma com tensão de 5V,
outra com tensão de 3.3V. Além disso, o Vin, caso não utilizado para alimentar o Arduino,
entregará uma tensão igual à tensão de alimentação da placa (se o Arduino está alimentado
por uma fonte de 12V no seu conector, o Vin oferecerá uma tensão de saída fixa também
de 12V, por exemplo). Além disso, temos 2 portas GND que são o terra (negativo).
5.2.5 Porta Reset

A porta reset serve para, quando acionada, resetar a nossa placa, apagando o código
carregado nela pelo bootloader e, com isso, interromper qualquer execução que estiver
ocorrendo no momento. Podemos também fazer isso simplesmente pressionando o botão
reset presente na placa (que está ligado à mesma porta). Mas é interessante esse
acionamento programaticamente para situações extremas. Por exemplo, imagine que
detectamos um comportamento inesperado de nosso sistema ou na execução de nosso
código que pode trazer riscos à segurança do usuário. Então caso, não consigamos parar
essa execução de outra forma (em um loop travado, por exemplo), resetamos a placa e
forçamos a interrupção de qualquer execução.
5.2.6 Porta RX e TX
Os pinos digitais 0 e 1 do Arduino Uno, são dedicados às portas RX e TX. Elas são
portas de comunicação serial direta, capazes de enviar comandos e informações (TX =
Transmiter) ou de receber comandos e informações (RX = Receiver) que são interpretadas
pela placa. Isso permite desde a programação do Arduino por outro Arduino (como o Pro
Micro ou o LilyPad que não possuem entrada USB para carregar os códigos através do
Pág.
bootloader), de um sensor ou atuador pelo Arduino (configurar os parâmetros de uma rede
WiFi em um módulo ESP8266) ou mesmo para que Arduinos possam trocar informações
durante o funcionamento (mensagens, valores de variáveis, medições, etc).
5.2.7 Portas de Interrupção

Os pinos digitais 2 e 3 do Arduino Uno, são dedicados às portas de interrupção.
Como o Arduino utilizada microcontroladores com apenas um núcleo, temos um
monoprocessamento. Isso na prática fará com que quando entrarmos um uma tarefa muito
pesada (um laço que executa várias vezes, um método que demora muito para ser
executado), enquanto essa tarefa não terminar, ficamos “travados” na linha de código.
Agora imagine um sistema crítico que realiza tarefas pesadas mas, caso um sensor detecte
uma situação de perigo, seja necessário interromper a execução. Se este sensor estiver
ligado a uma das portas de interrupção, ele poderá ser lido em paralelo, de forma
independente, mesmo que uma tarefa pesada esteja sendo realizada e a execução de nosso
código esteja parada. Assim, conseguimos implementar uma camada de segurança ao
nosso sistema.
5.2.8 Portas I2C (SDA e SCL)

Os pinos analógicos A4 e A5 do Arduino Uno, são dedicados às portas SDA (Serial
Data) e SCL (Serial Clock), utilizadas para permitir o uso do protocolo de comunicação I2C.
O I2C (Inter-Integrated Circuit), é na verdade uma comunicação serial, porém com uma
característica muito interessante: trabalha com endereçamento. Isso permite que
possamos ligar quantos sensores e atuadores I2C quisermos na mesma porta, pois na hora
de ler um valor ou enviar um valor, o endereço deles (que deve ser único) será utilizado
para auxiliar no direcionamento dos pacotes.
5.2.9 Portas SPI

De forma análoga ao I2C, as portas SPI (Serial Peripheral Interface) são uma
comunicação serial com endereçamento mas para a ligação entre placas ou entre a placa
e periféricos externos. No Arduino Uno, são implementadas nas portas digitais 10, 11, 12
e 13.
Pág.
5.2.10 Portas AVR

As portas AVR nada mais são do que as portas que podem ser controladas via
programação no Arduino. Incluem todas as portas digitais, todas as portas analógicas,
além da porta reset.
5.3 Programando com a Arduino IDE
Como já dito, um dos motivos da popularização do Arduino é a sua facilidade de ser

programado, seja pela linguagem amigável baseada em C/C++ (e com diversas bibliotecas
para fácil comunicação e controle de sensores e atuadores), seja pelo modo eficiente e
simples de se carregar o programa desenvolvido para a placa. Um dos grandes
responsáveis por isso é a Arduino IDE, nascida do projeto de adaptação do Processing e
integração com Wiring. Existem diversas IDEs que podem ser utilizadas para programar e
realizar upload dos códigos para a placa (como Visual Studio Code, Eclipse, Ardublock,
etc), mas a Arduino IDE sem dúvidas é a mais leve, limpa e simples. Neste disciplina, esta
será a nossa IDE padrão e é interessante conhecer algumas de suas características antes
de efetivamente começarmos a programar o Arduino.
5.3.1 Instalando e configurando o ambiente de trabalho

A Arduino IDE possui versões para Windows, Linux e Mac, contando com
instaladores simples e diretos, sem necessidade de configurações adicionais. O primeiro
passo é acessar a página de Downloads, escolher a versão mais adequada ao nosso sistema
operacional e realizar o download: https://www.arduino.cc/en/software/
Pág.
Após o download, um duplo clique no arquivo inicia a instalação. Dependendo do

sistema operacional, uma mensagem diferente de confirmação é exibida, bastando clicar
em Sim ou Ok. Neste exemplo, estamos realizando a instalação no Windows.
A próxima janela aberta traz as informações da licença de uso. Após lê-la, caso aceite,
clique no botão “I Agree”. Posteriormente, na tela de seleção de componentes a serem
instalados, podemos deixar todos marcados, como já acontece por padrão, e clicar em Next.
A próxima tela permite personalizar o local de instalação. Caso queira alterar o local
padrão, clique em Browse. Para confirmar o local, clique em Next.
Pág.
Após a instalação concluída, será exibida a última janela, mostrando que a execução do
setup está completa. Basta então clicar em Close.
Para verificar se a instalação aconteceu de forma correta, localize o ícone do Arduino IDE
(ou pesquisa através das ferramentas de seu sistema operacional) e clique sobre ele.
TUDO CERTO! Agora finalmente temos a ferramenta necessária para iniciar a

programação das nossas placas Arduino.
Pág.
5.3.2 Configurações iniciais

Com a IDE instalada, três configurações são necessárias. Primeiramente, devemos
ligar a nossa placa ao computador através da porta USB. Ao fazer isso pela primeira vez,
o sistema operacional deve reconhecê-la como um novo periférico USB. O led ON (à direita
da palavra Uno) deve acender indicando que a placa está energizada e o led TX (à esquerda
da palavra Arduino) deve piscar indicando que o Arduino consegue enviar mensagens ao
PC existindo, portanto, comunicação entre os dois.
Com o Arduino já conectado, devemos informar à Arduino IDE qual o modelo da

placa, para que sejam realizadas configurações internas importantes para a interpretação
do código e o seu upload através do bootloader. Para isso, clique no menu Ferramentas e
após na opção Placa. Muito provavelmente, a IDE já percebeu se tratar de nosso Arduino
(no caso, o Uno) e sugeriu esse modelo de placa. Mas caso o modelo esteja configurado
diferentemente disso, podemos ajustar clicando na opção correta.
Pág.
A segunda configuração inicial necessária é informar à qual porta COM do PC nosso

Arduino está conectado. Para isso, basta clicar no menu Ferramentas e ir até a opção
Porta. Aparecerão todas as portas COM que naquele momento estão em funcionamento.
Se o Arduino foi reconhecido e o melhor driver foi instalado para ele pelo sistema
operacional, a identificação será fácil pois o modelo estará indicado ao lado da porta. Caso
o sistema operacional tenha instalado apenas o driver USB padrão, o uso da placa ainda
acontecerá sem problemas, porém o modelo não será indicado ao lado da COM. A
alternativa é ver todas as COM apresentadas, remover o Arduino e verificar novamente as
COM que sobraram. Aquela que sumiu é então a COM à qual a placa estava conectada.
A terceira e última configuração inicial é dizer à nossa IDE a pasta base utilizada
para o salvamento de nossos projetos. No Windows, por padrão, é criada uma pasta
Arduino dentro da pasta Documentos do usuário. Para alterar, basta clicar no menu
Arquivo e após na opção Preferências. Na janela aberta, podemos então alterar o caminho.
Pág.
5.3.3 Testando a compilação, o upload e a execução do código

Para termos certeza que tudo está funcionando corretamente, vamos criar um
pequeno código, compilá-lo, enviá-lo para a placa e verificar a sua execução. Não cabe aqui
explicar de forma detalhada este código (pois isso será feito no próximo capítulo) e o
importante neste momento é entender o processo. Então, com o Arduino IDE aberto, digite
as seguintes linhas dentro do método setup e dentro do método loop:
Com nosso código pronto, precisamos agora salvar o projeto. Para isso, devemos
clicar no menu Arquivo e após na opção Salvar (ou utilizar o atalho Ctrl + S). Podemos
então dar um nome ao nosso projeto (neste exemplo, TesteArduino) e selecionar um local
para o salvamento (sendo que o diretório padrão configurado anteriormente será indicado).
Pág.
Com o projeto salvo, chega a hora de realizarmos a compilação e vermos se existe

algum erro em nosso código. Para isso, basta clicar no botão Verificar, o primeiro à
esquerda (logo abaixo do menu). Durante a verificação, aparecerá na área de mensagens
(abaixo) a indicação que o Sketch (rascunho) está sendo compilado, juntamente com uma
barra de progresso. Quando a compilação terminar, a indicação de compilação terminada
será acompanhada de mensagens informativas sobre o tamanho do Sketch e o quando o
mesmo ocupará da memória disponível na placa.
Caso algum erro for encontrado no código durante a compilação (para conseguir dar
um exemplo, removemos propositalmente o ponto e vírgula do final do comando da
penúltima linha) a barra inferior se tornará laranja e dentro da área escura o erro
encontrado será indicado.
Pág.
Consertados eventuais erros identificados e compilado com sucesso o código, é hora

de realizar o seu upload para a memória da placa, através do seu bootloader. Este processo
também é extremamente simples: basta clicar no segundo botão à esquerda (Carregar, que
possui uma seta) e o código será novamente compilado e enviado para a placa. Quando
isso ocorrer, repare que o led RX do Arduino piscará algumas vezes, indicando que a placa
recebeu algo de fora (no caso, de nosso PC). Quando o upload estiver concluído, a IDE
mostrará na parte inferior uma mensagem indicando que o carregamento ocorreu com
sucesso. Se alguma falha ocorrer (a placa não estiver conectada por exemplo), a IDE irá
apontar que o carregamento para o Arduino não teve sucesso.
Após o carregamento do código para a placa, o mesmo já está pronto para começar
a ser executado pelo Arduino. Não importa se a alimentação se der via USB (como está
acontecendo), via conector de energia ou via pino Vin (utilizando fontes externas nestes
dois últimos casos): enquanto estiver em funcionamento, a placa está rodando o último
código carregado nela. E o interessante é que como essa memória que recebe o programa
não é uma memória volátil, não importa se o Arduino for desligado por dias. Ao voltar a
ser ligado, o código volta a ser executado pois está gravado dentro da placa.
Vamos testar então se esta execução está ocorrendo com sucesso. O comando
Serial.println utilizado no exemplo, faz com que o Arduino envie via Serial (para quem
estiver conectado através da USB a ele, neste caso, nosso PC), a mensagem “Testando
arduino”, em um loop que se repete a cada 1 segundo. A Arduino IDE possui uma
ferramenta que permite monitorar tudo que é recebido e enviado através da porta COM
(Serial). Então, através dela, se o código está sendo executado corretamente e mensagem
está sendo enviada com sucesso, conseguiremos visualizá-la. Esta ferramenta se chama
Pág.
Monitor Serial e é acessada através do menu Ferramentas. Então, com o Arduino ainda
ligado ao PC e já com o programa carregado para a sua memória, abra o monitor serial e
verifique se a velocidade (frequência) de funcionamento que ele está utilizando é a mesma
com a qual configuramos o envio Serial da placa no código (no nosso caso, 9600, que é a
velocidade padrão). Deste modo, a mensagem deverá ser visualizada e perceberemos que
a cada 1 segundo ela é enviada novamente.
Caso queiramos apagar o código que está na memória da placa, interrompendo

definitivamente a execução, basta clicar e segurar por 3 segundos o botão Reset (ao lado
da entrada do cabo USB da placa). O led L (ao lado do led TX) irá piscar algumas vezes
confirmando que a memória foi limpa e que não existe mais código sendo executado pelo
Arduino.
Com estes passos concluídos temos certeza que a

IDE está bem instalada, o Arduino foi reconhecido pela
Serial, existe comunicação com o PC, o upload está
acontecendo com sucesso através do bootloader e a
placa está funcionando corretamente e executando o
código carregado em sua memória interna. Podemos
então, efetivamente, começar a trabalhar com o Arduino.
Pág.
5.4 Iniciando com a programação Arduino
Um projeto simples e interessante para começarmos a programação com o Arduino,

é realizar o controle, via programação, de leds conectados em suas portas digitais.
Relembrando, as portas digitais do Arduino podem funcionar como entrada (para ler
informações externas através de sensores) ou saída. Quando funcionam como saída,
podem se comportar como portas digitais convencionais, fornecendo 0V de tensão
(equivalente ao bit 0) ou 5V de tensão (equivalente ao bit 1), ou então modulando o sinal
de saída digital de modo que seja consumido como uma tensão variável e que podemos
ajustar (caso das portas PWM). Faremos 2 exemplos partindo desses princípios: o primeiro
apenas controlando a sequencia e tempo de acendimento dos leds e o segundo controlando
a sua luminosidade através de uma porta PWM. Mas antes, necessitamos conhecer alguns
conceitos iniciais.
5.4.1 Configurando as portas digitais como entrada ou saída

A configuração de portas digitais como entrada ou saída é simples e realizada
através de um método que recebe apenas dois parâmetros. Ele dirá se ela lê dados, envia
dados ou é uma porta especial com uso de um resistor de pullup interno. Não cabe o
aprofundamento sobre pullup, mas nos basta saber que esse tipo de configuração com
resistor é utilizada quando queremos ler um estado alto ou baixo (0 ou 1) eliminando
pequenas flutuações que podem ser interpretadas de forma errada. Isso é especialmente
útil quando usamos botões ou chaves interruptoras que ao serem totalmente pressionados
ou totalmente soltos, passam por estados intermediários que não desejamos detectar. Para
essa configuração, utilizamos o método abaixo:
pinMode( <porta>, <modo> );
<porta>
número da porta que queremos definir o modo
<modo>
modo de funcionamento da porta, que pode receber os
valores. Pode receber os valores:
- INPUT: porta funciona como entrada (leitura)

- OUTPUT: porta funciona como saída (controle)
- INPUT_PULLUP: funciona com porta com pullup (botões)
Pág.
5.4.2 Escrevendo o estado de saída da porta digital convencional

Quando uma porta digital está configurada como porta de saída (OUTPUT), podemos
escrever o seu estado, fazendo com que a mesma ligue (estado alto, com tensão de 5V) ou
desligue (estado baixo, com tensão de 0V). Para isso, utilizamos o método abaixo:
digitalWrite( <porta>, <estado> );
<porta>
número da porta que queremos definir o estado de saída
<estado>
Estado lógico da porta. Pode receber os valores:
- LOW: estado baixo (0V, desligada)

- HIGH: estado alto (5V, ligada)
5.4.3 Escrevendo o estado de saída da porta digital PWM

As portas PWM, assim como as portas digitais convencionais, também só
conseguem trabalhar com dois estados e, consequentemente, com tensões absolutas de
0V ou de 5V. Porém, enquanto nas portas digitais convencionais o estado de saída
permanece constante após sua escrita, nas portas PWM a tensão é gerada em forma de
onda que possui uma determinada frequência,
alternando entre os dois estados um determinado
número de vezes por segundo. Alterar a frequência
da alternância entre os dois estados, acaba criando
uma tensão média na saída, mais próxima de 0V se
o espaçamento for muito alto ou mais próxima de
5V se o espaçamento for muito curto, perto de uma
onda linear. Chamamos isso de Duty Cycle. Vamos
a um exemplo, conforme a figura ao lado: perceba que quando o Duty Cycle é de 100%, o
tempo em que a tensão permanece em 5V é de 100% e, portanto, a tensão de saída é muito
próxima a 5V. Já quando o Duty Cycle está com 20%, isso significa que em somente 20%
do tempo a tensão está em 5V (estando nos outros 80% em 0V) e isso faz com que a tensão
média da saída seja 20% dos 5V (no caso, 1V). Se o Duty Cycle fosse de 50%, durante
apenas metade do tempo a tensão estaria em 5V, gerando então uma tensão de saída de
metade dos 5V (no caso, 2,5V). O Arduino permite então em suas portas PWM, que o valor
de Duty Cycle seja alterado, alterando a tensão média de saída da porta gerada pela
Pág.
modulação dos estados, porém ao invés de trabalhar com percentuais, a placa trabalha
com níveis que podem ir de 0 (equivalente a 0V) até 255 (valor máximo, equivalente à 5V).
Qualquer valor intermediário entre 0 e 255 gera então uma tensão de saída entre 0V e 5V.
Para isso, utilizamos o seguinte método:
analogWrite( <porta>, <valor_pwm> );
<porta>
número da porta que queremos definir o estado de saída
<valor_pwm>
valor da modulação PWM entre 0 e 255 que irá gerar uma
tensão média de saída entre 0V e 5V
5.4.4 Criando paradas temporizadas

Durante a execução do código, muitas vezes após modificar o estado de uma porta,
ler o valor de um led e enviar uma ordem para um atuador, é necessária uma parada
temporizada que garanta que aquele estado se mantenha por um determinado tempo
mínimo e que a próxima ação só seja disparada após decorrido esse tempo. Para isso,
temos no Arduino alguns comandos que criam estas paradas com um tempo definido.
Veremos nesse momento o mais simples e utilizado deles, sendo que os demais serão
aprofundados e só farão sentido quando falarmos das interrupções de sistema. Então, para
criar uma parada temporizada no sistema, utilizamos o seguinte método:
delay( <tempo> );
<tempo>
tempo de parada, informado em milissegundos (ou seja, cada
1000 equivale a 1 segundo)
5.4.5 Escrevendo nosso código e entendendo o setup e o loop

Ao criarmos um novo projeto na Arduino IDE, percebemos que um pequeno trecho
de código automaticamente já é preenchido. Nele, existem dois métodos já prontos para
podermos utilizar: o setup e o loop. Estes são métodos estruturais do Arduino, previamente
programados com finalidades especiais e que controlam a execução dos comandos internos
aos seus blocos, em momentos determinados.
Pág.
setup: o método setup é o primeiro a ser

executado quando a placa Arduino é
energizada (ligada) e enquanto todos os
comandos escritos dentro do seu bloco não
forem executados, garantidamente nada
mais é executado. Isso é especialmente
pensado para reunirmos em um único
ponto os comandos que configuram,
inicializam e preparam a placa para a
execução do programa principal, trazendo
maior segurança, estabilidade e confiabilidade. Geralmente é aqui que inicializamos os
componentes que precisam ser previamente configurados ou ajustados, definimos os
valores de inicialização de nossas variáveis, iniciamos nossas portas do tipo Serial, etc.
loop: o método loop é o principal do Arduino e o responsável pela execução do nosso código
de forma contínua. Trata-se de um laço de repetição infinito que lê cada uma das linhas
de comando do seu bloco, de forma sequencial e, ao chegar ao seu final, volta para o início
e começa novamente a execução desde a primeira linha novamente. Assim, o Arduino não
utiliza o paradigma de orientação a eventos, onde temos listeners especializados (rotinas
que monitoram um estado ou comportamento) que disparam funções programadas. Aqui,
a cada loop, coletemos e verificamos dados para, com base neles, podermos tomar decisões
e/ou executar ações. Isso torna a programação muito mais natural, simples e amigável,
porém traz problemas para a execução de tarefas simultâneas, visto que cada comando
precisa esperar sua hora de ser executado. Geralmente o loop inicia ou termina com uma
interrupção temporizada, controlando assim, sua frequência de execução.
5.4.6 Exemplo 1: ligando e desligando leds

Neste primeiro exemplo, nosso objetivo é realizar o controle de 3 leds com o Arduino,
ligando-os e desligando-os em uma sequência pré-determinada e em um tempo pré-
determinado. Para isso, vamos ligar cada um dos 3 leds em portas digitais diferentes (no
nosso exemplo, nas portas 5, 6 e 7), que possam ter seu estado de saída alterado para alto,
garantindo uma tensão de 5V (através do seu pino indicado para isso, geralmente um pino
mais comprido ou com um joelho). O outro pino deverá ser ligado ao negativo (no Arduino,
à porta GND) para que a corrente que entra no led possa encontrar um caminho de saída
e retorno à sua fonte de tensão (a própria placa). Por segurança, como visto nas aulas
iniciais de conceitos de eletrônica, colocamos um resistor neste caminho (neste exemplo
Pág.
de 100), obrigando que a corrente passe por ele, reduzindo-a assim em todos os 3
segmentos, garantindo proteção para que o led não queime. Assim, a montagem do circuito
deverá ficar como a abaixo:
Toda vez que uma das portas tiver seu estado de saída alterado para alto, ela
fornecerá uma tensão de 5V que fará com que uma corrente atravesse o led (saindo pelo
GND) e o iluminando. Para isso, porém, necessitamos que antes as portas digitais sejam
configuradas como portas de saída e é justamente por aí que vamos começar a nossa
programação. Dentro do setup, duas coisas são necessárias: tornar as 3 portas digitais
portas de saída (através do método pinMode) e garantir que elas iniciam em estado baixo
(através do método digitalWrite). Então, teremos:
void setup(){
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
digitalWrite(5, LOW);
}
Agora, dentro do loop, podemos alternar as portas entre os estados alto e baixo (com o
método digitalWrite) e, assim, acender e apagar os leds. A criação de sequências diferentes
consequentemente implica em diferentes padrões de comportamento para o acendimento
dos leds. Deste modo, podemos utilizar a programação para gerar efeitos de movimento e
sequência. Vamos ver três entre as infinitas possibilidades e o efeito do código no padrão:
Pág.
Padrão 1: caso nosso código do loop seja igual a
void loop(){ este, o padrão de funcionamento dos leds será o
digitalWrite(5, HIGH); seguinte: o primeiro led (da porta 5) liga e após
delay(1000);
digitalWrite(5, LOW); um segundo, desliga. Após mais um segundo, o
delay(1000);
segundo led (da porta 6) liga e um segundo
digitalWrite(6, HIGH);
delay(1000); depois, desliga. Após mais um segundo, o terceiro
delay(1000); led (da porta 7) liga e um segundo depois, desliga.
digitalWrite(7, HIGH); Assim temos um acendimento sequencial e um
delay(1000);
digitalWrite(7, LOW); desligamento sequencial, led a led, da esquerda
delay(1000);
para a direita.
}

void loop(){ este, o padrão de funcionamento dos leds será o
digitalWrite(5, HIGH); seguinte: o primeiro led (da porta 5) liga, após um
delay(1000);
digitalWrite(6, HIGH); segundo o segundo led (da porta 6) também liga
delay(1000);
digitalWrite(7, HIGH); e após mais um segundo o terceiro led (da porta
delay(1000);
7) também liga. Após mais um segundo, todos os
digitalWrite(6, LOW); leds desligam ao mesmo tempo. Assim, temos um
delay(1000); acendimento sequencial, da esquerda para a
} direita, permanecendo todos os leds ligados até o

momento em que todos desligam juntos.

void loop(){
este, o padrão de funcionamento dos leds será o
digitalWrite(7, HIGH); seguinte: o terceiro led (da porta 7) liga, após um
delay(1000);
digitalWrite(6, HIGH); segundo o segundo led (da porta 6) também liga
delay(1000);
digitalWrite(5, HIGH); e após mais um segundo o primeiro led (da porta
delay(1000);
5) também liga. Após mais um segundo, o último
delay(1000); led a ser ligado (da porta 5) desligada, seguido do
delay(1000); penúltimo led a ser ligado (da porta 6) após mais
delay(1000); um segundo e finalmente seguidos do primeiro
} led a ser ligado (da porta 7). Assim, temos um

acendimento sequencial, da direita para a
esquerda, seguido de um desligamento sequencial, da esquerda para a direita.
Pág.
5.4.7 Exemplo 2: ligando o led e regulando a intensidade com PWM
Neste segundo exemplo, nosso objetivo é realizar o controle de apenas um led com
o Arduino, mas não somente o ligando e o desligando, mas controlando a sua luminosidade
através da modulação da tensão na saída (variando o Duty Cycle). Para isso, vamos ligar
o led (através do pino positivo) em uma porta digital PWM, indicadas com um sinal de til
(~) ao lado do número (no nosso exemplo, na porta 5). O outro pino deverá ser ligado ao
negativo (no Arduino, a porta GND) passando por um resistor (no nosso caso, de 100)
para baixar a corrente e evitar a sua queima. Assim, a montagem do circuito deverá ficar
como a abaixo:
Primeiramente, devemos configurar a porta 5 como uma porta de saída, afinal,

queremos através dela gerar uma tensão que alimentará o led. Também devemos garantir
que quando a placa for iniciada, seu estado inicial seja baixo. Não há diferença nos
métodos utilizados para isso, em relação ao exemplo anterior. Assim, em nosso setup,
teremos o seguinte código:
void setup(){
pinMode(5, OUTPUT);
Agora, dentro do loop, vamos fazer com que a cada 1 segundo a intensidade do led aumente
até que, ao atingir seu valor máximo, apague novamente. Para isso devemos utilizar o
método analogWrite e escrever na porta um valor entre 0 e 255. Quando mais perto de 0,
mais próximo de 0V. Quanto mais perto de 255, mais próximo de 5V. No exemplo, iremos
Pág.
aumentar essa intensidade variando o valor que controla o Duty Cycle de 50 em 50. Deste
modo, o led inicia apagado e a cada segundo aumenta um pouco a sua intensidade por
conta da maior tensão recebida e,
void loop(){
consequentemente, da maior corrente gerada
analogWrite(5, 50);
delay(1000); que o atravessa. Caso desejado, conseguimos
analogWrite(5, 100); calcular a tensão correspondente ao valor
delay(1000);
utilizado no analogWrite aplicando uma regra de
analogWrite(5, 150);
delay(1000); 3. Exemplo:
analogWrite(5, 200); Se 255 é igual a 5V, 50 é igual à quanto?

delay(1000);
analogWrite(5, 255); 255 = 5

delay(1000);
analogWrite(5, 0); 50 = x
delay(1000);
} Assim temos que: x = (5 . 50) / 255  1 V
De forma análoga, descobrimos que neste nosso exemplo, um valor de 100 no analogWrite
para controle do Duty Cycle, produz uma tensão de saída próxima à 2V, assim como um
valor de 150 produz uma tensão de saída próxima à 3V, um valor de 200 produz uma
tensão de saída próxima à 4V e um valor de 250 produz uma tensão de saída próxima à
5V. Lógico que caso a intensão seja descobrir esses valores posteriormente à construção
do circuito, o uso de um multímetro facilitaria e tornaria desnecessários os cálculos. Mas
quando pensamos no dimensionamento prévio, calcular estes mapeamentos é importante.
UNIDADE 4 - SENSORES
6 TRABALHANDO COM SENSORES
Os sensores são dispositivos que tem como função detectar

um determinado fenômeno e responder ao estímulo recebido.
Cada sensor é construído, então, com um propósito
específico e bem definido. Deste modo, para cada situação
que desejamos monitorar, devemos agregar um ou mais
sensores, conseguindo assim, obter as informações
desejadas do mundo externo. Nos últimos anos,
principalmente por conta das placas de prototipagem, mas
Pág.
também pela profusão de dispositivos eletroeletrônicos cada vez mais “inteligentes”,
surgiram diversos sensores de baixo custo e fácil uso. Queremos neste capítulo, trazer
uma coletânea dos principais sensores utilizados em conjunto com o Arduino (e em outras
placas similares em projetos Maker) e os códigos e técnicas utilizados para acessar suas
informações. Mas para isso, precisamos primeiramente entender como o Arduino lê as
informações dos mesmos.
Os sensores do Arduino podem ser de 2 tipos distintos: digitais e analógicos. A

diferença básica é que os sensores analógicos conseguem devolver ao Arduino qualquer
tensão entre 0V e 5V como resposta ao estímulo do fenômeno medido (e esse valor, como
veremos adiante, é mapeado para um número entre 0 e 1023) e os sensores digitais apenas
conseguem devolver ao Arduino ou 0V ou 5V (chamados de estado baixo e estado alto,
respectivamente). Assim, estes sensores digitais podem ser sensores de resposta binária
(aqueles que devolvem apenas duas respostas como sim ou não, detectado ou não
detectado, etc) ou sensores que utilizam combinações dos estados baixo e alto para o envio
de bits 0 ou 1 em uma sequência binária que após é mapeada em um valor. Abaixo, temos
um esquema que sintetiza então os modos de resposta destes sensores:
Os três sensores são de propósitos diferentes: o de cima é um sensor que informa a

detecção de chama, o do meio é um sensor que informa o valor RGB da cor detectada e o
de baixo é um sensor que mede a temperatura. Apesar de sujeitos ao mesmo estímulo
(uma mesma chama), cada um enviará ao Arduino um valor diferente, de uma forma
diferente e que representa uma informação diferente. O sensor de chama é um sensor de
resposta binária e ao detectar fogo envia ao Arduino 5V (equivalente ao estado alto, ou 1);
Pág.
já o sensor de cor RGB é um sensor de valor binário e alterna seus estados altos e baixos
para enviar ao Arduino, de modo binário, os valores de composição das 3 matizes que
compõe a cor (no caso 246 de vermelho, 165 de verde e 76 de azul, resultando em um tom
de laranja); finalmente o sensor de temperatura varia a sua tensão de acordo com a
temperatura medida e envia ao Arduino 2,3658 volts, que serão convertidos em um valor
entre 0 e 1023 (adiante entenderemos isso) que finalmente é mapeado para a temperatura
medida (no caso, 395ºC). Isso é importante para ilustrar que para podermos trabalhar
facilmente com sensores no Arduino, necessitamos entender não só como os diferentes
tipos de sensores enviam os dados gerados em resposta aos estímulos mas,
principalmente, como o Arduino deve lê-los e interpretá-los.
6.1 Leitura de sensores digitais de resposta binária
Para a leitura de sensores digitais de resposta binária, utilizamos o método

digitalRead, informando sua porta e tendo como resposta um estado baixo (0 / LOW) ou
um estado alto (1 / HIGH). Alguns exemplos deste tipo são o sensor PIR (objeto próximo
detectado ou não detectado), o sensor de vibração (vibração detectada ou não detectada) e
o push button (botão pressionado ou não pressionado).
digitalRead( <porta> );
<porta>
porta à qual o sensor de resposta binário está ligado
resposta:
a resposta do método será o estado LOW (0) ou HIGH (1)
6.1.1 Sensor de proximidade PIR: Exemplo detalhado

O sensor PIR é um sensor que altera o seu estado para HIGH quando detecta algum
movimento em seu raio de ação. Imagine então que queremos que um sensor de presença
do tipo PIR, ao detectar um objeto em movimento próximo a si, ligue um led como
indicativo. Os sensores digitais de resposta binária geralmente possuem 3 pinos: GND,
VCC (ou ++ ou 5V) e um pino de envio de sinal, que deve ser conectado em uma porta
digital qualquer. No caso do PIR, o pino 1 é este pino de sinal (por onde ele nos dará a
resposta binária da sua detecção, no caso, estado baixo se não detectar nada ou estado
alto caso detectar), enquanto o pino 2 (central) é o 5V e o pino 3 é o GND. Em nosso
Pág.
exemplo, o pino de sinal será ligado na porta 6, enquanto o positivo do led será ligado à
porta 5 (com seu o negativo em série com um resistor de 250). Deste modo, temos um
circuito como o esquematizado a seguir:
Com a ligação eletrônica concluída, devemos programar o Arduino para que quando
o PIR detectar movimento em seu entorno, o led indicativo ser aceso. Previamente, devemos
informar que a porta de sinal do PIR (6) é uma porta de entrada (INPUT), enquanto a porta
do led (5) é uma porta de saída (OUTPUT). Já no loop realizamos a leitura digital da porta
de sinal para detectar se o mesmo está baixo (neste caso desligamos o led) ou alto (neste
caso, ligamos o led). Assim, nosso código será como o apresentado a seguir:
void setup(){
pinMode(5, OUTPUT);
pinMode(6, INPUT);
}
void loop(){
delay(1000);
if(digitalRead(6) == HIGH) {
} else {
}
}
Importante novamente ressaltar, que todos os sensores de resposta binária, utilizam

exatamente a mesma lógica. Então se o PIR fosse substituído por um sensor de chama, ou
um sensor de som, ou qualquer outro do mesmo tipo, mantida a porta 6 no pino de sinal,
Pág.
o código para a leitura do estado seria exatamente o mesmo, sem qualquer mudança.
Então, vamos conhecer alguns dos principais sensores desta categoria.
6.1.2 Sensor de som

Este sensor nos informa quando um som em uma determinada altura é
detectado e quando isso ocorre, modifica o seu estado para HIGH. A sua
sensibilidade pode ser ajustada por meio de um trimpot presente em seu
corpo e com isso podemos definir a altura mínima para que a detecção
possa ocorrer (som mais alto ou mais baixo, de acordo com nossa necessidade).
Exemplos de projetos onde pode ser utilizado:
- Sistema de detecção de batidas na porta

- Sistema de ligamento / desligamento de luz ambiente com palmas
- Sistema de monitoramento de barulho em quartos hospitalares ou bibliotecas
6.1.3 Sensor de chama

Este sensor nos informa quando uma chama é detectada, modificando
seu estado para HIGH quando isso acontece. Esta detecção é possível
através da análise do registro da cor infravermelha emitida pela
temperatura da chama e pelo seu movimento. Assim como no sensor de
som, podemos regular a sensibilidade através de um trimpot. Alguns
sensores especiais deste tipo, possuem um segundo sensor de luz e um segundo trimpot
onde é possível o ajuste da cor da chama a ser detectada (azul, laranja, amarela ou
vermelha geralmente).
- Sistema de detecção de incêndio

- Sistema de controle de tempo de uso de um fogão
- Sistema de monitoramento de apagamento acidental de chama (cortando o gás)
6.1.4 Sensor de vibração

Este sensor nos informa quando uma vibração com determinada
força é detectada, modificando seu estado para HIGH quando isso
acontece. Esta detecção é possível por conta de uma mola que existe
dentro do seu receptáculo de metal, que vibra e toca as paredes
Pág.
permitindo a passagem de corrente. Também conta com um trimpot para ajuste da
sensibilidade de vibração.
- Sistema de monitoramento de vibração de máquinas (para evitar quebras)

- Sistema de detecção de quedas (de pessoas ou objetos)
- Sistema de contagem, frequência e ritmo de passos
6.1.5 Sensor de inclinação (TILT)

Este sensor é composto de uma cápsula com dois contatos internos
em aberto e uma pequena bolinha de metal. Quando o mesmo é
inclinado, após um determinado ângulo, a bolinha rola e toca os
contatos, fechando o circuito e modificando o seu estado para HIGH.
Com isso, este sensor pode ser utilizado para, ao ser posicionado e ajustado à um
determinado objeto, controlar quando uma inclinação máxima desejada for atingida. Conta
com um trimpot para regular o tempo mínimo de contato da bola de metal para que o
estado seja alterado.
- Monitoramento de inclinação de uma cadeira de rodas para evitar quedas

- Sistema de detecção de capotagem ou quedas de maquinário ou automóveis
- Detecção de vibrações
6.1.6 Chave magnética (reed-switch)

A chave magnética do tipo reed-switch é composta de duas finas placas de
metal internas a um bulbo de vidro, que ficam muito próximas entre si.
Quando a chave é exposta a um campo magnético de força suficiente, as
placas são atraídas ou repelidas e tocam-se, alterando o estado para HIGH
neste momento. Assim, a chave reed-switch é utilizada para a detecção de campos
magnéticos.
- Detector de metais
- Detector de minerais polarizados (imãs)
- Acesso a data center para evitar entrada com materiais magnéticos
Pág.
6.1.7 Sensor magnético de proximidade

Este sensor é composto de duas partes: uma base (equipada com
uma chave reed-switch interna) e uma elemento móvel (que contém
um imã). Quando as duas estão próximas, as chapas internas do
reed-switch são atraídas pelo imã e o circuito fica fechado, mas ao
serem afastadas, o estado do sensor é modificado para HIGH. Assim, fixando cada uma
delas em elementos diferentes, conseguimos controlar quando os elementos são afastados.
- Sistemas de alarme de invasão de residências (abertura de portas e janelas)

- Monitoramento de abertura de locais protegidos (cofres, gavetas, etc)
- Sistemas antifurto de peças de valor expostas
6.1.8 Push button

O push button é um tipo de botão muito popular em projetos eletrônicos por
não guardar estado (ou seja, é diferente de um interruptor que clicamos uma
vez para ligar e fechar o circuito e outra vez para desligar e abrir o circuito).
Sua característica é alterar o estado para LOW quando é pressionado e para
HIGH assim que é solto, detectando, deste modo, o clique.
- Qualquer tipo de projeto que necessite detectar clique de botão para executar,
ajustar ou programar algo.
6.1.9 Chave tátil capacitiva

Muito similar ao push button quanto à funcionamento: ao ser tocado,
muda o seu estado para LOW e ao ser solto muda o seu estado para
HIGH, detectando, desta forma, o clique. Sua única diferença é que
ao invés de utilizar um dispositivo mecânico para esse acionamento
(com partes móveis), utiliza um circuito eletrônico com um elemento
capacitivo para conseguir detectar em que momento está sendo tocado.
- Qualquer tipo de projeto que necessite detectar click de botão para executar,
ajustar ou programar algo, assim com o push button.
Pág.
6.1.10 Chave de 2 estados

A chave de dois estados é um botão similar a um interruptor pois guarda o
seu estado. Porém suas ligações possibilitam ao mesmo tempo, dependendo
da posição de dois pares distintos, ter um circuito aberto de um lado e
fechado de outro, invertendo quando o botão for clicado novamente. Assim,
podemos também utilizá-lo para detectar cliques, mas principalmente como chave liga-
desliga de circuitos ou sub circuitos ou mesmo como chave de configuração, cujas
combinações de estados representem diferentes ajustes.
- Qualquer tipo de projeto que necessite ligar ou desligar um circuito ou sub circuito
através de um botão ou que necessite de combinações de estado para configurações.
6.1.11 Chave de fim de curso

A chave de fim de curso possui um push button posicionado logo abaixo
de uma haste móvel, que pode movimentar-se em apenas um eixo (para
cima e para baixo). Quando algum objeto se aproxima e a empurra, em
um determinado ponto, o push button é pressionado e o seu estado
muda para HIGH. Assim, torna-se muito adequada quando necessitamos detectar quando
um objeto chega a um determinado ponto que desejamos para pará-lo, desacelerá-lo ou
mudar o seu curso. Impressoras, por exemplo, utilizam duas chaves deste tipo para que o
cabeçote de impressão saiba quando chegou ao limite da folha.
- Sistemas de monitoramento de aberturas (portas, janelas, gavetas)

- Braços mecânicos ou sistemas de peças móveis para definir limites máximos
- Elevadores de carga para saber quando desligar o motor na subida e descida
6.1.12 Encoder ótico e encoder magnético

Os encoders são sensores capazes de transformar movimento
mecânico em pulsos (geralmente através de sinais digitais, ou seja,
estado LOW ou HIGH), que são utilizados para estimar posição,
deslocamento ou velocidade. No encoder ótico, existe um feixe de luz
que incide sobre um sensor de luz e quando algo passa por eles
interrompendo o feixe, é contado um pulso modificando o estado para
Pág.
HIGH (geralmente utiliza-se um disco perfurado ou um pino achatado, presos à parte
móvel). Já no encoder magnético, existe um imã que é preso na parte móvel e um
dispositivo eletrônico com uma chave reed switch (ou um outro
sensor magnético) que detecta quando este imã passa por ele,
alterando então o estado para HIGH. Ambos são muito úteis quando
trabalhamos com motores, sistemas mecânicos com giros em eixos
ou mesmo para estimar a frequência de funcionamento de máquinas
e ferramentas com partes móveis.
6.1.13 Sensor de vazão

O sensor de vazão por efeito hall tem um funcionamento
similar a um encoder magnético, pois internamente possui
uma hélice que contém um pequeno imã que força a
disparada de um pulso a cada volta completa (mudando seu
estado de LOW para HIGH). Assim, quando o ar ou a água
passam por dentro do sensor, movem a hélice. Contar o total
de pulsos (voltas) em um segundo, nos permite estimar então o volume de ar ou água que
passou pela válvula que passou pelo sensor.
6.2 Leitura de sensores de resposta binária com uso de interrupções
Apesar de praticamente todos os sensores digitais de resposta binária permitirem a

leitura do seu estado a partir do método digitalRead, de forma simples, temos algumas
exceções que necessitam de uma técnica um pouco mais elaborada. Eles são justamente
os dois sensores vistos por último na relação anterior: os encoders e o sensor de vazão.
Um botão, um sensor de som, um sensor de chama, etc, são ativados poucas vezes por
segundo e além disso geralmente não nos interessa quantas vezes isso ocorreu. Portanto,
a técnica que utilizamos é dentro do loop, com um tempo de espera pequeno, ler a porta
consecutivas vezes até perceber uma mudança de estado e, a partir daí, tomar uma ação.
Já nos sensores do tipo encoder e no sensor de vazão, o total de mudanças de estado
(chamadas de pulsos), é fundamental para estimar as grandezas que estes sensores
medem (frequência, velocidade, rotação, vazão, etc). E é aí que temos um problema: não
podemos ler o estado dentro de um loop e a cada vez que HIGH for detectado mudar o
estado, pois não sabemos com que frequência isso deverá ser feito (e ela muda de acordo
com a velocidade do que está senso medido). E mesmo que a gente saiba, pode acontecer
de uma mesma mudança de estado ser lida duas ou mais vezes apenas porque a velocidade
Pág.
de execução está muito alta. Então, perdemos totalmente a precisão da leitura. É aí que
entram as interrupções.
O Arduino Uno possui duas portas de interrupção: a interrupção 0 (presente na

porta digital 2) e a interrupção 1 (presente na porta digital 3). Estas interrupções, quando
ativadas, funcionam mesmo que o código esteja travado em uma linha (em um delay muito
longo por exemplo). Além disso, possuem uma característica muito interessante: através
de um método próprio, podemos vincular um método criado por nós à interrupção para
que ele seja executado toda vez que esta interrupção perceber uma mudança de estado.
Este método é o attachInterrupt:
attachInterrupt( <interrupcao>, <metodo>, <modo> );
<interrupcao>
número da interrupção que queremos monitorar (0 – pino 2 ou 1 – pino 3)
<metodo>
método que será chamado a cada nova chamada da interrupção
<modo>
modo de disparo da interrupção. Pode receber os seguintes valores:
- LOW: dispara quando o estado da porta for para LOW

- CHANGE: dispara quando o estado da porta mudar (LOW para HIGH ou HIGH para LOW)
- RISING: dispara quando o estado do porta mudar de LOW para HIGH apenas
- FALLING: dispara quando o estado da porta mudar de HIGH para LOW apenas
O primeiro parâmetro do attachInterrupt é a interrupção na qual ligamos o sensor

que desejamos monitorar (0, caso esteja na digital 2 ou 1 caso esteja na digital 3). O
segundo parâmetro é qual é o método que queremos vincular à interrupção de modo a ser
disparado sempre que uma mudança de estado for percebida pela porta. O terceiro
parâmetro é a definição de como a porta deve perceber uma mudança de estado,
disparando a interrupção quando ela for detectada. Aqui, temos uma mudança na lógica
de leitura do sensor: ao invés de realizar múltiplas leituras da porta no loop, de forma
rápida e consecutiva, até que uma mudança de estado seja percebida (executando algo
quando isso ocorrer), criamos uma forma de só executar algo que desejamos quando uma
mudança for percebida, sem a necessidade de uma leitura constante dentro do loop.
Além disso, para ativar a interrupção e ela agir nas mudanças de estado, utilizamos
o método sei() e para interromper a interrupção utilizamos o método cli(). Para entender e
ver na prática o uso das interrupções, vamos a dois exemplos práticos.
Pág.
6.2.1 Sensor encoder: exemplo detalhado com uso de interrupções

Para o nosso primeiro exemplo, vamos considerar um
encoder do tipo óptico. O mesmo possui um emissor de luz
infravermelha e um receptor de luz infravermelha paralelo a
ele. Quando algo passa em frente a esta luz e a corta, o
encoder modifica seu estado de LOW para HIGH. Então, este
tipo de sensor geralmente necessita de um elemento preso à
parte móvel do objeto que queremos monitorar a frequência
de execuções (no caso do encoder óptico, geralmente motores) para que ele fique
continuamente interrompendo e liberando a passagem da luz, gerando assim, pulsos. No
nosso caso, iremos utilizar um disco preso a um motor. Este disco possui diversos furos e
conforme gira faz com que o encoder mude seu estado constantemente. Todos os sensores
do tipo encoder possuem no mínimo 3 pinos: um pino de sinal (que deve ser conectado à
nossa porta de interrupção), um VCC e um GND. Alguns deles possuem um pino adicional
analógico para a geração de ondas caso se deseje visualizar o comportamento da aceleração
e desaceleração em um osciloscópio ou gráfico.
No nosso exemplo, utilizaremos um encoder óptico de 4 pinos: o primeiro é o

analógico para produção de sinal e não será utilizado, o segundo é o digital de dados que
ligaremos à porta 2 (interrupção 0), o terceiro é o GND e o quarto é o VCC. Assim, teremos
o seguinte esquema eletrônico:
Pág.
Nosso primeiro objetivo no código é durante exatamente um segundo capturar o

total de pulsos gerados pelo movimento de nosso disco. Após, utilizando conceitos da física,
podemos converter o número de voltas em uma velocidade em metros por segundo.
velocidade (m/s) = voltas por segundo . 2 .  . r
O disco do nosso exemplo possui um raio de 1,5 cm (0,015 m) e 20 furos. Como

cada furo estimula um pulso, 20 pulsos equivalem a uma volta completa. Deste modo,
para descobrir o total de voltas, dividimos o total de pulsos por 20. Para a contagem destes
pulsos, precisamos criar um método que cada vez que for chamado aumente em um o
valor de uma variável que conte os pulsos. Este método deve ser vinculado à interrupção
0 para cada vez que o estado mudar de LOW para HIGH (ou seja, mudança do tipo RISING),
um novo pulso ser contado. Assim, teremos o seguinte código:
int pulsos;
void contaPulso(){
pulsos++;
}
void setup(){
attachInterrupt(0, contaPulso, RISING);
Serial.begin(9600);
}
void loop(){
pulsos = 0;
sei();
delay(1000);
cli();
float voltasSegundo = pulsos / 20;

float metrosSegundo = voltasSegundo * 2 * 3.1416 * 0.015;
float quilometrosHora = metrosSegundo * 3.6;
Serial.println(“Pulsos por segundo: ” + (String)pulsos);

Serial.println(“Voltas por segundo: ” + (String)voltasSegundo);
Serial.println(“Metros por segundo: ” + (String)metrosSegundo);
Serial.println(“Quilômetros por hora: ” + (String)quilometrosHora);
}
Entendendo o código: começamos criando uma variável inteira chamada de pulsos, que
irá contar o número de pulsos lidos. Essa variável será incrementada pelo método
contaPulso a cada vez que ele for chamado pela interrupção, aumentando seu valor em 1.
Dentro do setup, usamos o attachInterrupt para vincular o método contaPulso à
interrupção 0 que será acionada sempre que perceber uma mudança de LOW para HIGH
Pág.
(ou seja, do tipo RISING). Além disso no setup inicializamos nossa Serial para que
possamos escrever nela os resultados e visualizá-los posteriormente. Após, em cada
repetição do loop, zeramos a variável pulsos, ativamos a nossa interrupção com o método
sei (passando a contabilizar os pulsos), paramos a execução do código por exatamente 1
segundo e após desativamos a nossa interrupção com o método cli (terminando assim a
contagem de pulsos). Como a interrupção funciona independentemente da execução do
código principal, mesmo com ele parado no delay, os pulsos seguem sendo contabilizados
pelo período estabelecido. Ao final de 1 segundo, podemos finalmente pegar o total de
pulsos contabilizados e dividir por 20 para descobrir o total de voltas dadas neste segundo
e com estas voltas descobrir a velocidade em metros por segundo e após (multiplicando
por 3,6) em quilômetros por hora. Se tudo estiver certo, ao abrir o Monitor Serial devemos
ter uma saída parecida com esta:
Esse processo com uso de interrupções pode ser utilizado por qualquer tipo de
sensor que nos devolva uma mudança de estado que desejamos monitorar a frequência
(ocorrências em um determinado tempo). Então, este exemplo pode ser utilizado de base
para situações similares ou para sensores de funcionamento similar.
6.2.2 Sensor de vazão: exemplo detalhado com uso de interrupções

De forma similar ao exemplo anterior, um sensor de vazão emite um pulso a cada
volta de sua hélice. Para isso, iniciamos ligando o seu pino de sinal (geralmente o do meio,
mas isso pode mudar de acordo com o fabricante) à nossa porta de interrupção (no caso
deste exemplo, a interrupção 0 localizada na porta digital 2).
Pág.
Assim, teremos um esquema eletrônico similar ao representado abaixo:
Se contarmos o total de pulsos em um segundo (que no caso equivale diretamente

a voltas) e multiplicarmos por 5,5 (fator já calculado como o tamanho do giro é conhecido)
conseguimos estimar a vazão de ar ou líquido atravessando o sensor (litros por segundo).
Multiplicando esse valor por 60, temos a estimativa de litros por minuto e multiplicando
por 60 novamente temos a estimativa de litros por hora. Nosso código será então baseado
na realização da contagem dos pulsos (voltas) em 1 segundo, para obter os demais valores
desejados. Assim como no exemplo anterior do encoder, a contagem será realizada por um
método contaPulso que apenas incrementa a variável inteira pulsos (zerada ao final de
cada segundo). Assim, temos:
int pulsos;
void contaPulso(){
pulsos++;
}
void setup(){
attachInterrupt(0, contaPulso, RISING);
Serial.begin(9600);
}
void loop(){
pulsos = 0;
sei();
delay(1000);
cli();
float litrosSegundo = pulsos / 5.5;

float litrosMinuto = litrosSegundo * 60;
float litrosHora = litrosMinuto * 60;
Serial.println(“Litros por segundo: ” + (String)litrosSegundo);

Serial.println(“Litros por minuto: ” + (String)litrosMinuto);
Serial.println(“Litros por hora: ” + (String)litrosHora);
}
Pág.
Entendendo o código: o funcionamento é análogo ao funcionamento do código do encoder
então a mesma explicação vale para este exemplo. A única diferença é que após a obtenção
do total de pulsos em um segundo, utilizamos este total para calcular informações
diferentes (litros por segundo, por minuto e por hora). Se tudo funcionou corretamente,
devemos ter uma saída similar à essa em nosso Monitor Serial:
6.3 Leitura de sensores analógicos
A leitura de sensores analógicos é um pouco mais trabalhosa do que de sensores de

resposta binária. Por serem analógicos, eles respondem aos estímulos do mundo externo
com tensões entre 0V e 5V que são mapeadas nas portas analógicas em valores entre 0 e
1023. Esse valor é obtido com o uso do método analogRead, informando a porta.
digitalRead( <porta> );
<porta>
porta à qual o sensor analógico está ligado
resposta
a resposta do método será um valor entre 0 e 1023
Algumas vezes esse valor é utilizado diretamente, mas algumas vezes necessitamos
convertê-lo em alguma unidade da grandeza que está sendo medida. Para isso,
necessitamos estabelecer uma relação entre os valores medidos pelo sensor e os
respectivos valores de resposta (entre 0 e 1023) da porta analógica. Podemos então usar
duas técnicas: o cálculo de uma constante de conversão ou o mapping dos valores. O
Pág.
problema do primeiro método é que necessitamos utilizar regras de 3 combinadas e caso
os sensores meçam grandezas que não partam de 0 (ou que usem negativos, como um
sensor de temperatura), ainda necessitamos considerar um offset (deslocamento) a ser
somado ao resultado obtido. Como isso é muito comum (ou seja, dificilmente o primeiro
valor lido pelo sensor é 0), o Arduino possui um método especial que nos ajuda a converter
o valor lido entre 0 e 1023 na unidade da grandeza medida, de acordo com o valor mínimo
e máximo obtido pelo sensor.
6.3.1 Mapping de valores

O mapping de valores é o mapeamento da leitura de entrada (algo entre 0 e 1023)
de acordo com a grandeza medida pelo sensor, que busca facilitar a conversão na unidade
de medida que nos interessa. O Arduino nos oferece para isso o método map:
map(<valorLido>, <minPorta>, <maxPorta>, <minSensor>, <maxSensor>);
<valorLido>
valor lido na entrada analógica que queremos descobrir a quanto equivale
<minPorta>
valor gerado na porta digital quando o valor mínimo da grandeza desejada é lido
<maxPorta>
valor gerado na porta digital quando o valor máximo da grandeza desejada é lido
<minPorta>
valor mínimo da grandeza desejada lido pelo sensor
<maxPorta>
valor máximo da grandeza desejada lido pelo sensor
Vamos imaginar que temos um sensor de temperatura que consegue medir

temperaturas entre 10ºC e 100ºC. Vamos imaginar também que quando esse sensor está
medindo 10°C, o valor gerado na porta analógica é de 55 e quando está medindo 100ºC, o
valor gerado na porta analógica é de 985. Essas informações são detalhadas sempre no
datasheet dos componentes. Agora a pergunta: caso obtivermos uma leitura de valor 800
na porta, a quanto isso equivale em graus celsius neste sensor? Para descobrir, usamos o
map: o primeiro parâmetro é o valor lido que queremos converter em graus celsius (800),
o segundo e o terceiro parâmetros são os valores mínimo e máximo gerados na porta
analógica pelo sensor (55 e 985) e o quarto e quinto parâmetros são os valores mínimo e
máximo lidos pelo sensor (10 e 100).
Pág.
float graus = map(800, 55, 985, 10, 100)
Descobriríamos facilmente que um valor de 800 lido na porta analógica,

corresponde à aproximadamente 82ºC e o mesmo método poderíamos utilizar para
descobrir a equivalência em graus celsius para qualquer valor lido.
6.3.2 Sensor LDR: exemplo detalhado de captura direta de valor

O sensor LDR como já comentamos é um sensor que muda a sua resistência de acordo
com a luminosidade que incide sobre ele. Se conectarmos um de seus pinos à uma porta
analógica, conseguimos captar um valor que é maior quanto mais luz é detectada. Aqui,
não queremos converter para Lux (unidade formal para a quantidade de luz percebida),
mas apenas ler e tomar alguma decisão baseada em seu valor bruto vindo da porta. Assim,
a simples leitura com analogRead é suficiente. Em nosso exemplo, vamos então conectar
um pino do LDR à porta A0 e quando o valor lido na porta for menor do que 100 (luz muito
baixa) ativamos um led para iluminar (ligado à uma porta digital, no nosso caso a porta
3). Aqui, é importante ressaltar que os LDRs podem ser encontrados avulsos (possuindo
apenas dois pinos) ou já montados em encapsulamentos com 3 pinos. A grande diferença
destes últimos é que colocam o pino de saída do LDR já em série com um resistor de pullup
(geralmente de 10k) para reforçar a leitura. Assim, nosso esquema eletrônico será como
um dos apresentados a seguir:
Esquema 1: LDR avulso (sem encapsulamento em placa, incluindo o resistor de pullup):
Pág.
Esquema 2: LDR já encapsulado em uma placa com pullup incluído na mesma (neste
exemplo, o sensor tem como primeiro pino o VCC, o pino do meio o OUT que é a saída de
dados e o terceiro pino o GND).
Agora para a implementação de nossa lógica de ligar o led quando estiver escuro,
teremos:
void setup(){
pinMode(A0, INPUT);
pinMode(3, OUTPUT);
Serial.begin(9600);
}
void loop(){
delay(100);
int valorLido = analogRead(A0);
Serial.println(“Valor da luminosidade: ” + (String)valorLido);
if(valorLido < 100) {

} else {
}
Entendendo o código: inicialmente definimos a porta A0 (à qual está ligado o pino de

saída do LDR) como de entrada e a porta 3 (à qual está ligado o pino positivo do led) como
saída, já definindo seu estado como baixo para o led inicie desligado. Após, dentro do loop,
a cada ciclo de tempo lemos a porta A0 e o valor obtido na porta analógica (entre 0 e 1023)
é armazenado na variável valorLido. Caso valorLido for menor do que 100 (luminosidade
muito baixa detectada) o led é aceso. Caso contrário, o led é apagado.
Pág.
6.3.3 Sensor de gás

Os sensores de gás permitem detectar a presença de gases específicos em um ambiente e
estimar a sua concentração aproximada (com uma precisão mediana, mas suficiente para
detecções simples). Cada sensor é específico para um gás e assim temos sensores de
dióxido de carbono, monóxido de carbono, oxigênio, hidrogênio, entre outros. O uso, a
exemplo do exemplo do LDR, também é bastante simples, pois estes sensores analógicos
possuem um pino (geralmente identificado como A0), através do qual lemos um valor entre
0 e 1023 (maior, quanto maior a concentração do gás detectada). Assim, podemos tanto
ligar um led ou soar um alarme avisando da detecção do gás (ou da concentração perigosa
a partir de um determinado limite) ou tomar outras medidas desejadas. Em nosso exemplo
ilustrativo, iremos utilizar um sensor de monóxido de carbono para avisar quando sua
concentração em um ambiente não ventilado (uma sala com portas e janelas fechadas e
lareira ligada, por exemplo) for perigosa, acendendo um led de alerta (ligado à nossa porta
digital 3). Assim, teremos o seguinte esquema eletrônico:
Nossa lógica será muito similar ao exemplo do LDR, pois necessitamos a cada loop
ler a porta A0 e descobrir o valor que o sensor de gás está enviando para ela (entre 0 e
1023) para, de acordo com esse valor, ligar ou não o led. Vamos considerar que o limite
máximo do valor lido e que representa a concentração de monóxido de carbono no
ambiente é de 400. Assim, teremos o seguinte código:
Pág.
void setup(){
pinMode(A0, INPUT);
pinMode(3, OUTPUT);
Serial.begin(9600);
}
void loop(){
delay(100);
Serial.println(“Concentração de monóxido de carbono: ” + (String)valorLido);
if(valorLido > 400) {

} else {
}
6.3.4 Sensor óptico reflexivo

O sensor óptico reflexivo é composto de dois elementos: um emissor de luz
infravermelha e um receptor de luz infravermelha. Estes elementos são separados por uma
“parede” de plástico que não permite que eles “se enxerguem”. O receptor só consegue
perceber a luz infravermelha emitida quando a mesma reflete em um objeto a sua frente.
Assim, este tipo de sensor é muito útil para detectar quando um objeto passa por ele, pois
o objeto refletirá a luz infravermelha de acordo com sua distância ou mesmo com o seu
material (mais reflexivo ou menos reflexivo ao IR). Com isso, é possível até mesmo
identificar alguns tipos de materiais através do sensor. A captura do valor de luz refletida
se dá de forma fácil, também através de um pino analógico como nos exemplos anteriores,
variando apenas o que fazemos com esse valor. Veja o esquema eletrônico abaixo:
Pág.
O emissor infravermelho (azul) tem um pino ligado ao negativo e o outro ligado ao

positivo em série com um resistor de 330 (para baixar sua corrente). Deste modo,
permanece o tempo todo ligado emitindo luz. Já o receptor infravermelho (preto) tem um
pino ligado ao negativo e o outro pino ligado ao positivo em série com um resistor de pullup
de 10k. Desta mesma ligação sai um fio ligando a coluna à porta analógica A0. Quando
o receptor perceber luz infravermelha, um valor quantificando essa percepção é enviado à
porta analógica. Imagine que queremos usar esse sensor posicionado sobre a lente de um
óculos. Sabe-se que quando o olho está aberto, boa parte da luz infravermelha é absorvida
por ele, refletindo somente uma pequena parte que gera uma leitura geralmente inferior à
900. Porém, quando o olho é fechado, a pele da pálpebra reflete muito mais luz
infravermelha, o que gera uma leitura geralmente superior à 1000. Assim, podemos então
considerar valores intermediários (com uma margem de erro) e usar a seguinte lógica para
ligar e desligar o led conforme o usuário abre ou fecha os olhos.
void setup(){
pinMode(A0, INPUT);
pinMode(3, OUTPUT);
Serial.begin(9600);
}
void loop(){
delay(100);
Serial.println(“Quantidade de luz IR percebida: ” + (String)valorLido);
if(valorLido < 950) {

}
if(valorLido > 1000) {

}
6.3.5 Sensor Joystick

O sensor joystick nos traz um controle analógico capaz de detectar movimentos no
eixo x (para esquerda ou direita), no eixo y (para cima ou para baixo) e no eixo z (botão
clicado ou não). Assim, diferente dos exemplos anteriores, ele possui dois pinos analógicos
e um pino digital. O primeiro pino analógico (chamado de VRx) devolve valores entre 0 e
1023 que quantificam o movimento no eixo x (quando mais perto de 0, mais à esquerda e
Pág.
quanto mais perto de 1023, mais à direita). O segundo pino analógico (chamado de VRy)
devolve valores entre 0 e 1023 que quantificam o movimento no eixo y (quando mais perto
de 0, mais para cima e quanto mais perto de 1023, mais para baixo). Já o pino digital
(chamado de SW) informa se o botão foi pressionado (LOW) ou não (HIGH). Assim, para
utilizarmos o joystick de modo a capturar os movimentos realizados pelo usuário e
transformar em ações, devemos ler os 3 valores. Apenas para exemplificar, vamos mostrar
como escrever uma mensagem na serial informando qual o movimento o usuário está
realizando no joystick. Para isso, vamos analisar o circuito eletrônico abaixo, onde o VRx
está ligado à nossa porta A0, o VRy ligado à porta A1 e o SW ligado à porta 3:
Para a detecção dos movimentos, utilizamos o código abaixo, que pode ser
modificado para que ações desejadas sejam efetivamente realizadas.
void setup(){
pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(3, INPUT_PULLUP);
Serial.begin(9600);
}
void loop(){
delay(100);
if(analogRead(A0) == 0) {
Serial.println(“Esquerda”);
}
Serial.println(“Direita”);
}
Serial.println(“Para cima”);
}
Serial.println(“Para baixo”);
}
if(digitalRead(3) == LOW) {
Serial.println(“Botão clicado”);
}
}
Pág.
6.3.6 Sensor de temperatura LM35 – Exemplo detalhado de mapping de valor

Todos os sensores vistos até agora utilizam diretamente o valor lido na porta
analógica. A partir de agora veremos como o mapping pode nos ajudar na conversão destes
valores lidos para uma unidade de medida ou para uma referência desejada por nós.
Vamos começar com o Sensor de temperatura LM35. Este versátil sensor, nos permite
mensurar diversas faixas de temperatura. Segundo o seu datasheet, para uma leitura
precisa de temperaturas entre 0 e 150 graus, é gerada na porta analógica um valor entre
0 e 350. Outras temperaturas acima ou abaixo disso são possíveis, mas apresentarão um
erro maior. Vamos iniciar com a montagem do circuito eletrônico que é bastante simples,
pois o sensor possui um pino VCC à esquerda, um pino de saída (dados) central que
ligaremos à nossa porta A0 e um pino de GND à direita. Assim, temos:
Agora, em nosso código, configuramos a porta A0 como entrada e no loop lemos o

seu valor analógico (entre 0 e 1023) e logo em seguida, usamos o map fornecendo as
informações de máximos e mínimos, para o valor lido seja convertido em graus celsius:
void setup(){
pinMode(A0, INPUT);
Serial.begin(9600);
}
void loop(){
delay(100);

float temperatura = map(valorLido, 0, 150, 0, 350);
Serial.println(“Valor lido: ” + (String)valorLido);

Serial.println(“Temperatura: ” + (String)temperatura);
}
Pág.
Entendendo o código: o mapping permitido pelo método map, torna o código muito
simples e evita a realização de cálculos massivos e complexos na conversão. No setup a
porta A0 está configurada como entrada pois através dela que receberemos o valor vindo
de sensor LM35. Inicializamos também a Serial para poder escrever nela (e posteriormente
visualizar) os resultados obtidos. Dentro do loop, a cada 100 ms, lemos a porta A0 e
armazenamos o valor na variável valorLido. Agora, necessitamos converter esse valor lido
(qualquer coisa entre 0 e 1023) em graus celsius. Como conhecemos as temperaturas
mínima e máxima passíveis de leitura pelo LM35 (0ºC à 150ºC na faixa de valor que
queremos utilizar) e qual o valor máximo e mínimo que essas leituras provocam na entrada
da porta analógica (0 a 350 conforme datasheet do componente), utilizamos o método map
para que o valor lido seja convertido e armazenado na variável temperatura. Após,
escrevemos na Serial qual o valor lido através do sensor e qual a temperatura respectiva
em graus celsius. Se tudo ocorreu bem, teremos no nosso Monitor Serial uma saída como
esta:
Perceba que a nossa temperatura de saída é sempre “inteira” apesar de mostrada

como um decimal. Outra forma de calcular a temperatura de forma ainda mais precisa,
segundo o fabricante, caso se necessite dos décimos, seria multiplicar o valor lido por
5000, dividir o resultado por 1024 e dividir novamente o resultado por 10. Assim, teríamos:
float temperatura = ( (valorLido * 5000) / 1024 ) / 10
Porém, se estes décimos não são fundamentais para nosso projeto ou análise, torna-
se muito mais simples o uso da técnica de mapping através do método map do Arduino.
Pág.
6.3.7 Potenciômetro
Apesar dos potenciômetros serem componentes eletrônicos do tipo resistor variável,
podemos utilizá-los em nossos projetos como se fossem sensores dos quais conseguimos
detectar o giro. Para isso, basta conectar as suas extremidades ao 5V e o GND e o seu pino
central à uma porta analógica. Isso porque, ao girar o pino, a resistência gerada cria um
divisor de tensão entre o pino 5V e central e entre o central o GND. Deste modo,
conseguimos modificar a tensão que chega à porta digital, conforme o nosso giro. Para
testar, podemos criar um circuito eletrônico como o mostrado abaixo, com o pino central
do potenciômetro ligado à porta analógica A0 do Arduino e 3 leds ligados às portas digitais
3, 4 e 5.
Nessa configuração, independente do valor do nosso potenciômetro (que para efeito

de exemplo será de 5K), quando seu pino estiver totalmente para a esquerda, o valor lido
pela porta analógica será 1000 (mínima resistência implica em máxima tensão) e quando
seu pino estiver totalmente para a direita o valor lido pela porta analógica será 0 (máxima
resistência implica em mínima tensão). Para inverter, bastaria subtrair o valor lido de 1000
que, com isso, teríamos um valor que aumenta conforme o pino é girado para a direita.
Agora, para converter esse valor entre 0 e 1000 em uma resistência entre 0 e 5k,
podemos utilizar um mapping, mapeando o valor lido com base na escala de valores
possíveis na leitura analógica em comparação com a escala de valores possíveis da
resistência do potenciômetro. Colocando isso em código, teríamos:
Pág.
void setup(){
pinMode(A0, INPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
Serial.begin(9600);
}
void loop(){
delay(100);
int valorLido = 1000 - analogRead(A0);
float resistencia = map(valorLido, 0, 1000, 0, 5000);

Serial.println(“Resistência: ” + (String)resistencia);
Com o método map, o mapping do valor lido (algo entre 0 e 100) para transformação
em ohms (entre 0 e 5000) tornou-se simples. Agora, imagine que dentro do loop, logo após
as mensagens enviadas para a Serial com os valores, desejássemos que os leds fossem
ligados conforme o pino do potenciômetro fosse girado em sentido horário. Aqui,
poderíamos utilizar duas lógicas:
• Lógica 1: a primeira possibilidade (e mais convencional), é dividir os possíveis valores

lidos (de 0 a 1000) em três grupos de valores, sendo o primeiro de 0 a 333 (ligando
o led 1), o segundo de 334 à 666 (ligando o led 2) e o terceiro de 667 à 1000 (ligando
o led 3). Assim, basta testaria testar o valor lido com três condicionais para
identificar em qual grupo (faixa de valor) está e qual o respectivo led que deve ser
ligado. Teríamo, então:
if(valorLido >= 0 && valorLido <= 333) {

}

}

}
Pág.
• Lógica 2: para deixar o código mais elegante, poderíamos utilizar um mapping de

valores para converter o valor lido (algo entre 0 e 1000), em um valor entre 1 e 3,
que vai nos indicar exatamente qual led ligar. Apesar de necessitarmos de uma linha
a mais de código do que na solução anterior, o condicional fica mais simples e não
necessita de condição encadeada para testar faixas de valores. Assim, temos:
int faixaLed = map(valorLido, 0, 1000, 1, 3);
if(faixaLed == 1) {
}
if(faixaLed == 2) {
}
if(faixaLed == 3) {
}
6.3.8 Sensor de umidade do solo

O sensor de umidade do solo é especialmente desenvolvido para possibilitar sua
introdução no solo a ser monitorado e, de acordo com a umidade percebida, nos devolver
um valor analógico que varia de 0 (totalmente seco) até 1023 (totalmente encharcado). Este
sensor é composto de duas partes distintas: uma haste, responsável por ficar em contato
com o solo e uma placa lógica que captura as micro correntes geradas pela haste,
convertendo-as em informação sobre a umidade percebida. A placa geralmente possui 4
pinos, sendo eles o VCC (5V), o GND, o analógico e um pino digital que pode ser utilizado
caso não se deseje saber o valor da umidade, mas apenas mudar o estado do sensor
quando uma umidade máxima (ajustada através do trimpot presente em seu corpo) for
atingida. No nosso exemplo, não iremos utilizar esse pino digital, sendo o pino analógico
ligado à nossa porta A0. Para chamar a atenção e ilustrar melhor o nível de umidade do
solo, iremos fazer algo similar ao exemplo do potenciômetro, colocando 4 leds que são
acionados de acordo com 4 faixas de umidade que vamos estabelecer. Estes leds, serão
então ligados nas portas digitais 3, 4, 5 e 6. Deste modo, teremos um circuito eletrônico
como o mostrado a seguir:
Pág.
Para o nosso mapeamento, vamos definir 4 faixas que representem a umidade do

solo. Se dividirmos os 1024 valores possíveis por 4, teremos que cada faixa deve
contemplar 256 unidades de valor. Assim, poderíamos considerar que valores lidos entre
0 e 255 representam o solo muito seco, valores lidos entre 256 e 511 representam o solo
ressecado, valores lidos entre 512 e 765 representam o solo úmido e valores lidos entre
766 e 1023 representam o solo encharcado. Novamente tivemos um certo trabalho para
definir as faixas de valor e teremos ainda mais trabalho para, após realizada a leitura,
montar condicionais que testem o valor lido em relação às faixas definidas. Isso não é
necessário, pois podemos simplificar nossa lógica com o mapping dos valores,
transformando entradas entre 0 e 1023 em faixas entre 1 e 4:
void setup(){
pinMode(A0, INPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
Serial.begin(9600);
}
void loop(){
delay(100);
int faixa = map(valorLido, 0, 1023, 1, 4);

Serial.println(“Faixa de umidade: ” + (String)faixa);
if(faixa == 1) { //totalmente seco

}
Pág.
Neste exemplo, estamos apenas ligando e
if(faixa == 2) { //ressecado desligando leds como alerta para a umidade
digitalWrite(4, HIGH); percebida no solo, lembrando que quanto mais
digitalWrite(6, LOW); alta a faixa, mais úmido o solo (por causa do
}
if(faixa == 3) { //úmido modo como os valores analógicos são lidos, com
digitalWrite(4, LOW); o 0 sendo a menor umidade e o 1023 sendo a
digitalWrite(6, LOW); maior umidade). Poderíamos modificar o
}
if(faixa == 4) { //encharcado exemplo para, caso a faixa de solo muito seco
digitalWrite(4, LOW); seja identificada, ligar um relé (que veremos no
capítulo de “Atuadores”), ativando uma bomba
}
de água ou válvula solenoide e realizando a sua
} rega.
6.3.9 Sensor de respingos

O sensor de respingos é muito similar ao sensor de umidade do solo e conta com
uma placa de detecção de líquidos (cujas gotas permitem a passagem de micro correntes)
e uma placa que transforma essas micro correntes em informação, devolvendo um valor
entre 0 (totalmente molhada) e 1023 (totalmente seca). Os pinos deste sensor são análogos
aos do sensor anterior e a nossa única mudança neste exemplo é que em lugar dos leds
indicativos, queremos um motor DC alimentado pela porta 3 e que tenha força de, ao
perceber um início de chuva, mover uma polia que puxe a corda de um varal para proteger
as roupas. Podemos ter, então, um circuito eletrônico como o mostrado abaixo:
Pág.
Neste exemplo, vamos realizar o mapping com uma lógica um pouco diferente,
transformando o valor lido em um percentual de chuva que vá de 0 a 100. O problema é
que não é o 0 que representa a placa totalmente seca e o 1023 a placa totalmente molhada
e sim o inverso. Como fazemos o mapeamento das duas escalas, se uma está invertida em
relação à outra? Simples! Invertendo os valores de uma das escalas. Então, em nosso
código, após ler o valor da porta analógica, vamos transformá-lo em um percentual de 0 a
100 mas usando a escala de valor lido na porta invertida (1023 e 0 e não 0 e 1023).
Finalmente, caso o percentual de respingos na placa (chuva no nosso caso) for maior do
que 20 (que representa 20%) acionamos um motor por 10 segundos para puxar a corda e
proteger as roupas estendidas, por exemplo. Deste modo, temos:
void setup(){
pinMode(A0, INPUT);
pinMode(3, OUTPUT);
Serial.begin(9600);
}
void loop(){
delay(100);
float percentual = map(valorLido, 1023, 0, 1, 100);

Serial.println(“Percentual de chuva: ” + (String)percentual);
if(percentual > 20) {

delay(10000);
}
6.4 Leitura de sensores especiais
Vimos até aqui como ler os valores de sensores digitais de resposta binária (de forma
direta ou com uso de interrupções) e como ler valores de sensores analógicos (de forma
direta ou com o uso de mapping de valores). Os sensores de cada um desses dois grupos,
possuem um modo de uso similar, sendo perceptível que ao aprender um, entendemos
facilmente o funcionamento de outros.
Porém, alguns sensores possuem um funcionamento todo próprio e que difere

totalmente daqueles vistos até aqui. Alguns deles são digitais, mas ao invés de nos
devolverem uma resposta binária (LOW ou HIGH), devolvem uma sequência binária através
de uma combinação de mudanças de estado em uma determinada frequência (sendo
Pág.
necessário um sincronismo para a leitura e, após, a conversão do valor para base decimal).
Outros nos devolvem mais de um resultado em uma única sequência binária, sendo
necessárias operações de base binária para separar os bits de cada informação. Outros
por causa de sua complexidade nos oferecem bibliotecas que já possuem métodos para
adquirirmos facilmente o valor, mas que no obrigam a instanciar um objeto através do
qual os métodos são acessados (alguns destes objetos devem ser configurados ou os pinos
previamente informados).
Com isso, alguns sensores necessitam de um estudo em separado para

assimilarmos o seu funcionamento e o seu consequente uso. Entre estes sensores,
podemos citar principalmente os relacionados abaixo.
Não vamos neste capítulo aprofundar em todos eles, como fizemos nos capítulos
anteriores com os sensores digitais de respostas binária e com os sensores analógicos.
Porém, para alguns, vamos mostrar exemplos de uso (alguns detalhados, outros
resumidos) e para outros vamos comentar o seu uso e importância e indicar sites que
explicam de forma detalhada projetos com o seu uso.
Pág.
6.4.1 Sensor ultrassônico de distância (HC-SR04)

O sensor ultrassônico de distância é um sensor capaz de medir a distância do objeto
mais próximo à sua frente. Este tipo de sensor possui, além do 5V e do GND, dois outros
pinos que devem ser ligados à duas portas digitais: o Echo (responsável por emitir um sinal
ultrassônico) e o Trigger (responsável por receber de volta esse sinal refletido e contar o
tempo que ele demorou para chegar no sensor). Para isso, vamos fazer a seguinte ligação
eletrônica, como no esquema abaixo (trigger na porta 7 e echo na 6):
Por ser de valor binário, este sensor ultrassônico devolve como resposta uma
sequência de bits (0 e 1, através da alternância do estado baixo e alto na porta), cuja
captura e manipulação direta exigiria um trabalho grande. Por isso ele possui uma
biblioteca própria que contém métodos já programados para uso e que facilitam a captura
do valor medido. Neste caso, a biblioteca é a “Ultrassonic.h” e primeiramente precisamos
fazer o seu download:
Pág.
Após, necessitamos adicionar a biblioteca à nossa Arduino IDE. Para isso, devemos
clicar no menu “Sketch”, após em “Incluir biblioteca” e finalmente na opção “Adicionar
biblioteca .ZIP”:
Posteriormente, devemos procurar o local onde a biblioteca foi salva, selecioná-la e

clicar no botão “Abrir”. Após, a biblioteca está incluída em nossa IDE e pode ser utilizada
não somente nesse projeto, mas em qualquer futuro projeto desenvolvido nela.
Antes de irmos para a escrita do código, precisamos saber de 3 coisas importantes:
1) Mesmo com a biblioteca já incluída na IDE, para utilizá-la em nosso projeto

devemos realizar um include (inclusão) no código;
Pág.
2) O acesso ao sensor ultrassônico, conforme definição da biblioteca, se dá através
da declaração de um objeto Ultrassonic, que ao ser criado deve receber como
parâmetro duas informações: a porta digital do Arduino onde está ligado o pino
Trigger (no nosso exemplo, na 7) e a porta digital do Arduino onde está ligado o
pino Echo (no nosso exemplo, na 6);
3) Também conforme definição da biblioteca, o objeto Ultrassonic possui um

método específico que pode ser chamado para devolver o valor da distância lido
pelo sensor. Esse método é o Ranging e quando o utilizamos, devemos passar
por parâmetro ou o valor CM (caso queiramos a distância em centímetros) ou o
valor INC (caso queiramos a distância em polegadas).
Com essas informações, vamos construir um código que a cada 1 segundo, ativa o
sensor ultrassônico e pede a ele o valor da distância do objeto mais próximo, capturando
esse valor e escrevendo na nossa Serial, para que possamos visualizá-lo através do Monitor
Serial da nossa IDE. Deste modo temos:
#include <Ultrassonic.h>
Ultrassonic ultrassom(7,6);
void setup(){
Serial.begin(9600);
}
void loop(){
delay(1000);
float distancia = ultrassom.Ranging(CM);

Serial.print(distancia);
Serial.println(“ cm “);
}
Entendendo o código: começamos declarando um include à biblioteca “Ultrassonic.h”

para que nosso projeto faça uso dela e, logo abaixo, criamos um objeto do tipo Ultrassonic
(ao qual demos o nome de ultrassom) no qual informamos que o pino Trigger está ligado à
porta digital 7 e o pino Echo está ligado à porta digital 6. No setup, a única coisa necessária
é a inicialização da nossa Serial para podermos escrever nela o resultado lido, tornando
possível a visualização posterior. Perceba que em nenhum momento informamos se nossos
pinos 7 e 6 são de entrada ou saída. A própria biblioteca fará isso. Em nosso loop, a cada
1 segundo criamos uma variável distancia e jogamos para dentro dela o resultado da
chamada do método Ranging, que nos devolve a distância lida pelo sensor (em centímetros,
por causa do parâmetro CM utilizado). Finalmente, esta distância é escrita na Serial,
acompanhada do texto “ cm ”. Assim temos um resultado como o abaixo:
Pág.
Podemos perceber que o acesso aos valores do sensor ultrassônico, apesar de um

pouco mais elaborado do que os sensores de resposta binária, não traz um grau de
dificuldade alto. A maior dificuldade no uso de sensores deste tipo é justamente saber qual
biblioteca utilizar, de onde baixar, qual o objeto a ser criado, seus parâmetros de
inicialização e qual os métodos para o acesso aos valores mensurados ou estimados pelo
sensor. E isso para cada um dos sensores deste tipo que formos utilizar. Por isso mesmo,
iremos ver a partir de agora cada um dos principais sensores de valor binário já com as
instruções detalhadas para o seu uso. Todas as bibliotecas utilizadas, podem ser baixadas
diretamente do repositório: https://bit.ly/arduinoqi
6.4.2 Sensor de cor RGB (TCS230)

O sensor de cor RGB é um sensor capaz de estimar a cor de um objeto à sua frente,
devolvendo os valores de R, G e B que compõe esta cor. Este sensor possui três fotodiodos
capazes de reagir a determinadas cores, produzindo correntes elétricas. Este tipo de sensor
possui, além do 5V e do GND, uma série de outros pinos responsáveis por ajustar a
frequência de comunicação (S0 e S1), o filtro para cada uma das cores que formam o RGB
(S2 e S3), a saída de sinal (OUT), além de pinos auxiliares. Primeiramente, a frequência
determina a velocidade da saída dos pulsos e a modulação entre eles para que seja possível
a correta configuração de leitura. No Arduino e demais placas de prototipagem, o comum
é a configuração em 20%. Obtemos isso, modificando o estado da porta à qual o pino S0
está conectado para HIGH e modificando o estado da porta à qual o pino S1 está conectado
para LOW. A configuração das velocidades pode ser verificada na tabela abaixo:
Pág.
Definida a escala da frequência de saída, precisamos informar ao sensor qual é o

filtro de cor que queremos ativar. Se ativarmos, por exemplo, o filtro vermelho, o fotodiodo
sensível à cor vermelha irá ser ligado e reagir à mesma, produzindo uma corrente baixa
que dará origem a um pulso que pode durar de 0 a 255 unidades de tempo e que será
enviado à saída OUT. Essa configuração de qual filtro de cor estará ativo é realizada através
dos pinos S2 e S3 e pode ser verificada na tabela abaixo:
No momento que um filtro de cor é ativado e o pino OUT passa a enviar uma
frequência produzida pela reação do fotodiodo àquela cor (dentro da escala de saída
configurada), podemos medir o total de unidades de tempo de 0 a 255 de duração da onda.
Essa é a forma do sensor nos devolver o valor da cor detectada. Podemos fazer isso através
do método pulseIn, que pode ser visto abaixo:
pulseIn( <porta>, <tipo> );
<porta>
número da porta que queremos medira duração dos pulsos da frequência de saída
<tipo>
Tipo de pulso a ser lido (LOW – tempo em estado baixo / HIGH – tempo em estado alto)
Neste nosso exemplo, vamos ligar os pinos S0, S1, S2 e S3 nas portas 4, 5, 6 e 7 do
Arduino. Além disso, o pino de saída de sinal (OUT) será ligado à porta 3 do Arduino. Deste
modo, teremos um circuito eletrônico como o mostrado a seguir (simplificado pela
quantidade de fios, sem protoboard e com o sensor ligado direto à placa):
Pág.
Nosso código será baseado na mudança de filtros e na leitura da duração do pulso

emitido pela saída, um por vez, para termos os valores de RGB em separado. Assim, temos:
//criando constantes para mapear os pinos e facilitar o acesso

#define OUT 3;
#define S0 5;
#define S1 4;
#define S2 6;
#define S3 7;
void setup(){
pinMode(OUT, OUTPUT);
pinMode(S0, OUTPUT);
//configurando a escala de frequência para 20%

digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Serial.begin(9600);
}
Pág.
void loop(){
delay(1000);
//configurando o filtro para a cor vermelha e lendo o valor de R

int r = pulseIn(OUT, LOW);
//configurando o filtro para a cor verde e lendo o valor de G

int g = pulseIn(OUT, LOW);
//configurando o filtro para a cor azul e lendo o valor de B

int b = pulseIn(OUT, LOW);
Serial.println(“R: ” + (String)r);
Serial.println(“G: ” + (String)g);
Serial.println(“B: ” + (String)b);
}
Entendendo o código: começamos criando constantes que contém os nomes dos pinos e
o valor respectivo. O uso de constantes é bem interessante no C++ para organização do
nosso código, principalmente quando temos objetos que possuem um valor fixo, que não
se altera ao longo do código. Duas constantes do Arduino bem conhecidas são o LOW (cujo
valor mapeado é 0) e o HIGH (cujo valor mapeado é 1). Do modo como foram criadas, ao
usar no código a palavra S0, por exemplo, automaticamente a mesma é substituída por
seu valor respectivo (no caso 4) no momento da compilação. Continuando, os pinos
correspondentes às constantes criadas, são informados como de saída dentro do setup.
Ainda no setup, a escala de frequência de 20% do sensor (valor padrão para as placas de
prototipagem) é configurada através da combinação de S0 em estado HIGH e S1 em estado
LOW (conforme a primeira tabela apresentada). Além disso, nossa Serial é inicializada para
podermos escrever e visualizar os resultados. No loop, para que cada cor seja lida é
necessária a configuração do filtro da cor respectivo e a consequente leitura do tempo do
pulso gerado pela reação do fotodiodo àquela cor. Como esse valor é mapeado de 0 até 255
unidades de tempo (para que gere um valor de cor entre 0 e 255), a leitura simples do
mesmo na saída (OUTPUT) corresponde ao valor daquela cor RGB. Primeiramente
configuramos o filtro de cor para vermelho (S2 e S3 em LOW conforme a segunda tabela
apresentada) e lemos o tempo do pulso com o pulseIn, armazenando o resultado na variável
inteira r. Depois, configuramos o filtro de cor para verde (S2 e S3 em HIGH conforme a
segunda tabela apresentada) e lemos o tempo do pulso com o pulseIn, armazenando o
resultado na variável inteira G. Finalmente, configuramos o filtro de cor para azul (S2 em
Pág.
LOW e S3 em HIGH conforme a segunda tabela apresentada) e lemos o tempo do pulso
com o pulseIn, armazenando o resultado na variável inteira b. Para finalizar, escrevemos
os valores das 3 variáveis em nossa Serial. Com isso, um resultado similar a este deverá
ser visualizado através do nosso Monitor Serial:
6.4.3 Sensor de umidade e temperatura (DHT11)

Este sensor permite medir temperaturas entre 0ºC e 50ºC e a umidade relativa do
ar entre 20% e 95%. Pode ser encontrado de forma avulsa (com 4 pinos) ou encapsulado
em placas (geralmente com apenas 3 pinos). Os pinos que nos importam são o VCC (5V),
GND e o pino de dados, que deve ser ligado a uma porta digital. Em sua versão avulsa
(apenas o sensor), a sequência é sempre, da esquerda para a direita, VCC – DADOS – N.C
– GND, onde o N.C não é utilizado. Já quando encapsulado em placas, cada fabricante
pode alterar a sequência de pinos, sendo importante a análise. Aqui, mostramos um
exemplo onde a sequência de pinos definida pelo fabricante do encapsulamento é GND –
DADOS – VCC.
Em funcionamento, este sensor informa a

umidade e a temperatura através de sequências
binárias e para facilitar a captura dessas
informações podemos utilizar a biblioteca DTH
que contém a implementação de um objeto DTH
através do qual podemos chamar dois métodos:
readHumidity (que nos retorna a umidade
relativa do ar) e readTemperature (que nos
retorna a temperatura em graus celsius). Ao ser inicializado, o objeto DHT necessita de
dois parâmetros: o primeiro é o número da porta digital onde está ligado o pino de dados
Pág.
do sensor e o segundo é qual o tipo de sensor, visto que a mesma biblioteca serve para
outros sensores da mesma família (no nosso caso, utilizamos a constante DTH11). Esta
biblioteca necessita de uma biblioteca secundária desenvolvida pela Adafruit e utilizada
na implementação de diversos sensores, chamada de AdafruitSensor. Porém, em nosso
código, apenas a primeira necessita de include.
Abaixo, é demonstrado um exemplo de como ler as informações de umidade e

temperatura e escrever as mesmas na Serial, com o pino de dados do sensor DHT11 ligado
à porta digital 3 do Arduino.
#include <DHT.h>
DHT dht(3,DHT11);
void setup(){
Serial.begin(9600);
dht.begin();
}
void loop(){
delay(1000);
int umidade = dht.readHumidity();

int temperatura = dht.readTemperature();
Serial.println(“Umidade: ” + (String)umidade + “ porcento”);

Serial.println(“Temperatura: ” + (String)temperatura + “ºC”);
}
6.4.4 Sensor RFID (RC522)

Este sensor permite a leitura do valor de Id (código único de identificação) de TAGs
RFID (etiquetas ativas, etiquetas passivas, cartões e chaveiros). Isso pode ser bastante útil
em identificação (de produtos, por exemplo) ou em controle de acesso (de funcionários, por
exemplo). Ele pode ser utilizado inclusive para gravar dados dentro das TAGs graváveis.
Um exemplo de como fazer isso pode ser visto no link abaixo:
https://www.filipeflop.com/blog/como-gravar-dados-no-cartao-rfid
Porém, esta funcionalidade é um pouco mais complexa (avançada) e neste exemplo

o que nos interessa é descobrir o Id já gravado nas tags e utilizá-los para controle de
acesso. Para entender o uso do sensor RFID, vamos iniciar por seu esquema eletrônico que
necessita do uso de uma série de portas (algumas fixas, que não podem ser alteradas).
Pág.
Nesse esquema, foram colocados também dois leds (um verde e um vermelho) como um
auxílio visual mostrando se o cartão liberou ou não o acesso.
Os 4 primeiros pinos do sensor RFID, são ligados nos 4 pinos digitais que
implementam a comunicação SPI no Arduino em uma sequência fixa. A ligação efetuada
está descrita na tabela abaixo:
Pino do sensor Porta do Arduino

1 - SDA 10
2 - DAS 13
3 - MOSI 11
4 - MISO 12
Além destes, o pino RST do sensor (pino 7) deve ser ligado à uma porta digital PWM
que pode ser escolhida (neste exemplo optou pela porta 9), o pino GND ao GND do Arduino
e o pino VCC ao 3,3V do Arduino. Muito cuidado aqui, pois este sensor pode ser danificado
se submetido à uma tensão de 5V. Para finalizar, o pino positivo do led verde foi ligado à
porta digital 3 e o pino positivo do led vermelho foi ligado à porta digital 4.
OBSERVAÇÃO: Para o uso do sensor RFID teremos que importar 1 biblioteca não nativa
para nossa IDE: MFRC522, que pode ser baixada no link: https://bit.ly/arduinoqi
Pág.
Um exemplo de código para identificação e leitura de nossas tags (ligando os leds

indicativos para simular um acesso negado ou permitido) é mostrado abaixo:
#include <SPI.h>
#include <MFRC522.h>
//criação do objeto MFR522 informando as portas dos pinos SDA e RST

MFRC522 sensor(10, 9);
//criação de um vetor de tags liberadas para acesso

String tagsLiberadas[] = {“44AB18C9”, “AB1515C0”};
void setup(){
Serial.begin(9600);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
//inicialização da comunicação SPI e do objeto que representa o sensor

SPI.begin();
sensor.PCD_Init();
//mensagem inicial para o usuário

Serial.println(“Aproxime a sua TAG RFID do sensor”);
}
void loop(){
//busca novos cartões e quando encontra seleciona um para ser lido
if( !sensor.PICC_IsNewCardPresent() ) { return; }
if( !sensor.PICC_ReadCardSerial() ) { return; }
//mostra o ID da TAG RFID lida

String idLido = “”;
for(byte i = 0; i < sensor.uid.size; i++) {
idLido.concat(String(sensor.uid.uidByte[i], HEX));
}
Serial.println(“ID da TAG lida: ” + (String)idLido);
//compara se o ID da TAG lida é algum dos liberados existentes no vetor

bool liberado = false;
for(int i = 0; i < (sizeof(tagsLiberadas)/sizeof(String)); i++) {
if(idLido.equalsIgnoreCase(tagsLiberadas[i]) ){
liberado = true;
}
}
//verifica se a variável liberado mudou para true e libera ou não o acesso

//simulamos isso através de uma mensagem na Serial e dos leds
if(liberado == true){
Serial.println(“Acesso liberado!”);
} else {
Serial.println(“Acesso negado!”);
}
delay(3000);
Pág.
Entendendo o código: o código utilizado é de um nível mais avançado e não cabe aqui
explicar de forma aprofundada cada linha e método apresentado. O importante é entender
a ideia geral para poder utilizar o sensor RFID nos projetos desejados. Primeiramente
criamos um objeto MFRC522, responsável por representar o sensor RFID e oferecer acesso
à métodos para trabalhar com ele. Ainda antes do setup, um vetor (array) de Ids permitidos
foi criado, já recebendo dois Ids que quando lidos podem liberar o acesso. Quando você for
reproduzir os seus exemplos, aproxime a TAG desejada do sensor, anote o Id mostrado no
monitor serial e acrescente ou substitua os Ids deste vetor. Dentro do setup, após a
inicialização da Serial e da definição das portas dos leds como saída (iniciando em estado
LOW), a comunicação SPI e o objeto que representa o sensor RFID são inicializados. No
loop, forçamos que o sensor RFID fique continuamente tentando detectar novas TAGs RFID
e, quando detectada, que a mesma seja lida. No momento que isso acontece, forçamos um
laço de repetição que percorre todo vetor interno do sensor (que armazena o Id lido de
forma binária) e transformamos cada uma das sequências em caracteres hexadecimais
para que o Id lido possa ser mostrado na nossa Serial. Logo após, em um novo laço,
percorremos o vetor de Ids permitidos, comparando um a um com aquele que acabou de
ser lido pelo sensor, verificando se é um dos permitidos. Caso seja, informamos sobre o
acesso liberado na Serial e ligamos o led verde. Caso contrário, informamos sobre o acesso
negado e ligamos o led vermelho. Esse exemplo poderia ser modificado para, por exemplo,
ao invés de ligar um led, ligar um relé pela porta digital que solte ou puxe uma trava
elétrica, liberando ou bloqueando uma porta ou portão.
6.4.5 Sensor acelerômetro e giroscópio (MPU6050)

Este tipo de sensor nos permite obter a velocidade e a rotação nos seus 3 eixos (X,
Y e Z) enquanto é movimentado. Assim, conseguimos capturar os valores deste movimento
e tomar alguma ação ou reproduzi-lo em atuadores. Imagine um braço mecânico que deve
acompanhar o mesmo movimento do braço de um cirurgião, ou mesmo um joystick que
transforme movimentos do jogador em ação no jogo (como faz o Wii). Aqui neste exemplo
de uso, por simplificação, não iremos implementar ações para os movimentos detectados,
mas mostrar como capturar suas informações para uso futuro. Este sensor possui 8 pinos,
mas na prática utilizamos apenas os 4 primeiros: em ordem, VCC, GND, SCL (que
obrigatoriamente deve ser conectado à porta A5) e SDA (que obrigatoriamente deve ser
conectado à porta A4). Assim, teremos o seguinte esquema eletrônico:
Pág.
Um exemplo de código para a leitura e apresentação das velocidades e giros nos 3

eixos do acelerômetro/giroscópio é trazido abaixo:
#include <Wire.h>
//criação uma constante para armazenar o endereço I2C do sensor

const int MPU = 0x68;
void setup(){
Serial.begin(9600);
//inicialização da comunicação I2C (Wire) e do sensor

Wire.begin();
Wire.beginTransmission(MPU);
Wire.write(0x6B);
Wire.write(0);
Wire.endTransmission(true);
}
void loop(){
delay(10);
//solicitação dos dados do sensor

Wire.beginTransmission(MPU);
Wire.write(0x3B);
Wire.endTransmission(false);
Wire.requestFrom(MPU, 14, true);
//leitura dos valores e armazenamento em variáveis

inc aX = Wire.read()<<8|Wire.read();
inc aY = Wire.read()<<8|Wire.read();
inc aZ = Wire.read()<<8|Wire.read();
inc tmp = Wire.read()<<8|Wire.read();
inc gX = Wire.read()<<8|Wire.read();
inc gY = Wire.read()<<8|Wire.read();
inc gZ = Wire.read()<<8|Wire.read();
Serial.print(“ACEL|X:” + (String)aX + “,Y:” + (String)aY + “,Z:” + (String)aZ + “|”);

Serial.print(“ GIRO |X:” + (String)gX + “,Y:” + (String)gY + “,Z:” + (String)gZ + “|”);
Serial.println(“ TEMP |” + (String)tmp + “|”);
Pág.
Entendendo o código: inicialmente é definido o endereço do sensor pois um endereço

sempre é obrigatório na comunicação I2C (Wire). O padrão é 0x68 para os sensores
MPU6050 vindos de fábrica, mas eles possuem jumpers que podem ser soldados,
modificando fisicamente o endereço (o que não é o nosso caso). Dentro do setup, comandos
são disparados através da Wire para abrir a comunicação I2C, inicializar o sensor, fazer
as configurações inicias e encerrar a comunicação. Dentro do loop, executamos alguns
comandos para reabrir a comunicação com o sensor e solicitar que o mesmo devolva os
seus dados para a Wire. Quando isso acontece, os vários dados do sensor (aceleração em
X, Y e Z, giro em X, Y e Z e temperatura) são armazenados em um array de binários em
uma ordem pré-estabelecida. São criadas então variáveis que irão receber estes 7 valores,
lidos em ordem de dentro da Wire, sempre em conjuntos de 8 bits (deslocando mais 8 bits
após a leitura). Deste modo, por mais diferente que essa leitura binária pareça, ao final
deste processo temos os 7 valores do sensor em 7 variáveis diferentes, podendo exibi-los
em nosso Monitor Serial como no exemplo, ou utilizá-los para tomar outras ações conforme
nossa necessidade.
6.4.6 Sensor de carga com amplificador (HX711)

O sensor de carga (ou célula de carga) é uma espécie de sensor piezo com duas
placas que, ao serem comprimidas, provocam micro correntes (mais fortes conforme mais
força é aplicada). Deste modo, estes sensores podem ser utilizados como balança digital,
fazendo uma relação entre as correntes medidas
(e amplificadas pelo HX711 para poderem ser
percebidas pelas placas de prototipagem) e os
pesos que as produzem. Para entender o seu
funcionamento, acesse o link abaixo para
visualizar um exemplo completo desenvolvido
por Matheus Gebert Straub no site da UsinaInfo,
explicando o passo a passo da construção de
uma balança digital caseira para até 5Kg.
https://www.usinainfo.com.br/blog/balanca-arduino-com-celula-de-peso-e-hx711-
tutorial-calibrando-e-verificando-peso/
Pág.
6.4.7 Sensor de gestos (APDS-9960)

Os sensores de gestos são capazes de detectar quando realizamos determinados
movimentos próximos deles, com as mãos ou os dedos. Os sensores mais comuns (como
o APDS-9960) detectam o movimento da mão de cima para baixo, de baixo para cima, da
esquerda para a direita e da direita para a esquerda. Alguns sensores mais sofisticados
detectam movimentos especiais como, por exemplo, a mão afastando ou aproximando ou
mesmo gestos circulares. Detectando esses movimentos, podemos programar o Arduino
para executar determinadas ações como resposta a cada um deles (imagine controlar uma
TV da cama, podendo trocar o canal, ajustar o volume e ligar e desligar, apenas
movimentando a mão). Apesar do APDS-9960 detectar apenas os 4 movimentos básicos
citados, ele tem mais uma funcionalidade extra: funciona também como um detector de
cores RGB. Para entender o seu
funcionamento, acesse os dois links
abaixo. No primeiro, Gedeane Kenshima,
do site FelipeFlop mostra como usar o
APDS-9960 para detectar cores RBG e
transferir a cor detectada para um led
RGB. No segundo, Euler Oliveira, do blog
da Master Walker Shop, mostra como
detectar os 4 gestos básicos com o sensor.
https://www.filipeflop.com/blog/como-utilizar-o-sensor-de-gestos-e-rgb-sparkfun/
https://blogmasterwalkershop.com.br/arduino/como-usar-com-arduino-sensor-de-
gestos-e-de-cor-apds-9960
6.4.8 Sensor de reconhecimento de voz (V3)

A integração de reconhecimento de voz no Arduino é muito interessante e nos
permite controlar as suas ações apenas falando, com o uso de comandos de voz.
Geralmente para isso, necessitamos criar um aplicativo para smarthone que é o
responsável por capturar a voz, reconhecer os comandos e mandar ordens ao Arduino
através de uma conexão serial (por bluetooth, wifi ou mesmo cabo USB). Porém, isso
acrescenta um grau de complexidade ao nosso projeto. O sensor de reconhecimento de voz
V3 simplifica este processo. Ele é capaz de armazenar internamente até 80 palavras
diferentes, narradas pelo usuário através de um programa de treinamento. Destas 80, 7
Pág.
podem ser ativadas por vez e caso alguma delas seja
detectada, o sensor avisa ao Arduino enviando esta
palavra para que a placa, por sua vez, pode tomar
uma determinada ação. Assim, conseguimos realizar
o desenvolvimento de sistemas que sejam totalmente
controlados por voz, sem a necessidade de apps
adicionais, de smartphone e mesmo de internet. Para
entender melhor o seu funcionamento, entre no link
abaixo para visualizar o exemplo desenvolvido por
Matheus Gebert Straub do site UsinaInfo, explicando
deste o treinamento das palavras no sensor até a
detecção destas palavras pelo Arduino.
https://www.usinainfo.com.br/blog/projeto-reconhecimento-de-voz-arduino/
6.4.9 Sensor de batimentos cardíacos (KY-039)

O sensor de batimentos cardíacos é especialmente desenvolvido para um
monitoramento cardíaco pouco invasivo, através de luz infravermelha e ultravioleta que
controla as pulsações, podendo ser posicionado no peito, ponta dos dedos da mão ou pés,
lóbulo da orelha e pulso. Este sensor além do valor de batimentos (e alguns mais
elaborados até da pressão arterial), entrega uma saída em sinal analógico que pode ser
utilizada para a visualização em um gráfico do tipo “eletrocardiograma”. Para entender o
funcionamento, acesse o primeiro link
para visualizar um exemplo desenvolvido
pela Gedeane Kenshima do site FelipeFlop,
com sincronização de um led de acordo
com os batimentos. No segundo link do
Canal TCD, um vídeo mostrando a geração
de gráfico estilo eletrograma com a
ferramenta Plotter Serial Arduino IDE.
https://www.filipeflop.com/blog/aprenda-usar-o-sensor-de-frequencia-cardiaca/
https://www.youtube.com/watch?v=dfOI8LKHIkM
Pág.
6.4.10 Sensor GPS (Neo-6M)

O sensor GPS é especialmente desenvolvido para conseguir obter informações do
sistema GPS global, comunicando o maior número de satélites possível para uma
triangulação e estimativa de posição de qualidade. Seu uso é interessante em qualquer
sistema eletrônico e de IOT que necessite descobrir a posição global (como em robôs,
veículos de carga, drones, barcos de monitoramento, etc). Para entender o funcionamento,
acesse o primeiro link para visualizar um exemplo desenvolvido pela equipe Montain Baja
do portal Vida de Silício, com a captura e tratamento
das coordenadas, total de satélites consultados e
data e hora global. Já no segundo link, um sistema
automotivo para gravar o caminho percorrido por
um carro em um cartão SD com a posterior
importação para o Google Maps (permitindo ver o
caminho percorrido), desenvolvido por Diego Moreira
da UsinaInfo.
https://portal.vidadesilicio.com.br/modulo-gps-neo-6m/
https://www.usinainfo.com.br/blog/projeto-arduino-gps-6m-registrando-localizacao/
UNIDADE 5 – ATUADORES
7 TRABALHANDO COM ATUADORES
Se os sensores são fundamentais para capturar as informações do mundo externo,

os atuadores são fundamentais para que o Arduino aja sobre ele, seja executando ações
mecânicas ou seja externalizando informações (de forma visual, sonora ou háptica). Em
conjunto com algum meio de comunicação, essa é a tríade base do IOT. Os atuadores são
geralmente mais simples do que os sensores em acionamento e controle, bastando muitas
vezes energizá-los (seja com até 5V utilizando alguma das portas do próprio Arduino, seja
de forma externa com tensão maiores e através do uso de fontes secundárias e relés). Até
mesmo no controle de motores e servos motores (que necessitam de bibliotecas especiais
Pág.
e possuem métodos para controle de passo, velocidade e rotação), a maior dificuldade não
é nem no código (muito simples) mas na transferência e controle do movimento produzido,
levando a complexidade para o lado da mecânica e não da eletrônica ou da programação.
Neste capítulo, conheceremos os principais atuadores, suas utilidades e formas de uso.
7.1 Atuadores de ativação simples com até 5V
Muitos dos atuadores do Arduino são de ativação simples, bastando alimentá-los

com tensão provinda de alguma das portas digitais. Para alguns deles isto basta e para
outros, simples métodos nativos são suficientes para o seu controle. Todos estes atuadores
utilizam portas digitais e, com isso, a simples mudança de estado da porta geralmente é o
único controle necessário.
7.1.1 Leds
O primeiro atuador visto ao longo deste livro e o mais utilizado até
aqui, o led é fundamental em praticamente qualquer circuito
eletrônico apesar de ser muito simples (seja para mostrar que um
circuito está energizado e em funcionamento, seja para mostrar
informações sobre estados ou acontecimentos). O seu uso já foi
amplamente visto e sabemos que o seu controle é vinculado à
simples mudança de estado de uma porta digital ou, no caso dos leds RGB, à regulagem
da tensão das portas digitais PWM (por meio da mudança dos seus Duty Cycles).
Aplicações: informação de circuito ligado ou desligado, informações de acontecimentos

monitorados, de mudanças de estado de sensores, criação de optoacopladores para isolar
2 circuitos diferente e um ativar o outro com luz, efeitos visuais em geral.
7.1.2 Emissor laser

Este emissor é um gerador simples de laser, com um feixe
concentrado de luz (geralmente vermelha, azul ou verde) que
pode ser projetado de 1 a 15 Km de acordo com a potência. Os
compatíveis com Arduino (e com diversas outras placas de
prototipagem), são desenvolvidos para serem alimentados com
tensão a partir dos 3,3 V.
Pág.
Aplicações: sistemas de segurança de áreas em conjunto com LDR para acionar quando
o feixe de laser é cortado, controle de circulação em ambientes (entrada e saída ou
contagem de pessoas), ativação simples à longa distância de um circuito a partir de outro.
7.1.3 Vibracall
O vibracall nada mais é do que um pequeno motor com uma hélice
de peso desequilibrado (bem mais pesada de um lado), gerando
uma forte vibração ao girar. Muito comum em smartphones e
joysticks de consoles mais modernos, no objetivo de chamar
atenção do usuário para algum evento. Seu funcionamento
também é bastante simples, vibrando quando alimentado por
tensões de 3,3V à 5V, sendo possível seu controle através da mudança de estado de uma
porta digital.
Aplicações: substituição dos leds em sistemas adaptados para deficientes visuais (sinais
visuais trocados por sinais hápticos), sistemas que necessitem chamar atenção do usuário
ou comunicar algo através de uma vibração (ou uma sequência delas).
7.1.4 Buzzer
O buzzer é um tipo de piezo especialmente construído para
produzir vibrações com força suficiente para gerar sons. Estes
sons são mais simples que os produzidos por um autofalante,
geralmente beeps em uma determinada frequência. O buzzer
pode ser do tipo ativo (aqueles que contam com um oscilador
interno e são capazes deles próprios criarem modulações que
gerem os sons) ou passivo (aqueles que não contam com
oscilador interno sendo incapazes de gerar sons sem alguém que os entregue um sinal
modulado, neste caso, a placa). Estes últimos são os mais comuns em prototipagem.
Aplicações: substituição dos leds em sistemas adaptados para deficientes visuais (sinais
visuais trocados por sinais sonoros), sistemas que necessitem chamar atenção do usuário
ou comunicar algo através de beeps (ou uma sequência deles), sistemas que necessitem
Pág.
da reprodução de uma música simples ou uma sequência sonora em resposta de uma
ação.
Para utilizar um buzzer passivo no o Arduino, necessitamos de apenas dois

métodos: tone (que gera o som) e o noTone (que interrompe a geração).
tone( <porta>, <frequencia> ); noTone( <porta> );
<porta> <porta>
porta digital à qual o buzzer está ligado porta digital à qual o buzzer está ligado
<frequencia>
Frequência em hertz de vibração do buzzer
Quanto à frequência de vibração, cada valor gera uma percepção sonora (som)
diferente. Para termos uma referência, algumas tabelas da área da física dos sons
relacionam as frequências com as notas musicais produzidas. Abaixo, temos um
mapeamento completo das principais notas, dentro do espectro audível para os seres
humanos e com a organização por oitavas.
Então, para a emissão de um som que reproduza determinada nota, em

determinada oitava, basta utilizar o valor da frequência dentro do método tone, seguido de
um delay que garanta sua execução por um determinado tempo e finalmente por um
noTone para encerrar a sua reprodução.
Pág.
Quanto a ligação eletrônica, é bastante simples. Os buzzers avulsos (sem a placa)
devem ter o pino positivo (indicado com um sinal de + ou com uma perna mais longa)
ligado à porta digital desejada e o outro ao GND, posicionando em algum dos dois um
resistor a partir de 100 para reduzir a corrente e garantir que o componente não queime.
Já os buzzers encapsulados em uma placa possuem 3 pinos, sendo um deles o GND, o
outro o VCC e o outro o pino de sinal que deve ser ligado à porta desejada do Arduino.
Estas placas já possuem um resistor interno que garante a redução. Abaixo um exemplo
de ligação eletrônica dos dois tipos de buzzer à um Arduino. O primeiro (avulso) ligado à
porta digital 4 e o segundo (encapsulado em uma placa) ligado à porta digital 3.
Abaixo, o exemplo de um código com uso do buzzer (ligado à porta digital 3 neste
caso) para reproduzir as 8 notas do famoso toque das chamadas telefônicas a cobrar,
utilizando o Sol, Lá e Si da quarta oitava e o Dó e Ré da quinta oitava.
void setup(){
pinMode(3, OUTPUT);
}
void loop(){
tone(3, 395.50); delay(500); noTone(3); //Sol (4ª oitava)
tone(3, 444.00); delay(500); noTone(3); //Lá (4ª oitava)
tone(3, 528.00); delay(300); noTone(3); //Dó (5ª oitava)
tone(3, 444.00); delay(250); noTone(3); //Lá (4ª oitava)
tone(3, 498.40); delay(450); noTone(3); //Si (4ª oitava)
tone(3, 592.42); delay(300); noTone(3); //Ré (5ª oitava)
tone(3, 498.40); delay(250); noTone(3); //Si (4ª oitava)
tone(3, 528.00); delay(500); noTone(3); //Dó (5ª oitava)
delay(1000);
}
Pág.
7.1.5 Relé
Os relés são um dos componentes mais importantes na automação
para ligar e desligar, através de um sinal de 5V, outros componentes
e dispositivos que necessitem de tensões maiores do que esta
(alimentados por uma fonte de tensão secundária que os sustentem).
Os relés são como interruptores, criando um ponto do circuito que
pode ser aberto (interrompendo o fluxo de corrente) ou fechado (permitindo o fluxo de
corrente). A diferença é que ao contrário dos interruptores comuns (como a chave de luz,
por exemplo) que necessitam de uma força mecânica para alternar entre seus dois estados,
os relés são acionados eletronicamente, recebendo uma tensão de 0V ou 5V que
movimentam a chave interna para um lado ou para outro.
Aplicações: qualquer sistema que necessite ativar (ligar) ou desativar (desligar) um

componente ou dispositivo alimentado por uma fonte secundária em um subcircuito,
permitindo assim controlar até mesmo aqueles que necessitem de tensões que o Arduino
não pode fornecer (inclusive eletrodomésticos).
Os relés de estado sólido avulsos, possuem geralmente 5 pinos. Já módulos relé

(encapsulados em placas que podem possuir um ou mais relés), possuem pelo menos um
pino a mais para garantir potência de acionamento, como será visto abaixo:
Os dois primeiros pinos (1 e 2) são os que vão movimentar a chave interna que
funciona como interruptor (através do acionamento de uma bobina) e devem ser ligados a
quem vai controlar esta chave do relé (no nosso caso, o Arduino), observando a polarização
correta. Já o pino de alimentação extra (3) está presente apenas nos módulos relé e é
utilizado para garantir potência no acionamento da chave (5V fixos sendo o pino 2 ligado
então à uma porta digital para funcionar como o 5V de controle). Relés avulsos ligados
diretamente a placas Arduino muitas vezes não encontram força suficiente para
movimentar a chave e necessitam do uso de um transistor em um circuito secundário para
Pág.
amplificar a corrente, tornando mais complexo seu uso. Já quem vai ser controlado (ligado
ou desligado) deve ter um dos fios que o conecta à fonte secundária segmentado (cortado)
e um dos lados desse fio deve ser ligado ao pino comum do relé (C ou COM). Já o outro
lado do fio pode ser conectado ou no pino normalmente fechado (NF ou NC) ou no pino
normalmente aberto (NA ou NO) do relé. A diferença entre eles é que no pino normalmente
aberto o contato só é fechado quando uma tensão é aplicada à bobina pelo controle,
permanecendo no restante do tempo aberto e sem permitir a passagem de corrente. Já no
pino normalmente fechado, a corrente naturalmente flui por ele estar fechando o contato,
sendo o fluxo interrompido apenas quando tensão é aplicada à bobina pelo controle,
abrindo o contato do circuito. Deste modo, na hora de definir qual deles utilizaremos,
devemos dar preferência por aquele que naturalmente garantirá o estado no qual o circuito
permanecerá por mais tempo, evitando gasto desnecessário de energia.
Para utilizar relés como controle de ligamento e desligamento de dispositivos

externos ao circuito do Arduino, utilizamos um esquema similar ao apresentado abaixo. O
único cuidado é que nos relés avulsos de estado sólido do tipo Metaltex (os mais comuns
com controle em 5V e possibilitando até 250 V e 10 A no circuito secundário) os pinos são
fixos. Já nos módulos relés, cada fabricando define o seu encapsulamento e podemos ter
diferença na posição dos 3 pinos.
A lâmpada do esquema apresentado, pode ser substituída pelo dispositivo que

desejamos controlar (ligar e desligar através do relé). Sua alimentação, pode ser um plug
conectado a uma tomada, mas pode ser também uma fonte de energia, bateria, entre
outros. No nosso exemplo, um dos fios da lâmpada está ligado ao pino Comum do relé (C)
e o outro ao pino Normalmente Fechado (NF). Por isso, a lâmpada ficará normalmente
ligada e quando o relé for acionado (alimentado com tensão através do pino de controle)
ela desligará pois o interruptor se moverá e o circuito antes fechado irá abrir. Se
quiséssemos o efeito contrário, com a lâmpada (ou qualquer equipamento que estivermos
controlando) normalmente desligada, ligando apenas quando o relé for ativado (alimentado
Pág.
com tensão através do pino de controle), bastaria ligar um dos fios ao pino Comum (C) e o
outro ao pino Normalmente Aberto (NA). Temos então um circuito de controle de
dispositivos externos acionados simplesmente pela mudança de estado da porta digital à
qual o pino de controle do relé estiver conectado (em nosso caso, no pino 3).
É importante ressaltar que os módulos podem ser simples, com apenas um relé, ou
com múltiplos, independentes entre si. A diferença na pinagem é que para cada relé
adicional, temos um pino de de acionamento a mais (geralmente chamado de IN), como
podemos ver no comparativo abaixo entre um módulo simples e um módulo duplo.
7.2 Atuadores de ativação simples com tensões superiores à 5V
Como vimos no exemplo do relé, a lâmpada a ser acesa e apagada (110V ou 220V)
não poderia ser alimentada diretamente por uma porta digital do Arduino pois ela não
forneceria o necessário para o seu funcionamento. Nestes casos, necessitamos alimentar
o dispositivo a ser controlado por uma fonte externa e nesse circuito secundário colocamos
um elemento de chaveamento, que pode ser um interruptor, um transistor ou um relé.
Estes dois últimos possuem a grande vantagem de não serem mecânicos e poderem ser
acionados eletronicamente, mas o relé certamente é o de mais simples uso, como
demonstrado anteriormente. Deste modo, praticamente qualquer dispositivo que necessite
de uma tensão ou uma corrente mais alta do que aquelas que o Arduino pode fornecer,
pode ser alimentado por uma fonte secundária e ter um relé controlando o seu
acionamento (através de uma simples mudança de estado em uma porta digital). A seguir,
vamos ver alguns dos principais atuadores deste tipo que são utilizados em projetos de
IOT.
Pág.
7.2.1 Solenoide
Um solenoide é um dispositivo dotado de um pino móvel metálico
(chamado de pistão) envolto por uma bobina. Quando esta bobina
é alimentada gera um campo magnético, tornando-se um
eletroímã poderoso o suficiente para atrair ou repelir o pistão com
força. Quando não alimentada a bobina, o pistão volta à sua
posição original, geralmente por conta de uma pequena mola
presa a si. Assim, o ativar e desativar de um solenoide permite
que este pistão se mova com força para frente ou para trás, criando um movimento de vai
e vem que pode ser aproveitado para gerar movimentos lineares ou para garantir o seu
estado para fora ou para dentro de acordo com a situação (como uma trava). É importante
quando adquirimos um solenoide saber se o mesmo é positivo (pistão para fora em estado
normal, sendo puxado quando energizada a bobina) ou negativo (pistão para dentro em
estado normal, sendo empurrado para fora quando energizada a bobina). Quanto à
alimentação, geralmente necessitam de 12V e a partir de 1A de corrente.
Aplicações: sistemas que necessitem de perfuração (elemento perfurante preso ao

cabeçote do pistão) ou soco mecânico linear ou batida para arremesso e movimentação,
travas, válvulas de ar e de água, entre outros.
7.2.2 Válvula solenoide

As válvulas solenoides são válvulas para controle de vazão de
ar ou de água que, ao invés do uso de um registro convencional
que abre e fecha de acordo com um movimento aplicado nele
(giro para a esquerda ou para a direita), utiliza um solenoide
interno. Geralmente, as válvulas são do tipo “Normalmente
Fechadas”, permitindo a passagem de água ou ar apenas no
momento em que o solenoide é alimentado (e interrompendo a passagem assim que a
alimentação for também interrompida).
Aplicações: sistemas de irrigação (seja para vasos, hortas, plantações ou hidratação de

animais) e sistemas de controle ou de ajuste de vazão de ar ou água (para definição de
volume máximo de uso permitido ou aquisição de informações em tempo real sobre o gasto
imediato e/ou acumulado).
Pág.
7.2.3 Trava solenoide

A trava solenoide é uma espécie de fechadura que também se
beneficia de um solenoide, utilizando o pistão para controlar o
movimento do seu pino para dentro ou para fora, permitindo, assim,
um travamento ou destravamento sem o uso de maçanetas e nem
de chaves. Assim como as válvulas e solenoides mais comuns,
geralmente é encontrado na versão positiva, com o pino para fora
travando e o destravamento ocorrendo apenas quando o seu solenoide é alimentado.
Aplicações: controles de acesso em portas, janelas ou gavetas, com acionamento a

distância por uma rede de comunicação ou por botão interno (como em prédios e entradas
de condomínios) ou integrado a sistemas de identificação (como um leitor de digitais, leitor
de íris ou leitor de tags RFID).
7.2.4 Bomba submersa

A bomba submersa é um motor dotado de uma hélice interna
capaz sugar água por uma entrada e empurrá-la com força por
uma saída. Quando desejamos criar um fluxo de água em um
caminho curto, que não ultrapasse alguns poucos metros, ela é
uma alternativa barata e simples de usar.
Aplicações: aquários, fonte de água, pequenas sistemas de irrigação caseiros,

misturadores de líquidos, borbulhadores, sistemas pneumáticos simples.
7.2.5 Bomba de ar
A bomba de ar, como o próprio nome diz, é um motor capaz de
bombear ar sugado de uma entrada para uma determinada saída.
Quando desejamos criar um fluxo de ar em um caminho curto,
criar um sopro com força razoável ou movimentar o ar entre dois
contêineres distintos, essa bomba é uma ótima opção.
Aplicações: bombas de vácuo, sistemas pneumáticos simples, sopradores, borbulhadores,

misturadores, circuladores e injetores de gás.
Pág.
7.3 Displays
Apesar de existirem diversos atuadores que nos permitam comunicar informações

de forma visual, nenhum é tão eficiente e flexível quanto os displays. Seja através de
caracteres simples, textos ou até mesmo animações, os displays são amplamente
utilizados em projetos de IOT pela facilidade com que os dados, alertas e informações são
mostrados ao usuário (principalmente quando queremos criar centrais de controle). Em
projetos IOT simples e projetos maker, são três os principais tipos utilizados pela sua
facilidade e baixo custo: de 7 segmentos, LCD e OLED.
7.3.1 Display de 7 segmentos

O display de 7 segmentos foi o display mais popular na eletrônica
ao longo de muitos anos, sendo somente nos últimos 20 anos
substituído por tecnologias melhores após a queda acentuada dos
seus valores (como os displays LCD e OLED). Seu uso era
considerado bastante simples por conta da sua construção.
Basicamente, ele é composto de 7 leds (ou 8 em caso do ponto
decimal), cada um posicionado no interior do display em uma concavidade coberta por um
material mais escuro (geralmente de plástico ou vidro). Quando cada um dos leds é ligado,
percebe-se o seu segmento iluminado. Ele possui um cátodo comum a ser ligado no GND
e cada um desses leds possui um pino que deve ser ligado em uma porta que controle o
seu acendimento. Deste modo, a construção dos dígitos torna-se uma
simples combinação de segmentos iluminados e não iluminados,
controlados, no caso do Arduino, pela simples mudança de estados das
portas conectadas aos pinos do display. Estes segmentos são
representados por letras, para fins de organização. Para ilustrar, é
mostrada a imagem ao lado com este esquema de pinos e letras. Se
precisássemos gerar o dígito 3, seria necessário ligar os leds dos
segmentos A (pino 7), F (pino 9), E (pino 1), D (pino 2) e G (pino 10).
Pela mesma lógica, se precisássemos gerar o dígito 2, seria necessário
ligar os leds dos segmentos A (pino 7), B (pino 6), G (pino 10), E (pino
1) e D (pino 2). Para um exemplo, vamos considerar o esquema
eletrônico apresentado a seguir:
Pág.
Para nosso exemplo, vamos criar um contador que a cada 1 segundo incrementa o
dígito, iniciando em zero e terminando com o ponto (após chegar à 9). Uma primeira ação
necessária é mapear cada um dos segmentos do display (A, B, C, D, E, F, G e PONTO) com
as respectivas portas digitais onde cada um foi conectado, senão o acesso através do
número da porta se tornará bem mais difícil. Um método ligaTodos também é necessário
para limpar qualquer segmento ligado quando queremos trocar o dígito, evitando
repetições nos desligamentos. Em nosso setup, indicamos todos os segmentos (portas)
como output e chamamos o método criado para garantir que todos iniciem desligados.
#define A 6 //laranja
#define B 7 //amarelo
#define C 9 //cinza
#define D 10 //turquesa
#define E 11 //marrom
#define F 5 //roxo
#define G 4 //rosa
#define P 8 //verde (ponto)
void desligaTodos(){
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(P, LOW);
}
void setup(){
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
pinMode(P, OUTPUT);
desligaTodos();
}
Pág.
Já dentro do loop, a cada um segundo, um dígito é formado modificando o estado

das portas que ligam os segmentos para HIGH e definindo uma espera de 1 segundo após
a visualização, seguida de uma chama ao método que desliga todos os segmentos.
void loop(){
//dígito 0
digitalWrite(A, HIGH); digitalWrite(B, HIGH); digitalWrite(C, HIGH);
digitalWrite(D, HIGH); digitalWrite(E, HIGH); digitalWrite(F, HIGH);
delay(3000); desligaTodos();
//dígito 1
digitalWrite(B, HIGH); digitalWrite(C, HIGH);
//dígito 2
digitalWrite(A, HIGH); digitalWrite(B, HIGH); digitalWrite(G, HIGH);
digitalWrite(E, HIGH); digitalWrite(D, HIGH);
//dígito 3
digitalWrite(D, HIGH); digitalWrite(G, HIGH);
//dígito 4
digitalWrite(B, HIGH); digitalWrite(C, HIGH); digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
//dígito 5
digitalWrite(A, HIGH); digitalWrite(F, HIGH); digitalWrite(G, HIGH);
digitalWrite(C, HIGH); digitalWrite(D, HIGH);
//dígito 6
digitalWrite(F, HIGH); digitalWrite(E, HIGH); digitalWrite(D, HIGH);
digitalWrite(C, HIGH); digitalWrite(G, HIGH);
//dígito 7
//dígito 8
digitalWrite(D, HIGH); digitalWrite(E, HIGH); digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
//dígito 9
digitalWrite(F, HIGH); digitalWrite(G, HIGH);
//ponto
digitalWrite(P, HIGH);
delay(3000); desligaTodos()
Pág.
O código por trás do uso do display de 7 segmentos é relativamente simples, sem

uma lógica muito elaborada e, portanto, de fácil entendimento. Porém, é bastante
trabalhoso e excessivamente grande para a produção de pouco efeito. Obviamente que ele
poderia ser melhorado, utilizando-se array para representar as 7 ou 8 posições do display
(atribuindo 0 ao segmento desligado e 1 ao segmento ligado) e passando esse array como
parâmetro de um método que o percorre dando digitalWrite em cada posição de acordo
com o seu valor. Porém o maior problema do uso do display de 7 segmentos não é a
programação, mas o número excessivamente grande de portas digitais ocupadas.
7.3.2 Display LCD

Os displays LCD possuem uma matriz de leds que
representam pixels, que aparecem quando expostos
à uma luz de fundo. Diferente do display anterior, os
caracteres não são formados por segmentos simples
controlados individualmente. Além de visualmente
bonitos, estes displays tem a capacidade de controlar estes pixels de forma transparente
ao desenvolvedor, ofertando métodos através dos quais enviamos Strings que são
processadas e transformadas automaticamente em caracteres na tela. Quando
necessitamos mostrar informações com múltiplos dígitos, o uso de display de 7 segmentos
se torna inviável pelo total de portas necessárias e pela quantidade desproporcional de
código para implementação da lógica. Os displays LCD tornam-se alternativas mais
adequadas, mais simples e visualmente mais bonitas. Antes de vermos seus dois usos
mais comuns (de forma direta ou com adaptador I2C), vamos conhecer seu pinout:
Pág.
• VSS: pino de saída da corrente do circuito do display, ligado ao GND do Arduino;

• VCC: pino de alimentação do circuito lógico do display, ligado ao 5V do Arduino;
• VEE: pino de contraste entre fundo e letras. Em montagens simples (como as do

nosso exemplo), pode ser ligado diretamente ao GND o que configura contraste
máximo (para tensão 0). Mas podemos também ligar à uma digital PWM e regular a
tensão, regulando assim o contraste.
• RS: pino de configuração do display para aceite de instruções ou visualização de

dados, sendo a alternância entre estes estados controlada automaticamente pelo
circuito interno e Arduino.
• R/W: pino de configuração do display para escrita (LOW) ou leitura (HIGH). Como
os displays que utilizaremos não são táteis (que possibilitam o funcionamento
também como entrada), serão sempre de saída e, portanto, basta não usar a porta
e nem energizá-la (LOW).
• E: pino de configuração do display como habilitado ou não habilitado para receber

nova leitura. É automaticamente controlado pelo circuito interno.
• D0 à D7: pinos de dados, por onde o display recebe os bytes dos caracteres a serem
exibidos. Caso se deseje trabalhar com o alfabeto convencional e os caracteres
especiais existentes em todos os teclados, utilizamos somente 4 bits, necessitando
apenas dos pinos D4, D5, D6 e D7. Caso se deseje trabalhar com toda a gama de
carateres da codificação UTF-8 (incluindo Kanji, alfabeto cirílico e etc), utilizamos 8
bits e, portanto, os 8 pinos.
• LED+: VCC dos leds do display, ligado ao 5V do Arduino
• LED-: GND dos leds do display, ligado ao GND do Arduino. Por segurança, é
indicado baixar a tensão da porta com um resistor a partir de 100. Isso pode ser
feito ou no LED+ ou no LED-.
Conhecendo os pinos do display, fica mais fácil compreender a sua ligação ao

circuito eletrônico que enviará as sequências de caracteres que deverão ser mostradas. O
seu uso pode se dar de duas formas: direta ou com o uso de uma interface de comunicação
I2C. Apesar dos métodos para o seu controle serem iguais, as ligações eletrônicas e
bibliotecas são diferentes.
Pág.
PRIMEIRA FORMA DE USO: DIRETA
Na forma de uso direta, necessitamos da ligação eletrônica de um número

considerável de pinos nas portas do Arduino, mas nada muito diferente do necessário para
um display de 7 segmentos. Para isso, consideramos as funções vistas no pinout.
Teríamos, então, um circuito eletrônico similar a este:
No caso de uma ligação direta, utilizamos a biblioteca LiquidCrystal, nativa da

Arduino IDE, sem a necessidade de download. A mesma nos fornece um objeto do tipo
LiquidCrystal que representa um display LCD e que quando inicializado, necessita de 6
parâmetros (para usos simples, sem necessidade de cobrir todos caracteres UTF-8): porta
do pino RS, porta do pino E e porta dos pinos D4, D5, D6 e D7. Inicializado o objeto (begin,
informando o total de linhas e colunas), ele nos permite acesso a alguns métodos como:
clear(); setCursor( <coluna>, <linha> );
limpa o display <coluna>

Coluna onde desejamos posicionar o display,
iniciando em 0
print( <texto> );
<linha>
<texto> linha onde desejamos posicionar o display,
iniciando em 0
texto a ser escrito no display
Pág.
Como exemplo de código, vamos escrever o mesmo texto que aparece na montagem
eletrônica, com a String “QI – INTERNET” na primeira linha (0) a partir da primeira coluna
(0) e com o a String “OF THINGS” na segunda linha (1) a partir da sexta coluna (5).
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup(){
lcd.begin(16, 2); //display do exemplo possui 2 linhas de 16 colunas cada
}
void loop(){
//limpando o display
lcd.clear();
//posicionando e escrevendo a primeira parte da String

lcd.setCursor(0, 0); //coluna 0 (primeira) da linha 0 (primeira)
lcd.print(“QI - INTERNET”);
//posicionando e escrevendo segunda parte da String

lcd.setCursor(5, 1); //coluna 5 (sexta) da linha 1 (segunda)
delay(1000);
}
SEGUNDA FORMA DE USO: I2C
Na segunda forma de uso direta, podemos ligar o nosso display à um adaptador I2C
para displays, permitindo o envio das informações através de uma comunicação Serial com
endereçamento. Assim, utilizamos apenas a porta SDA e SCL do Arduino. Entretanto, este
adaptador deve ser soldado às costas do display, cobrindo todos os seus 16 pinos:
Após a soldagem, ao invés de usarmos os pinos do display, utilizamos os pinos do

adaptador I2C, como no esquema eletrônico a seguir:
Pág.
No caso de uma ligação deste tipo, precisamos da biblioteca LiquidCrystal_I2C, não

nativa da Arduino IDE e cujo download pode ser feito neste link: https://bit.ly/arduinoqi.
A sua instalação é análoga ao processo demonstrado no passo a passo do sensor
ultrassônico. Além disso, a biblioteca nativa Wire também é fundamental pois ela é a
responsável por controlar a comunicação I2C. Temos a disposição então um objeto do tipo
LiquidCrystal_I2C que representa um display LCD com interface I2C e que quando
inicializado, necessita de 3 parâmetros: endereço do display (0x27, caso não alterado
mecanicamente através de solda nos pinos de endereçamento), total de colunas e total de
linhas do display. Após instanciado, o objeto nos fornece exatamente os mesmos métodos
da biblioteca LiquidCrystal do exemplo anterior. Assim, teríamos um código muito similar,
como podemos ver abaixo:
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup(){
lcd.init(); //inicializa o display com comunicação I2C
lcd.backlight(); //ativa a luz de fundo do display
}
void loop(){
//limpando o display
lcd.clear();
//posicionando e escrevendo a primeira parte da String

lcd.setCursor(0, 0); //coluna 0 (primeira) da linha 0 (primeira)
//posicionando e escrevendo segunda parte da String

lcd.setCursor(5, 1); //coluna 5 (sexta) da linha 1 (segunda)
lcd.print(“OF THINGS”);
delay(1000);
}
Pág.
7.3.3 Display OLED

Os displays OLED são uma evolução dos displays LCD. Apesar de também serem
baseados no uso de leds iluminados individualmente, aqui temos componentes sólidos e
orgânicos no lugar do cristal líquido da tecnologia anterior. Pela sua construção e modo
de funcionamento, os displays OLED não necessitam de uma luz de fundo (backlight) e
assim conseguem reproduzir o preto puro (algo inviável nos displays LCD). Mesmo os
displays OLED mais simples (como os utilizados para prototipagem), possuem uma
resolução mais alta, com pixels menores, otimização na geração de imagens e até a
possibilidade de trabalhar com mais de uma cor (como azul e amarelo). Geralmente
utilizam comunicação I2C (sendo necessárias, então, somente duas portas do Arduino) e
contam com múltiplos modelos, cada um com suas bibliotecas e métodos próprios,
dependentes de sua construção e dos recursos disponibilizados. O uso de displays OLED,
por sua variedade e diferenças profundas no
uso de cada modelo, foge do escopo de
nosso curso. Porém, para uma ideia geral, é
disponibilizado abaixo o link de um projeto
desenvolvido por Adilson Thomsen, do site
FelipeFlop, exemplificando o uso de uma
das dezenas de modelos encontrados no
mercado: o SSD1306, de resolução 128 x 64
e 3 cores.
https://www.filipeflop.com/blog/como-conectar-display-oled-arduino/
7.4 Motores
Os motores são atuadores de grande importância em projetos das mais diversas

áreas e em IOT não é diferente. É possível o uso de motores de correntes altas através de
relés, como vimos anteriormente, porém são os motores de baixa corrente os mais
utilizados e com o maior custo benefício, equilibrando valores baixos de aquisição e
flexibilidade de aplicação nas mais diversas situações. Falaremos aqui especificamente de
três deles, cada um com suas peculiaridades que os tornam mais ou menos adequados
para cada tipo de projeto: motor DC, motor de passo e servo motor.
Pág.
7.4.1 Motor DC + Ponte H

Os motores DC são os motores mais simples e baratos entre
os utilizados em projetos de prototipagem e o seu uso
consiste em alimentá-los para que os mesmos girem.
Quanto maior a tensão aplicada, maior a velocidade e a
força desenvolvidas. Geralmente (salvo em motores DC
especiais, como os utilizados em drones), não possuímos a
possibilidade de realizar ajustes finos e nem possuímos
muitos parâmetros passíveis de personalização em seu
movimento. Isso é uma desvantagem pela pouca
flexibilidade, mas pode ser também uma vantagem por
conta da simplicidade. Motores DC são amplamente
utilizados na movimentação de robôs que não necessitem
de um ajuste muito fino e nem da garantia de movimentos
milimétricos. Também é bastante comum o seu uso aliado
com correias, polias e esteiras, sendo um gerador de
movimentos posteriormente controlados com transferidores mecânicos. Neste motor, dois
são os parâmetros que nos interessam controlar:
Velocidade: a velocidade do motor é diretamente proporcional à tensão aplicada a ele.

Desde modo, se o motor for alimentado com até 5V, uma boa alternativa é ligar qualquer
um dos seus polos (ele não é polarizado) ao GND e o outro à uma porta digital PWM
qualquer, pois nela, através do controle do Duty Cycle, regulamos a tensão de saída. Já
para sabermos a velocidade, uma das possibilidades mais simples é anexar um disco
perfurado ao eixo do motor e com ele contarmos os giros por segundo através de um
encoder óptico, transformando estes giros em metros por segundo e após em quilômetros
por hora. Caso não lembre como fazer isso, consulte o capítulo 6.1.12 (Encoder óptico e
Encoder magnético).
Direção do giro: a direção do giro dos motores DC (horário ou anti-horário), depende

diretamente da polarização de sua ligação à fonte de alimentação. Se escolhermos um dos
seus polos e ligarmos ele ao GND e o outro à uma alimentação (fonte, bateria, porta digital
do Arduino, etc) ele irá girar em um sentido e se invertermos ele irá girar em um sentido
inverso. Se para nosso uso o giro em um só sentido é suficiente, basta descobrir qual a
polarização correta. Mas caso tenhamos a necessidade de que esse giro mude de sentido
ao longo do uso (para provocar movimentos para frente ou para trás, para auxiliar em uma
Pág.
freada ou diminuição brusca de velocidade, etc), obviamente que não seria adequado que
realizássemos essa inversão manualmente. É aí que entra a Ponte H. Este componente
tem um princípio muito simples: em um dos seus lados, temos dois terminais onde
conectamos um motor e no outro temos dois terminais onde conectamos a fonte de
alimentação do mesmo. Porém, existem dois pinos adicionais binários que devem ser
ligados à duas portas digitais e, de acordo com a combinação de estados dessas portas
(LOW ou HIGH) ele inverte ou desinverte a polaridade, fazendo com que o motor mude o
sentido de sua rotação. Uma das grandes vantagens da ponte H é que além da simplicidade
nessa inversão, ela permite a alimentação com fontes externas para o controle de motores
de maior potência. Quanto ao giro, os dois pinos ligados às portas digitais apresentam as
seguintes combinações lógicas:
As pontes H geralmente são encontrados em módulos duplos, permitindo o controle

de dois motores de forma simultânea e possuindo, desse modo, além de um VCC e um
GND, mais 4 pinos de controle (2 para cada motor). Abaixo, um esquema eletrônico de uso
de uma ponte H dupla.
Pág.
Neste esquema, o GND e o VCC estão conectados no Arduino, utilizando como

alimentação dos motores os 5V fornecidos por ele. Porém se fossem motores mais potentes
e que necessitassem de uma tensão maior, bastaria ligar o VCC e GND da ponte H em uma
fonte externa (12V por exemplo) e não ao Arduino. Realizadas as ligações, o controle do
sentido do giro fica bastante simples, baseado na mudança de estados das portas (6 e 7
no motor, 1 e 4 e 5 no motor 2). Abaixo um exemplo onde os motores iniciam desligados,
após movimentam-se juntos no mesmo sentido freando após 2 segundos e por último
movimentam-se em sentidos opostos por mais 2 segundos.
#define A_M1 6
#define B_M1 7
#define A_M2 4
#define B_M2 5
void setup(){
pinMode(A_M1, OUTPUT);
pinMode(B_M1, OUTPUT);
pinMode(A_M2, OUTPUT);
pinMode(B_M2, OUTPUT);
}
void loop(){
//iniciando com os motores desligados
digitalWrite(A_M1, LOW);
digitalWrite(B_M1, LOW);
delay(2000);
//movimentando os dois para frente (mesmo sentido)

digitalWrite(B_M1, HIGH);
delay(2000);
//freando os dois motores

digitalWrite(A_M1, HIGH);
delay(2000);
//movimentando os dois em sentido inverso

delay(2000);
Pág.
7.4.2 Motor de passo

Os motores de passo são motores especiais com três
características bastante interessantes: uma grande força
(torque) proporcionada pelo uso de uma caixa de redução
interna, a possibilidade do controle de sua velocidade e a
possibilidade do controle da amplitude do seu movimento (ou
seja, o quanto irá se movimentar a cada comando). Por estas
caraterísticas, eles não são motores para uso de velocidade pois são bem mais lentos que
os DC, porém contam com uma precisão incomparavelmente maior. Assim, são muito mais
adequados para ações onde a precisão dos movimentos é mais importante que a velocidade
de realização da ação. Essa precisão é possível pois os motores de
passo trabalham internamente com múltiplas bobinas dispostas ao
longo do perímetro do seu corpo circular. Os múltiplos canais (que
alimentam estas bobinas) são ativados alternadamente em um
movimento que force o deslocamento linear do rotor interno, girando
o pino do motor e travando quando o movimento é interrompido. Essa sequência de
energização das bobinas e o consequente movimento do rotor, pode ser implementado
manualmente através da mudança de estados das portas de controle, porém se tornaria
complexa de acordo com a angulação necessária a cada passo e daria origem a trechos de
código extensos. Para facilitar o uso, existem adaptadores especiais chamados de “Drivers
para Motor de Passo” que simplificam o processo, oferecendo interfaces com bibliotecas
que contém métodos que possibilitam um controle mais lógico e direto. Um desses drivers
(e talvez o mais famoso) é o ULN 2003 e o circuito eletrônico para controle do motor ficaria
como o exemplo retirado do site FelipeFlop e desenvolvido por Adilson Thomsen:
Pág.
Em sua grande maioria, os motores de passo (como o do exemplo) possuem 5 fios

para o controle das bobinas e das sequências de energização, sendo que estes fios
terminam em um plug que facilita a conexão do motor com um driver. O ULN2003, além
de contar com o encaixe para o plug do motor, possui uma porta GND (identificada com o
sinal de menos) e uma porta VCC (identificada com o sinal de mais) com uma tensão de
entrada suportada entre 5V e 12V. Assim, caso o motor de passo utilizado seja de até 5V,
estes dois pinos poderiam ser ligados diretamente ao VCC e GND do Arduino. Caso o motor
de passo necessitasse de maior corrente (6V, 9V, 12V) estes pinos poderiam ser ligados
diretamente à uma fonte que forneça essa tensão. Além disso, os 4 pinos de controle do
driver (nomeados de IN1, IN2, IN3 e IN4), devem ser ligados à 4 portas digitais do Arduino
para que através delas os movimentos e a velocidade sejam controlados.
O Arduino conta com uma biblioteca nativa para esse fim, chamada de Stepper. Ela
nos traz um objeto do tipo Stepper que para ser instanciado necessita de 5 parâmetros: o
número de passos por evolução (o padrão é 500 e esse será o valor que vamos usar para
basear os outros movimentos) e as portas do Arduino onde foram ligados os pinos de
controle, EXATAMENTE nesta ordem: IN1, IN3, IN2 e IN4. Instanciado o objeto, ele nos
oferece dois métodos importantes: setSpeed para controle da velocidade e step para
controle do movimento gerado pelo motor.
setSpeed( <velocidade> ); step( <passos> );
<velocidade> <passos>
rotações por minuto do motor total de passos de deslocamento (giro)
Na configuração padrão de um motor de passo, um giro completo necessita de 2048

passos (sequências possíveis na combinação das bobinas). Isso significa que cada grau é
equivalente a 5 passos (2048 / 360 = 5). Deste modo, caso se precise ordenar uma rotação
em graus ao motor, podemos facilmente calcular, multiplicando o ângulo por 5 para a
conversão em passos. Além disso, o valor positivo gera um movimento em sentido horário
e um valor negativo gera um movimento em sentido anti-horário. Quanto a velocidade, na
configuração default (com o número de passos por evolução em 500), os motores mais
simples suportam velocidade entre 0 e 70 RPM.
Para ilustrar, veja o código da próxima página. Nele é instanciado um objeto

Stepper, respeitando a sequência de parâmetros estabelecida. Dentro do loop, o motor tem
sua velocidade configurada para 30 RPM e recebe uma ordem para girar 360º em sentido
Pág.
horário (valor positivo e ângulo multiplicado por 5 para transformação em passos) e após
em sentido anti-horário (valor negativo e ângulo multiplicado por 5 para transformação em
passos). Para finalizar, o motor tem sua velocidade reduzida para 10 RPM e recebe uma
ordem para girar 180º em sentido horário e depois 180º em sentido anti-horário.
#include <Stepper.h>
Stepper motor(500, 8, 10, 9, 11);
void setup(){
void loop(){
//360º em sentido horário e depois 360 em sentido anti-horário à 30 RPM

motor.setSpeed(30);
motor.step(360*5);
delay(1000);
motor.step(-360*5);
delay(1000);
//180º em sentido horário e depois 90º em sentido anti-horário à 10 RPM

motor.setSpeed(10);
motor.step(180*5);
delay(1000);
motor.step(-90*5);
delay(1000);
7.4.3 Servomotor
Os servomotores são motores similares aos de passo, com
força e precisão, porém com uma facilidade de uso ainda
maior, visto que seus movimentos se baseiam no
deslocamento do eixo para um ângulo entre 0º e 180º.
Assim, podemos perceber que a desvantagem é a limitação
do movimento, não sendo possível o giro completo (salvo
em servomotores especiais e muito mais caros, ou
modificados internamento, o que não é recomendado). Mas mesmo assim, este giro de 180º
geralmente é suficiente para a realização de movimentos que não sejam o de deslocamento,
com a grande vantagem de os servos serem mais baratos do que os motores de passo. Para
se ter ideia das possibilidades que os servos nos oferecem, mesmo com a limitação do giro,
é disponibilizado um link da UsinaInfo onde Matheus Gebert Straub apresenta o
funcionamento de um kit de peças de madeira que possibilitam a montagem de um braço
Pág.
robótico, controlado através de 2 joysticks, com uso
de 4 servos para rotação em 3 eixos além do
movimento de abre e fecha da garra. Neste exemplo
está sendo utilizada uma Shield para a conexão dos
servomotores, mas a mesma é desnecessária já que
eles podem ser conectados diretamente ao Arduino,
usando, cada um, uma porta digital para o controle
(além do VCC e do GND da placa).
https://www.usinainfo.com.br/blog/braco-robotico-arduino-com-servo-motor-e-joystick/
A ligação de um servomotor ao Arduino é bastante simples e similar ao esquema

mostrado abaixo (onde o pino de controle foi ligado à porta digital 3):
Para o controle efetivo do movimento do servomotor, utilizamos a biblioteca Servo,

nativa do Arduino, que nos oferece um objeto do tipo Servo que não necessita de nenhum
parâmetro ao ser instanciado. Após, podemos acessar com este objeto dois métodos
importantes: attach (que nos permite indicar à qual do Arduino o pino de controle do servo
foi conectado) e write (que nos permite dizer ao servo o ângulo para o qual ele deve deslocar
o seu eixo).
attach( <porta> ); write( <angulo> );
<porta> <angulo>
porta do Arduino onde o pino de controle ângulo entre 0º e 180º para o qual o
do servo foi ligado Servo deve deslocar o seu eixo
Pág.
Para um melhor entendimento, veja o código do exemplo abaixo onde iniciamos o

servomotor em 0º, deslocamos para 180º, após voltamos para 90º, depois 45º até que o
loop reinicie e o ângulo volte a ser de 0º, iniciando um novo ciclo de movimento. Perceba
que diferentemente do motor de passo, não controlamos a velocidade do servo. Outra
característica interessante é que como o ponto máximo à direita é de 0º e o ponto máximo
à esquerda é de 180º, o deslocamento em sentido horário e anti-horário é natural, apenas
informando a posição desejada através do ângulo, sem a necessidade do uso de valores
positivos e negativos para informar o sentido.
#include <Servo.h>
Servo motor;
void setup(){
motor.attach(3);
}
void loop(){
//deslocando o eixo do servo para 0º → 180º → 90º → 45º

motor.setSpeed(0);
delay(1000);
motor.setSpeed(180);
delay(1000);
motor.setSpeed(90);
delay(1000);
motor.setSpeed(45);
delay(1000);
}
7.5 Emissor Infravermelho
O emissor infravermelho é um fotodiodo capaz de emitir luz infravermelha,

invisível à nós humanos, mas perceptível por câmeras, lentes e fotodiodos
receptores. Quanto a aparência, não se difere de um led de alto brilho (com
invólucro transparente) e o seu funcionamento básico é similar: alimentado
com tensão, o mesmo “acende”. Esse componente é de fundamental
importância e base dos chamados “controle remotos”. O controle remoto
nada mais é do que um circuito eletrônico programado para que cada botão
pressionado emita uma sequência de “piscadas” infravermelhas, com
Pág.
diferentes tempos de duração e diferentes espaçamentos. Estas piscadas podem então ser
percebidas por um receptor infravermelho, através do qual estimamos essas durações e
espaçamentos. Assim, temos uma forma eficiente de enviar um sinal codificado através de
um dispositivo e este sinal ser recebido por outro dispositivo com a capacidade de o
descodificar. Isso torna possível programar ações diferentes no dispositivo que percebe o
sinal para cada código recebido através da modulação
infravermelha. Um controle de televisão de uma
determinada marca, por exemplo, está preparado
para emitir sinais com uma codificação para cada
uma de suas teclas e as televisões dessa marca, por
sua vez, estão preparadas para ler esses sinais e
executar uma ação para cada um dos códigos de cada
uma das teclas deste controle.
Não nos interessa aqui aprofundar em como ocorre essa codificação e

descodificação, os tempos, frequências e durações dos pulsos. O interessante para nós,
em nossos projetos de IOT, é que um controle remoto pode ser “clonado”, descobrindo o
sinal que cada tecla emite. Isso permite duas coisas na prática após a clonagem: utilizar o
controle remoto para controlar o Arduino ou usar o Arduino para controlar os dispositivos
preparados para usar aquele controle remoto. Vamos ver estes dois processos em
separado, até mesmo por utilizarem duas técnicas diferentes. Para os dois exemplos,
vamos montar um mesmo circuito eletrônico de clonagem e teste como o abaixo:
Pág.
Neste circuito, temos na parte de baixo em receptor infravermelho, responsável por

perceber os sinais luminosos. Este sensor com 3 pinos (sinal, que ligamos na porta digital
5, VCC e GND) geralmente é mais adequado pois como conta com um pino adicional para
alimentação, tem uma maior capacidade de percepção com sinais fracos. Porém, um
receptor de 2 pinos também poderia ser utilizado, obrigando apenas que o controle seja
pressionado mais próximo a ele. Acima, temos um emissor infravermelho de 5mm (existem
também de 3mm, porém emitem sinais mais fracos e não podem ser alimentados
diretamente com 5V) com a perna mais curta ligada ao negativo e a perna mais longa ligada
à porta digital 2. Ele é o responsável por emitir sinais infravermelhos e através dele vamos
tentar controlar algum equipamento que responda ao controle remoto clonado. Já na porta
7 temos um led que iremos utilizar para testar se através de um controle clonado
conseguimos controlar o Arduino, ligando o led com uma de suas teclas e desligando com
outra. Utilizaremos a biblioteca especial IRRemote que fornece diversos métodos para
trabalhar com o envio, codificação e descodificação do sinal infravermelho. Esta biblioteca
pode ser baixada no link: https://bit.ly/arduinoqi
Com isso, podemos começar os nossos experimentos. Aqui não é objetivo o

aprofundamento nos códigos que descobrem as teclas ou geram as sequências e
frequências de envio e codificação, mas sim ter um passo a passo do processo para
posteriormente poder adaptá-lo e utilizá-lo em nossos projetos.
7.5.1 Clonando o controle remoto para controlar o Arduino

Neste primeiro experimento, iremos utilizar o circuito montado para descobrir
através do receptor infravermelho os códigos enviados pelas teclas de um controle remoto
quando pressionadas. A partir daí, vamos escolher duas delas para que liguem ou
desliguem o led conectado na porta 7 do Arduino.
Passo 1: descobrir o código hexadecimal das teclas
Primeiramente, se desejamos “clonar” um controle para utilizar suas teclas de modo a

comandarem o Arduino, necessitamos descobrir qual o código enviado em infravermelho
por cada uma delas. Neste exemplo, vamos utilizar um controle remoto universal da LG
para televisores, mas pode-se utilizar qualquer controle remoto desejado. Abra o Arduino
IDE, cole o seguinte código e envie para a placa:
Pág.
#include <IRremote.h>
IRrecv receptor(5);
decode_results resultado;
void setup(){
Serial.begin(9600);
receptor.enableIRIn();
}
void loop(){
if(receptor.decode(&resultado)){
Serial.println(resultado.value);
receptor.resume();
}
delay(100);
}
Após, abra o monitor Serial e pressione rapidamente (sem segurar) as teclas do seu
controle remoto. Para cada tecla pressionada será mostrado um número que é o resultado
da descodificação daquela tecla. Para garantir que o código está correto, pressione algumas
vezes a mesma tecla para verificar se os códigos conferem, pois é normal o aparecimento
de ruídos que modifiquem o valor final lido. No exemplo abaixo, no controle de televisores
LG, estes foram os códigos exibidos ao pressionar os botões volume para cima e volume
para baixo:
Com isso descobrimos que sempre que pressionamos a tecla de volume para cima,
recebemos um código 55152015 no Arduino e sempre que pressionamos a tecla volume
para baixo recebemos um código 551534655.
Pág.
Passo 2: usando o código descoberto das teclas para controlar o Arduino
Depois de mapear as teclas que desejamos, podemos criar um programa no Arduino que
sempre que recebe um código infravermelho de uma tecla, testa qual o valor desse código
e executa algo. Em nosso exemplo, iremos fazer com que sempre que a tecla volume para
cima for pressionada (código 55152015) o led da porta 7 acenda e sempre que a tecla
volume para baixo for pressionada (código 551534655) o led da porta 7 apague.
#include <IRremote.h>
IRrecv receptor(5);
decode_results resultado;
void setup(){
Serial.begin(9600);
pinMode(7, OUTPUT);
receptor.enableIRIn();
}
void loop(){
if(receptor.decode(&resultado)){
if(resultado.value == 551502015){ //volume para cima
}
if(resultado.value == 551534655){ //volume para baixo
}
receptor.resume();
}
delay(100);
}
Se tudo estiver certo e as teclas tiverem sido corretamente mapeadas, o led pode ser ligado
e desligado com o controle. Abaixo, nosso exemplo com o controle da TV LG funcionando
e com o led ligado através da tecla de volume para cima.
Pág.
7.5.2 Clonando o controle remoto para controlar equipamentos

Neste segundo experimento, iremos utilizar o circuito montado para descobrir,
(através do receptor infravermelho) as sequências enviadas pelas teclas e gerar
automaticamente um código que consiga reproduzir (através do emissor infravermelho)
exatamente as mesmas piscadas com as mesmas durações e frequências. Deste modo,
conseguimos posteriormente com o Arduino reproduzir essas sequências infravermelhas
através de seu emissor, se tornando o próprio Arduino um controle remoto capaz de operar
dispositivos eletroeletrônicos.
Passo 1: gerar o código que reproduz a sequência de piscadas infravermelhas de cada

uma das teclas
Primeiramente, necessitamos realizar a clonagem, gerando os códigos que reproduzam as

sequências infravermelhas exatas (piscadas de determinada duração e frequência) de cada
tecla. Para isso, abra o Arduino IDE, cole o código abaixo e envie para a placa:
#define MAXPULSE 65000

#define RESOLUTION 20
#define IRpin_PIN PIND
#define IRpin 5
uint16_t pulses[100][2];
uint8_t currentpulse = 0;
void setup(void){
Serial.begin(9600);
Serial.println("Ready to decode IR!");
}
void loop(){
uint16_t highpulse = 0;
uint16_t lowpulse = 0;
while (IRpin_PIN & _BV(IRpin)) {
highpulse++;
delayMicroseconds(RESOLUTION);
if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
printpulses();
currentpulse = 0;
return;
}
}
pulses[currentpulse][0] = highpulse;
while (! (IRpin_PIN & _BV(IRpin))) {
lowpulse++;
delayMicroseconds(RESOLUTION);
if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
printpulses();
currentpulse = 0;
return;
}
}
pulses[currentpulse][1] = lowpulse;
currentpulse++;
}
Pág.
void printpulses(void) {
Serial.println("\n\r\n\rReceived: \n\r OFF \t ON");

for(uint8_t i = 0; i < currentpulse; i++) {
Serial.print("delayMicroseconds(");
Serial.print(pulses[i][0] * RESOLUTION, DEC);
Serial.print(");\n");
Serial.print("pulseIR(");
Serial.print(pulses[i][1] * RESOLUTION, DEC);
Serial.print(");\n");
}
}
Agora abra o monitor Serial e pressione rapidamente (sem segurar) as teclas do seu
controle remoto. Para cada tecla pressionada será gerado um código com diversas linhas,
que reproduzem a emissão do infravermelho recebida. Copie esse código para cada tecla
desejada (logo abaixo da linha OFF ON). Em nosso exemplo, vamos utilizar apenas a tecla
liga/desliga.
Passo 2: usando o código descoberto das teclas para controlar o Arduino
Depois de copiar os códigos gerados para cada tecla, vamos criar um programa no Arduino
que execute esses códigos, testando se o emissor infravermelho, através deles, consegue
controlar o equipamento do controle remoto clonado. Podemos, para melhor organização,
criar um métodos para a execução destes códigos clonados de cada tecla. No nosso caso,
vamos criar um método ligarDesligar() que receberá o código da tecla Liga/Desliga copiado
anteriormente e dentro do loop, a cada 10 segundos, vamos chamar esse método, ligando
ou desligado a televisão.
Pág.
void setup(){
pinMode(2, OUTPUT);
}
void pulseIR(long microsecs){

cli();
while(microsecs > 0){
delayMicroseconds(10);
delayMicroseconds(10);
microsecs -= 26;
}
sei();
}
void ligaDesliga(){ //código gerado para a tecla Liga/Desliga colado no método

delayMicroseconds(7984); pulseIR(9260); delayMicroseconds(4660); pulseIR(560);
}
void loop(){
//a cada 10 segundos o Arduino liga ou desliga a TV

delay(10000);
ligaDesliga();
Se tudo estiver ok e o mapeamento realizado de forma correta,

o Arduino conseguirá, através do seu emissor infravermelho,
controlar o equipamento como se fosse o seu próprio controle
remoto. Em nosso exemplo, na imagem ao lado, podemos ver
a televisão ligada pelo Arduino através da clonagem do botão
Liga/Desliga do controle remoto universal da LG. Como visto,
mapeamos apenas uma tecla, mas adaptando nosso exemplo,
podemos controlar totalmente um ou mais aparelhos de
marcas diferentes com um único emissor infravermelho.
Pág.
UNIDADE 6 – TÓPICOS AVANÇADOS
8 MÓDULOS ESPECIAIS E COMUNICAÇÃO
Além dos sensores e atuadores vistos, o Arduino conta com uma série de módulos
especiais (alguns deles que podem inclusive funcionar como entrada ou saída de dados de
forma alternada). Entre os seus diversos fins, três são muito importantes e agregam novas
possibilidades aos nossos projetos: gravação da dados e comunicação. Por isso, iremos ver
nesse capítulo o módulo de cartão MicroSD (que permite a gravação de dados de nosso
Arduino em arquivos que podem ser lidos e manipulados) e módulos de comunicação
bluetooth, ethernet e wifi (que permitem a comunicação do Arduino com outros
dispositivos além do seu acesso à internet para o recebimento e o envio de informações e
mesmo para funcionarem como servidores web fornecendo webpages para controle e
visualização de informações).
8.1 Módulo de Cartão MicroSD
Até o momento, trabalhamos com o entendimento dos sensores

e atuadores para adquirir informações do mundo externo
(compreendendo o que está acontecendo no entorno do
Arduino) e agir sobre ele (seja comunicando ou seja executando
ações dos mais diversos tipos). Porém, em nenhum momento,
nos preocupamos com uma funcionalidade essencial na grande
maioria dos projetos: o registro das informações, armazenando
os dados lidos pelos sensores, as ocorrências programadas para
serem detectadas e as ações executadas pelo sistema. Quando esse registro nos basta em
um sistema local, o Módulo de Cartão MicroSD acaba se tornando muito interessante.
Como o próprio nome nos indica, ele consegue dar à nossa placa a possibilidade de ler e
escrever em um cartão MicroSD, abrindo ou criando arquivos e guardando neles
informações pertinentes. Veremos a seguir os principais métodos necessários além de um
exemplo de uso do módulo especial.
Pág.
8.1.1 Principais métodos para trabalhar com arquivos e MicroSD

Entre os principais métodos necessários para trabalhar com arquivos e cartões SD,
estão a verificação da existência de um cartão no leitor, a verificação da existência de um
determinado arquivo, a criação de um arquivo novo, a abertura de um arquivo existente,
a escrita nesse arquivo (inclusão de linhas) e a exclusão do arquivo.
Verificar se o cartão MicroSD está presente no leitor
if(SD.begin(<porta>)) { ... }
Abrir um arquivo existente através do nome (ou criar novo) em modo escrita
File <nome_desejado> = SD.open(<caminho_nome_extensao>, FILE_WRITE);
Abrir um arquivo existente através do nome (ou criar novo) em modo leitura
File <nome_desejado> = SD.open(<caminho_nome_extensao>);
Escrever uma linha em um arquivo aberto

<nome_objeto_file>.println(“Conteudo”);
Fechar e salvar um arquivo após editar
<nome_objeto_file>.close();
Percorrer um arquivo aberto pegando o seu conteúdo
while(<nome_objeto_file>.avaiable(){... <nome_objeto_file>.read(); ...}
Apagar do MicroSD um arquivo existente (pelo nome)
SD.remove(caminho_nome_extensao);
8.1.2 Esquema eletrônico de ligação do leitor

Os leitores de cartão MicroSD compatíveis com o Arduino utilizam a comunicação
SPI, um tipo de comunicação Serial especial para periféricos externos à placa e que
oferecem uma troca de mensagens padronizada (já utilizamos esta interface no projeto do
leitor RFID visto neste livro). Nela, as portas são fixas pois respeitam os pinos especiais
que implementam a SPI (SCK, MOSI, MISO) e no Arduino Uno estão organizados da porta
digital 11 até a porta digital 13. O único pino que permite variação é o CS que em nosso
Pág.
exemplo está ligado à porta digital 4. Deste modo, a ligação eletrônica torna-se simples
(apesar de ser inflexível) e o esquema é apresentado abaixo. Tenha o cuidado de verificar
se o seu modelo de Leitor de Cartão MicroSD possui alimentação de 5V ou 3.3V pois é
comum encontrar leitores dos dois tipos.
8.1.3 Exemplo prático: histórico de temperaturas de um forno de pizza

Como exemplo de uso do Leitor de Cartão MicroSD, vamos imaginar um sistema de
controle de temperatura de um determinado ambiente monitorado. O sistema deve ter 3
botões: o primeiro inicia um monitoramento onde a cada 1 segundo a temperatura é
medida e onde, com o passar do tempo, devem ser identificadas a menor mínima e a maior
máxima do período (ligando o led para indicar monitoramento ativo); o segundo finaliza o
período (que deve ser contabilizado por um contador crescente) e paralisa o
monitoramento, gravando uma linha de log em um arquivo texto chamado
“logtemperaturas.txt” com o número do período, duração em segundos, temperatura
mínima e temperatura máxima medidas (e desliga o led para indicar monitoramento
inativo); o terceiro abre o arquivo de log e exibe todo o seu conteúdo no monitor serial. A
cada medição (ou seja, a cada um segundo), cada nova mínima ou máxima descoberta
deve disparar um beep como indicativo. Para a implementação de nosso exemplo, vamos
utilizar o circuito eletrônico mostrado a seguir:
Pág.
Em relação ao código, necessitamos apenas de alguns dos métodos de manipulação

de cartão SD e arquivos além de identificar o clique dos botões e, durante o monitoramento,
testar a temperatura medida para verificar se ela é menor que a menor mínima encontrada
até o momento ou maior do que a maior máxima encontrada até o momento. Deste modo,
teremos um código como o a seguir:
#include <SPI.h>
#include <SD.h>
int segundos, período = 0;

float minima, maxima;
bool ativo = false;
void setup(){
Serial.begin(9600);
pinMode(A0, INPUT_PULLUP);
pinMode(A5, INPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
while(!SD.begin(10)){
Serial.println("Por favor, insira um cartão MicroSD válido!");
delay(5000);
}
Serial.println("Cartão MicroSD válido! Iniciando o sistema...");
Pág.
void loop() {
if(digitalRead(A0) == LOW){
ativo = true;
segundos = 0;
periodo++;
minima = 999;
maxima = -999;
}
if(digitalRead(A1) == LOW){
if(ativo == true){
ativo = false;
File arquivo = SD.open("logtemperaturas.txt", FILE_WRITE);
arquivo.println("Periodo:" + (String)periodo + "|Tempo:" + (String)segundos +
"|Mínima:" + (String)minima + "|Máxima:" + (String)maxima;
arquivo.close();
}
if(digitaRead(A2) == LOW){
File arquivo = SD.open("logtemperaturas.txt");
Serial.println("");
Serial.println("**********************************************************");
Serial.println("************* LOG DE TEMPERATURAS *************");
Serial.println("**********************************************************");
while(arquivo.available()){
Serial.write(arquivo.read());
}
arquivo.close;
}
if(ativo == true){
float temperaturaLida = map(valorLido, 0, 150, 0, 350);
if(temperaturaLida < minima){

minima = temperaturaLida;
tone(6, 528);
delay(1000);
noTone(6);
} else if(temperaturaLida > maxima){
maxima = temperaturaLida;
tone(6, 528);
delay(1000);
noTone(6);
} else {
delay(1000);
}
Entendendo o código-fonte: Iniciamos o código-fonte com a importação das duas

bibliotecas que permitem o acesso a cartões SD (SD.h) e a comunicação especial que
reconhece o leitor SD como um periférico (SPI.h). Além disso, são declaradas variáveis para
o armazenamento da mínima e máxima encontradas, o total de segundos decorridos, o
Pág.
número do período e uma indicação de se o monitoramento está ativo ou parado. No setup,
inicializamos a Serial e indicamos o tipo das portas A0, A1, A2 (utilizadas pelos botões
como INPUT_PULLUP), A5 (utilizada pelo sensor de temperatura LM35 como INPUT) e 7
(utilizada pelo buzzer como OUTPUT). Após, ainda dentro do setup, testamos se existe um
cartão MicroSD presente no leitor, ficando o código preso dentro do while enquanto um
cartão não for encontrado e seguindo adiante (para o loop) quando for. No loop, possuímos
um condicional para testar o pressionamento de cada um dos 3 botões. Caso o botão em
A0 seja pressionado, ligamos o led, inicializamos as variáveis, zerando segundos,
incrementando periodo e atribuindo true para a variável ativo (indicando que o
monitoramento está ativo), 999 para a variável minima (para que qualquer valor lido
primeiro seja menor do que ela) e -999 para a variável maxima (para que qualquer valor
lido primeiro seja maior do que ela). Caso o botão em A1 seja pressionado, se o
monitoramento estiver em andamento, desligamos o led, atribuímos false à variável ativo,
abrimos o arquivo "logtemperaturas.txt" (para escrita) e damos um println dentro dele,
escrevendo uma nova linha com as informações de período, tempo, mínima e máxima do
período (fechando o arquivo logo em seguida). Caso o botão A2 seja pressionado,
escrevemos na Serial um cabeçalho que indica o log de temperaturas, abrimos novamente
o arquivo "logtemperaturas.txt" (para leitura) e enquanto ainda tivermos dados não lidos
dele, percorremos e escrevemos o conteúdo na Serial. Finalmente, a cada ciclo do loop,
capturamos a temperatuda do LM35 (utilizando um map para converter o valor capturado
em graus celsius) e testamos se ele é maior do que a maior máxima ou menor do que a
menor mínima capturadas até o momento (substituindo o valor caso seja e emitindo um
beep para informar uma nova mínima ou máxima encontrada).
8.2 Módulo Bluetooth
Uma das formas de comunicação mais utilizadas em IOT para a troca de

informações é o bluetooth. Ele é um tipo de sinal de rádio que permite a
criação de uma rede de comunicação entre diversos dispositivos presentes
dentro da área de cobertura do sinal (um raio de aproximadamente 100m).
Por ser relativamente comum e muito utilizado por smartphones é uma
alternativa viável e segura para estabelecer uma comunicação entre um
smartphone e o nosso Arduino. Porém, diferentemente do Esp32 e de
algumas outras placas especiais, o Arduino Uno (e as variantes mais comus
como Mega, Nano, Leonardo, Due, etc) não conta com um bluetooth nativo
e necessita de um módulo adicional que agregue a ele este recurso. Entre as
Pág.
diversas opções existentes no mercado, as mais conhecidas e utilizadas são as da família
HC, principalmente por sua simplicidade e baixo custo. Os módulos dessa família possuem
pequenas variações em seus recursos (podem funcionar em modo escravo ou modo misto,
podem ter comunicação otimizada, etc), mas todas as versões possuem a implementação
da comunicação básica necessária para a troca de informações e isso é o que diretamente
nos interessa aqui. A comunicação bluetooth é na verdade uma comunicação Serial, porém
mais segura dada a necessidade de um pareamento e de um endereçamento que
identifique o dispositivo ao qual desejamos conectar. Neste livro, não é nosso objetivo o
aprofundamento no funcionamento do bluetooth e no protocolo de comunicação que o
sustenta e nem como a comunicação serial é implementada em outras linguagens de
programação, mas sim na sua utilização prática com o Arduino. Por isso, veremos como
descobrir o MacAddress de um módulo HC, realizar o pareamento e implementar o envio
e recepção de mensagens via Serial no Arduino, comunicando com um app Android mobile
desenvolvido através de blocos (sem programação com o AppInventor 2).
8.2.1 Principais métodos para trabalhar com o módulo HC

Como o módulo HC trabalha com bluetooth, baseado em comunicação Serial (na
conexão estabelecida entre o módulo e o dispositivo ao qual deseja se comunicar) podemos
fazer uso da biblioteca “SoftwareSerial”, nativa do Arduino e que auxilia na troca de
mensagens utilizando esta tecnologia. Ela nos fornece um objeto do tipo SoftwareSerial
através do qual conseguimos acessar métodos para ler informações externas recebidas
através da Serial ou para enviar informações através da Serial. A instanciação de um objeto
desta classe é realizada como segue abaixo, informando as portas do Arduino onde o pino
RX e o pino TX do módulo estão conectados:
SoftwareSerial <nome_objeto_serial>(<porta_pino_RX>, <porta_pino_TX>);
Criado o objeto, o mesmo deve ser inicializado atribuindo uma velocidade de

trabalho pois trata-se de um objeto serial:
<nome_objeto_serial>.begin( <velocidade> );
Inicializado o objeto, para enviar uma String via serial basta dar um print:
<nome_objeto_serial>.print( <string_desejada> );
Pág.
Já para ler dados externos que cheguem através do bluetooth (via serial), devemos
criar um laço que deve ser executado enquanto o objeto perceber que ainda possui dados
recebidos pendentes, concatenando-os em uma variável o resultado. Para testar se ainda
existem dados recebidos (bytes) não lidos, utilizamos o método available:
<nome_objeto_serial>.available()
Para pegar cada um destes bytes não lidos, utilizamos o método read, convertendo
o byte em um caractere:
char(<nome_objeto_serial>.read())
8.2.2 Ligação eletrônica

A ligação eletrônica dos módulos da família HC é bastante simples. Não importa se
o modelo é do tipo mestre/escravo (6 pinos, como o HC05) ou somente do tipo escravo (4
pinos, como o HC06), os 4 pinos que nos interessam para o estabelecimento de uma
comunicação são: VCC, GND, TX e RX (sendo estes dois últimos ligados a qualquer porta
digital do Arduino). Assim, o nosso esquema eletrônico de ligação será similar ao
apresentado abaixo, de acordo com o número de pinos do módulo (6 como no à esquerda
e 4 como no à direita):
Pág.
8.2.3 Pareamento do HC com um Smartphone Android

Assim como todo dispositivo bluetooth, antes de ser acessado e utilizado em
conjunto com um smartphone, o módulo HC deve ser descoberto e pareado, criando assim
uma conexão segura. O processo para essa descoberta e o pareamento, pode diferir um
pouco de smartphone para smartphone, de acordo com a versão do sistema operacional
(Android no nosso caso) e das mudanças de interface da fabricante. Porém, apesar de
pequenas diferenças, o processo será sempre muito similar ao mostrado a seguir.
Primeiramente, devemos tocar na barra superior do Android, segurar e arrastar para

baixo, para acessar os atalhos rápidos. Depois, ao encontrar a opção “Bluetooth”, é
necessário pressionar e segurar por alguns segundos para que as opções de configuração
sejam abertas. Ao abrir, caso o bluetooth esteja desativado, devemos ativar.
Após, um clique na opção “Procurar” fará com que o smartphone identifique todos
os dispositivos bluetooth próximos a si e caso o HC estiver ligado, aparecerá na lista de
dispositivos disponíveis. Basta agora clicar sobre o HC e será aberta uma caixa de diálogo
solicitando uma senha de pareamento. Devemos então digitar a senha default (1234) e o
Pág.
dispositivo realizará o pareamento, estabelecerá a conexão e passará a ser exibido na lista
de dispositivos pareados.
8.2.4 Descoberta do Mac Address do módulo HC

Em diversas linguagens de programação, ao tentar estabelecer uma conexão
bluetooth com um dispositivo devemos obrigatoriamente informar o MAC Address do
mesmo. O Mac Address é um endereço físico que identifica cada dispositivo em uma rede
de forma única, sendo necessário para direcionar a troca de mensagens. Existem diversos
apps para Android que auxiliam nessa tarefa. Um deles é o “Bluetooth Mac Address
Finder”, que pode ser baixado e instalado gratuitamente. Ao abrir o app, percebemos 3
guias na parte superior, sendo que a inicial é a “DISCOVER”. Como nosso módulo HC já
está pareado (não precisa ser descoberto), basta clicar em “PAIRED”, localizar o nosso HC
na lista de dispositivos pareados (no exemplo abaixo, só existe ele na lista) e o endereço
Mac estará visível abaixo do seu nome.
Pág.
8.2.5 Exemplo prático: criando app em Android integrado com Arduino

Para demonstrar o funcionamento prático da comunicação bluetooth entre o
Arduino (através do módulo HC) e outro dispositivo, iremos desenvolver um aplicativo
Android para smartphone que possa receber o valor de distância lida por um sensor
ultrassônico do Arduino e mostrar na tela em tempo real (comunicação HC/Arduino →
Android) e que possua na mesma tela um botão através do qual possa ordenar ao Arduino
o ligamento e desligamento de um led quando pressionado (comunicação Android →
HC/Arduino). O fundamental para nós neste livro é o entendimento do código do lado do
Arduino e não outras linguagens de programação, como já citado anteriormente. Então
para facilitar o desenvolvimento do lado do Android, iremos criar o App através do App
Inventor 2, serviço online do MIT que permite o desenvolvimento através do arrastar de
componentes e de blocos de função (sem a necessidade de programação). Caso você não
conheça o App Inventor e nunca tenha desenvolvido aplicativos com linguagens de blocos
(como por exemplo o Scratch), recomendamos que previamente assista a série de vídeos
do excelente curso de App Inventor para Android, produzido pelo professor Flávio
Pág.
Guimarães no canal “Brincando com ideias”. O curso completo consiste de 36 aulas que
vão do básico até a integração com banco de dados e o desenvolvimento de um sistema de
automação residencial completo. Porém, os 5 primeiros vídeos da série (links abaixo)
trazem todos os conceitos básicos necessários para compreender a ferramenta e começar
a produzir os primeiros aplicativos Android, auxiliando no entendimento da combinação
de blocos que será criada neste nosso exemplo.
Links dos 5 primeiros vídeos da série:
https://youtu.be/TKPXS7V1YLo
https://youtu.be/1gOx1HoAkkY
https://youtu.be/ePyUC23z0gc
https://youtu.be/DWRGfa21DBk
https://youtu.be/cOVu015orxQ
Vamos iniciar o projeto pelo seu esquema eletrônico. Utilizaremos um módulo HC-
05 (lembrando que o modelo não importa pois para comunicação todos possuem os
protocolos desejados) com seus pinos TX e RX ligados, respectivamente às portas 8 e 9 do
Arduino. Para testar o envio de dados do Arduino para exibição no app Android, um sensor
ultrassônico será incluído, com seus pinos Trigger e Echo ligados, respectivamente, às
portas 6 e 7 do Arduino. Já para testar o envio de comandos do app Android para o
Arduino, um led é suficiente e o seu pino positivo será conectado à porta 5 da placa. Deste
modo, teremos o seguinte esquemático eletrônico:
Pág.
No App Inventor, o layout do aplicativo de nosso exemplo (que pode ser visto abaixo,
com a configuração visual à esquerda e a árvore de componentes à direita) contará com 5
elementos visuais importantes:
• Um Label (lblStatus) que informará o status da conexão bluetooth;

• um ListPicker (lstDescobertos) que mostrará uma lista de todos os dispositivos
bluetooth descobertos pelo smartphone para que possamos selecionar o HC;
• um Button (btnDesconectar) que encerrará qualquer conexão bluetooth ativa;
• um Button (btnLigaDesliga) que quando pressionado enviará ao Arduino, de forma
alternada, um aviso para ligar ou desligar o led;
• um TextBox (txtDados) que mostrará em tempo real a distância do ultrassônico
recebida do Arduino através da conexão bluetooth;
Pág.
Além deles, outros dois elementos não visuais são necessários para a
implementação desejada do aplicativo:
• um BluetoothClient (blue) responsável por acessar o serviço bluetooth do Android,

estabelecer e controlar a conexão;
• um Clock (timer) que a cada um segundo se encarregará de receber e mostrar na
tela o valor da distância recebida do Arduino através da conexão bluetooth.
Quanto a programação dos blocos, vamos dividi-la em cinco partes independentes

para um melhor entendimento.
Blocos parte 1) Listando os dispositivos bluetooth descobertos pelo smartphone
Ao clicarmos no ListPicker lstDescobertos, antes da lista ser exibida (bloco

when/BeforePicking) devemos setar os seus itens. Isso é feito através do bloco
set/Elements da própria lista, que deve receber por parâmetro uma lista de itens a exibir.
O que desejamos mostrar são todos os dispositivos bluetooth descobertos pelo
smartphone. Para isso, utilizamos o bloco AdressesAndNames do nosso BluetoothClient
blue que retorna o MacAdress e o nome de identificação de cada um desses dispositivos.
Blocos parte 2) Estabelecendo uma conexão bluetooth com o dispositivo selecionado
Ao fecharmos o ListPicker lstDescobertos (bloco when/AfterPicking), pegamos o

dispositivo selecionado na lista (através do seu bloco Selection) e passamos o mesmo como
parâmetro do bloco call/ConectAddress, para que o BluetoothClient blue tente estabelecer
uma conexão com ele. Caso a conexão seja estabelecida com sucesso é retornado
verdadeiro e assim entramos no bloco then de nosso condicional if. Nele, modificamos o
Pág.
texto do Label lblStatus para “(conectado)” (através do seu bloco set/Text) e habilitamos o
Clock timer para que a cada 1 segundo receba o valor da distância do ultrassônico vinda
do Arduino. Para habilitar, basta utilizar o bloco set/TimerEnabled passando por
parâmetro o valor true.
Blocos parte 3) Desconectando do dispositivo bluetooth
Ao clicarmos no Button bntDesconectar (bloco when/Click), encerramos a conexão

através do bloco call/Disconect de nosso BluetoothCliente blue. Após encerrada,
modificamos o texto do Label lblStatus para “(não conectado)” e o texto do TextBox txtDados
para “sem dados para exibir” (através dos seus respectivos blocos set/Text), voltando ao
estado inicial do aplicativo antes da conexão. Além disso, o Clock timer deve ser desativado
pois como não estamos mais conectados ele não receberá mais dados de distância do
ultrassônico para exibir. Fazemos isso através de seu bloco set/TimerEnabled passando
por parâmetro true.
Blocos parte 4) Exibindo o valor recebido do Arduino a cada 1 segundo (distância)
Ao inserir o Clock timer, seu TimerInterval pode ser definido e em nosso exemplo,
utilizamos o valor 1000 (1 segundo). Assim, a cada ciclo de tempo (bloco when/Timer)
devemos verificar se recebemos alguma coisa do Arduino através da conexão. O
componente BluetoothClient blue, através do bloco call/BytesAvailableToReceive nos
informa o número de bytes recebidos através da conexão e não utilizados. Então, dentro
de um bloco if/then, podemos testar se esse número de bytes recebidos e não usados é
maior do que zero, o que significa que temos uma nova informação de distância do
ultrassônico. Então, neste caso, retiramos do buffer de recebimento de informações do
bluetooth blue (através do bloco call/ReceiveTextNumberOfBytes) o mesmo número de
Pág.
bytes que descobrimos ter recebido anteriormente (bloco call/BytesAvailableToReceive) e
alteramos o texto do TextBox txtDados para essa sequência de bytes capturada (bloco
set/text), mostrando o valor da distância recebida.
Blocos parte 5) Enviando uma mensagem ao Arduino para ligar ou desligar o Led
Ao clicar no Button btnLigaDesliga (bloco when/Click), primeiramente testamos em

um bloco if/then se o nosso BluetoothClient blue está conectado, através do seu bloco
IsConnected (pois caso não esteja, não faz sentido tentar enviar alguma coisa ao Arduino).
Caso esteja, devemos verificar qual o estado do Button btnLigaDesliga, pois o mesmo botão
será utilizado para duas ordens diferentes, enviadas de forma alternada. Se o seu texto for
igual à “Led Desligado” (bloco Text) quando clicado, significa que devemos ligar o Led.
Então, modificamos o texto do botão (bloco set/Text) para “Led Ligado”, sua cor para azul
(bloco set/BackgroundColor) e enviamos através do BluetoothCliente blue (bloco
call/SendText) a String “on” para o Arduino, indicando ao mesmo que o led deve ser ligado.
Já se texto do btnLigaDesliga não for igual à “Led Desligado” (bloco Text) quando clicado é
porque é igual a “Led Ligado”, o que significa que devemos desligar o Led. Então,
modificamos o texto do botão (bloco set/Text) para “Led Desligado”, sua cor para vermelho
(bloco set/BackgroundColor) e enviamos através do BluetoothCliente blue (bloco
call/SendText) a String “off” para o Arduino, indicando ao mesmo que o led deve ser ligado.
Concluído o aplicativo, o mesmo já pode ser gerado e instalado no smartphone da

forma mais conveniente (lembrando que, conforme os vídeos do uso básico do App
Inventor, temos a opção de compilação USB direta com instalação automática, geração de
apk com download e instalação manual ou geração de QR code com download e instalação
Pág.
manual). Abaixo, três imagens que mostram, em sequência, o ícone do app instalado no
Smartphone, a tela do app após sua abertura e a lista de dispositivos bluetooth
descobertos ao clicar no ListPicker (neste caso, apenas o módulo HC-05 utilizado no nosso
exemplo):
Agora, finalmente vamos realizar a programação do nosso Arduino Uno para que ele
funcione em conjunto com o app Android criado, enviando a ele através da conexão
bluetooth as distâncias lidas pelo sensor ultrassônico e recebendo dela, também através
da conexão bluetooth, indicativo de quando ligar ou desligar o led (através das palavras
“on” e “off”). Além da importação das bibliotecas (Ultrasonic.h e SoftwareSerial.h), da
criação dos objetos indicando as portas (conforme explicado anteriormente no esquema
eletrônico) e a inicialização das Seriais (entre elas o bluetooth), a lógica é extremamente
simples.
No Loop, a cada 1 segundo, testamos dentro de um while se existe algo a receber

pela conexão bluetooh (objeto blue). Se sim, enquanto houverem bytes recebidos, os
mesmos são concatenados em uma variável de texto (a String recebido), um a um. Ao final,
Pág.
quando saímos do laço, temos dentro desta variável o texto recebido byte a byte de forma
serial. Então, basta testar qual é este texto. Em nosso exemplo, se ele for a palavra “off”
(enviada pelo aplicativo Android) o led deve ser desligado através da mudança de estado
da porta 5 para LOW. Se a palavra for “on”, o led deve ser ligado através da mudança de
estado da porta 5 para HIGH. Além disso, a cada 1 segundo, descobrimos a distância do
objeto mais próximo através da chamada do método Ranging (CM) do objeto ultrassom,
armazenando este valor na variável distancia. Em seguida, através do objeto blue,
enviamos de forma serial com o método println o valor desta mesma variável, através da
conexão bluetooth, para que chegue ao app Android.
#include <Ultrasonic.h>
#include <SoftwareSerial.h>
Ultrasonic ultrassom(7,6);
SoftwareSerial blue(8,9);
void setup(){
Serial.begin(9600);
blue.begin(9600);
pinMode(5, OUTPUT);
}
void loop() {
delay(1000);
//Testando o recebimento de dados através do bluetooth

String recebido = "";
while(blue.available()){
recebido += char(blue.read());
}
//Executando o que foi recebido (caso algo tenha sido recebido)

if(recebido == "on"){
}
if(recebido == "off"){
}
//Obtendo e enviando informação da distância através do bluetooh

float distancia = ultrassom.Ranging(CM);
blue.println(distancia);
Com tudo pronto, conseguimos agora através do app Android selecionar o módulo
HC, estabelecer uma conexão bluetooth entre o smartphone o Arduino, visualizar na tela
a distância medida pelo ultrassônico e ordenar o ligamento/desligamento do led.
Pág.
Abaixo, o print da tela do aplicativo funcional (recebendo uma distância de 73cm do

ultrassônico) e uma foto do circuito montado com o led ligado através do clique do botão:
8.3 Módulo WiFi (ESP-8266)
Não podemos falar de Internet das Coisas com o Arduino sem efetivamente
vermos como fazê-lo acessar a internet, o que possibilita desde a
comunicação com outros dispositivos, leitura e gravação em bancos de
dados online, uso de webservices, entre outros. Existem diversas formas
possíveis para isso, desde o uso de um smartphone como ponte através de
uma comunicação bluetooth, até o acesso direto através do uso de módulos
que permitam a conexão cabeada (módulo ethernet) ou sem fio (módulo
WiFi). O mais popular destes módulos WiFi é o ESP-8266, pelo seu baixo custo, facilidade
de uso e alcance.
Pág.
8.3.1 Principais métodos para trabalhar com o módulo ESP-8266

Para facilitar o uso do módulo, existe uma biblioteca própria que permite a criação
de um objeto que representa uma conexão WiFi e através do qual podemos chamar
métodos que permitem a autenticação, o envio e recebimento de dados e até mesmo a
criação de um servidor HTTP que retorna um HTML como resposta a uma solicitação
recebida em determinado endereço, permitindo, assim, a criação de uma página Web para
visualizar informações e até mesmo enviar dados ou ordens ao Arduino. Esta biblioteca é
a “WiFiEsp.h” e pode ser baixada no link: https://bit.ly/arduinoqi
A instanciação de um objeto desta classe que represente um servidor web

(WiFiEspServer) é realizada como segue abaixo, informando a porta HTTP utilizada para
estabelecer a conexão (sendo a 80 a porta padrão, modificada apenas em redes especiais
e com redirecionamento para outras portas):
WiFiEspServer <nome_objeto>( <porta_http> );
Um WiFiEspServer necessita de uma conexão serial para estabelecer a comunicação

e poder receber e enviar dados. Assim, precisamos da importação da biblioteca
“SoftwareSerial.h” e da criação de um objeto deste tipo, informando em qual portas do
Arduino estão conectados, respectivamente, os pinos RX e TX do módulo (ou de seu
adaptador, como veremos adiante).
SoftwareSerial <nome_objeto>( <porta_RX>, <porta_TX> );
A biblioteca nos oferece outro objeto muito importante (já criado) chamado WiFi. Ele
é responsável por diversas verificações e configuração de nossa conexão. O mesmo deve
ser inicializado através de um método init, porém recebendo como parâmetro o endereço
de alocação (&) de um objeto do tipo SoftwareSerial. Assim, sua inicialização seria como a
demonstrada abaixo:
WiFi.init( &<nome_objeto_SoftwareSerial> );
Pág.
Após a inicialização, o objeto WiFi deve receber um endereço IP para que consiga ter
acesso à autenticação na rede de internet do usuário, respeitando a faixa de IPs desta rede.
Para isso, utilizamos o método IPAddress que recebe por parâmetro os 4 números (4
octetos) que compõe o endereço.
<nome_objeto_WiFiEspServer>.config( IPAddress(<n1>,<n2>,<n3>,<n4>) );
Com endereço configurado, podemos tentar conectar em uma rede WiFi. Para
auxiliar na manipulação (byte a byte), vamos criar duas variáveis auxiliares (arrays de
caracteres) às quais atribuiremos o nome da rede (SSID) e a sua senha. Após, as utilizamos
como parâmetro do método begin do objeto WiFi que estabelece a conexão.
char <variavel_nome_rede>[] = "nome_da_sua_rede";

char <variavel_senha_rede>[] = "senha_da_sua_rede";
WiFi.begin( <variavel_nome_rede>, <variavel_senha_rede> );
A chamada deste método begin do objeto WiFi sempre retorna um código de status
que pode ser testado para verificar a situação da conexão. São eles:
• WL_NO_SHIELD: não detectado um shield WiFi (o ESP8266 ou outro qualquer)

• WL_IDLE_STATUS: shield detectado mas em estado IDLE (ainda não conectado)
• WL_CONNECTED: conexão estabelecida com sucesso
• WL_NOT_CONNECTED: conexão não estabelecida
Este mesmo status também pode ser testado mesmo antes ou após a chamada do
método begin (ou seja, fora do seu retorno), através do método status do WiFi.
WiFi.status()
Com a conexão estabelecida e o Web Server ativo, podemos criar um WiFiEspClient,

que será o responsável por responder às solicitações dos clientes através da porta 80
(requisições HTTP).
WiFiEspClient <nome_objeto_WiFiEspCliente> =
<nome_objeto_WiFiEspServer>.available();
Pág.
Após criado, podemos testar o objeto WiFiEspClient dentro de um if pois sempre

que um novo cliente tenta conectar ele nos devolve um true.
if( <nome_objeto_WiFiEspClient> ) ...
Também podemos verificar se a conexão do cliente já aconteceu e está ativa,

momento a partir do qual podemos receber ou enviar informações para ele. Para isso,
utilizamos o método connected.
<nome_objeto_WiFiEspClient>.connected()
Além disso, outra verificação importante é se estamos recebendo alguma coisa

(requisição HTTP) do nosso cliente.
<nome_objeto_WiFiEspClient>.available()
Para o recebimento dessas informações através da serial da conexão estabelecida,

podemos criar um objeto do tipo RingBuffer (como uma variável global) para receber e
armazenar os bytes recebidos. Como parâmetro, passamos o tamanho desejado para nosso
buffer.
RingBuffer <nome_objeto_RingBuffer>(<tamanho_buffer>);
Este objeto necessita de uma inicialização simples através de um método init.
<nome_objeto_RingBuffer>.init;
Caso se perceba o recebimento de uma requisição do cliente, podemos pegar byte a

byte dela através do método read do cliente e armazenar no buffer com o seu método push,
para depois testar o que foi recebido.
<nome_objeto_RingBuffer>.push(<nome_objeto_WiFiEspClient>.read())
)
Pág.
Geralmente essa leitura byte a byte é realizada dentro de um laço que é executado
enquanto existir requisição do cliente (available). Sabemos que o recebimento encerrou
quando a requisição HTTP trouxer a sequência “\r\n\r\n” (duas quebras de linha). Assim,
conseguimos testar com um condicional se esta sequência está no final do texto
armazenado dentro do buffer, com o método endsWith.
if( <nome_objeto_RingBuffer>.endsWith("\r\n\r\n") ) ...
Quando uma requisição HTTP é recebida, nosso objeto WiFiEspClient pode enviar
de volta ao cliente uma resposta, que pode ser desde uma simples String ou até mesmo
uma página web completa que será exibida através de um browser. Esse envio é possível
através do método println.
<nome_objeto_WiFiEspClient>.println("texto_a_enviar");
Após enviar a resposta, devemos encerrar a conexão do cliente para ficar esperando
uma nova requisição. Para isso, utilizamos o método stop.
<nome_objeto_WiFiEspClient>.stop();
8.3.2 Ligação eletrônica

O módulo ESP-8266 (geralmente alimentado com 3.3V) pode ser utilizado de forma
direta, ligando os seus pinos nas portas do Arduino (sendo que 5 dos 8 pinos necessitam
de ligações e 2 deles obrigam a criação de um divisor de tensão, tornando o projeto
eletrônico um pouco mais complexo). Porém, existem no mercado diversos adaptadores
para o módulo (alimentados com 5V), que recebem seus 8 pinos (já com os divisores de
tensão necessários internalizados no adaptador) e que permitem a comunicação com o
Arduino de forma serial, necessitando assim da ligação de apenas um pino VCC, um GND,
um TX e um RX. Os dois tipos de ligação (com ou sem adaptador) funcionam de forma
eficiente, sendo escolhidas de acordo com a necessidade. A seguir, os dois esquemas são
apresentados.
Pág.
Esquema eletrônico com acesso direto (resistores do divisor de tensão de 1K e

resistor da porta positiva de 10K):
Esquema eletrônico com uso de adaptador:
Pág.
8.3.3 Exemplo prático: comunicação e controle com webpage através do WiFi

Para um exemplo prático, vamos adaptar o projeto anterior para que com o uso de
requisição HTTP o usuário possa acessar uma página web e através dela ver a distância
medida pelo ultrassônico do Arduino, além de controlar um led através de um botão. O
esquemático eletrônico será o mesmo, respeitando as mesmas portas, apenas removendo
o módulo bluetooth e colocando em seu lugar um módulo ESP-8266 integrado a um
adaptador. Deste modo, teremos:
Vamos então programar o nosso Arduino. Para um melhor entendimento, vamos

quebrar o código em partes para facilitar a explicação.
Código parte 1) Includes, variáveis e objetos iniciais
#include <SoftwareSerial.h>
#include <WiFiEsp.h>
//Variáveis auxiliares
char nomeRede[] = "Sentido da Vida Network";
char senhaRede[] = "sentido=42";
int statusLed = LOW;
int distancia = 0;
//Objetos das bibliotecas

SoftwareSerial serialWiFi(8,9);
WiFiEspServer servidor(80);
RingBuffer bufferAux(8);
Pág.
Inicialmente realizamos o include das 3 bibliotecas necessárias ao projeto:
“Ultrasonic.h” (para o uso do sensor ultrassônico), “SoftwareSerial.h” (para a criação de
uma comunicação serial utilizada pelo WiFi para comunicação) e WiFiEsp (para criação
dos objetos que implementam um servidor e um cliente web). Após, criamos algumas
variáveis auxiliares que conterão o nome e senha da rede e o status inicial do dispositivo
WiFi (IDLE até que ele seja conectado posteriormente). Também é necessária uma variável
para representar o estado do led (iniciando com LOW) e uma variável para guardar a
distância lida pelo ultrassônico (iniciando com 0). Além das variáveis, criamos também
alguns objetos: ultrassom (informando as portas onde estão ligados os pinos trigger e echo
do sensor ultrassônico), serialWiFi (informando as portas TX e RX do módulo ESP8266 e
que será utilizado pelo WiFi para comunicação), servidor (informando a porta 80 para
implementar o objeto WiFiEspServer e aceitar requisições) e bufferAux (informando 8 bytes
de tamanho para implementar o objeto BufferRing que armazenará as informações da
requisição recebida pelo WiFi).
Código parte 2) Setup e inicializações iniciais
void setup(){
pinMode(5, OUTPUT);
Serial.begin(9600);
serialWiFi.begin(9600);
WiFi.init(&serialWiFi);
WiFi.config(IPAddress(192,168,0,100));
}
No setup, definimos a porta 5 (do led) como saída e iniciamos com ela desligada. O
objeto Serial assim como o serialWiFi (também um serial), precisam ser iniciados com o
método begin e a sua velocidade (aqui, 9600, que é o valor padrão). Já o objeto WiFi, ao
ser iniciado com o init, recebe por parâmetro o endereço de uma conexão serial (no nosso
caso, o endereço de serialWiFi). Após, o seu endereço IP é configurado para 192.168.0.100.
Código parte 3) Testando a conexão
void loop() {
if(WiFi.status() == WL_NO_SHIELD){
return;
}
if(status != WL_CONNECTED){
status = WiFi.begin(nomeRede, senha);
return;
} else {
servidor.begin();
}
Pág.
Ao executar o loop, testamos se o status da conexão é WL_NO_SHIELD pois se for,

o Arduino não encontrou nenhum módulo WiFi ou o mesmo parou de funcionar. Caso isso
aconteça, abandonamos o laço e tentamos de novo até que um módulo seja detectado.
Após, testamos se o status da conexão é WL_CONNECTED que só é possível após a conexão
e autenticação serem realizadas com sucesso. Enquanto isso não acontecer, tentamos
novamente conectar utilizando o nome (SSID) e a senha da rede (armazenadas previamente
nas variáveis nomeRede e senhaRede). Quando a conexão finalmente ocorrer, inicializamos
o servidor (objeto do tipo WiFiEspServer) e seguimos adiante no loop.
Código parte 4) Implementando o cliente para receber requisições HTTP
statusLed = ultrassom.Ranging(CM);
WiFiEspClient cliente = servidor.available();
if(cliente) {
bufferAux.init();
while(cliente.connected()){
if(cliente.available()){
bufferAux.push(cliente.read());
if(bufferAux.endsWith("\r\n\r\n")) {
respostaRequisicao(cliente);
break;
}
if(bufferAux.endsWith("GET /L")){
statusLed = 1;
}
else{
if (bufferAux.endsWith("GET /D")) {
statusLed = 0;
}
}
}
}
cliente.stop();
}
} //fim do loop
Primeiramente lemos o valor da distância do sensor ultrassônico e armazenamos na

variável distancia. Em seguida, criamos um cliente web (objeto WiFiEspCliente) através de
uma instância do servidor inicializado anteriormente. Colocando cliente em um if, ele nos
retorna true quando perceber que um novo cliente está tentando estabelecer uma conexão.
Então, iniciamos o buffer (com o método init). Enquanto o cliente estiver conectado,
entramos em um laço testando se existe algum byte da requisição HTTP a receber
(available). Se sim, lemos (read) byte a byte a cada repetição do laço e inserimos dentro do
Pág.
buffer (push). Assim, cada byte depositado no buffer faz com que tenhamos um texto
parcial dentro dele. Com isso, podemos testar qual o texto atual existente no final deste
buffer com o método endsWith. Se terminar com “\r\n\r\n” é porque a requisição HTTP
chegou ao fim e então enviamos uma resposta ao cliente (através de um objeto
WiFiEspClient), que no nosso caso é uma página web montada com o método
respostaRequisicao (explicado na próxima etapa). Se terminar com “GET /L” é porque
recebemos um /L (de Ligado) através da requisição, que corresponde à uma ordem para
ligar o Led. Se terminar com “GET /D” é porque recebemos um /D (de Desligado) através
da requisição, que corresponde à uma ordem para desligar o Led. Ao final, interrompemos
e fechamos a conexão para ficar à espera de uma nova requisição.
Código parte 5) Retornando uma página para a requisição
void respostaRequisicao(WiFiEspClient cliente){

cliente.println("HTTP/1.1 200 OK");
cliente.println("Content-Type: text/html");
cliente.println("<!DOCTYPE HTML>");
cliente.println("<html>");
cliente.println("<head>");
cliente.println("<title>Controle Web Arduino</title>");
cliente.println("</head>");
cliente.println("<body>");
cliente.println("<div style='text-align: center'>");
cliente.println("
Informações da Placa Arduino");
cliente.println(" DISTÂNCIA");
cliente.println("" +
(String)distancia + " cm"
cliente.println(" ESTADO ATUAL DO LED");
if(statusLed == HIGH){
cliente.println("LIGADO");
cliente.println("<a href=\"/D\" style='color:white;background-color:red;
text-decoration:none;padding:10px;'>desligar</a>");
} else {
cliente.println("DESLIGADO");
cliente.println("<a href=\"/L\" style='color:white;background-color:blue;
text-decoration:none;padding:10px;'> ligar </a>");
}
cliente.println("</body>");
cliente.println("</html>");
delay(10);
}
O método respostaRequisicao, utiliza o objeto WiFiEspClient recebido por parâmetro

para, através dele, enviar como resposta linhas que componham uma página HTML que,
quando recebida pelo cliente, será mostrada pelo browser. Esta página é bem simples e
possui alguns elementos centralizados dentro de uma div. Primeiramente, temos um título
Pág.
(“Informações da Placa Arduino”) com letra maior do que as demais. Para exibir a distância
lida do ultrassônico, temos um subtítulo (“DISTÂNCIA”) seguido de um parágrafo com o
valor da variável distância concatenado. Logo em seguida, posicionamos um subtítulo
(“ESTADO ATUAL DO LED”). Abaixo deste subtítulo queremos montar dois elementos
importantes: um texto que informe o estado atual do led (com letra azul quando ligado e
vermelha quando desligado) e um botão para ligar ou desligar o led (com letra branca e
fundo azul quando indicar a ação ligar ou vermelho quando indicar a ação desligar). Nós
sabemos quando efetuar uma ou outra montagem através da análise da variável
estadoLed. É importante perceber que nosso botão nada mais é do que uma âncora que
quando montada tem seu href (link) configurado de modo a tentar abrir um endereço /D
ou /L, o que acaba gerando uma requisição HTTP que contém, respectivamente “GET /D”
ou “GET /L”. É assim que conseguimos enviar o indicativo para ligar ou desligar o led via
requisição HTTP ao clicar, sendo esta recebida pelo cliente e interpretada. Assim, quando
o cliente acessar o endereço IP configurado no objeto WiFi (no nosso exemplo,
192.198.0.100), através do browser, a página será enviada como resposta, como abaixo:
Abaixo, uma foto do projeto montado com o led ligado após o Arduino receber uma
requisição “GET /L” com o clique na âncora da página (botão “ligar”):
Pág.
8.3.4 Adaptando o exemplo para redes cabeadas com a biblioteca Ethernet.h

Outra forma muito interessante de colocar nosso Arduino na internet é o uso de
módulos ethernet, que permitam sua ligação à uma rede cabeada (cabos de par trançado).
Apesar de ser um meio um pouco menos prático e que demanda a existência (ou a criação)
de uma infraestrutura maior, pode ser uma alternativa interessante em algumas situações.
Diferentemente da tecnologia WiFi que possui alguns
poucos módulos muito bem consolidados e disseminados,
para redes ethernet existem uma profusão de soluções
distintas, que variam de Shields (placas secundárias que
são encaixadas sobre a placa Arduino estendendo suas
funções, como na imagem à
esquerda que mostra uma
W5100) a módulos simples (como na imagem à direita que
mostra uma ENC28J60). A grande quantidade, variedade e as
múltiplas peculiaridades de dispositivos que agreguem ao
Arduino a funcionalidade ethernet, faz com que tenhamos uma
multiplicidade de opções, mas quanto à ligação eletrônica a grande maioria desses
módulos utilizam comunicação SPI. Geralmente isso faz com que os pinos utilizados sejam
os mesmos, variando quais são necessários, o que já pode provocar pequenas mudanças
no esquemático eletrônico. Porém, todos os módulos (mesmo aqueles que já possuem uma
biblioteca própria) são compatíveis no uso e na implementação com a biblioteca
“Ethernet.h”. Portanto, independente do módulo escolhido, do esquemático eletrônico e
das peculiaridades presentes, conhecendo esta biblioteca conseguimos programar e
utilizar qualquer um destes módulos ethernet em nossos projetos. Para encerrar este
capítulo dedicado a módulos especiais e comunicação, vamos adaptar apenas o código do
nosso exemplo anterior para ver as diferenças do uso de WiFi (com a biblioteca
“WiFiEsp.h”) e de redes ethernet (com a biblioteca “Ethernet.h”) com o Arduino. O
esquemático eletrônico não será apresentado pois deve ser seguido conforme o módulo
escolhido. Nos limitaremos aqui ao código e à lógica de programação.
Inicialmente, vamos ver os principais métodos da biblioteca “Ethernet.h” e

estabelecer uma comparação com a biblioteca “WiFiEsp.h”, pois facilmente perceberemos
que muitos objetos e métodos são equivalentes. Ambas as bibliotecas necessitam de um
servidor web e de um cliente web, sendo o cliente uma instância identificada de um
servidor após autenticado. Assim, podemos verificar que os métodos para a criação deste
Pág.
cliente e deste servidor na “Ethernet.h” são análogos aos da biblioteca WiFiEsp vista
anteriormente. O servidor (EthernetServer) também necessita na criação, como parâmetro,
da porta utilizada para receber as requisições HTTP (por padrão a 80).
EthernetServer <nome_objeto>( <porta_http> );
O cliente (EthernetCliente) também recebe uma instância detectada do servidor

após a autenticação do mesmo.
EthernetClient <nome_objeto_EthernetClient> =
<nome_objeto_EthernetServer>.available();
Uma das diferenças em relação à biblioteca WiFiEsp são as inicializações dos

objetos. O servidor é iniciado com um simples método begin, sem parâmetros.
<nome_objeto_EthernetServer>begin();
Já o objeto que representa a conexão Ethernet, precisa de mais informações do que

o objeto WiFi que recebia apenas o IP. Um objeto Ethernet em sua criação nos obriga a
informar 4 parâmetros para configuração da rede: um MacAddress para o módulo (através
de um array com 6 números hexadecimais), um endereço IP fixo, um endereço de gateway
da rede e um endereço que represente a sub-máscara de rede (todos esses 3 últimos,
através de um objeto IPAddress, o mesmo utilizado no exemplo anterior para criar e
informa o IP do WiFi). Assim, temos:
byte <nome_variavel_mac> = {<n1>,<n2>,<n3>,<n4>,<n5>,<n6>}

IPAddress <nome_variavel_ip>(<n1>,<n2>,<n3>,<n4>);
IPAddress <nome_variavel_mascara>(<n1>,<n2>,<n3>,<n4>);
IPAddress <nome_variavel_gateway>(<n1>,<n2>,<n3>,<n4>);
Ethernet.begin(<nome_variavel_mac>, <nome_variavel_ip>,
<nome_variavel_gateway>, <nome_variavel_mascara>);
Todos os demais métodos do EthernetClient são análogos aos do WiFiEspClient,

como pode ser conferido a seguir.
Pág.
Testar o objeto EthernetClient para identificar novo cliente está tentando conectar:
if( <nome_objeto_EthernetClient> ) ...
Verificar se a conexão do cliente já aconteceu e está ativa:
<nome_objeto_EthernetClient>.connected()
Verificar se estamos recebendo alguma coisa (requisição HTTP) do nosso cliente:
<nome_objeto_EthernetClient>.available()
Para o recebimento dessas informações através da serial da conexão estabelecida,

também podemos criar um objeto do tipo RingBuffer, exatamente como mostrado
anteriormente (e por isso mesmo não iremos repetir os métodos). Também utilizamos o
método push para depositar no buffer byte a byte lido do objeto EthernetClient:
<nome_objeto_RingBuffer>.push(<nome_objeto_EthernetClient>.read())
)
Já quando aos status da conexão, podemos utilizar dois métodos distintos do objeto
Ethernet. O primeiro serve para indicar a não detecção de hardware ethernet compatível
(retornando a constante EthernetNoHardware).
Ethernet.hardwareStatus()
)
Já o segundo serve para indicar se a conexão foi estabelecida com sucesso e existe
comunicação ativa (retornando as constantes LinkON e LinkOFF).
Ethernet.linkStatus()
)
Conhecendo estes comandos, podemos ver agora as diferenças no código ao adaptar

o exemplo anterior para o uso de conexão ethernet em lugar de conexão WiFi para a
comunicação.
Pág.
#include <SPI.h> //mudou
#include <Ethernet.h> //mudou
//Variáveis auxiliares
char macRede[] = {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45}; //mudou
IPAddress ipRede(192,168,0,100); //mudou
IPAddress mascaraRede(255,255,255,0); //mudou
IPAddress gatewayRede(192,168,0,1); //mudou
int statusLed = LOW;

int distancia = 0;
//Objetos das bibliotecas

EthernetServer servidor(80); //mudou
RingBuffer bufferAux(8);
void setup(){
pinMode(5, OUTPUT);
Serial.begin(9600);
}
void loop() {
if(Ethernet.harwareStatus() == EthernetNoHardware){ //mudou

return;
}
if(Ethernet.linkStatus() != LinkON){ //mudou
Ethernet.begin(macRede, ipRede, gatewayRede, mascaraRede); //mudou
return;
} else {
servidor.begin();
}
statusLed = ultrassom.Ranging(CM);
EthernetClient cliente = servidor.available(); //mudou
if(cliente) {
bufferAux.init();
while(cliente.connected()){
if(cliente.available()){
bufferAux.push(cliente.read());
if(bufferAux.endsWith("\r\n\r\n")) {
respostaRequisicao(cliente);
break;
}
if(bufferAux.endsWith("GET /L")){
statusLed = 1;
}
else{
if (bufferAux.endsWith("GET /D")) {
statusLed = 0;
}
}
}
}
cliente.stop();
}
} //fim do loop
Pág.
Perceba que ao longo do código, existem alguns comentários “//mudou” que

identificam que aquela linha específica sofreu alguma alteração do exemplo do código do
projeto com WiFiEsp em relação ao código do projeto adaptado para Ethernet. Esta
alteração pode ser o nome do objeto, o valor dos parâmetros, o total de parâmetros, etc.
Porém, queremos reforçar com estas indicações visuais que a lógica não se altera e todo o
restante do código permanece exatamente igual. Logo, a mesma explicação passo a passo
dada para o código do exemplo anterior (da página xxx até a página xxx), vale para o código
deste exemplo. Inclusive o método respostaRequisicao que monta a página retornada
mostrando o valor do ultrassônico e criando um botão para ligar e desligar o led, não sofre
qualquer tipo de alteração (e por isso nem foi trazido novamente neste exemplo).
Assim conseguimos perceber que colocar o Arduino na internet, seja com uso de
WiFi ou de Ethernet, é um processo muito similar e o domínio de uma das técnicas implica
no fácil entendimento e adaptação da outra. Deste modo, ampliamos significativamente as
possibilidades em nossos projetos IOT, não limitando os dispositivos à comunicação local,
mas permitindo que nossas soluções estejam, agora, na nuvem. Assim, quase de forma
literal, o céu é nosso limite.
Pág.

Apostila IOT Versão Final

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila IOT Versão Final

Enviado por

Direitos autorais:

Formatos disponíveis

QI ESCOLAS E FACULDADES

CURSOS TÉCNICOS – EIXO TECNOLOGIA DA INFORMAÇÃO

Desenvolvido por: Prof. Rodrigo M. Barreto

UNIDADE 1 – INTERNET DAS COISAS ............................................................................ 6

UNIDADE 2 - TÓPICOS BÁSICOS DE ELETRÔNICA ANALÓGICA ................................. 20

UNIDADE 3 – INTRODUÇÃO AO ARDUINO ................................................................... 64

UNIDADE 5 – ATUADORES ......................................................................................... 136

UNIDADE 6 – TÓPICOS AVANÇADOS ......................................................................... 170

UNIDADE 1 – INTERNET DAS COISAS

O termo IoT (Internet of Things, ou

Essa troca de informações e as decisões tomadas, podem envolver tanto hardware

1.1 Requisitos do IOT

É impossível listar todos os componentes,

Sensores de baixo custo: você sabe o valor do sensor

1.2 Áreas principais do IoT

Automação e Controle: é o controle dos dispositivos que compõe o sistema inteligente da

Segurança e Vigilância: é a implementação de segurança através dos sistemas

Comunicações: é a implementação de comunicação e troca de informações entre diversos

Serviços e entretenimento: é a implementação do acesso a serviços e a entretenimento

Produtividade: é a implementação de inteligência em qualquer uma das 4 áreas anteriores

1.2.2 Indústria 4.0

Inteligência artificial: busca de padrões, aprendizagem automática, tomada de decisões

Computação em nuvem: uso da nuvem para armazenamento, acesso e compartilhamento

Robótica avançada: interação com humanos, auto ajuste de processos, tomadas de

Manufatura digital: incorporação de ferramentas para manufatura com base em sistemas

Sistemas de simulação: sistemas para simulações variadas, que podem ir desde

Integração de sistemas: integração das múltiplas tecnologias entre si de forma otimizada,

Digitalização: transformação digital e modernização de processos internos, fabris,

1.2.4 Smart Cities

Sociedade e bem-estar: formas de garantir um bom nível social, educacional econômico

Economia e negócios: formas de garantir o desenvolvimento econômico através da criação

Meio ambiente e urbanismo: formas de garantir a proteção ao meio ambiente (controle

1.3 Cultura Maker

Se o IoT tem um grande responsável por

1.3.1 O Manifesto Maker

Fazer – Algo fundamental para o significado do ser

Compartilhar – O sentimento total de plenitude de um

Presentear – Há poucas coisas mais altruístas e

Os makerspaces, mesmo sendo iniciativas que partiram de hobistas e entusiastas,

1.3.3 Placas de Prototipagem

2.1 Energia elétrica, fluxo de elétrons e observações iniciais

Os átomos são formados de 3 partículas essenciais: os nêutrons e prótons (que

Carga do átomo e busca pela neutralidade: os átomos sempre buscam o equilíbrio de

Desequilíbrio leva ao movimento e movimento leva à corrente: quando o desequilíbrio

Os 3 átomos têm carga total

Remover 3 elétrons do átomo à

O átomo do meio, ao perder 2

O átomo mais à esquerda ao

Ordenando o movimento dos elétrons e forçando uma corrente: como ilustrado no

2.2 Exemplificando Tensão x Corrente e Resistência

Através das observações iniciais sobre o comportamento das partículas

• Tensão Elétrica é a força que move os elétrons dentro de um circuito, gerada

O que podemos avaliar dos dois exemplos?

• Ambas as pilhas transferirão uma carga máxima de 10 elétrons do ânodo para o

• Na primeira pilha, com o passar do tempo, o sistema vai entrando em equilíbrio de

• Claramente na segunda pilha, dada a força de atração (diferença de potencial) muito

O que podemos avaliar dos dois exemplos?

2.3 Formalização das observações sobre Tensão, Corrente e Resistência

Observações similares a essa serviram de base para a formulação de leis que

2.3.1 Representação formal de um circuito eletrônico básico

2.3.2 Primeira Lei de Ohm

U=I.R I=U/R R=U/I

Claramente vemos que se soubermos o valor de quaisquer duas variáveis,