Apostila Aduino 2014 (1)

Prévia do material em texto

CAPACITAÇÃO 
TÉCNICA 
NA PLATAFORMA 
ARDUINO
CONTROLE E PROCESSOS INDUSTRIAIS
CARLOS BARREIRA DA SILVA FARINHAS
A expansão do Ensino Técnico no Brasil, fator importante para melhoria de nossos recursos humanos, é um dos pilares do desenvolvimento do país. Esse 
objetivo, dos governos estaduais e federal, visa à melhoria da competitividade de 
nossos produtos e serviços, vis-à-vis com os dos países com os quais mantemos 
relações comerciais. 
Em São Paulo, nos últimos anos, o governo estadual tem investido de forma 
contínua na ampliação e melhoria da sua rede de escolas técnicas - Etecs e Classes 
Descentralizadas (fruto de parcerias com a Secretaria Estadual de Educação e com 
Prefeituras). Esse esforço fez com que, de agosto de 2008 a 2011, as matrículas do 
Ensino Técnico (concomitante, subsequente e integrado, presencial e a distância) 
evoluíssem de 92.578 para 162.105. 
A garantia da boa qualidade da educação profissional desses milhares de jovens 
e de trabalhadores requer investimentos em reformas, instalações/laboratórios, 
material didático e, principalmente, atualização técnica e pedagógica de professores 
e gestores escolares. 
A parceria do Governo Federal com o Estado de São Paulo, firmada por 
intermédio do Programa Brasil Profissionalizado, é um apoio significativo para 
que a oferta pública de ensino técnico em São Paulo cresça com a qualidade 
atual e possa contribuir para o desenvolvimento econômico e social do estado e, 
consequentemente do país.
Almério Melquíades de Araújo 
Coordenador de Ensino Médio e Técnico
Centro Estadual de Educação Tecnológica Paula Souza
Diretora Superintendente
Laura Laganá
 
Vice-Diretor Superintendente
César Silva
 
Chefe de Gabinete da Superintendência
Luiz Carlos Quadrelli
 
Coordenador do Ensino Médio e Técnico
Almério Melquíades de Araújo
REALIZAÇÃO
Unidade de Ensino Médio e Técnico
Grupo de Capacitação Técnica, Pedagógica e de Gestão - Cetec Capacitações
Responsável Cetec Capacitações
Lucília dos Anjos Felgueiras Guerra
Responsável Brasil Profissionalizado
Silvana Maria Brenha Ribeiro
Coordenador de Projetos
Luiz Saito
Revisão de Texto
Yara Denadai
Revisão de Conteúdo
Marcos Augusto Cunha Couto Estácio
Projeto Gráfico
Diego Santos
Fábio Gomes
Priscila Freire
Projeto de formação continuada de professores da educação profissional do 
Programa Brasil Profissionalizado - Centro Paula Souza - Setec/MEC
“Para você beber vinho numa taça cheia de chá, é necessário primeiro 
jogar fora o chá para, então, beber o vinho.”
Sumário
Por que utilizar a Plataforma Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
A família Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Microcontrolador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Características: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Periféricos: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Descrição dos pinos:. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
O conjunto didático da empresa EMPRETEC. . . . . . . . . . . . . . . . . . . . . . . . . . . 18
A placa Arduino compatível - EMPRETEC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Pinos Digitais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Pinos Analógicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Pinos de alimentação (POWER). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
LEDs indicativos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
A Linguagem utilizada para programação.. . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Exemplo de programa.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Explicando o programa Blink. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Instalação.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
O ambiente de programação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Escrevendo um programa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Alterando o programa.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
EX-1 – Conectando LEDs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
EX-2 – Conectando LEDs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
EX-3 – Conectando LEDs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Adicionando variáveis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
EX-4 – Inserindo variável tempo 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
EX-5 – Inserindo variável tempo 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Ligando um botão e lendo o estado de um botão. . . . . . . . . . . . . . . . . . . . . 46
EX-6 – Ligando um botão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
EX-7 – Ligando um botão II. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
EX 8 – Ligando dois botões.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
EX-9 – Ligando botão com Pull up interno. . . . . . . . . . . . . . . . . . . . . . . . 50
Usando a biblioteca bounce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Resolvendo operações lógicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
EX-10 - Operações lógicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
EX-11 - Expressões lógicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Utilizando o monitor serial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
EX-12 – Calculando valores em um retificador. . . . . . . . . . . . . . . . . . . . . 58
EX-13 – Calculando a quantidade de azulejos. . . . . . . . . . . . . . . . . . . . . 59
EX-14 - Operações lógicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
EX-15 - Expressões lógicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
If (forma simples) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Estruturas condicionais – comando if - else . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
EX-16 - Utilizando comando if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
EX-17 - Utilizando comando if 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
EX-18 - Utilizando comando if 3.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Utilizando if else. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
EX-19 - Utilizando comando if – else. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Comando for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Entradas analógicas.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Lendo sensores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Utilizando a função MAP.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
EX- 20 – Mapeando o potenciômetro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
EX- 21 – Controlando o Led com o LDR. . . . . . . . . . . . . . . . . . . . . . . . . . . 78
PWM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
EX- 22 – Controlando o Led com PWM. . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
O sensor de temperatura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
EX- 23 – Mapeando o sensor de temperatura. . . . . . . . . . . . . . . . . . . . . 83
Utilizando o relé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
EX- 24 – Acionando o relé em uma determina temperatura. . . . . . . . 87
Utilizando o sensor reflexivo.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
EX- 25 – Reconhecendo cores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Controle de motor DC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
EX- 26 – Controle de velocidade e direção de um motor DC através 
de ponte H com transistores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Utilizando o L293D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
EX- 27 – Controle de velocidade e 
direção de um motor DC com CI L293D . . . . . . . . . . . . . . . . . . . . . . . 98
Motor de passo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
EX- 28 – Controle de motor de passo com ULN2003. . . . . . . . . . . . . . 102
Por que utilizar a Plataforma Arduino.
Capítulo 1
Arduino é o nome dado a uma plataforma de desenvolvimento de microcontrola-
dores feita para simplificar o projeto eletrônico, prototipagem e experimentação 
para artistas, hackers, amadores, pessoas que tenham pouco conhecimento de 
eletrônica e/ou de programação.
Arduino contêm um microcontrolador Atmega - que é um “computador” com-
pleto com CPU, RAM, memória Flash, e pinos de I/O todos em um único chip e foi 
projetado para que possa ser ligado diretamente nos pinos de I/O, diversos tipos 
de sensores, LEDs, pequenos motores, relés, etc. Através desses pinos, é possível 
ler tensões de entrada (digital ou analógico) entre 0 e 5 volts. 
O Arduino se conecta ao seu computador via USB e pode ser programado de 
forma simples, utilizando uma linguagem bem parecida com a linguagem C / C + 
+ em uma IDE desenvolvida para esse fim.
O projeto Arduino que conhecemos hoje, foi iniciado no ano de 2005 com a fina-
lidade de ser uma opção barata para que alunos pudessem realizar seus projetos 
com microcontroladores. Foi desde o início desenvolvida para ser uma platafor-
ma (um conjunto de soluções) open-source composto por uma placa, cujo es-
quemas estão disponíveis no site oficial, um ambiente de desenvolvimento (IDE) 
disponível gratuitamente e por uma linguagem de programação simples e fácil 
de utilizar, além de ser multiplataforma, podendo rodar em ambientes Windows, 
Linux e MAC.
A plataforma Arduino foi feita para aprender mexendo! Pode-se ensinar desde 
lógica de programação simples até avançada. É possível ensinar vários conceitos 
de eletrônica, como diversos componentes são ligados às saídas de microcontro-
ladores e como o microcontrolador entende esses componentes.
A plataforma Arduino é, sem exageros, um excelente recurso educacional.
Atualmente, o projeto UNO é a placa de referência adotada pela equipe 
Arduino que mantém na página oficial – www.arduino.cc, toda a documen-
tação atualizada com referências e exemplos de códigos de aplicação.
Figura 1- Vista da frente e de traz da placa UNO-R3.
Existem outras placas disponíveis como o DUE que é uma placa que possui um 
número maior de I/O,
Figura 2 - Placa DUE
Os outros produtos disponíveis podem ser vistos no site :
http://arduino.cc/en/Main/Products
A família Arduino.
Capítulo 2
13
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Existem ainda placas que são adicionadas a placa do Arduino que acrescentam 
funcionalidades à plataforma. Essas placas são conhecidas com Shields. Um 
exemplo disso é o shield ethernet. Com ele o Arduino poderá ser conectado à 
internet a partir de qualquer tomada RJ45.
Figura 3 - Shield Ethernet
Outros modelos de Shields podem ser vistos em: 
http://arduino.cc/en/Main/Products
Além dos modelos oficiais, como o projeto é aberto, existem diversas empresas 
e grupos que a partir da documentação disponível, desenvolvem produtos e em 
muitos casos também o comercializam. Uma lista com todos os modelos simila-
res reconhecidos pode ser encontrada no endereço seguinte:
http://playground.arduino.cc/Main/SimilarBoards
 Um ótimo exemplo de um produto nacional e reconhecido pela equipe Arduino 
é o Severino.
O Severino é um projeto nacional que pode ser livremente reproduzido e toda a 
documentação pode ser encontrada nesta página:
Figura 4 - Severino
http://www.arduino.cc/en/Main/ArduinoBoardSerialSingleSided3
14
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Um outro exemplo é o projeto que será utilizado nesta capacitação comercializa-
do pela empresa EMPRETEC que é uma placa Arduino compatível baseada no 
modelo Duemilanove.
Figura 5 – Arduino compatível EMPRETEC
O microcontrolador utilizado é o ATmega328P, um µC AVR integrante da série 
ATmegaXX8 da Atmel. Atualmente são os melhores µC de 8 bits disponibilizados 
pela Atmel em encapsulamento DIP de 28 pinos. O XX da série indica a quanti-
dade de memória FLASH disponível. Portanto, o ATmega328P possui 32KBytes 
de memória FLASH com barramento de 8 bits. A letra P significa que este micro 
trabalha consumindo menos energia do que outros processadores.
Figura 6 - Diagrama em blocos ATMEGA
Capítulo 3
Microcontrolador.
Watchdog
Timer debugWIRE
PROGRAM
LOGIC
SRAM
Watchdog
Oscillator
Oscillator
Circuits/
Clock
Generation
Power
Supervision
POR/BOD &
RESET
Flash
EEPROM
8bit T/C 0
8bit T/C 2
Analog
Comp.
Internan
Bandcap
USART 0
PORT D (8) PORT B (8) PORT C (7)
RESET
AVCC
AREF
GND
XTAL[1.2]
ADC[6.7]PC[0.6]PB[0.7]PD[0.7]
SP1 TW1
D
AT
A
BU
S
16bit T/C 1 A/D Conv.
G
N
D
VO
C
16
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Características:
• Arquitetura RISC.
• 130 instruções otimizadas para trabalhar com compiladores de alto nível em 
especial o C, a maioria executada em apenas 1 ciclo de relógio.
• Possui 32 registradores de propósito geral de 8 bits (R0 a R31)
• Operação de até16MIPS (milhões de instruções por segundo) a 16MHz
• 8 KBytes me memória de programa FLASH de auto programação In-System.
• 512 Bytes de memória EEPROM.
• 1KByte de memória SRAM.
• Ciclos de escrita e apagamento: memória FLASH 10.000 vezes, EEPROM 
100.000 vezes.
Periféricos:
• 23 I/O programáveis;
• 2 temporizadores/contadores de 8 bits com Prescaler separado, 1 modo de 
comparação.
• 1 temporizadores/contadores de 16 bits com Prescaler separado, modo de 
comparação e captura.
• Contador de tempo real (com cristal externode 32.768 Hz) conta precisamen-
te 1s.
• 3 canais PWM.
• 6 canais A/D com precisão de 10 bits
• Interface serial para dois fios orientada a Byte (TWI), compatível com o pro-
tocolo I2C.
• Interface serial USART.
• Interface serial SPI Master/Slave
• Watchdog Timer com oscilador interno separado
• Oscilador RC interno (não há necessidade de cristal externo ou outra fonte 
de clock).
• 5 modos de Sleep: Idle; Redução de ruído do A/D; Power-Down; Power Safe 
e Standby.
17
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
D
es
cr
iç
ão
 d
o
s 
p
in
o
s:
Fig
ur
a 7
 –
 Pi
na
ge
m
.
A EMPRETEC é uma empresa nacional que desenvolveu um projeto próprio 
baseado na plataforma Arduino. Utilizando o modelo Duelmilanove como 
base, a placa é compatível com o modelo UNO, observando-se que as 
funcionalidades agregadas ao projeto UNO – R3 (última versão), não estão 
disponíveis neste modelo.
O kit consiste basicamente de uma placa Arduino – compatível e um conjunto 
de peças disponíveis em pequenas placas de PCI contendo barramentos para 
conexões de fios, além de matriz de contatos e componentes soltos como LEDs 
e resistores.
Figura 8 - Kit EMPRETEC
Informações sobre o kit podem ser obtidas neste endereço: 
http://www.empretecnet.com.br/do/Home
O conjunto didático da empresa 
EMPRETEC.
Capítulo 4
A figura a seguir, mostra a placa 
desenvolvida pela EMPRETEC. Faremos 
uma pequena descrição de suas partes. 
Capítulo 5
A placa Arduino compatível - 
EMPRETEC.
Figura 9 - Placa Arduino compatível
Esta placa será conectada ao computador 
através da entrada USB. Por essa conexão, a 
placa será alimentada com 5V e também se 
comunicará com o computador.
Figura 10 - Conexão USB
Após a gravação do programa na memória do 
microcontrolador, a placa pode ser desligada do 
computador e conectada à uma fonte de alimen-
tação externa através de um pino tipo P2. Ela 
pode ser alimentada com tensões de 7,5V até no 
máximo 12V. O projeto contém um regulador de 
tensão de 5V.
Figura 11 - Conexão para fonte externa.
20
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
A conexão entre o microcontrolador e os di-
versos componentes, sensores e demais dis-
positivos é feita através de blocos de termi-
nais disponíveis nas laterais da placa. Este é 
o diferencial do projeto da EMPRETEC para as 
demais placas compatíveis.
Figura 12 - Blocos de terminais.
Os terminais mais externos do são destina-
dos à distribuição do GND.
O GND também pode ser encontrado na 
linha de terminais que estão diretamente 
conectados à saída do microcontrolador e 
nos terminais destinados à distribuição da 
fonte de alimentação – POWER.
Figura 13 - Distribuição GND.
A segunda fileira de terminais é destinada 
à distribuição de 5V, que também pode ser 
encontrada nos terminais POWER.
Figura 14 - Distribuição Vcc.
Os terminais internos que estão na terceira 
fileira do conector, estão conectados aos 
pinos do microcontrolador e serão descri-
tos a seguir.
Figura 15 - Pinos conectados ao Micro controlador.
21
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Pinos Digitais.
Nesta placa, existem 14 pinos digitais numerados de 0 até 13. 
Para estes pinos, o limite máximo de corrente é de 40mA (I/O), sendo recomen-
dado utilizar valores até 20mA. Estes pinos têm também um resistor pull-up in-
terno que vem desligado de fábrica e é ativado por software.
Figura 16 - Pinos Digitais.
Além de serem pinos de I/O, alguns tem funcionalidades específicas que estão 
descritas a seguir.
Terminais Denominação Descrição
0
RX – Utilizado para receber dados seriais 
TTL
Estes terminais além 
de estarem conectados 
aos pinos TXD e RXD do 
microcontrolador, também 
estão ligados ao CI FTDI que 
faz a comunicação serial 
entre o microcontrolador e o 
computador. 
1
TX – Utilizado para transmitir dados 
seriais TTL
2 ,3 ISR (Interrupt Service Routine)
Estes pinos podem ser 
configurados para chamar 
uma interrupção
3, 5, 6, 9, 10 e 11. PWM (Pulse Width Modulation) 
Fornecem uma saída PWM 
de 8 bits.
10 (SS) (Slave Select)
Estes pinos são utilizados 
para permitir a comunicação 
do microcontrolador com 
um ou mais periféricos 
utilizando o protocolo SPI 
(Serial Peripheral Interface).
11 MOSI (Master Out Slave In)
12 MISO (Master In Slave Out)
13 SCK (Serial Clock)
13 LED
O pino 13 também está 
conectado à um LED que 
está montado na placa.
Tabela 1 - Função dos pinos digitais.
22
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Pinos Analógicos.
O Arduino tem 6 pinos analógicos – A0 
até A5 - todos pinos de entrada com 
resolução de 10 bits (0 a 1023). 
Por padrão, estas entradas recebem 
tensões de 0 até 5V. Através do pino 
AREF, o limite superior da tensão pode 
ser alterado.
Figura 17- Pinos Analógicos.
Assim como nos pinos digitais, alguns pinos têm funções especiais.
Terminais Denominação Descrição
A4 DAS (Serial Data Line)
Estes pinos suportam 
comunicação I2C (TWI – 
Two- Wire Interface).
A5 SCL (Serial Clock Line)
Tabela 2- Pinos Analógicos.
Pinos de alimentação (POWER)
Os pinos de alimentação fornecem 
tensões para placas externas como os 
Shields. Estão disponíveis 2 tensões di-
ferentes, 5V e 3,3V sendo esta limitada 
à 50mA. Além deles são fornecidos tam-
bém dois pinos GND.
Neste barramento, existem ainda dois 
outros pinos.
Figura 18 - Pinos POWER.
- RESET: fornece o comando RESET para uma placa externa.
- VIN: Encaminha tensão de alimentação externa.
23
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
LEDs indicativos.
A placa contém ainda 4 LEDs indicativos.
Figura 19 - LEDS indicativos.
Comunicação com o PC
Estes LEDs indicarão quando um programa está 
sendo transferido do computador para o micro-
controlador.
LED
conectado 
ao pino 13
POWER
indica que a placa está ligada
A Linguagem utilizada para 
programação.
Capítulo 6
A plataforma Arduino utiliza a linguagem de programação Arduino baseada em 
Wiring que é uma linguagem de programação open-source para microcontrola-
dores. A estrutura desta linguagem é muito parecida com a linguagem C sendo 
que aqueles que dominam a linguagem de programação C terão pouquíssima 
dificuldade para programar um Arduino. A estrutura básica da linguagem de 
programação do Arduino é bastante simples e é composta de pelo menos duas 
partes, que são os blocos setup e loop.
O primeiro bloco é o setup. Nele serão declaradas as variáveis e as configurações 
dos pinos utilizados, se serão de entrada ou de saída. Nele também será iniciali-
zada a comunicação serial se for utilizada.
O bloco setup, é executado apenas uma única vez, quando o programa é inicia-
lizado.
No bloco loop, os pinos de entrada e saída serão constantemente “lidos”, sen-
do os estados processados pelo µC (de acordo com as instruções do programa) 
e alterados quando for o caso. O processo é contínuo e será encerrado apenas 
quando uma interrupção acontecer ou o µC for desligado.
Para escrever um programa, entre outros elementos, são utilizadas funções que 
são pequenos blocos de programas usados para montar o programa principal. 
São como sub-rotinas, procedimentos ou bibliotecas, escritas para realizar tare-
fas repetitivas.
Toda a função deve der declarada antes de ser chamada, atribuindo-lhe um tipo e 
um nome seguido de parênteses onde serão colocados os parâmetros da função. 
Entre chaves { }, serão escritos os procedimentos que afunção deverá executar.
A função setup()
É chamada apenas uma única vez e é responsável por iniciar os modos de traba-
lho dos pinos, e a porta serial. Deve ser incluído no programa mesmo que não 
exista alguma declaração para ser feita. 
25
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Como em qualquer linguagem de programação a forma como a palavra é escri-
ta, determina se será ou não reconhecida dando então o necessário significado 
ao programa que está sem do feito. A palavra setup (e as outras utilizadas na 
linguagem de programação do Arduino) devem ser escritas como determina a 
referência da linguagem. Os dois parênteses escritos logo a seguir, nesta função, 
serão vazios, sem parâmetros, porém não poderão ser suprimidos.
A função loop()
Logo após a função setup, a função loop é escrita e dentro desse bloco é que 
estará distribuído o conjunto de instruções que caracterizarão o programa. Este 
bloco será lido sequencialmente e cada linha executada a partir da primeira até 
a última. Após isso, o programa volta para a primeira linha e executa novamente 
cada uma das linhas do programa, ciclicamente.
Exemplo de programa.
Capítulo 7
Vamos então utilizar um programa básico do Arduino que é o que faz o Led que 
está conectado ao pino 13 da placa piscar para exemplificar a estrutura de pro-
gramação do Arduino.
Figura 20 - Programa 1- Blink.
O código escrito acima é de domínio público e pode ser encontrado na própria 
IDE do Arduino no menu exemplos. Como em todo programa, o recurso de co-
mentar o texto, explicando o que ele faz e o que cada linha deve executar está 
presente.
27
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
/* */ é utilizado para escrever um comentário de duas ou mais linhas.
// é utilizado em comentários de uma linha.
O uso de comentários é importante para registrar a intenção do programador e 
servindo também para resgatá-la. Não serve apenas para traduzir o significado 
da função ou parâmetro más sim para explicar o que se espera que aconteça.
Neste texto, vamos retirar os comentários do programa a fim de enfatizar a sequ-
ência de instruções.
Figura 21 - Programa 2 - Blink sem comentários.
Explicando o programa Blink.
int led = 13;
Antes do bloco setup, é necessário declarar as variáveis que 
serão utilizadas no programa.
int se refere ao tipo de números que a variável pode manipular. 
No caso, a variável é do tipo inteiro e pode armazenar números 
de até 16 bits com um range de -32.768 até 32.767.
led se refere ao nome da variável. Pode ser qualquer nome, 
utilizando caracteres alfanuméricos. 
= operador de atribuição. 13 se refere a saída 13 da placa.
Então, nesta linha, foi criada uma variável chamada led do tipo 
int (que armazena números na faixa de 2^-10 até 2^10 – 1) e 
que está fisicamente conectada ao pino 13 da placa, e que neste 
caso, também está conectado ao led da placa.
No final existe o sinal ; (ponto e vírgula) que encerra um 
procedimento.
28
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
void setup() { 
 pinMode(led, OUTPUT); 
}
Este é o bloco setup.
A função setup, não retorna valor algum e por isso, é do tipo void.
Logo após, entre chaves { }, são apresentadas as funções e suas 
declarações. As chaves limitam um procedimento.
Vários procedimentos podem ser escritos dentro da função 
setup sempre separados por chaves.
pinMode – Esta função determina o modo do pino, se ele será 
um pino de entrada (INPUT) ou de saída (OUTPUT).
Logo após a função, entre parênteses, é necessário informar o 
pino, no caso – led - e a palavra OUTPUT. Isto quer dizer que o 
pino led é uma saída.
void loop() {
 digitalWrite(led, HIGH); 
 delay(1000); 
 digitalWrite(led, LOW); 
 delay(1000); 
}
Este é o bloco loop.
Assim como no setup, loop é uma função do tipo void.
digitalWrite é a função que escreve no pino digital, um 
determinado valor, um estado. Logo a seguir da função, entre 
parênteses, segue o nome do pino – led – e o estado que é HIGH. 
Ou seja, o pino led foi setado para 1.
Em seguida, a função delay é iniciada. Esta função atrasa a 
execução do programa pelo tempo especificado a seguir, entre 
parentes. O valor declarado é 1000. Como a base desta função 
é o milissegundos, o programa ficará parado por 1000 ms, ou 1 
segundo. Assim o led ficará aceso por 1 segundo.
digitalWrite é novamente iniciado. Isto é necessário pois o 
primeiro digitalWrite, acendeu o led. Então é necessário apaga-
lo (a finalidade do programa é fazer o led piscar).
Então, o estado do led é definido como LOW ou 0. O led ficará 
apagado então por 1 segundo.
O programa ficará executando o loop, linha por linha, até que o 
equipamento seja desligado.
Tabela 3 - Explicando o programa.
Instalação.
Capítulo 8
Para utilizar qualquer placa Arduino oficial, basta ir até a página de download 
- http://arduino.cc/en/Main/Software - e escolher a opção do sistema 
operacional instalado em seu computador. No caso da versão para Windows, 
o arquivo estará compactado. Basta então fazer a descompactação do arquivo 
e executar os procedimentos comuns utilizados para instalação de qualquer 
software. Para os outros sistemas operacionais, o procedimento é semelhante. 
Este arquivo que será baixado e instalado em seu computador é o ambiente de 
programação do Arduino, ou IDE. Atualmente, a versão da IDE é a 1.0.5.
Em placas Arduino compatíveis, como é o caso da placa da EMPRETEC, as ve-
zes é necessário instalar um driver de comunicação próprio da placa. No CD que 
acompanha o kit, existe um instalador com um atalho para a instalação desse 
driver.
Uma vez feito isso, a plataforma está praticamente pronta para uso.
O ambiente de programação.
Capítulo 9
É no IDE do Arduino que o programa será escrito e também transferido para a 
placa a fim de ser gravado no µC. Para isso, é necessário conectar a placa do µC 
através de um cabo USB ao computador. Inicie então a IDE que terá a aparência 
mostrada abaixo. 
Figura 22 - IDE do Arduino.
Barra de menus
Área onde o programa 
será escrito
Área de mensagens
Barra de botões
Modelo da placa 
e porta serial 
COM utilizada
Nome provisório 
do código e 
versão da IDE
31
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
É possível alterar a linguagem do ambiente para português. Isso é feito selecio-
nando preferencias no menu Arquivo.
Figura 23 - Menu Arquivo.
Na caixa aberta, selecione a língua e depois reinicie o IDE.
Figura 24 - Preferencias.
O próximo passo é configurar o tipo de placa que será utilizado. A placa da EM-
PRETEC é do tipo Duelmilanove. Então no menu Ferramentas, selecione Placa. 
Da lista de opções aberta, selecione o modelo Arduino Duemilanove w/ ATme-
ga328.
Figura 25 - Configurando o modelo de placa.
32
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Após definir o modelo da placa é necessário verificar em qual porta COM a placa 
está conectada.
Vá até o painel de controle e em Sistema, selecione Gerenciador de Dispositi-
vos. Procure em Portas (COM E LPT) qual é a COM que a placa está conectada.
Figura 26 - Localizando a COM.
Voltando a IDE, confirme o número da COM selecionada. Ela deve ser a mesma 
que a indicada no painel de controle.No exemplo, a porta COM deve ser a 6. En-
tão vá no menu Ferramentas e selecione Porta Serial. Na lista de COM selecione 
a indicada no painel de controle.
Figura 27 - Conferindo a porta COM.
Pronto!Agora é necessário escrever o programa. Vamos utilizar o programa “Pis-
car” que já detalhamos.
Escrevendo um programa.
Capítulo 10
Escreva na IDE o programa blink (piscar) como mostrado abaixo.
Figura 28 - Blink escrito no IDE.
Após a escrita é necessário compilar o 
código. Nesta etapa, o código escrito 
será “conferido” e caso algo esteja er-
rado, uma mensagem será mostrada. 
Caso tudo esteja correto, o código será 
reescrito em linguagem de máquina 
pela própria IDE. Para fazer isso, clique 
no botão verificar disponível na barra 
de botões.
Ao terminar, o programa está pronto 
para ser transferido para o µC.
Figura 29 - Compilando.
Não se esqueça de salvar o programa. Isso pode ser feito no menu Arquivo.
Perceba que ao escrever o programa na 
IDE, as palavras assumem cores, 
Cinza para comentários;
Laranja para funções;
Azul para constantes;
Preto para nome de variáveis e 
demais símbolos.
Quando uma palavra que remete a uma 
função ou a um estado for escrita errada, 
ele aparecerá preta.
34
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Para transferir o programa para o µC, é 
necessário pressionar o botão carregar 
disponível na barra de botões.
Observando a placa, perceba que os dois 
leds TX e RX piscam rapidamente. Este é o 
sinal de que o programa está sendo trans-
ferido e gravado no µC.
Ao terminar a transferência, o LED 13 co-
meça a piscar, ficando 1 segundo aceso e 
1 segundo apagado. Caso isso não acon-
teça, reveja os passos anteriores e repita 
a operação.
Figura 30 - Gravando o programa no micro.
Alterando o programa.
Capítulo 11
O que pode ser alterado neste último programa, o “piscar”.
Para alterar o programa, basta fazer as mudanças na própria IDE, escrevendo ou 
reescrevendo o programa que está lá. Vamos mudar o tempo em que o LED per-
manece aceso ou apagado e para isso, altere o programa para que o LED perma-
neça aceso por 100ms e apagado por 500ms.
Figura 31 - Alterando o programa.
Após fazer as alterações, salve este programa com um nome diferente e repita 
os passos de verificar e carregar. Observe o LED da placa. Ele pisca mais rapi-
damente.
Mas, e se for necessário ligar dois LEDs? Como fazer?
36
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Fácil, é só utilizar a velha matriz de contatos e alguns componentes.
Relembrando alguns conceitos...
Para ligar um LED em uma das portas de saída é necessário ligar um resistor em 
série com o LED. A tensão na porta no estado 1 é 5V e portanto um resistor entre 
150Ω a 330Ω deve satisfazer essa condição.
Vamos primeiro montar o circuito. 
Ligue na matriz de contatos dois LEDs, cada um com o seu resistor em série como 
mostra o esquema a seguir.
Figura 32 - Ligando dois LEDs.
Uma vez montado o circuito, é necessário alterar o programa. Então vamos para a IDE.
Declarando as variáveis: 
tipo e onde estão ligadas.
int led1 = 2;
int led2 = 3;
Setup void setup() {
Agora configurar o pino 
como saída.
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
A função loop. void loop() {
O estado (aceso ou 
apagado) e o tempo que 
cada LED ficará aceso.
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
delay(500);
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
delay(500);
}
Tabela 4 - Programa 2 LEDs.
Salve o programa, compile e grave-o no µC e observe o funcionamento.
37
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-1 – Conectando LEDs.
Figura 33 - Circuito com 4 LEDs.
int led1 = 2;
int led2 = 3;
int led3 =_________;
int led4 =_________;
void setup() {
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led_____ , OUTPUT);
pinMode(led_____ , ____________);
}
void loop() {
 digitalWrite (led1, HIGH);
 delay(500);
 digitalWrite (led2, HIGH);
 delay(_______);
 digitalWrite (led ______ , HIGH);
 delay(_______);
_________________________________
_________________________________
}
Figura 34 - Completando o programa.
38
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-2 – Conectando LEDs.
Figura 35 - Conectando Leds 2.
Neste espaço, escreva programa solicitado.
39
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-3 – Conectando LEDs.
Conectando LEDs 3.
Neste espaço, escreva programa solicitado.
Adicionando variáveis.
Capítulo 12
Nos programas anteriores, o tempo que determinava quando cada LED acendia 
ou apagava era escrito dentro da função delay. Isto significa que cada vez que for 
necessário modificar o tempo, é necessário alterar cada um dos valores. Em vez 
disso, uma variável “tempo” pode ser criada e será esta variável que ficará dentro 
da função delay. Assim, para alterar o valor do “tempo” basta alterar apenas uma 
esta variável.
Para criar uma variável o primeiro passo é determinar qual deve ser o tipo da va-
riável. O tipo determina qual o tipo de dado e sua extensão além de diretamente 
influenciar no tamanho do arquivo.
Tipo Descrição
void
A palavra reservada void é usada em declarações de funções. Este tipo indica 
que a função não retorna nenhum valor quando é executada.
Boolean
O tipo boolean pode representar valores booleanos, verdadeiro (true) ou 
falso(false). Um tipo boolean ocupa um byte da memória.
char
O tipo char armazena valores de 1 byte. Caracteres são codificados em um 
único byte e são especificados na tabela ASCII. O tipo char  é sinalizado e 
representa números de -128 a 127. Para números não sinalizados usa-se o 
tipo byte.
unsigned 
char
unsigned char armazena valores de 1 byte não sinalizados, é mesmo que 
utiliza o tipo byte. A faixa de valores vai de 0 a 255.
byte Armazena valores de 8 bits não sinalizados de 0 a 255. 
int
Inteiros são tipos primários de armazenamento. No Arduino Uno( e em outras 
placas baseadas em ATMEGA) um int armazena valores de 16 bits(2 bytes). 
Esse tipo compreende valores de -32768 a 32767.
unsigned int
No Arduino UNO e em outras placas baseadas em ATMEGA armazenam 
valores de 16 bits não sinalizados, ou seja, apenas valores positivos de 0 a 
65535.
word
O tipo armazena valores de 16 bis não sinalizados que compreendem valores 
de 0 a 65535.
41
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
long
O tipo de dado Long armazena valores inteiros sinalizados de 32 bits (4 
bytes) que compreendem a faixa de -2147483648 a 2147483647.
unsigned 
long
O tipo unsigned long armazena valores de 32 bits (4 bytes) não sinalizados 
que compreendem a faixa de 0 a 429967295.
short O tipo short armazena valores de 16 bits (2 bytes) sinalizados.
float
O tipo float armazena valor em ponto flutuante, ou seja, um valor que 
possui casas decimais. O tipo float armazena valores de 32 bits (4 bytes) e 
compreendem a faixa de -3,4028235 E+38 a 3,4028235 E+38.4.
double O tipo double também armazena valores de ponto flutuante, porém no 
Arduino Uno e outras placas baseadas em ATMEGA esse tipo é exatamente o 
mesmo que o tipo float, sem ganho de precisão, 
Figura 37 - Variáveis
De acordo com a tabela, é preferível utilizar o tipo byte para a variável tempo e 
também para as variáveis led. Isto resultará em um programa que ocupa menos 
espaço de memória.
42
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-4 – Inserindo variável tempo 1.
Figura 38 - Ligando 4 LEDs.
byte led1 = 2;
byte led2 = 3;byte led3 = 4;
byte led4 = 5;
byte tempo = 0;
void setup() {
 . . . 
}
void loop() {
 digitalWrite (led1, HIGH);
 delay(tempo);
 …
 }
43
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-5 – Inserindo variável tempo 2.
Figura 39 - Ligando 4 LEDS.
Neste espaço, escreva programa solicitado.
Operadores são símbolos utilizados para construir expressões aritméticas, lógicas 
e comparação. A tabela a seguir mostra os tipos e exemplifica o uso.
Tipo Operador Símbolo Exemplo Retorno
A
rit
m
ét
ic
os
Atribuição = a = x “x” guarda o valor de a
Resto da 
divisão
% x= 7%5 “x” guarda 2, o resto da divisão
Soma + x = a + 3 “x” guarda o resultado da soma
Subtração - x = a - 3
“x” guarda o resultado 
da subtração
Produto * x = a * 3
“x” guarda o resultado 
da multiplicação
Divisão / x = a / 3 “x” guarda o resultado da divisão
Co
m
pa
ra
çã
o
Comparação == y == b 1 se “y” é igual a “b”, se não 0
Diferença != y! = b 1 se “b” é diferente de “y”, se não 0
Menor que < y < b
1 se “y” é menor do 
que “b”, se não 0
Maior que > y > b
1 se “y” é maior do 
que “b”, se não 0
Menor ou 
igual
<= y <= b
1 se “y” é menor ou 
igual a “b”, se não 0
Maior ou 
igual
>= y >= b
1 se “y” é maior ou igual 
a “b”, se não 0
Operadores.
Capítulo 13
45
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Ló
gi
co
s
AND &&
z > 0 && c 
< 2
1 se a expressão for verdadeira
OR || z > 0 || c < 2 1 se a expressão for verdadeira
NOT ! !x > 0 1 se a expressão for falsa
Tabela 5 - Operadores
Além desses, existem também os operadores bit a bit que realizam operações de 
bit e os operadores compostos.
Tipo Operador Símbolo Exemplo Retorno
Bi
t a
 b
it
AND bit a bit & 0011 & 0001 0001
OR bit a bit | 0011 | 0001 0011
XOR bit a bit ^ 0011 ^ 0001 0010
NOT bit a bit ~ ~1100 0011
Desloca para 
a esquerda
<< w << 3
Se w = 000011, após o 
deslocamento w = 111000
Desloca para 
a direita
>> w >> 3
Se w = 111000, após o 
deslocamento w = 000111
Co
m
po
st
os
Soma += w+ = d w = w+d
Subtração -= w- = d w = w-d
Produto *= w* = d w = w*d
Divisão /= w/ = d w = w/d
Incremento ++ w ++ w = w+1
Decremento -- w -- w = w-1
AND bit a bit &= w &=d w = w & d
OR bit a bit |= w !=d w = w ! d
Tabela 6 - Operadores bit a bit.
Botões, chaves ou interruptores estão presentes em 
diversas situações nos circuitos digitais. A configura-
ção básica para montar um botão é utilizando um re-
sistor de pull-up. Desta forma, o pino do µC receberá 
sempre nível lógico 1. Ao pressionar o botão, o pino 
será levado ao referencial de terra, recebendo nível 
lógico zero. O resistor de 10KΩ sempre será ligado 
ao positivo da fonte de alimentação (pull-up) e esta 
deve ser a mesma que alimenta o µC.
Já na parte de programação, é necessário que a por-
ta em que o botão foi ligado seja constantemente 
lida para saber se o valor é igual à 1 ou igual à 0. A 
função digitalRead(pino) é utilizada para ler o esta-
do do botão que retornará HIGH ou LOW dependen-
do do estado do botão.
O programa abaixo, será utilizado para ler o estado de um botão que controlará o 
LED que está no pino 5 da placa Arduino.
int LED = 5; 
int BOTAO = 6;
Inicie declarando as variáveis globais LED e BOTAO.
int val = 0; 
É necessário criar uma outra variável para determinar o estado 
inicial do botão. Chamaremos de “val” e o estado “0” inicial é 
atribuído.
void setup() {
pinMode(LED, OUTPUT); 
pinMode(BOTAO, INPUT); 
}
Definem-se os modos dos pinos.
void loop(){
val = digitalRead(BOTAO); Nesta linha, a variável “val” recebe o valor lido no botão.
digitalWrite(led, val);
}
Nesta linha, o valor escrito na variável “val” é atribuído ao LED
Tabela 7- Programa para ler um botão.
Ligando um botão e lendo o 
estado de um botão.
Capítulo 14
47
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-6 – Ligando um botão.
Figura 41 - Esquema de ligação com 4 LEDS e 1 botão.
Transfira este programa para o µC.
int BOTAO = 6;
int LED = 5; 
int val = 0;
void setup () {
pinMode (LED,OUTPUT);
pinMode(BOTAO,INPUT);
}
void loop(){
val=digitalRead(BOTAO);
digitalWrite(LED,val);
 }
Após observar o funcionamento do circuito, complete o quadro abaixo:
Como está a chave?
Estado Lógico 
da chave
Estado do LED
Estado lógico 
do LED
Sem ser pressionada
Sendo Pressionada
Tabela 8 - Registro do funcionamento do circuito.
48
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-7 – Ligando um botão II.
Escreva no espaço abaixo a solução.
int BOTAO = 6;
int LED = 5; 
int val = 0;
void setup () {
pinMode (LED,OUTPUT);
pinMode(BOTAO,INPUT);
}
void loop(){
}
49
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX 8 – Ligando dois botões.
• Acrescente ao circuito mais um botão.
• Modifique o programa para que cada um dos botões controle um dos LEDs.
Escreva no espaço abaixo a solução.
int BOTAO = 6;
int LED = 5; 
int val = 0;
void setup () {
}
void loop() {
 }
Existe a possibilidade de não utilizar resistores de Pull up ao utilizar chaves, pois 
o AtMega 328 possui resistores de Pull up internos e são ligados através de uma 
linha de comando. Para acionar o resistor de Pull up interno basta acrescentar a 
seguinte linha de código:
digitalWrite(nome_da_variavel_pino, HIGH);
Outra forma de ativar o pull up interno é utilizar a seguinte expressão:
pinMode(numero_do_pino , INPUT_PULLUP);
50
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-9 – Ligando botão com Pull up interno
• Modifique o circuito utilizado no EX-8, retirando o resistor de Pull up da en-
trada 6.
• Modifique o programa indicando o uso do resistor de Pull up interno.
Escreva no espaço abaixo a solução.
Sabemos que uma chave ao ser acionada, cria uma série de ruídos que poderão 
ser “entendidos” pelas entradas do microcontrolador e erroneamente interpreta-
dos pelo programa. Esses “ruídos” são denominados de bounce e em alguns ca-
sos, é necessário eliminá-los para que o programa não interprete um valor errado. 
Uma das maneiras de eliminar esse ruído, é proporcionando um atraso entre o 
primeiro acionamento do interruptor e a leitura na entrada do microcontrolador.
Existem algumas maneiras de reduzir ou mesmo eliminar a influência desse tipo 
de ruído. Vamos abordar a maneira que emprega o uso de uma biblioteca pronta 
e feita exatamente para isso que está disponível na página:
http://arduino.cc/playground/Code/Bounce
Nesta página, é possível através do link baixar a biblioteca que está compactada. 
Os passos seguintes mostrarão como instalar esta biblioteca no IDE do Arduino.
1 – Comece baixando o arquivo.
2 – Salve o arquivo na área de trabalho.
3 – Descompacte o arquivo. Uma pasta com o nome do arquivo será criada.
4 – Agora é necessário levar esta pasta para a pasta no computador, criada 
durante a instalação do programa, onde estão as bibliotecas denominada 
de libraries.
5 – Reinicie o IDE e pronto, a nova biblioteca está disponível.
Usando a biblioteca bounce.
Capítulo 15
Utilizando operadores lógicos, podemos escrever expressões lógicas. Aprovei-
tando o circuito montado com 4 Leds e duas chaves, vamos escrever o programa 
que faça a operação lógica AND entre as chaves ligadas aos pinos 6 e 7.
Escreva o programa abaixo na IDE e teste o funcionamento.int Botao1 = 6;
int Botao2 = 7;
int LED = 2; 
int val1 = 0;
int val2 = 0;
int resultado = 0;
void setup () {
pinMode (LED,OUTPUT);
pinMode(Botao1,INPUT);
pinMode(Botao2,INPUT);
}
void loop(){
val1=digitalRead(Botao1);
val2=digitalRead(Botao2);
resultado = val1&&val2;
digitalWrite(LED,resultado);
 }
Resolvendo operações lógicas.
Capítulo 16
53
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-10 - Operações lógicas.
• Acrescente ao programa anterior, as operações lógicas OR, XOR e NOT que 
serão realizadas entre os botões 1 e 2 e o resultado de cada uma, mostrado 
nos LEDS 3, 4 e 5.
• Utilize o espaço abaixo para registrar o programa.
54
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-11 - Expressões lógicas.
• Elabore 4 programas para resolver cada uma das expressões lógicas seguintes:
• S1 = (A.B) + (/A . /B) 
• S2 = /B + (/A . B)
• S3 = {/(A + B) + (/A . B)}
• S4 = A ^ B + /A
• Utilize o espaço a seguir para registrar os programas.
Toda a placa da família Arduino, possui pelo menos uma porta serial que serve 
para comunicação entre a placa Arduino e o PC ou entre outros dispositivos se-
riais. A UART - Universal Asynchronous Receiver Trasmitter – no Arduino está 
disponível tanto na própria entrada USB como também nos pinos 0 e 1 da placa. 
A interface é utilizada para comunicação com o PC e outros dispositivos que con-
tenham saídas USB e os pinos 0 e 1 para comunicação entre outros dispositivos 
como outras placas Arduino ou Shields que trabalham em conjunto com o Ardui-
no.
A comunicação serial no Arduino é do tipo Full Duplex assíncrona e a taxa de 
transmissão mais utilizada é de 9600bps, más esta taxa pode ser alterada em fun-
ção da velocidade que o dispositivo que se quer conectar trabalhe.
A visualização da comunicação entre o Arduino e o PC, por exemplo, será feita no 
Monitor Serial, que pode ser acessado de duas formas:
- através do menu Ferramentas:
Figura 42 - Menu Ferramentas.
Utilizando o monitor serial.
Capítulo 17
56
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
- através do botão monitor serial.
Figura 43 – Localização do botão do monitor serial.
Ao iniciar o monitor de uma das duas maneiras, será aberta uma caixa, onde é 
possível enviar dados para o Arduino como também receber dados processados 
por ele.
Figura 44 - Monitor serial.
Funções básicas utilizadas na comunicação serial.
Serial.begin(9600);
Função empregada para configurar a comunicação serial. A taxa de comunicação 
Serial [Arduino x PC], padrão é de 9600 bps. Sempre que a comunicação serial for 
utilizada, esta função será escrita dentro do setup e quando ativa a comunicação 
serial, os pinos 0 e 1 da placa Arduino não podem ser utilizados como entrada.
Serial.available();
Esta função fica constantemente lendo a porta serial do Arduino. Caso algum 
valor estiver sendo mandado, ela enviará um valor maior do que 0, retornando 
o número de Bytes disponíveis para leitura. Caso nada estiver sendo enviado, a 
porta retornará 0.
Serial.read();
Lê o primeiro byte que está no buffer que comporta-se como uma FIFO. Quando 
retornar -1, significa que não existem dados a serem resgatados.
Serial.write();
Esta função será utilizada para escrever na Serial, ou seja, envia algo para o com-
putador que se estiver disponível, receberá a informação.
57
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Serial.println();
Esta função, escreve o caractere em ASCII e ao final, transmite o caractere Carrier 
Return (retorno ao início da linha) e o caractere New Line (mudança para a pró-
xima linha).
Quando for necessário retornar o valor em ASCII, basta alterar a última linha do 
programa. Em vez de
Serial.write (valordigitado); 
escreva,
Serial.println(valor digitado); 
Vamos escrever uma mensagem de boas-vindas. Escreva o programa a seguir no 
IDE e grave no Arduino.
 void setup()
 {
 Serial.begin(9600);
 } 
 void loop()
 {
Serial.print (“ Ola, ESCREVA SEU PRIMEIRO NOME ! Seja 
bem-vindo(a) a “);
Serial.println (“Capacitação Técnica na Plataforma Ar-
duino. “);
 }
 Abrindo o monitor serial será possível ler a frase.
58
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-12 – Calculando valores em um retificador.
• Escreva um programa que mostre no monitor serial os valores de tensão em 
um circuito retificador como o mostrado na figura abaixo. O valor da tensão 
aplicado ao primário do Trafo é a única variável que poderá ser alterada no 
programa. Considere: relação de transformação - 10:1 e Vd = 700mV. O moni-
tor serial deve mostrar os valores de:
• 1 – Tensão eficaz do primário do Trafo;
• 2 – Tensão de pico no primário do Trafo;
• 3 – Tensão eficaz no secundário do Trafo;
• 4 – Tensão de pico no secundário do Trafo;
• 5 – Tensão máxima presente na saída do retificador;
• 6 – Tensão na carga considerando que o capacitor está fora do circuito;
• 7 – Tensão na carga considerando o capacitor de filtro.
O esquema do circuito está mostrado na figura abaixo.
Figura 45 - Circuito retificador em ponte com filtro capacitivo.
59
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-13 – Calculando a quantidade de azulejos.
• Escreva um programa para ler as dimensões de uma cozinha retangular com 
altura de 3m, largura de 5m e o comprimento é a única variável que pode-
rá ser modificada no programa. Calcule e mostre a área total da cozinha a 
quantidade de caixas de azulejos para se colocar em todas as suas paredes 
sem descontar a área ocupada por portas e janelas e com o desconto de 5m2 
para a área ocupada por portas e janelas. Informe a quantidade de caixas de 
azulejos necessária para as situações descritas acima com e sem uma sobra 
de 10% do total. Considere que cada caixa de azulejos pode preencher 1,5m2 
de parede.
• Mostre os valores solicitados no monitor serial.
60
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Utilizando operadores lógicos, podemos escrever expressões lógicas. Aprovei-
tando o circuito montado com 4 Leds e duas chaves, vamos escrever o programa 
que faça a operação lógica AND entre as chaves ligadas aos pinos 6 e 7.
Escreva o programa abaixo na IDE e teste o funcionamento.
int Botao1 = 6;
int Botao2 = 7;
int LED = 2; 
int val1 = 0;
int val2 = 0;
int resultado = 0;
void setup () {
pinMode (LED,OUTPUT);
pinMode(Botao1,INPUT);
pinMode(Botao2,INPUT);
}
void loop(){
val1=digitalRead(Botao1);
val2=digitalRead(Botao2);
resultado = val1&&val2;
digitalWrite(LED,resultado);
 }
61
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-14 - Operações lógicas.
• Acrescente ao programa anterior, as operações lógicas OR, XOR e NOT que 
serão realizadas entre os botões 1 e 2 e o resultado de cada uma, mostrado 
nos LEDS 3, 4 e 5.
• Utilize o espaço abaixo para registrar o programa.
62
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-15 - Expressões lógicas.
• Elabore 4 programas para resolver cada uma das expressões lógicas seguin-
tes:
• S1 = (A.B) + (/A . /B) 
• S2 = /B + (/A . B)
• S3 = {/(A + B) + (/A . B)}
• S4 = A ^ B + /A
• Utilize o espaço a seguir para registrar os programas.
O comando if – else é utilizado para controle de fluxo. Existem três formas de uti-
lização– a forma simples, composta e a forma aninhada.
If (forma simples)
O comando if será utilizado quando em um programa quisermos que determina-
da parte deste seja executada apenas se uma condição for alcançada.
A estrutura onde o comando if é utilizado é a seguinte:
 If (condição de teste “argumento”)
 {
 Função que será executada se for 
verdadeiro;
 }
Se a condição testada não for verdadeira, então é entendido que é falsa e o loop 
continua. Vejamos o programa exemplo a seguir:
int LED = 2;
int tempo = 100
void setup() {
pinMode (LED , HIGH);
}
void loop(){
pinMode (LED , HIGH);
delay (tempo);
pinMode (LED , LOW);
delay (tempo);
tempo = tempo + 100;
if(tempo > 3000)
{
tempo =100;
}
}
Estruturas condicionais – 
comando if - else
Capítulo 18
64
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-16 - Utilizando comando if
• Modifique o programa exemplo anterior de modo que cada um dos 4 LEDS 
sejam acesos, nas seguintes condições:
• LED ligado ao pino 2 pisca desde o início do programa.
• LED ligado ao pino 3 pisca a partir de 500ms;
• LED ligado ao pino 4 pisca a partir de 1000ms;
• LED ligado ao pino 5 pisca a partir de 2000ms;
65
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-17 - Utilizando comando if 2.
• Elabore um programa utilizando o comando if de maneira que os botões con-
trolem os LEDs da seguinte forma:
• LED ligado ao pino 2 pisca a um ritmo de 100ms se nenhum botão estiver 
pressionado.
• LED ligado ao pino 3 pisca a um ritmo de 100ms se o botão ligado ao pino 6 
for pressionado.
• LED ligado ao pino 4 pisca a um ritmo de 100ms se o botão ligado ao pino 7 
for pressionado.
• LED ligado ao pino 5 pisca a um ritmo de 100ms se os botões ligados aos 
pinos 6 e 7 forem pressionados simultaneamente.
66
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
É possível acender LEDs utilizando o teclado do computador através do Monitor 
Serial. O programa abaixo mostra como fazer isso. Escreva-o no IDE e faça o teste.
int LED = 2;
void setup() {
Serial.begin(9600);
pinMode(LED, OUTPUT);
}
void loop() {
char tecla;
tecla = Serial.read();
if(tecla == ‘V’)
{
digitalWrite(ledPin, HIGH);
}
delay(1000);
}
Como pôde observar, este programa faz apenas o LED acender. Modifique-o para 
que seja possível também apagar o LED. Faça isso no próximo exercício.
67
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-18 - Utilizando comando if 3.
• Modifique o programa anterior para que seja possível acender e apagar o LED 
utilizando teclas do teclado do computador e o monitor serial.
68
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Utilizando if else.
O comando if else, permite o teste de uma condição e realizar duas coisas. Se o 
teste for verdadeiro, executa a parte 1 e se o teste for falso, realiza a parte 2
É possível acender LEDs utilizando o teclado do computador através do Monitor 
Serial. O programa abaixo mostra como fazer isso. Escreva-o no IDE e faça o teste.
int LED = 2;
void setup() {
Serial.begin(9600);
pinMode(LED, OUTPUT);
 }
 
void loop() {
char tecla;
tecla = Serial.read();
if(tecla == ‘V’)
{
digitalWrite(LED, HIGH);
}
else
{
if(tecla == ‘v’)
{
digitalWrite(LED, LOW);
}
delay(1000);
}
}
69
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX-19 - Utilizando comando if – else.
• Modifique o programa exemplo anterior de modo que cada um dos 4 LEDS 
possam se r acesos e apagados nas seguintes condições:
• Atribuir uma tecla para cada LED. Cada LED será aceso pela tecla relacionada 
à ele.
• Atribuir uma tecla para cada LED. Cada LED sera apagado pela tecla relacio-
nada à ele.
• Atribuir uma tecla que faça todos os LEDS acenderem;
• Atribuir uma tecla que apague todos os LEDS.
70
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Comando for.
O comando for é utilizado em estruturas de repetição quando queremos que 
uma operação seja realizada algumas vezes, como por exemplo, fazer um led 
piscar um certo número de vezes.
 A estrutura do comando for é a seguinte: 
 For (condição inicial; teste; incremento ou decremento)
 {
 Comandos;
 }
Para entender melhor a utilização do comando for, vamos estudar o programa 
abaixo que deve fazer o LED ligado ao pino 2 piscar exatamente 15 vezes.
 int LED = 2;
 int tempo = 100;
 void setup() {
 pinMode(LED, OUTPUT);
 }
 Void loop() {
 digitalWrite(LED, HIGH);
 delay(tempo);
 digitalWrite(LED, LOW);
 delay(tempo);
digitalWrite(LED, HIGH);
 delay(tempo);
 digitalWrite(LED, LOW);
 delay(tempo);
 REPETIR ESTAS ÚLTIMAS 4 LINHAS POR MAIS 
13 VEZES.
 delay(1000);
 }
Então, para fazer o LED piscar exatamente 15 vezes, é necessário escrever 15 ve-
zes os comandos para acender e apagar o LED.
Uma maneira mais simples e curta de fazer o mesmo utilizando o comando for 
pode ser visto no exemplo a seguir:
 int LED = 2;
71
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
 int tempo = 100;
 void setup()
 {
 pinMode(LED, OUTPUT);
 }
 Void loop()
 {
 For(int i = 0; i<15; i ++)
 {
 digitalWrite (LED, HIGH);
 delay(tempo);
digitalWrite (LED, LOW);
 delay(tempo);
 }
 delay(1000);
 }
Na plataforma Arduino, existem 6 entradas analógicas, A0 até A5, que são utili-
zadas para a leitura dos valores de tensão analógica provenientes de sensores 
analógicos. Estas entradas podem receber tensões entre 0 à 5V VDC.
A tensão proveniente do sensor (sinal, informação), será entregue à um circuito 
conversor analógico – digital (A/D) que converterá o valor analógico do sinal em 
um valor digital (binário) de 10 bits.
A resolução do conversor será:
Equação 1- Cálculo da resolução.
Então a cada 5mV aproximadamente, a palavra binária será modificada.
De (V) Até (V) Valor binário
0,00 0,00488 00000000002
0,00488 0,00976 00000000012
0,00976 0,01464 00000000102
... ...
4,9776 4,98248 11111111012
4,98248 4,98736 11111111102
4,98736 4,99712 11111111112
Tabela 9 - Valores da converção.
A função utilizada para ler os pinos analógicos é analogRead().
Os pinos analógicos serão constantemente lidos, sendo o tempo de leitura apro-
Entradas analógicas.
Capítulo 19
73
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
ximado de 100 microssegundos o que leva a uma taxa de leitura próxima de 
10.000 leituras por segundo.
O valor de retorno, é um número int de 0 a 1023.
Para simular um sensor analógico, podemos utilizar um potenciômetro. Ele for-
mará um divisor de tensão e a tensão do cursor em relação ao negativo será 
aplicada à entrada analógica. Desta forma, quando a posição do cursor do poten-
ciômetro for alterada, a tensão em relação ao cursor também irá variar.
O programa para isso pode ser escrito da seguinte forma:
int pot = A0; 
int led = 10;     
int valmed = 0;  
Nesta linha, são declaradas as variáveis “pot” 
– potenciômetro, que será ligado ao pino 
A0. A variável “led” – LED, que será ligado ao 
pino 10 e também a variável “valmed” – valor 
medido cujo valor inicial atribuído é zero.
void setup() {
 pinMode(led,OUTPUT);   
}
No setup, é definido com de saída o 
pino onde o LED está ligado.
 void loop() { 
    valmed = analogRead(pot);digitalWrite(led, HIGH);   
    delay(valmed);           
   
  digitalWrite(led, LOW);    
   
  delay(valmed); 
}
No loop, o valor lido através de analogRead 
na entrada analógica A0 (potenciômetro), 
é atribuído à variável valmed.
digitalWrite, define o estado inicial da variável led 
com HIGH, ou seja, o LED ficará aceso e a função 
delay, define o tempo que o LED permanecerá assim 
que será igual ao valor lido no potenciômetro.
O mesmo acontece a seguir quando o LED é 
apagado, pois digitalWrite define o estado em LOW 
e ficará assim pelo tempo definido em valmed.
Isto se repetirá indefinidamente, e o tempo que 
o LED permanece aceso ou apagado é definido 
pelo valor do potenciômetro lido na entrada A0.
Figura 46 – controlando o ritmo das piscadas do LED..
Outra função interessante no monitor serial é poder ver a leitura dos valores lidos 
em uma entrada analógica. Desta forma, podemos “ver” o comportamento de um 
sensor e a partir daí, aperfeiçoar o código. Vamos utilizar o programa a seguir para 
testar isso.
// Monitor 6
// monitorando sensores:
Nome do programa.
int sensor = 0; Cria uma variável chamada sensor que está ligada 
ao pino 0 (A0) do tipo int.
void setup() { Inicia-se o setup.
Serial.begin(9600);
 }
Inicia-se a comunicação serial.
 void loop() { Inicia-se o método setup;
 sensor = analogRead(A0); Atribui-se à variável sensor, o valor lido na porta A0 
analógica.
Serial.print(“Valor lido=”); Escreve na serial “Valor lido =”
Serial.println(sensor); Escreve o valor contido na variável sensor, pula 
linha e retorna ao início da linha.
delay(1000); 
 }
Atraso de 1 segundo.
Figura 47- Lendo a varivel analógica no monitor serial.
Grave o programa no microcontrolador;
Ligue o cursor do potenciômetro ao pino A0 e os extremos ao Vcc e GND.
Abra o monitor serial e varie a posição do cursor do potenciômetro. Os valores 
Lendo sensores.
Capítulo 22
75
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
dos extremos do potenciômetro correspondem aos valores mostrados 0 e 1023.
Figura 48 - Valores mostrados no monitor serial.
A função map(), é uma função matemática que pode ser utilizada para transfor-
mar uma sequência de números em uma outra sequência. Para utilizá-la é neces-
sário inserir a primeira faixa numérica, o número menor e o maior que foi medido 
e depois, a faixa que se quer transformar com o seu número menor e maior cor-
respondente. A sintaxe da função map é a seguinte:
map(variável, do valor menor , do valor maior , para menor valor , para o 
maior valor);
O programa abaixo, faz isso.
// Monitor 7
// monitora map:
Nome do programa.
 int sensor = 0; Cria a variável sensor do tipo int e já atribui-se o valor 
0 à ela.
 void setup() { Inicia-se o método setup.
Serial.begin(9600);
 }
Inicia-se a comunicação serial.
void loop() { Inicia-se o método loop.
 sensor = map 
(analogRead(A0),0,1023,0,100);
Atribui-se o valor lido em A0 já mapeado para a 
variável sensor.
Serial.print(“Valor=”);
Serial.println(sensor); Escreve na serial o valor da variável sensor e pula linha.
delay(1000); 
 }
Espera 1 segundo para nova leitura.
Figura 49 - Programa exemplo de uso da função MAP.
Utilizando a função MAP.
Capítulo 23
77
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX- 20 – Mapeando o potenciômetro.
• Monte um circuito com 5 LEDs, sendo dois verdes, um vermelho e dois ama-
relos conectados nas saídas 2,3,4, 5 e 6 do Arduino, respectivamente. 
• Faça o mapeamento do potenciômetro. 
• Elabore um programa que faça o LED vermelho acender quando o potenciô-
metro estiver na metade do seu curso. O LED verde conectado ao pino 2 deve 
acender com o potenciômetro em 230°. O LED verde ligado ao pino 3, acende 
quando o potenciômetro estiver em 185°. O LED amarelo conectado ao pino 
6 acende com o potenciômetro em 50° e o LED ligado ao pino 5 acende com 
o potenciômetro em 95°. Use o espaço abaixo para fazer suas anotações. 
78
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX- 21 – Controlando o Led com o LDR.
• Modifique o programa mostrado na figura 46 substituindo o potenciômetro 
pelo LDR. O ritmo das piscadas do LED deve aumentar com a intensidade da 
luz que atinge o LDR.
Caso o resistor ligado esteja conectado ao positivo da 
fonte de alimentação (pull-up), o LDR quanto menos luz 
chegar até o LDR, maior será a tensão aplicada à entra-
da analógica. Então o circuito se comportará como um 
sensor de sombra.
Figura 50 - Sensor de sombra.
Já se o LDR é que for diretamente conectado ao positivo 
da fonte de alimentação, então quando mais luz chegar 
ao LDR, maior tensão será aplicada à porta analógica e o 
circuito se comportará como um sensor de luz.
Figura 51 - Sensor de sombra.
O LDR (Light Dependent Resistor) resistor dependente da luz, é um dispositivo 
cujo o valor da resistência entre os seus terminais, depende da quantidade de luz 
que chaga até o seu corpo. Quanto mais luz chega até o dispositivo, menor será 
o valor da resistência. E quanto menos luz chega até o dispositivo, maior será a 
resistência entre os seus terminais. Para ligar um LDR à uma porta analógica do 
Arduino, é necessário montar um circuito divisor de tensão.
PWM (Pulse Width Modulation) – modulação por largura de pulso – é uma técnica 
utilizada para obter um valor analógico a partir de uma variação digital. Em uma 
saída digital, a tensão poderá variar entre +5V e 0. Se o nível lógico da saída for 
sempre 1 ou sempre 0, o resultado será um valor constante. Porém se em vez de 
fixar a saída em um valor único e sim fazer variá-lo entre 1 e 0 (+5V e 0), a tensão 
resultante não será mais constante e sim uma proporção do valor máximo da ten-
são, ou seja uma porcentagem de +5V.
Independentemente da frequência, se uma saída variar o entre 1 e 0 de tal for-
ma que em cada período, o valor da tensão seja +5V perdure por exatos 50% do 
tempo total do período (o nível 0 terá a mesma duração), o valor médio da tensão 
serão exatos 2,5V.
Observando a figura abaixo. t1 equivale ao tempo de duração do nível lógico 1 e 
t2 corresponde ao tempo de duração do nível lógico 0. T vale portanto t1 + t2.
Figura 52 - Onda quadrada.
O valor médio da tensão poderá ser obtido usando a seguinte fórmula:
Equação 2 - Cálculo do valor médio.
PWM.
Capítulo 24
80
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
Assim, se o tempo de duração do nível alto, também conhecido como ciclo ativo, 
for alterado, será possível obter um valor médio de tensão entre 0 e 5V.
Na placa do Arduino UNO e equivalentes, apenas algumas saídas digitais podem 
ser utilizadas como saídas PWM, são as saídas dos pinos 3, 5, 6 ,9, 10 e 11, sen-
do que a frequência da tensão nessas saídas quando utilizadas como PWM é de 
490Hz.
A função analogWrite(pino,valor) configura o pino indicado como sendo 
uma saída PWM e portanto, nele existirá um sinal com frequência igual a 
490HZ, com o ciclo ativo definido pelo valor dentro do parênteses.
O parâmetro valor corresponde a variação de 0 até 255. 
Se valor = 0; a tensão na saída será 0V,
Se valor = 255; a tensão na saída será 5V.
EX- 22 – Controlando o Led com PWM.
• O objetivo é controlar o brilho de um LED utilizando a técnica de PWM. Para 
isso, ligue um potenciômetro à uma entrada analógica e o LED a uma das I/O 
digitais que podem executar a função PWM. 
• Elabore o código utilizando as funções analogRead para ler o valor do po-
tenciômetro e transformar em um valor binário, e a função analogWriteque 
escreve na saída digital, o valor indicado. 
O CI LM35 é um circuito integrado com a função de trabalhar como sensor tem-
peratura de precisão, com tensão de saída linearmente proporcional à tempera-
tura dada em ºC. O LM35 não necessita de qualquer calibração externa e pode 
proporcionar precisão de ± 0,5 ° C à temperatura ambiente. De baixo custo está 
classificado para operar em uma faixa de -55 ° C a +150 ° C.
Como o CI fornece uma tensão de ~10mV a cada ºC de variação de temperatura 
ele não percorre toda a gama possível de valores disponíveis na entrada analógi-
ca (0 – 5), então, é comum aplicar uma fórmula para melhorar a faixa de leituras 
que é a seguinte:
Temperatura = AVcc* analogRead(pinoanalógico)*100/1024
Equação 3 - fórmula de ajuste para temperatura.
O programa que pode ser utilizado para a leitura da temperatura no terminal se-
rial é o seguinte:
int pinoSensor = 0; Declaração da variável 
pinoSensor onde será ligado 
o terminal de saída do 
LM35 e deve ser conectado 
no pino A0 da placa.
int valorLido = 0;
float temperatura = 0;
Declaração da variável 
valorLido e temperatura.
void setup() {
Serial.begin(9600);
}
Inicia-se o método setup 
e a comunicação serial.
void loop() { Inicia-se o método loop.
valorLido = analogRead(pinoSensor); Atribui-se à variável 
“valorLido” o valor que está 
na variável “pinoSensor”.
O sensor de temperatura.
Capítulo 25
temperatura = 5.0*analogRead(pinoSensor)*100.0/1024; Aplica-se a fórmula para 
ampliação da faixa de leitura.
Serial.print(“Temperatura atual: “);
Serial.println(temperatura);
Escreve na serial o valor 
da temperatura lido.
delay(1000);
}
Atrasa o programa em 1 segundo.
Figura 53 - Lendo temperatura com o LM35.
Verifique se o código escrito está correto e grave-o no micro. Abra o monitor 
serial e veja a indicação da temperatura.
Para variar o valor da temperatura, basta segurar com os dedos o corpo do LM35.
Fazer o mapeamento deste sensor permite atribuir ao valor lido, uma outra gama 
de leituras.
//temperatura com map. Nome do programa
int pinoSensor = 0;
int valorLido = 0;
float temperatura = 0;
Declarando as variáveis 
pinoSensor atribuindo o 
valor 0 que corresponde ao 
pino A0 da placa Arduino.
valorLido é uma variável 
onde será guardado o valor 
já transformado em binário 
apresentado à entrada A0.
Temperatura é a variável 
que guardará o valor lido 
e aplicada a função map 
da temperatura lida.
void setup() {
Serial.begin(9600);
}
Início do método setup
Inicia-se a comunicação serial
void loop() { Método loop
valorLido = analogRead(pinoSensor); Atribui-se à variável valorLido, 
o valor existente em 
pinoSensor, ou seja, em A0.
temperatura = 5.0* analogRead(pinoSensor)*100.0/1024; Aplica a fórmula no valor 
lido do pinoSensor (A0).
temperatura = map (temperatura, 25,31,0,100); Aplica a função map
Serial.print(“Temperatura atual: “);
Serial.println(temperatura);
Imprime a frase e o valor lido.
delay(1000); Retarda em 1 segundo.
Figura 54 - Mapeando o LM35.
83
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
EX- 23 – Mapeando o sensor de temperatura.
• Monte um circuito com 5 LEDs, sendo dois vermelhos, dois amarelos e um 
verde conectados nas saídas 3,4,5, 6 e 7 do Arduino, respectivamente. 
• Faça o mapeamento do sensor de temperatura. 
• Elabore um programa que faça o LED verde acender entre 0 e 50%. Os LEDs 
amarelos, devem acender entre 50 e 60% e entre 60 e 70% respectivamente. 
Os LEDs vermelhos, acendem entre 70 e 80% e entre 80 e 100%. 
• Os LEDs devem permanecer acesos e só apagarão quando a condição não for 
verdadeira. 
Sempre que a tensão requerida pela carga e/ou a corrente solicitada pela carga 
forem maiores do que a tensão de alimentação da placa Arduino (5V) ou maior do 
que a máxima corrente que uma saída pode fornecer (40mA), é necessário utilizar 
um dispositivo de interface entre a plataforma Arduino e o que se quer utilizar.
O Relé é um dispositivo muito utilizado quando a tensão da carga não é com-
patível com a utilizada na plataforma Arduino e em especial, quando a carga for 
por exemplo uma lâmpada ou um dispositivo eletrônico alimentado pela rede 
elétrica.
Não é recomendado, embora possa ser possível a ligação direta da bobina do relé 
na saída da plataforma Arduino e por isso, utiliza-se um transistor que terá a fun-
ção de trabalhar como uma chave eletrônica, recebendo em sua base, um sinal 
de tensão em baixíssima potência e podendo acionar com folga a bobina do relé.
O esquema abaixo mostra como o relé está interligado como o transistor. Existe 
ainda um LED e um resistor, não mostrados no esquema que tem a função de 
indicar quando o módulo recebe um sinal na entrada.
O diodo em paralelo com a bobina do relé, serve para eliminar os efeitos da des-
carga da bobina no momento do seu desligamento.
O acionamento do relé pode ser parecido com o tipo de acionamento utilizado 
para o LED. Basta estabelecer uma condição relacionada ao estado do botão. Se o 
botão estiver em 1, o relé deve permanecer desligado e se o botão estiver em 0, 
o relé deve ser acionado.
Figura 55 - Relê acionado por transistor.
Utilizando o relé.
Capítulo 26
85
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
O código a seguir mostra isso.
//Acionando rele com botão. Nome do programa
int BOTAO = 5 ; Variável botão relacionada ao pino 5
int RELE = 7 ; Variável relé relacionada ao pino 7
int val = 0; Variável val que armazenara valores intermediários
void setup(){ Método setup.
pinMode(RELE,OUTPUT); Estabelece o pino 7 como saída digital.
pinMode(BOTAO,INPUT);
}
Estabelece o pino 5 como entrada digital.
void loop(){ Método loop
val=digitalRead(BOTAO); Atribui a variável val, o valor lido na variável botão.
if(val==HIGH)
{
Testa o valor de val se igual a 1
digitalWrite(RELE,LOW);
}
Se verdadeiro, a variável relé vai para 0
else
{
Se não
digitalWrite(RELE,HIGH);
}
}
A variável relé vai para 1.
Figura 56 - Código para acionar um relé.
Para montar o circuito utilize um botão com o seu resistor pull-up conectado ao 
pino 5 e o módulo do relé que será conectado ao pino 7 da placa Arduino.
As vezes utilizamos um botão para ligar e outro botão para desligar o circuito. O 
programa a seguir faz isso.
//Botao liga e botao desliga Nome do programa
const int bliga = 5; Declara a variável bliga e atribui o pino 5.
const int bdesliga = 4; Declara a variável bdesliga e atribui o pino 4.
const int ledPin = 3; Declara a variável ledPin e atribui o pino 3.
int bliga1 = 1; Declara a variável bliga1 e atribui o valor inicial igual a 
1..
int bdesliga1 = 1; Declara a variável bdesliga1 e atribui o valor inicial igual 
a 1.
void setup() { Inicia o setup
 pinMode(ledPin, OUTPUT); Estabelece a variável ledPin como saída
86
C
ap
ac
it
aç
ão
 t
éc
n
ic
a 
n
a 
p
la
ta
fo
rm
a 
A
rd
ui
n
o
 pinMode(bliga, INPUT); Estabelece a variável bliga como entrada
 pinMode(bdesliga,INPUT); Estabelece a variável bdesliga como entrada.
}
void loop(){ Método loop
 bliga1 = digitalRead(bliga); Atribui a variável bliga1 o valor lido em bliga
 bdesliga1 = digitalRead(bdesliga); Atribui a variável bdesliga1 o valor lido em bdesliga
 if (bliga1 == LOW) { Lê e compara o estado de bliga1 se igual a 0
 digitalWrite(ledPin, HIGH); Se verdadeiro, a variável ledPin assume 1
 } 
 if (bdesliga1 == LOW) { Lê e compara a variável bdesliga se igual a 0
 digitalWrite(ledPin,LOW); Se verdadeiro, a variável bdesliga assume 0
 }
}
Figura 57 - Botão