V1.

8 – Junho/2025

Olá, Maker!

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

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

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

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

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

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

Aproveite bastante e bons estudos!

Sumário

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

Introdução ............................................................................................................... 4
Revisão de circuitos elétricos ................................................................................ 5
Carga e corrente elétrica ..................................................................................... 6
Tensão elétrica..................................................................................................... 7
Potência e energia ............................................................................................... 7
Conversão de níveis lógicos e alimentação correta de circuitos..................... 8
Revisão de componentes eletrônicos ................................................................. 10
Resistores elétricos ........................................................................................... 10
Capacitores ........................................................................................................ 12
Diodos e LEDs ................................................................................................... 14
Transistores ....................................................................................................... 16
Protoboard ......................................................................................................... 19
Parte II – Arduino Uno SMD ..................................................................................... 20
Parte III - Instalando e conhecendo a Arduino IDE ................................................. 24
Parte IV - Seção de Exemplos Práticos ................................................................... 27
Exemplo 1 - Leitura de Sinais Analógicos com Potenciômetro ..................... 28
Exemplo 2 - Controle de LEDs com Botões ..................................................... 31
Exemplo 3 - Acionamento de buzzer com um botão ....................................... 33
Exemplo 4 - Acionamento de LED conforme do Luz Ambiente...................... 36
Exemplo 5 - Medindo a Temperatura do Ambiente ......................................... 39
Exemplo 6 – Efeito fade ..................................................................................... 41
Exemplo 7 - Controlando o brilho do LED com potenciômetro...................... 42
Exemplo 8 - Acendendo um LED com Sensor Reflexivo Infravermelho ........ 44
Exemplo 9 – Diferença entre transistores NPN e PNP na prática................... 46
Exemplo 10 – Acionando displays de 7 segmentos ........................................ 49
Parte V - Cálculo do resistor de base dos transistores ......................................... 53
Parte VI – Principais comandos do Arduino ........................................................... 55
Considerações finais ............................................................................................ 57
 Parte I – Conceitos elétricos, introdução aos
componentes e instalação da IDE

Introdução

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

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

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

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

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

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

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

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

Preparado? Vamos começar!

Revisão de circuitos elétricos

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Com o Arduino UNO e na maioria dos componentes eletrônicos, lidamos com a corrente
elétrica contínua. É diferente da corrente e tensão elétrica da tomada de sua casa, que
são alternadas.

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

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

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

Quando conectamos os dois polos por meio de uma carga (como um LED, resistor,
motor, por exemplo), a corrente elétrica é gerada e flui devido a essa diferença de
potencial (conceito que será explicado mais adiante). A corrente é a forma como a
energia é transportada e utilizada pelos componentes do circuito.

Tensão elétrica

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

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

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

Potência e energia

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

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

P=VxI

Essa é a chamada potência instantânea. Com essa fórmula, para saber qual a potência
dissipada em um resistor, por exemplo, basta informar a tensão aplicada nos terminais
do resistor e a corrente que passa por ele. O conceito de potência é importante pois
muitos hobbistas acabam não tendo noção de quais valores de resistência usar, ou
mesmo saber especificar componentes de forma adequada.
Um resistor de 33 ohms de potência igual a 1/4W, por exemplo, não pode ser ligado
diretamente em circuito de 5V, pois nesse caso a potência dissipada nele seria maior
que a que ele pode suportar.

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

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

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

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

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

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

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

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

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

⚫ Usar um divisor de tensão;

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

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

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

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

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

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

⚫ Buzzer Ativo 5V;

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

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

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

Resistores elétricos

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

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

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

Em algumas aplicações você pode precisar de resistores com precisão maior, como 1%.
Também há casos em que a precisão não é tão importante, podendo ser utilizados
resistores com tolerância de 10%. Em alguns casos, pode ser necessário usar resistores
com maior potência, como 1W, enquanto em outros a potência pode ser menor, como
1/8W. Essas variações dependem da natureza específica de cada circuito."

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

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

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

V=RxI

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

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

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

Figura 1: Faixas coloridas em um resistor

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

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

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

Figura 2: Código de cores para resistores

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

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

Capacitores

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

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

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

O importante que você deve saber para utilizar o Kit é que os capacitores podem ser de
quatro tipos:
 ⚫ Eletrolíticos;
⚫ Cerâmicos;
⚫ Poliéster;
⚫ Tântalo.

Capacitor eletrolítico

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

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

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

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

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

Capacitores cerâmicos

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

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

faixa de tensão de até 500V.

223 = 22 x 1000 = 22.000 pF = 22 nF

Por fim, há também os capacitores de poliéster e de tântalo. No Kit Iniciante para

Arduino, você receberá apenas exemplares de capacitores eletrolíticos e cerâmicos.

Diodos e LEDs

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

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

Figura 4: Diodo e seus terminais

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

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

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

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

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

Transistores

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

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

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

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

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

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

- Transistores de Efeito de Campo (FET):

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

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

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

▪ NPN: No transistor NPN, a corrente principal entra pelo coletor e sai pelo
emissor (considerando o sentido convencional da corrente). Para que o
transistor NPN conduza, é necessário aplicar um sinal positivo na base.
Esse sinal permite que a corrente flua do coletor para o emissor, habilitando a
condução do transistor.
▪ PNP: O funcionamento do transistor PNP é oposto ao NPN. Nele, a corrente
principal entra pelo emissor e sai pelo coletor. Entrando em condução ao
aplicarmos um sinal negativo na base. Esse sinal negativo na base permite que
a corrente flua do emissor para o coletor, habilitando a condução do transistor.
Modos de operação

Para facilitar a compreensão do funcionamento do transistor, vamos associar o tipo

NPN a uma torneira. Nesta analogia, o coletor representa a entrada de água na
torneira, o emissor representa a saída de água e, a base, equivale ao registro. Para o
PNP, a analogia é a mesma, diferenciando-se apenas na função do coletor e do
emissor.

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

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

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

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

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

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

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

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

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

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

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

feita no sentido horizontal, percorrendo toda a largura da protoboard. Essas linhas
geralmente são usadas para fornecer alimentação positiva (VCC) e negativa (GND) aos
componentes do circuito.
Os demais componentes do kit (Buzzer, potenciômetro, display de 7 segmentos e push-
buttons) serão explicados em seções de exemplos, nas quais iremos apresentar um
circuito prático para montagem onde será apresentado o funcionamento de cada um
deles, assim como será feito para os sensores de luz (LDR) e temperatura (NTC). O Micro
Servo 9g SG90 TowerPro também terá uma seção de exemplo dedicada a cada ele.

Parte II – Arduino Uno SMD

Após a empresa Arduino ter lançado em 2005 o Arduino Uno, essa placa se popularizou
e hoje ela é a placa Arduino mais famosa do planeta e com milhões de unidades
vendidas.

Algumas pessoas não sabem, mas as placas Arduino não possuem patente, e eles
disponibilizam o projeto de suas placas para qualquer um reproduzir, fazer
modificações e fazer melhorias. Com isso, um grupo de pessoas resolveram lançar a
placa Uno SMD.

A placa Uno SMD é compatível 100% com uma placa Uno do projeto original, inclusive
em todas as Shields. Algumas diferenças são meramente de projeto, como a troca de
alguns tipos de componentes por outro, e a principal troca estética é a troca do chip
Atmega328P no modelo PTH (que fica encaixado na placa) pelo modelo SMD.

A sigla SMD significa Surface Mounted Device, que traduzindo é algo como Dispositivo
Montado em Superfície, isso significa que diferente do PTH, esse tipo de chip é soldado
diretamente na superfície da placa sem precisar de furo.

Isso faz com que o chip possa ser muito menor que o PTH (que significa algo como
Terminal Inserido no Furo”, por não precisar fazer furos. Como pode ser visto na placa,
o chip que é como o cérebro do Arduino muda demais de tamanho de uma placa para
outra devido essa tecnologia.
Mas uma pergunta pode estar pairando, que é: “Mas por o chip ser menor, isso não
significa que seja menos potente?”. A resposta para essa pergunta é não, porque no
caso do chip maior ele não tira nenhuma vantagem por ser maior, tendo dentro do chip
muito espaço vazio somente para cumprir o requisito de ser PTH.

Bom, sabendo disso, agora podemos explorar outra diferença, que é o chip responsável
por fazer a conversão USB-Serial. Esse chip é usado para fazer com que seu computador
reconheça sua placa Arduino, e faz a interface da “linguagem” do USB para a linguagem
do Arduino, que no caso é serial UART.

No projeto original o chip utilizado é o Atmega16U2, enquanto no modelo SMD o chip

utilizado é o CH340G. No funcionamento não altera em absolutamente nada, e ambos
os chips são capazes de fazer a mesma coisa, a única diferença está na instalação dos
drivers e no reconhecimento automático da Arduino IDE.

O chip do Arduino original, o Atmega16U2, tem seus drivers (driver é um pequeno

programa instalado no seu sistema operacional para que ele saiba como operar o
dispositivo) instalados automaticamente quando você instala a sua Arduino IDE. Logo,
você não necessita instalar driver nenhum para fazer funcionar sua placa.

Já na placa Uno SMD, por ela utilizar o chip CH340G, você necessita instalar o driver
CH340G. Por sorte, é um processo bem simples, bastando baixar o driver e instalar no
seu computador como se faz com um programa comum.

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

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

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

Com o driver instalado, vamos apenas confirmar se a placa está sendo reconhecida
corretamente pelo computador. Para isso, abra o Gerenciador de Dispositivos do
Windows (basta abrir o menu iniciar e pesquisar por “gerenciador de dispositivos”).
Nele, procure o item “Portas COM e LPT” e veja se a placa está sendo exibida como na
imagem abaixo:
Parte III - Instalando e conhecendo a Arduino IDE
A Arduino IDE é a plataforma oficial para programação do Arduino. Vamos começar
sua instalação fazendo o download do instalador, que pode ser encontrado no site
oficial – clicando aqui.
Recomendamos sempre que você instale a versão estável mais recente disponível para
seu sistema operacional. Como estamos utilizando o Windows 10 em nosso
computador, vamos selecionar a opção Windows Win 10 and newer, 64 bits:

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

Após esses passos, o download irá iniciar automaticamente. Quando terminar, execute
o arquivo baixado e clique em “Eu concordo” na janela exibida.
Nas telas seguintes, basta clicar em “Próximo” e “Instalar”. Ao término, clique em
concluir para abrir a IDE.
Com a IDE instalada e aberta, vamos conhecer os recursos que serão úteis nessa
apostila. Primeiramente, vamos fazer uma pequena configuração, que será útil
futuramente. Clique em “Arquivo”, na parte superior e vá em “Preferências”. A tela
abaixo será exibida:

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

Feito isso, você está pronto para iniciar a montagem e programação dos exemplos!

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

Agora vamos entrar nas seções de exemplos em si. Os conceitos da Parte I são
importantes caso você esteja começando a trabalhar com eletrônica. No entanto,
devido ao aspecto prático da montagem, não necessariamente você precisa de ler toda
a parte introdutória para montar os circuitos abaixo, mas recomendamos que estude os
componentes e suas particularidades para complementar seu conhecimento.
Em cada exemplo vamos apresentar os materiais utilizados, o diagrama, o código e mais:
em um exemplo específico, deixamos um desafio para que você complete o
funcionamento do projeto com base nos conhecimentos adquiridos.

Vamos começar!

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

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

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

Nesse exemplo, vamos conectar a saída de um potenciômetro a uma entrada

analógica da Arduino UNO. Dessa forma, vamos ler o valor de tensão na saída do
potenciômetro e vê-la variando de 0 a 1023. Mas, como assim, 0 a 1023?

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

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

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

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

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

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

Tensão = Valor*(5/1024)

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

Lista de materiais:

Para esse exemplo você vai precisar de:

⚫ Arduino UNO;
⚫ Protoboard;
⚫ Potenciômetro 10K;
⚫ Jumpers.

Diagrama de circuito

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

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

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

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

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

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

// Apostila Eletrogate - KIT INICIANTE

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

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

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

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

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

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

Serial.print(voltage); // imprime a tensão
Serial.print(" Valor: "); // imprime no monitor serial
Serial.println(sensorValue); // imprime o valor
delay(500); // atraso de 500 milissegundos
}
No código, nós declaramos a variável sensorValue para armazenar as leituras da entrada
analógica A0 e a variável Voltage para armazenar o valor lido convertido para tensão.
Declaramos como sendo do tipo float pois precisamos trabalhar com casas decimais, o
que não é permitido no tipo int.

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

Exemplo 2 - Controle de LEDs com Botões

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

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

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

Lista de materiais:

Para esse exemplo você vai precisar:

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

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

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

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

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

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

// Apostila Eletrogate - KIT INICIANTE

#define PinButton 6 // define pino digital D6

#define ledPin 7 // define pino digital D7

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

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

Exemplo 3 - Acionamento de buzzer com um botão

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

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

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

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

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

Lista de materiais:

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

Diagrama de circuito:
Carregue o código abaixo em seu Arduino:

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

//Apostila Eletrogate - KIT INICIANTE

#define BUTTON 3
#define BUZZER 4

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

void loop(){
if (digitalRead(BUTTON) == LOW){
digitalWrite(BUZZER, HIGH);
} else {
digitalWrite(BUZZER, LOW);
}
delay(100);
}
Exemplo 4 - Acionamento de LED conforme do Luz Ambiente

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

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

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

A imagem abaixo mostra o sensor em mais detalhes:

Foto resistor (LDR)

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

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

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

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

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

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

Lista de materiais:

Para esse exemplo você vai precisar:

⚫ LDR;
⚫ Resistor de 10KΩ;
⚫ 1 Arduino UNO;
⚫ Protoboard;
⚫ Jumpers.

Diagrama de circuito:

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

A0, de forma que a tensão de saída do divisor varia de acordo com a variação da
resistência do sensor. Assim, vamos identificar as variações na intensidade de luz pelas
variações na tensão do sensor.
Quanto maior a intensidade de luz, menor a resistência do sensor e, consequentemente,
menor a tensão de saída.
Carregue o código abaixo e varie a luminosidade sobre o LDR.

// Exemplo 4 - Sensor de luz LDR

// Apostila Eletrogate - KIT INICIANTE

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

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

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

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

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

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

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

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

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

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

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

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

interferência de fontes luminosas próximas, que não sejam parte do ambiente.
Exemplo 5 - Medindo a Temperatura do Ambiente

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

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

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

Existem dois tipos básicos de termistores:

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

aumenta à medida que a temperatura aumenta;

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

diminui à medida que a temperatura aumenta.

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

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

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

Lista de materiais:

⚫ 1 Sensor de temperatura NTC;

⚫ Arduino UNO + cabo USB;
⚫ 1 resistor de 10KΩ;
⚫ Protoboard;
⚫ Jumpers para conexão no protoboard.
 Diagrama de circuito:

Carregue o código abaixo e meça a temperatura com o NTC:

// Exemplo 5 - Sensor de temperatura NTC

// Apostila Eletrogate - KIT INICIANTE

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

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

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

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

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

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

Diagrama de circuito:

Carregue o código a seguir:

 // Exemplo 6 - Efeito fade
// Apostila Eletrogate - KIT INICIANTE

#define LED 3 //nomeia o pino 3

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

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

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

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

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

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

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

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

Lista de materiais:
 • Arduino Uno + cabo;
• Potenciômetro 10KΩ;
• 1 LED;
• 1 Resistor de 330Ω
• Protoboard;
• Jumpers.

Diagrama de circuito

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

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

// Apostila Eletrogate - KIT INICIANTE

#define LED 3 //nomeia o pino do LED

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

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

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

Faça o upload do código após as conexões e gire o eixo do potenciômetro para variar o
brilho do LED.
Exemplo 8 - Acendendo um LED com Sensor Reflexivo Infravermelho
O sensor ótico reflexivo TCRT5000 é um dos mais populares para utilização em projetos
com Arduino. O sensor é fabricado pela Vishay, uma tradicional fabricante de
componentes eletrônicos. Recomendamos fortemente, a leitura do datasheet do
sensor:
https://www.vishay.com/docs/83760/tcrt5000.pdf
Trata-se de um sensor reflexivo que possui um emissor infravermelho e um
fototransistor. O emissor é um led infravermelho que emite um sinal nessa faixa do
espectro. Já o fototransistor é o receptor que faz a leitura do sinal refletido. Ou seja, o
led emite um feixe infravermelho que pode ou não ser refletido por um objeto. Caso o
feixe seja refletido, o fototransistor identifica o sinal refletido e gera um pulso em sua
saída.
Tensão direta do LED emissor é de 1,25 V com uma corrente máxima de 60 mA. A
corrente máxima do fototransistor é de 100 mA.
A distância máxima de detecção não é grande, ficando em torno de 25 mm (dois
centímetros e meio), o que pode limitar um pouco a sua aplicação. O fototransistor vem
com um filtro de luz ambiente, o que maximiza a identificação do feixe infravermelho
refletido.

Sensor TCRT5000 visto por cima Fonte: Vishay

Lista de materiais:
⚫ Arduino UNO R3;
⚫ Protoboard;
⚫ Sensor TCRT5000;
⚫ Led vermelho 5mm;
⚫ Resistor de 330;
⚫ Resistor de 10K;
⚫ Jumpers para ligação no protoboard;
Diagrama de Circuito:
O terminal Anodo (A) positivo do LED infravermelho está ligado por meio de um resistor
de 330R ao VCC (5V) e o seu terminal catodo (K) negativo está ligado em GND. O Coletor
(C) do fototransistor está ligado ao resistor de 10K (que está conectado no VCC) e
também na entrada digital D7 do Arduino. Essa entrada é que vamos usar para
identificar se o sensor percebeu algum objeto ou não. O Emissor (E) do fototransistor
está ligado ao GND.
O LED vermelho para indicação do Sensor, tem o terminal Anodo (A) positivo conectado
à um resistor de 330R que está conectado à porta digital D8 do Arduino. O terminal
catodo (K) negativo está ligado ao GND.
Código:

// Exemplo 8 - Sensor Ótico Reflexivo TCRT5000

// Apostila Eletrogate - KIT INICIANTE V2

int leituraSensor; // variavel de leitura do sensor

int led = 8; // led indicador = D8 do Arduino
int fotoTransistor = 7; // coletor do fototransistor = D7 do Arduino

void setup()
{
pinMode(led, OUTPUT); // pino do led indicador = saida
pinMode(fotoTransistor, INPUT); // pino do coletor do fototransistor = entrada
}

void loop()
{
leituraSensor = digitalRead(fotoTransistor); // leitura do sensor TCRT5000
if (leituraSensor == 0 ) // se o led refletir a luz
digitalWrite(led, HIGH); // acende LED indicador
else // senão
digitalWrite(led, LOW); // apaga LED indicador
delay(500); // atraso de 0,5 segundos
}

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

Exemplo 9 – Diferença entre transistores NPN e PNP na prática

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

Lista de materiais:

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

Diagrama de circuito

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

do tipo de transistor usado. Embora os transistores NPN (BC548) e PNP (BC558)
tenham a mesma disposição de terminais (Coletor – Base – Emissor), a forma como a
corrente flui através deles é diferente - reveja o esquemático dos transistores, lá na
página 17.

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

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

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

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

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

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

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

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

transistor pelo emissor e sai pelo coletor.

Com esses conceitos em mente, carregue o código no Arduino e veja o funcionamento

do circuito:

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

//Apostila Eletrogate - KIT INICIANTE

//Definição dos pinos

#define PNP 5
#define NPN 6

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

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

delay(1000); // Aguarda 1 segundo

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

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

delay(1000); //Aguarda 1 segundo

}
Exemplo 10 – Acionando displays de 7 segmentos
Os displays de 7 segmentos surgiram a partir da evolução dos LEDs. Um LED é um diodo
semicondutor que emite luz quando uma corrente elétrica o atravessa. Para evitar que
ele queime, é essencial limitar a corrente, por isso um resistor em série deve ser utilizado
ao energizá-lo.
Cada segmento do display é, na verdade, um LED individual. Ao acionar os segmentos,
podemos formar números e letras (com algumas limitações). Os segmentos são
identificados por letras de A a G, além do ponto decimal, rotulado como DP.
Existem dois tipos de displays: catodo comum e anodo comum. No display de catodo
comum, os negativos de todos os segmentos estão conectados a um único pino. No
display de anodo comum, os positivos são os pinos interligados entre si, resultando em
um acionamento invertido em relação ao catodo comum.
Neste projeto, utilizamos um display de 7 segmentos de catodo comum. Os pinos
marcados com bolinhas pretas representam os pinos comuns dos catodos. Utilize
apenas um desses pinos, pois ambos estão interligados internamente. Os demais devem
ser conectados ao Arduino através de um resistor para limitar a corrente.

Lista de componentes

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

Em nosso código, vamos explorar dois novos recursos da programação: arrays e

funções. Começando com os arrays, para ilustrar, imagine uma gaveta que guarda um
único parafuso – esta representa uma variável. Agora, pense em uma segunda gaveta
com divisórias, onde cada compartimento contém um parafuso de tamanho diferente.
Isso é o que chamamos de array.

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

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

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

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

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

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

void exibir(int caractere) {

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

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

void loop() {
for (int i = 0; i < 3; i++) { // Mude o limite para o número total de caracteres
configurados no switch + 1
exibir(i);
delay(1000); // Esperar 1 segundo entre os caracteres
}
}
Seu funcionamento é bem simples: criamos um array com 8 posições para armazenar
os pinos do Arduino onde os LEDs do display estão conectados. Também criamos
arrays de mesmo tamanho contendo os pinos que devem estar ligados ou desligados
para formar cada caractere. No setup, configuramos os pinos utilizando um laço for e o
comando pinMode(i, OUTPUT), que interpreta o valor em cada índice do array como
sendo o número do pino e o configura como saída.

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

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

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

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

Fazendo isso, você colocará à prova todo o seu aprendizado até aqui ao mesmo tempo
que o coloca em prática, desenvolvendo habilidades essenciais para a programação do
Arduino.
Parte V - Cálculo do resistor de base dos
transistores
Vamos abordar aqui como o cálculo do resistor de base deve ser feito. É de suma
importância dimensioná-lo corretamente pois, como visto anteriormente, esse resistor
é o responsável por controlar a corrente que fluirá pelo transistor.
O primeiro passo é calcular a corrente de base usando a fórmula
𝐼𝑐
𝐼𝑏 = , onde:
𝛽

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

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

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

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

Se utilizarmos qualquer valor de ganho dentro da faixa especificada, o transistor

funcionará na região ativa. Para que o transistor em opere em modo saturação, o
ganho utilizado no cálculo deve ser muito inferior ao ganho mínimo (nesse caso, a 200),
sendo comum utilizar apenas 10% desse valor.
Outros parâmetros também são importantes ao dimensionar um transistor para seu
circuito, como corrente de coletor máxima suportada, tensão máxima etc., ambos
presentes no datasheet. Não abordaremos esses detalhes nessa apostila.
Dito isso, vamos considerar o exemplo 12 da apostila como modelo de cálculo. Nele,
nós temos que:

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

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

• Vb equivale a 5V;
• Vbe equivale a 0,7V;
• Ib equivale a 0,00375A
Substituindo:
𝑉𝑏−𝑉𝑏𝑒 5−0,7 4,3
𝑅𝑏 = → 𝑅𝑏 = → 𝑅𝑏 = → 𝑅𝑏 = 1.146,66
𝐼𝑏 0,00375 0,00375
Veja que o valor encontrado para Rb é de 1.146Ω, porém não encontramos esse
resistor comercialmente. O valor mais próximo disponível no Kit Iniciante é de 1KΩ
(1000Ω), portanto esse deve ser o resistor utilizado na base do transistor no exemplo
12.
E aí, já consegue confirmar o valor dos resistores de base para o exemplo 11?
Deixaremos essa tarefa como exercício para você!
Parte VI – Principais comandos do Arduino
Nesta seção, trazemos um resumo dos comandos da Arduino IDE utilizados ao longo
dos exemplos. Essas referências são ferramentas valiosas para esclarecer suas dúvidas
sobre a sintaxe (a estrutura dos comandos) e, mais importante, para desvendar o
funcionamento de cada um deles. Aproveite esta oportunidade para aprofundar seu
conhecimento e dominar a programação no Arduino!

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

externas, como a Servo.h.
• #define: Define constantes que serão usadas ao longo do código, como um
pino do Arduino.
• pinMode(pino, modo): Comando usado para configurar um pino como entrada
(INPUT), saída (OUTPUT) ou ainda como um tipo especial de entrada que
dispensa o uso de resistores para acionar botões (INPUT_PULLUP).
• digitalWrite(pino, valor): Define se o pino configurado estará ligado (HIGH) ou
desligado (LOW).
• digitalRead(pino): Faz a leitura de um pino digital, verificando se está ligado ou
desligado.
• analogRead(pino): Faz a leitura de um pino analógico, retornando valores
entre 0 e 1023.
• analogWrite(pino, valor): Envia um sinal PWM para os pinos digitais
compatíveis.
• delay(x): Pausa a execução do código por x milissegundos.
• millis(): Retorna o número de milissegundos desde que o Arduino começou a
rodar o código.
• map(fonte, in_min, in_max, out_min, out_max): Converte um intervalo inicial
proveniente de uma (como uma entrada analógica) para outro, de maneira
proporcional.
• Serial.begin(velocidade): Inicializa a comunicação serial com uma velocidade
específica em bits por segundo.
• Serial.print() e Serial.println(): Imprimem dados no monitor serial. O segundo,
acrescido de uma quebra de linha.
• if (condição) / else: Laço condicional (Se condição, execute y, senão, execute z).
• for (inicialização; condição; incremento): Laço de repetição que itera sobre um
bloco de código um número definido de vezes (x recebe y, enquanto x for
menor que z, incremente x).
• switch (variável)/ case possível valor / break: estrutura usada para selecionar
um bloco de código a ser executado com base no valor da variável. As
 possibilidades são listadas com o comando “case” e encerradas com o
comando “break”.
• int: Usado para iniciar uma variável ou array do tipo inteiro, que trabalha
somente com números inteiros (sem casas decimais).
• float: Usada para criar variáveis e arrays que precisam receber números com
ponto flutuante (números com casas decimais).
• unsigned long: Usado para criar variáveis que precisam armazenar grandes
números positivos, como os fornecidos pela função millis().
• void: Usado para criar funções que não retornam nenhum tipo de valor.
• Servo / attach / write: comandos dedicados da biblioteca Servo.h, usados para
criar o objeto que receberá as funções da biblioteca, configurar o pino em que
o servo está conectado e enviar os pulsos de forma correta.

Sugerimos que, além de consultar esse pequeno resumo, acesse a documentação

oficial do Arduino e estude os demais comandos e sua sintaxe através do link a seguir:

• https://www.arduino.cc/reference/pt/
Considerações finais
Essa apostila tem por objetivo apresentar alguns exemplos básicos sobre como utilizar
os componentes do Kit Iniciante para Arduino, a partir dos quais você pode combinar e
fazer projetos mais elaborados por sua própria conta.

Nas referências finais, também tentamos indicar boas fontes de conteúdo objetivo e
com projetos interessantes. Sobre esse ponto, que consideramos fundamental,
gostaríamos de destacar algumas fontes de conhecimento que se destacam por sua
qualidade.

O fórum oficial Arduino possui muitas discussões e exemplos muito bons. A comunidade
de desenvolvedores é bastante ativa e certamente pode te ajudar em seus projetos. No
Project Hub poderá encontrar milhares de projetos com Arduino.

⚫ Fórum oficial Arduino: https://forum.arduino.cc/

⚫ Project Hub Arduino: https://create.arduino.cc/projecthub

O Instructables é a ótima referência do mundo maker atual. Pessoas que buscam

construir suas próprias coisas e projetos encontram referências e compartilham suas
experiências no site.

⚫ Instructables: https://www.instructables.com/

O Maker Pro é outro site referência no mundo em relação aos projetos com Arduino. Há
uma infinidade de projetos, todos bem explicados e com bom conteúdo.

⚫ Maker pro: https://maker.pro/projects/arduino

Em relação à eletrônica, teoria de circuitos e componentes eletrônicos em geral,

deixamos alguns livros essenciais na seção finais de referências. O leitor que quer se
aprofundar no mundo da eletrônica certamente precisará de um livro basilar e de bons
conhecimentos em circuitos eletroeletrônicos.

No mais, esperamos que essa apostila seja apenas o início de vários outros projetos e,
quem sabe, a adoção de Kits mais avançados, como os de Robótica e Arduino Advanced.
Qualquer dúvida, sugestão, correção ou crítica a esse material, fique à vontade para
relatar em nosso blog oficial: http://blog.eletrogate.com/
Referências gerais

1. Fundamentos de Circuitos Elétricos. Charles K. Alexander; Matthew N. O.

Sadiku. Editora McGraw-Hill.
2. Circuitos elétricos. James W. Nilsson, Susan A. Riedel. Editora: Pearson; Edição:
8.
3. Microeletrônica - 5ª Ed. - Volume Único (Cód.: 1970232). Sedra, Adel S. Editora
Pearson.
4. Fundamentals of Microelectronics. Behzad Razavi. Editora John Wiley & Sons;
Edição: 2nd Edition (24 de dezembro de 2012).

Abraços e até a próxima!