ARDUINO

BÁSICO

Aulas Práticas

Prof. Artur A. Vilares Filho

Arduino Básico

Sumário
Introdução .................................................................................................................................................... 3
Arduino IDE (Arduino Integrated Development Evironment) ...................................................................... 4
Área de trabalho ....................................................................................................................................... 6
Ferramentas ............................................................................................................................................. 6
Seleção do modelo da placa Arduino ....................................................................................................... 7
Seleção da porta de comunicação serial (COM). ..................................................................................... 8
Área de edição .......................................................................................................................................... 9
A placa Arduino UNO R3 .............................................................................................................................. 9
Questões propostas: .............................................................................................................................. 10
Prática 01 – Pisca Led 1 - Blink ................................................................................................................... 11
O sketch .................................................................................................................................................. 11
Entendendo o sketch .............................................................................................................................. 12
Um pouco sobre funções: ...................................................................................................................... 14
Explicando o sketch ................................................................................................................................ 14
Questões propostas: .............................................................................................................................. 16
Prática 02 – Pisca Led 2 .............................................................................................................................. 17
Circuito (Hardware): ............................................................................................................................... 18
O sketch .................................................................................................................................................. 19
Entendendo o sketch .............................................................................................................................. 20
Questões propostas: .............................................................................................................................. 20
Prática 03 – Led e Botão ............................................................................................................................. 21
Circuito (Hardware): ............................................................................................................................... 21
O sketch .................................................................................................................................................. 23
Entendendo o sketch .............................................................................................................................. 23
Questões propostas: .............................................................................................................................. 25
Prática 04 – Controle de Luminosidade de LED ......................................................................................... 26
Circuito (Hardware): ............................................................................................................................... 28
O sketch .................................................................................................................................................. 29
Entendendo o sketch .............................................................................................................................. 29
Questões propostas: .............................................................................................................................. 30
Prática 05 – Controle de luminosidade de LED com LDR ........................................................................... 31
Circuito (Hardware) ................................................................................................................................ 32
O sketch .................................................................................................................................................. 33
Entendendo o sketch .............................................................................................................................. 33
Questões propostas: .............................................................................................................................. 34

Artur A. Vilares Filho

Arduino Básico

Prática 06 – Semáforo para pedestres ....................................................................................................... 35

Circuito (Hardware) ................................................................................................................................ 35
O sketch .................................................................................................................................................. 36
Entendendo o sketch .............................................................................................................................. 37
Questões propostas: .............................................................................................................................. 37
Prática 07 - Termômetro utilizando NTC .................................................................................................... 38
O sketch .................................................................................................................................................. 39
Entendendo o sketch .............................................................................................................................. 40
Questões propostas: .............................................................................................................................. 42
Anexo 1 ....................................................................................................................................................... 43

Artur A. Vilares Filho

Arduino Básico

Introdução

O Arduino é uma plataforma de prototipagem eletrônica programável de hardware e software livres

(open-source) construída em uma única placa. O cérebro do Arduino é um microcontrolador AVR com
suporte de entrada/saída e uma linguagem de programação. Existem hoje inúmeros modelos de Arduíno
que utilizam diferentes microcontroladores no seu funcionamento. Por ser de código aperto, o Arduíno
pode ter seu hardware replicado livremente bem como seu software (IDE) pode distribuído sem
restrições.

O projeto do Arduino começou em 2005 como uma ferramenta para alunos do curso “Interaction Design
Institute Ivrea” na Itália, com o objetivo de fornecer uma maneira fácil e de baixo custo para iniciantes e
profissionais criarem dispositivos que interagissem com seu ambiente usando sensores e atuadores.
Como exemplos comuns de dispositivos, incluem robôs simples, controladores de temperatura,
detectores de movimento, dentre outros.

No site oficial do Arduino (www.arduino.cc) pode-se encontrar uma vasta quantidade de materiais de
suporte, modelos de placas, exemplos de programas, bem como guias de referências da linguagem do
Arduíno além do software Arduino IDE disponível para download.

Para o uso do Arduíno é necessário um computador onde deverá ser instalado o programa de edição e
compilação do código desenvolvido (IDE). Também se faz necessário a obtenção de componentes
eletrônicos e uma base de montagem tipo “protoboard” tendo em vista que a ideia é o desenvolvimento
de dispositivos que possam ser controlados por um microcontrolador e que interajam com o ambiente.

O presente trabalho pretende fornecer orientações iniciais sobre o uso da plataforma de prototipagem
Arduino associada à montagem de circuitos eletrônicos em “protoboard” e em circuito impresso, bem
como a utilização da Arduino IDE para desenvolvimento de programas, compilação e gravação desses na
memória do microcontrolador que compõem a plataforma.

No decorrer deste trabalho serão apresentadas práticas com exemplos de programas a serem executados
na plataforma Arduino, esquemas dos circuitos a serem montados com respectivos desenhos da
montagem em protoboard virtual. Explicações sobre os componentes básico que serão utilizados e o
funcionamento do programa e do hardware, seguirão a respectiva prática. Ao final de cada prática serão
propostos exercícios para melhor compreensão e fixação dos conceitos vistos.

Artur A. Vilares Filho 3

Arduino Básico

Arduino IDE (Arduino Integrated Development Evironment)

Partindo do princípio que a IDE do Arduino já esteja instalada, ao executar o programa no computador
deve-se obter uma tela como a mostrada na Figura 1.

Figura 1 - Arduino IDE

O programa desenvolvido na IDE é chama de “sketch” e na Figura 1 é possível observar que a própria IDE
já nomeou o Sketch inicial, no entanto é melhor deixar as coisas organizadas, assim, crie uma pasta onde
seus Sketch serão gravados. Renomeie seu Sketch com um nome que sugira o que este programa faz, por
exemplo: um programa que faz priscar um LED pode ser chamado de “Pisca_LED”, Figura 2. Ao renomear
seu programa, a IDE irá criar uma pasta com o nome dado e dentro dela irá gravar seu Sketch, Figura 3.

Artur A. Vilares Filho 4

Arduino Básico

Figura 2 - Salvar como...

Figura 3 - Nome dado ao Sketch será igual ao nome da pasta criada pela IDE

Figura 4 - Sketch renomeado para "Pisca_LED".

Artur A. Vilares Filho 5

Arduino Básico

Área de trabalho

Ferramentas

Área de edição do
sketch

Área de mensagens

Figura 5 - Barra de ferramentas, área de trabalho e área de mensagens

Ferramentas
A Arduino IDE apresenta uma barra de ferramentas com botões de atalho que facilitam a execução de
tarefas constantemente utilizadas, estas tarefas também podem ser realizadas através do menu “pop-
up”.

Figura 6 -= Menu "pop-up"

Figura 7 - Barra de ferramentas contém atalhos para as tarefas comuns. Pode-se passar o mouse sobre cada botão para ver uma
descrição.

Tabela 1 - Botões da barra de ferramentas

Verifica erros de
sintaxe no sketch.

Artur A. Vilares Filho 6

Arduino Básico

Carrega (grava) o
sketch na memoria do
Arduino.
Abre um novo sketch
para edição.

Abri um sketch
previamente salvo.

Salva um sketch no
computador.

Abre o Monitor Serial

da IDE.

Seleção do modelo da placa Arduino

Conecte a placa Arduino à USB do computador.

No menu “pop-up” selecione “Ferramentas > Placa: > Arduino AVR Boards” - Figura 8.

Figura 8 - Menu para seleção da Placa Arduino

Escolha a placa que será utilizada na lista que irá aparecer – Figura 9. No nosso caso utilizaremos o Arduino
UNO.

Artur A. Vilares Filho 7

Arduino Básico

Figura 9 - Lista com as placas existentes

Seleção da porta de comunicação serial (COM).

Ainda no item “Ferramentas > Porta:” do menu “pop-up”, escolha a porta “COM” em que o Arduino está
conectado - Figura 10.

Figura 10 - Seleção da porta de comunicação "COM" onde o Arduino está conectado

Note que a porta COM poderá ser diferente da mostrada na figura 10, pois cada computador poderá
mostrar um número de porta diferente.

Artur A. Vilares Filho 8

Arduino Básico

Área de edição
É na área de edição que se digita o código do Sketch.

Todo Sketch apresenta as duas principais funções: void setup() e void loop(). Na Prática 01
será explicado com detalhe o uso de cada função.

Figura 11 - Principais funções do skecht do Arduino

A placa Arduino UNO R3

Para o desenvolvimento das práticas será utilizado o Arduino UNO R3, cuja identificação da pinagem é
mostrada na figura 12 abaixo.

USB

Pinos Digitais (I/O)

Fonte
externa
7 a 12V

Pinos Analógicos
Pinos de Alimentação
Figura 12 - Identificação da pinagem do Arduino UNO R3

Artur A. Vilares Filho 9

Arduino Básico

Questões propostas:
1) O que é a IDE Arduino?

2) Como é chamado o programa desenvolvido na IDE do Arduino

3) Qual o valor das tensões especificadas para a fonte de alimentação externa do Arduino?

4) Quais os passos para configurar o tipo de placa na IDE Arduino?

5) Qual a função do botão presente na barra de ferramentas da IDE do Arduino?

6) Quais os passos para a seleção da porta na IDE, onde o Arduino está conectado?

Artur A. Vilares Filho 10

Arduino Básico

Prática 01 – Pisca Led 1 - Blink

Para o desenvolvimento da Prática 01 vamos carregar na Arduino IDE um Sketch exemplo chamado
“Blink” que está disponível na opção Exemplo do item Arquivo da IDE. Para acessar o exemplo clique em:
“Arquivo > Exemplos > 01 Basics > Blink” – Figura 13.

Figura 13 - Carregando o sketch Blink dos Exemplos da Arduino IDE

Feito isto, o sketch será aberto na Arduino IDE e se parecerá com o código listado a seguir. Poderá haver
algumas diferenças no código em função da versão de IDE que você estará utilizando.

O sketch
/*
Blink
Turns an LED on for one second, then off for one second, repeatedly.
Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino
model, check the Technical Specs of your board at:
https://www.arduino.cc/en/Main/Products
modified 8 May 2014
by Scott Fitzgerald
modified 2 Sep 2016
by Arturo Guadalupi
modified 8 Sep 2016
by Colby Newman
This example code is in the public domain.
https://www.arduino.cc/en/Tutorial/BuiltInExamples/Blink
*/

// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.

Artur A. Vilares Filho 11

Arduino Básico
pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

Entendendo o sketch
Antes de começarmos com a análise do programa, vamos conhecer um pouco da placa Arduino UNO. O
Arduino UNO possui 14 pinos digitais que podem ser configurados individualmente como entrada ou
como saída de informação digital, são chamados de pinos digitais.

O Arduino é uma peça de hardware digital programável, assim ele funciona baseado no código binário. O
código binário é formado por variáveis lógicas que podem assumir níveis lógicos 0 ou 1 que em termos de
eletrônica significam 0V ou 5V. Assim quando dissermos que um pino do Arduino apresenta nível lógico
1 é porque nesse pino está presente um sinal de 5V e quando o pino apresenta nível lógico zero é porque
nesse pino a tensão é igual a 0V.

Na linguagem de programação do Arduino (C++) o nível lógico 1 é representado pela palavra HIGH (ALTO)
e o nível lógico 0 é representado pela palavra LOW (BAIXO).

A placa do Arduino UNO apresenta ainda um LED (Light Emitting Diode – Diodo Emissor de Luz) ligado ao
pino 13, identificado na placa pela letra “L” – destaque visto na Figura 14.

Figura 14 - Identificação do LED montado na placa Arduino UNO e ligado ao pino 13

Analisando o código vemos que logo no início temos um texto que na apresentação do sketch aparecem
com a cor cinza. Note que no começo do texto aparecem os caracteres “/*” e vai até os caracteres “*/”
estes caracteres indicam o início e o término de um bloco de comentários. Toda vez que desejamos fazer

Artur A. Vilares Filho 12

Arduino Básico

um comentário que irá ocupar mais de uma linha, devemos utilizar estes caracteres para delimitar o início
e o final deste bloco.

Exemplo 1:

/* Este é um trecho de comentários que

pode ocupar várias linhas.
Ao final dos comentários, deve-se finalizar com * e / */

Repare que no sketch temos também a ocorrência de comentários (na cor cinza) que inicia com “//” estes
caracteres são utilizados quando queremos fazer um comentário de apenas uma linha.

Exemplo 2:

//Este é um comentário de apenas uma linha.

Os comentários são importantes para documentar seu programa (Sketch). Os comentários também
ajudam na compreensão do código e no registro do porquê foi procedido daquela maneira, naquele
código. Estude os comentários existentes no sketch Blink e procure compreender sua importância.

Coloque sempre comentários nos seus códigos, isso demonstra um bom procedimento do programador
e uma forma adequada de organização no desenvolvimento de códigos em qualquer linguagem de
programação.

Os comentários não são compilados (transformados em código binário) pela IDE, servem apenas como
documentação.

Se analisarmos o sketch Blink notamos que apenas 7 linhas representam partes do programa em si
(código) e somente estas serão compiladas e transferidas (upload) para a memória flash do Arduino.

Vamos então analisar o funcionamento do código do sketch. Todo programa estruturado, com é o caso
da linguagem C, possui uma sequência que deve ser respeitada:

1. estrutura de inclusão de bibliotecas;

2. estrutura de declaração dos escopos das funções ou das próprias funções
3. estrutura de declaração de variáveis globais;
4. estrutura de Setup
5. estrutura de Loop
6. estrutura das funções

No sketch Blink vemos apenas duas dessas estruturas: estrutura de Setup e Estrutura de Loop também
chamadas de função Setup e função Loop.

Artur A. Vilares Filho 13

Arduino Básico

Um pouco sobre funções:

Uma função na linguagem C tem sempre o seguinte formato:

tipo nome(tipo parametros){ }

onde

tipo – é o - tipo de dado que a função irá retornar após ser executada.

nome – é o nome que a função irá receber, geralmente dá-se um nome que indique a o que a função faz,

por exemplo, se a função deve nos dar (retornar) o valor da raiz quadrada de um número pode-se nomeá-
la como “raiz” ou “raizquadrada”.

Ao se nomear uma função deve-se ter alguns cuidados: O nome da função deve ser único naquele código,
não se pode utilizar uma palavra reservada da linguagem C, não se pode iniciar o nome de uma função
por números, não se deve deixar espaços entre palavras, por exemplo: “raiz quadrada” não é válido
como nome de função, não se pode utilizar caracteres especiais em nome de funções (/, *,! etc).

A linguagem C é “case sensitive”, ou seja, as letras maiúsculas e minúsculas são diferenciadas, por
exemplo: Raiz é diferente de raiz.

(tipo) – é o tipo de dado que iremos passar para a função. Veremos mais adiante os tipos de dados da
linguagem C.

(parâmetros) – lista de parâmetros que receberão os valores (argumentos) a serem tratados na função.

{ } – são caracteres que delimitam o início e final do bloco pertencente à função.

Estudaremos as funções mais adiante no curso.

Explicando o sketch
void setup() {

Declaração de início da função setup do programa. A função setup será executada uma única fez assim
que o sketch for iniciado pela energização ou reset do Arduino. A função setup é utilizada para inicializar
variáveis locais, configurar o modo dos pinos (INPUT ou OUTPUT), inicializar bibliotecas etc.

O termo “void“ indica que a função não irá retornar nenhum tipo de dado e o fato de não existir nada
entre os parênteses significa que não será passado nenhum parâmetro para a função.

pinMode(LED_BUILTIN, OUTPUT);

Artur A. Vilares Filho 14

Arduino Básico

A declaração permite escolher o modo do pino, se é entrada (INPUT) ou saída (OUTPUT). O termo
“LED_BUILTIN“ é uma palavra reservada da linguagem do Arduino e é equivalente escrevermos “13” pois
a IDE interpreta este nome como sendo o pino 13.

Como queremos acender ou apagar um LED que está conectado ao pino 13 do Arduino, devemos
configurar este pino como saída de dado digital (OUTPUT). Então a forma geral da declaração será:

pinMode(PINO, Modo);

Onde “PINO” corresponde ao número do pino e “Modo”, se o pino será uma entrada digital “INPUT” ou
uma saída digital “OUTPUT”. Repare que toda declaração na linguagem C é terminada com um ponto e
vírgula “;”.

void loop() {

Declaração de inicio da função loop() que faz exatamente o que o nome sugere, ou seja, repete-se
indefinidamente enquanto a placa Arduino estiver energizada, permitindo que o programa realize
mudanças e reaja a mudanças. A função loop()permite que a placa Arduino seja controlada ativamente.

{
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}

Este trecho corresponde ao programa propriamente dito, ou seja, é o que realmente queremos que o
Arduino faça.

Vejamos então o significado de cada linha do trecho:

digitalWrite(LED_BUILTIN, HIGH);

Instrução de escrita digital. Como o pino 13 (LED_BUILTIN) é um pino digital e está configurado como
saída digital, ele pode assumir um dos dois níveis digitais possíveis, 0 (LOW) ou 1 (HIGH). No caso estamos
escrevendo 1 (HIGH) no pino 13. Isso significa que vai existir uma tensão de 5V no pino 13 do Arduino
nesse instante, portando um LED ligado a esse pino irá acender.

delay(1000);

Delay é uma função pronta do Arduino. O número inserido entre parêntesis corresponde ao valor em
milissegundos, que o Arduino irá esperar para seguir para a próxima instrução. No caso temos um delay
de 1000ms, ou seja, o Arduino irá esperar um segundo para executar a próxima instrução, veremos então
o LED aceso por um segundo

digitalWrite(LED_BUILTIN, LOW);

Artur A. Vilares Filho 15

Arduino Básico

Análogo à instrução anterior, só que desta vez rescreveremos o nível lógico zero (LOW) no pino 13, ou
seja, colocando tensão zero volts nesse pino, fazendo com que o LED apague.

delay(1000);

Novamente a função delay()irá fazer com que o Arduino espere um segundo antes de voltar ao início
da função loop.

Repare que tanto na função setup quanto na função loop, as instruções estão contidas entre {} (chaves).
Sempre que quisermos executar um conjunto de instruções dentro de uma função ou comando, devemos
colocar estas instruções entre chaves.

Uma vez entendido o funcionamento do programa, podemos compila-lo e fazer o upload para a placa
Arduino. Para compilar e enviar o código compilado para a placa do Arduino basta clicar no botão carregar

na barra de ferramentas. Espere o upload ser completado e pronto. O LED da placa do Arduino
(Figura 14) deverá piscar com intervalos de um segundo

Questões propostas:
1. O que faz a função setup?
2. O que faz a função loop?
3. Como seria escrito a instrução para a configuração do pino 10 do Arduino como uma entrada
digital?
4. Em que local do sketch a instrução da questão anterior deveria ser colocada para o
funcionamento correto?
5. Qual parâmetro deveria ser modificado no sketch da prática 1 para que o LED acendesse e
apagasse com intervalos de 1,5s? Qual o valor do novo parâmetro?

Artur A. Vilares Filho 16

Arduino Básico

Prática 02 – Pisca Led 2

Na Prática 01 vimos como fazer o upload de um sketch para a placa Arduino, vimos também as funções
“setup()“ e “ loop()“, bem como a instrução de configuração os pinos digitais do Arduino e o uso da
função de atraso da biblioteca da Arduino IDE ”delay()“ . Ainda na Prática 01 aprendemos como fazer o
LED on-board conectado ao pino 13 do Arduino acender e(ou) apagar. Nesta prática iremos fazer algo
semelhante, só que o LED será conectado externamente através do pino 9 do Arduino.

Um LED é um diodo emissor de luz e como diodo ele só conduz a corrente elétrica em um sentido,
bloqueando a corrente em sentido oposto. Assim que um LED entra em condução, ou seja, que a tensão
sobre ele atinge um valor ligeiramente acima da barreira de potencial, ele se comporta quase como um
curto-circuito, ou seja, a correte atinge valor elevado para um pequeno acréscimo da tensão acima da
barreira de potencial. Como a tensão na saída digital do Arduino em nível lógico 1 fica bem acima dessa
barreira, necessita-se de um resistor em série com o LED para limitar a corrente máxima que irá passar
pelo LED a fim de preservar sua integridade.

Vejamos como ficaria o hardware para a conexão do LED:

Saída R A K
do
Arduino LED

Figura 15 – Circuito para ligação de um LED em uma saída digital do Arduino

Para o cálculo do resistor limitador de corrente para o LED utiliza-se a equação abaixo.

𝑉𝑉𝑜𝑜 − 𝑉𝑉𝐿𝐿𝐿𝐿𝐿𝐿
𝑅𝑅 =
𝐼𝐼𝐿𝐿𝐿𝐿𝐿𝐿

Os valores padrões para um LED vermelho difuso normal são VLED = 1,7V e ILED = 20mA, considerando que
em nível lógico 1 na saída digital do Arduino tenhamos 5V, pode-se então calcular o valor da resistência R
como segue:
5 − 1,7
𝑅𝑅 = = 165 𝛺𝛺
20. 10−3

Uma vez calculado o valor do resistor, deve-se também calcular a potência mínima desse resistor. Isso
pode ser realizado utilizando-se a equação:

𝑃𝑃𝑚𝑚𝑚𝑚𝑚𝑚 = 𝑅𝑅. 𝐼𝐼𝐿𝐿𝐿𝐿𝐿𝐿 2

Assim:

𝑃𝑃𝑚𝑚𝑚𝑚𝑚𝑚 = 165 . (20. 10−3 )2 = 66𝑚𝑚𝑚𝑚

Artur A. Vilares Filho 17

Arduino Básico

Perceba que 165Ω não é um valor comercial (vide Tabela de Valores Comerciais no Anexo 1), assim deve-
se ajustar o valor para o mais próximo acima de 165Ω, que no caso seria 180Ω. No laboratório iremos
utilizar um resistor de 220Ω, que reduzirá a corrente a um valor bem abaixo de 20mA, mas sem prejudicar
a luminosidade de forma perceptível. Quanto a potência mínima que o resistor deve ter, poderia ser de
1/8W = 125mW ou maior, ficando assim, bem acima do valor mínimo, veja a Figura 16.

Saída R A K
do
220R
Arduino 1/8W
LED

Figura 16 – Circuito com o valor definido do Resistor limitador de corrente para o LED: 220Ω - 1/8W e Identificação da
polaridade do LED

Circuito (Hardware):
Para a montagem do circuito, iremos utilizar um Protoboard, um LED, um resistor de 220Ω e fios
“jumpers” – Figura 17.

Figura 17 – Protoboard e Jumpers para montagem de circuitos

Abaixo o esquema do circuito eletrônico a ser montado.

3V3

Vin
5V

Power
RST
D13
AREF
D12
PWM
D11
ARDUINO

PWM
D10
PWM
UNO

D9
Digital Input/Output

D8
D7
A

PWM
A0 D6
PWM
A1 D5 D1
Analog Input

A2 D4 LED
PWM
A3 D3
K

A4 D2
TX
A5 D1
RX R1
GND

A6 D0 220R

Figura 18 – Circuito mostrando a ligação do LED ao pino 9 do Arduino

A montagem em protoboard ficaria como mostra a figura 19

Artur A. Vilares Filho 18

Arduino Básico

Figura 19 – Montagem em protobard do circuito com LED no pino 9

O sketch
/*
Título: Prática 2 – Pisca Led 2
Data: 06/2022
Autor: Artur A. Vilares Filho
Descrição:
O sketch irá ligar um LED conectado ao pino 9 do Arduino por 1 segundo e
desligar por 1 segundo repetidamente.
*/
//cria uma variável do tipo inteira com o nome pino_LED e atribui
//o valor 9 a essa variável

int pino_LED=9;

void setup() {
// inicializa o pino digital 9 como uma saída.
pinMode(pino_LED, OUTPUT);
}

void loop() {
digitalWrite(pino_LED, HIGH); // liga o LED (a tensão no pino 9 é 5V)
delay(1000); // espera por 1 segundo
digitalWrite(pino_LED, LOW); // desliga o LED (a tensão no pino 9 é zero volts)
delay(1000); // espera por 1 segundo
}

Artur A. Vilares Filho 19

Arduino Básico

Entendendo o sketch
O código é bem pareceido com o da prática 01, assim iremos nos focar apenas nas modificações. A
principal diferença está na declaração:

int pino_LED=9;

Esta linha declara uma variável denominada pino_LED como sendo do tipo inteira “int” e atribui a ela o
valor 9. No Arduino as variáveis armazenam valores (dados) cujos tipos devem ser definidos na declaração
de tais variáveis. Os valores atribuidos às variáveis ficam armazenados na memória RAM do Arduino. A
tabela 2 a seguir mostra os tipos válidos de dados e seu respectivo tamanho.

Tabela 2 – Tipos de dados e tamanho que ocupam na memória RAM

Tipo Descrição Tamanho

bool Pode armazenar dois valores: true ou false. 8 bits = 1 byte
byte Armazena valores numéricos de 8 bits sem sinal 0 a 255
char Armazena caracteres 8 bits = 1byte
float Armazena dados em ponto flutuante (com virgula) 32 bits -3,4028235E+38 a 3,4028235E+38
int (integer) Armazena valores inteiros de 16bits -32.768 a 32.767
Fonte: https://www.arduino.cc/reference/pt/

pinMode(pino_LED, OUTPUT);

A declaração configura o pino 9 como saída (OUTPUT) de dado digital

digitalWrite(pino_LED, HIGH);

A instrução escreve o valor 1 (HIGH) na saída digital, no caso, o pino 9.

As demais linhas são análogas ao sketch da Prática 01.

Uma vez entendido o funcionamento do sketch, podemos compila-lo e fazer o upload para a placa
Arduino.

Verifique o funcionamento do circuito, certificando-se que ele funcione como o esperado.

Questões propostas:
1. Ao escolhermos o valor do resistor limitador de corrente para o LED igual a 220Ω, reduzimos a
corrente no circuito. Recalcule então a nova corrente que circulará pelo LED quando a saída digital
estiver em nível 1.
2. No caso da questão 1, qual a potência dissipada pelo resistor de 220Ω?
3. Qual modificação deveria ser feita no esquema do circuito se quiséssemos que o LED acendesse
quando a saída digital do Arduino estivesse em nível lógico baixo? Redesenhe o circuito com a
modificação.

Artur A. Vilares Filho 20

Arduino Básico

Prática 03 – Led e Botão

Já sabemos como conectar um LED a uma saída digital do Arduino e como aciona-lo através de
programação. Nesta prática vamos ver como ligar um botão tipo “push button” ou chave táctil ao Arduino
e ler o estado lógico deste botão (o ou 1)

Veja os circuitos abaixo, no primeiro circuito temos um dos terminais do resistor ligado ao Vcc (5V) e o
outro terminal ligado ao botão e à entrada do Arduino. Veja que estando o botão aberto, o nível lógico
no pino de entrada será igual a um (HIGH), pois o resistor está ligado diretamente ao Vcc. Quando
pressionarmos o botão, o pino de entrada do Arduino ficará ligado à terra (GND) através do botão, assim,
o nível lógico vai para zero (LOW). O resistor presente no circuito é chamado de resistor de PULL-UP.

No segundo circuito temos exatamente o contrário, um dos terminais do resistor está ligado diretamente
à terra (GND) e o outro está conectado ao botão e à entrada do Arduino. Estando o botão aberto, a
entrada do Arduino estará conectada à terra através do resistor ficando então em nível lógico zero (LOW),
quando pressionarmos o botão esta entrada ficará conectada ao Vcc através do botão, levando o nível
lógico na entrada do Arduino para 1 (HIGH). O resistor do segundo circuito é chamado de resistor de PULL-
DOWN.

Vcc Vcc

Resistor
de
PULL-UP
Entrada Entrada
do do
Arduino Arduino
Resistor
de
PULL-DOWN

(a) (b)

Figura 20 – (a)Resistor de PULL-UP – (b)Resistor de PULL-DOWN

Circuito (Hardware):
Para esse circuito iremos utilizar, além do protoboard, um LED e o resistor de 220Ω, um resistor de 10kΩ
e uma chave táctil (push-button). O resistor de 10kΩ servirá de resistor de “pull-down”, garantindo nível
lógico zero (LOW) no pino de entrada do Arduino quando a chave táctil não estiver pressionada. Os
componentes adicionais são mostrados na figura 21.

ou
Figura 21 - Chave táctil (dois modelos) e resistor de 10kΩ como PULL-DOWN

Artur A. Vilares Filho 21

Arduino Básico

A seguir o esquema do circuito eletrônico a ser montado.

3V3

Vin
5V
Power
RST
D13
AREF
D12
PWM
D11

ARDUINO
PWM
D10
PWM

UNO
D9

Digital Input/Output
D8
D7
PWM
A0 D6

A
PWM
A1 D5
Analog Input

A2 D4
PWM D1
A3 D3
A4 D2 S1 LED

K
TX
A5 D1
RX
GND

A6 D0 R1
220R

R2
10k

Figura 22 – Circuito com LED e Chave táctil

A montagem em protoboard:

Figura 23 – Montagem em protoboard

Artur A. Vilares Filho 22

Arduino Básico

O sketch
/*
Título: Prática 3 – LED e Botao (Chave Táctil)
Data: 06/2022
Autor: Artur A. Vilares Filho
Descrição:
O sketch irá ler o estado do pino 2 onde esta ligado um botão (chave táctil)
Se o estado do pino for alto (HIGH) o LED irá acender caso contrário o LED irá
apagar.
*/
//cria uma constante inteira com o nome pino_LED e atribui o valor 9
const int pino_LED = 9;
//cria uma constante inteira com o nome Botao e atribui o valor 2
const int Botao = 2;
//cria uma variável tipo inteira com o nome EstadoBotao e atribui o valor 0
int EstadoBotao = 0;

void setup() {
// inicializa os pinos digitais.
pinMode(pino_LED, OUTPUT); //pino do led será saída
pinMode(Botao, INPUT); //pino do botão será entrada

void loop() {

EstadoBotao = digitalRead(Botao); //Lê o estado do Botao (pino2) e armazena na

//variável EstadoBotão

if(EstadoBotao == HIGH){

digitalWrite(pino_LED, HIGH); // liga o LED se o botão for pressionado

}
else {
digitalWrite(pino_LED, LOW); // desliga o LED se o botão for solto
}
}

Entendendo o sketch
const int pino_LED = 9;
const int Botao = 2;

Nas duas linhas vemos a declaração de variável, só que diferentemente dos códigos das prática anteriores,
aqui aparece o termo “const“, este termo é uma palavra-chave que corresponde a um qualificador que
modifica o comportamento da variável, fazendo com que a variável seja de “apenas-leitura” e seu valor
não poderá ser alterado. Isto é útil e mais recomendado quando se quer designar, por exemplo, um nome
para um pino do Arduino, como é o caso do sketch desta prática. Nesse caso, o compilador irá identificar
que se trata de uma constante e não irá armazenar o valor atribuído na memória RAM do Arduino, mas
sim, considerar o valor atribuído diretamente no código ao fazer a compilação.

int EstadoBotao = 0;

Declara uma variável do tipo inteira de nome EstadoBotao e atribui o valor zero a esta variável. Esta
variável será utilizada no programa para armazenar o valor lógico do pino onde o botão está conectado.

pinMode(pino_LED, OUTPUT);

Artur A. Vilares Filho 23

Arduino Básico

Configura o pino pino_LED que corresponde ao pino 9 da placa, como saída (OUTPUT ).

pinMode(Botao, INPUT);

Configura o pino Botao que corresponde ao pino 2 da placa, como entrada (INPUT).

EstadoBotao = digitalRead(Botao);

Lê o valor do pino Botao que corresponde ao pino 2 e armazena o resultado na variável EstadoBotao.
Como o botão está conectado através de um resistor de PULL-DOWN, se o botão for pressionado o valor
lógico no pino 2 será 1 (HIGH) caso contrário o valor lógico será zero (LOW).

A forma geral da declaração “digitalRead” será:

digitalRead(Pino);

Onde Pino corresponde ao pino que se quer ler.

if(EstadoBotao == HIGH){

Temos aí uma estrutura de controle. O comando if checa uma condição e executa o comando a seguir
ou um bloco de comandos delimitados por chaves, se a condição for verdadeira (true). No caso, dentro
do parêntese temos a comparação entre o conteúdo da variável EstadoBotao e o nível lógico 1, “HIGH”.
O operador “==” tem o significado de igual (comparação). Se o conteúdo da variável “EstadoBotao” for
igual a 1 “HIGH” o bloco de comando a seguir será executado, caso contrário o bloco não será executado.

A forma geral do comando if é:

if (condição){
//comando(s)
}
As condições sendo testadas dentro dos parênteses geralmente requerem o uso de um ou mais
operadores que são mostrados na Tabela 3 abaixo.

Tabela 3 – Operadores de comparação

Operadores de comparação (relacionais)

Operador Exemplo Significado
== x == y x é igual a y
!= x != y x é diferente de y
< x<y x é menor que y
> x>y x é maior que y
<= x <= y x é menor ou igual a y
>= x >= y x e maior ou igual a y
Fonte: https://www.arduino.cc/reference/pt/language/structure/control-structure/if/

digitalWrite(pino_LED, HIGH);

Escreve 1 (HIGH) no pino digital, no caso, pino 9 se a condição testada no comando if for verdadeira.

Artur A. Vilares Filho 24

Arduino Básico
else {

O else é parte da estrutura if...else. Diz-se que todo else tem seu if. Esta estrutura de controle
permite maior controle sobre o fluxo de código que o comando básico if, pois permite que múltiplos
testes possam ser agrupados. Uma cláusula else, se presente, será executada se a condição do comando
if resulta em falsa (false).

No caso do código, se a condição do if for falsa, o bloco de comando (delimitada por chaves) após o
else será executado.

digitalWrite(pino_LED, LOW);

Escreve zero (LOW) no pino digital 9 se a condição do if for falsa. Note que esta linha só será executada
se a condição testada no comando if resultar em falsa (false).

Tente entender bem a estrutura if...else, pois ela é muito utilizada em programação.

Tendo entendido bem o funcionamento do sketch, podemos fazer a compilação e o upload para a placa
do Arduino.

Observe bem o funcionamento do programa e comprove que o mesmo funciona como o esperado.

Questões propostas:
1. Modifique o sketch da prática 03 de modo que o LED fique aceso quando o botão estiver solto e
apague quando o botão estiver pressionado.
2. Suponha que ao invés de se utilizar no circuito do botão (chave táctil) um resistor de PULL-DOWN,
fosse utilizado um resistor de PULL-UP (veja a Figura 20), quais modificações deveriam ser feitas
no sketch se quiséssemos acender o LED ao pressionar o botão?
3. Desenhe o circuito mostrando a ligação do botão com o resistor de PULL-UP ligado ao pino 2 do
Arduino como referenciado na questão anterior.
4. Suponha o trecho de código a seguir:

x = 20;
y = 10;
if(x < y){
c = x + y;
}
else {
c = x – y;
}
Ao final da execução do trecho do código, qual seria o valor da variável “c” ?
5. Qual a utilidade de se nomear um pino do Arduino com a declaração de uma variável?
6. Qual a diferença entre nomear um pino do Arduino no sketch utilizando a declaração de variável
como tipo int e como tipo const int ?

Artur A. Vilares Filho 25

Arduino Básico

Prática 04 – Controle de Luminosidade de LED

Vimos nas práticas anteriores como acionar um LED ligado a um pino digital do Arduino. Verificamos que
com a declaração digitalWrite() podemos escrever 0 (LOW) ou 1 (HIGH) em um determinado pino. Mas,
e se quisermos que a tensão em um determinado pino varie, por exemplo, de 0V a 5V. Como o Arduino é
um elemento digital, a princípio nos parece que conseguir essa variação de tensão não seja possível,
porém, existe uma técnica chamada PWM (Pulse Width Modulation – Modulação por Largura de Pulso)
que nos permite “enganar” um componente (motor, LED, Lâmpadas etc.) fazendo com que esse “pense”
que está sendo alimentado por uma tensão que pode variar. A técnica consiste em gerar uma onda
quadrada com valor máximo de 5V, com período constante, mas com os tempos em que o sinal está em
nível alto e em nível baixo variáveis proporcionalmente.

Figura 24 - Sinal PWM com diversos valores de Duty Cycle

A figura 23, mostra diversos sinais com os tempos em nível alto e nível baixo diferentes, mas com o mesmo
período, isso faz com que a tensão média resultante para cada sinal varie. O termo Duty Cycle ou Ciclo de
Serviço corresponde ao tempo em que o sinal está em nível alto em relação ao período total, por exemplo:
se um sinal com período total de 150ms fica em nível alto durante 30ms temos um Duty Cicle igual a 20%.

𝑇𝑇𝐻𝐻 30. 10−3

𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷 = . 100 = . 100 = 20%
𝑇𝑇 150. 10−3

Na figura 23 podemos notar que para um Duty Cycle de 0% temos um valor médio igual a 0V e para um
Duty Cycle igual a 100% temos um valor médio de 5V. Para um Duty Cycle de 50% temos então uma
tensão média de 2,5V, assim, podemos concluir que o Duty Cycle representa em porcentagem a tensão
média na saída.

Artur A. Vilares Filho 26

Arduino Básico

Vejamos o exemplo do cálculo realizado anteriormente (Duty Cycle = 20%) teríamos então 20% de 5V
como tensão média, que corresponde à 1V. Com base nisso, podemos calcular a tensão média com a
equação:
𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷
𝑉𝑉𝐷𝐷𝐷𝐷 = . 𝑉𝑉𝑉𝑉𝑉𝑉
100

20
𝑉𝑉𝐷𝐷𝐷𝐷 = . 5 = 1𝑉𝑉
100

O Arduino possui pinos específicos para a geração de sinal PWM, esses pinos são identificados na placa
com um sinal de til (~) como mostra a figura 24.

Figura 25 - Os pinos capazes de gerar um sinal PWM são identificados com (~)

No Arduino UNO temos 6 pinos para saída PWM que são: pinos 11, 10, 9, 6, 5 e 3.

Para gerar um sinal PWM em um desse pinos é necessário chamar a função analogWrite()no sketch, que
tem a seguinte sintaxe: analogWrite(pino,valor) , onde pino é um dos pinos marcados com (~) e valor
é o um valor que vai de 0 a 255 onde 0 corresponde à 0% e 255 corresponde a 100% de Duty Cycle.

Tabela 4 - Valores de Duty Cycle e respectivos valores a serem passados para a função "analogWrite".

Duty Cycle (%) Valor Tensão média (V)

0 0 0
25 64 1,25
50 127 2,5
75 191 3,75
100 255 5

Artur A. Vilares Filho 27

Arduino Básico

Circuito (Hardware):

3V3

Vin
5V
Power
RST
D13
AREF
D12
PWM
D11
PWM
D10
ARDUINO
PWM
D9
Digital In/Out - PWM
UNO

D8
D7
PWM
D6
A0 PWM
D5
A1
Analog In

D4
A2

A
PWM
D3
A3
D2
A4 TX
D1
A5 RX
GND

D0
K

K
220R 220R 220R

Figura 26 - Circuito com a conexão dos LEDs aos pinos PWM do Arduino

Figura 27 - Montagem do circuito em protoboard

Artur A. Vilares Filho 28

Arduino Básico

O sketch
/*
Título: Prática 4 – Controle de Luminosidade de LEDs
Data: 06/2022
Autor: Artur A. Vilares Filho
Descrição:
O sketch gerar um sinal de PWM nas saídas 9, 6 e 5 do Arduíno com Duty Cycle variáveis,
aumentando de 0 a 255 e em seguida diminuindo gradativamente.
*/

const int LEDvermelho = 9;

const int LEDamarelo = 6;
const int LEDverde = 5;
int brilho;

void setup() {
pinMode(LEDvermelho, OUTPUT);
pinMode(LEDamarelo, OUTPUT);
pinMode(LEDverde, OUTPUT);
}

void loop() {
// aumenta o brilho dos LEDs, incrementando de 5 em 5 passos
for( brilho = 0 ; brilho <= 255; brilho = brilho + 5) {
analogWrite(LEDvermelho, brilho);
analogWrite(LEDamarelo, brilho);
analogWrite(LEDverde, brilho);
// aguarda 30 milisegundos
delay(30);
}
// diminui o brilho dos LEDs, decrementando de 5 em 5 passos
for( brilho = 255 ; brilho >= 0; brilho = brilho - 5) {
analogWrite(LEDvermelho, brilho);
analogWrite(LEDamarelo, brilho);
analogWrite(LEDverde, brilho);
// aguarda 30 milisegundos
delay(30);
}
}

Entendendo o sketch
Inicialmente são declaradas variáveis do tipo cosnt int para nomear os pinos onde os LEDs estarão
conectados. Uma variável denominada brilho é declarada como inteiro (int). Essa variável será utilizada
no controle do comando for e tambem como argumento dentro da função analogWrite() para definir o
valor do PWM a ser gerado nos pinos onde estão conectados os LEDs.

for( brilho = 0 ; brilho <= 255; brilho = brilho + 5) {

O comando for é usado para repetir um bloco de códigos delimitado por chaves, de maneira controlada.
O controle do número de repetições é feito por uma variável de controle. O comando é útil para qualquer
operação repetitiva. No caso do sketch, a variável de controle do comando for é a variável brilho.

A sintaxe do comando é:

for (inicialização; condição; incremento){

// comandos;
}

Artur A. Vilares Filho 29

Arduino Básico

A inicialização ocorre primeiro (brilho = 0) e apenas uma vez. A condição (brilho <= 255) é testada;
se é verdadeira, o bloco de comandos é executado e o incremento (brilho + 5) é realizado. Novamente
a condição é testada, se é verdadeira, o bloco de comandos é executado e o incremento é realizado e
novamente a condição é testada. Quando a condição se torna falsa, o loop termina e o programa
prossegue. No caso, o loop se repete até que a variável brilho assuma valor maior do que 255. Em
resumo, a variável brilho será incrementada de 5 em 5 a partir de zero até atingir o valor 255.

analogWrite(LEDvermelho, brilho);
analogWrite(LEDamarelo, brilho);
analogWrite(LEDverde, brilho);

A cada repetição, o bloco delimitado por chaves é executado. A função analogWrite () terá como
argumento a variável brilho, variando de 0 a 255, gerando assim um sinal PWM que irá aumentando em
incrementos de 5 em 5. Isso irá causar um aumento gradativo do brilho dos LEDs

Após sair do primeiro for, o programa irá entrar no segundo for que tem o funcionamento análogo ao
primeiro, só que desta vez a variável brilho inicializara em 255 e será decrementada de 5 em 5 até atingir
0, fazendo com que o sinal PWM gerado nas saídas tenha o Duty Cycle reduzido até zero, diminuindo
gradativamente o brilho dos LEDs, assim o processo se repete indefinidamente.

Entendido o funcionamento do programa, podemos agora fazer o upload do código para o Arduino.

Verifique o funcionamento do circuito e comprove que o mesmo se comporta como o esperado.

Questões propostas:
1. O que significa quando dizemos que um sinal PWM tem um Duty Cycle de 90%?
2. Em um sinal PWM com período de 200ms, a onda fica em nível alto durante 25ms, assim, calcule o
Duty Cycle correspondente.
3. Deseja-se que no pino 3 (pino PWM do Arduino) tenhamos uma tensão média de 2V modulada em
PWM, calcule que valor deve ser colocado na função analogWrite() para que isso ocorra.
4. Modifique o sketch mostrado na prática 4 de modo que cada LED vá tendo o seu brilho
gradativamente aumentado sequencialmente, um após o outro e em seguida diminuído também
sequencialmente, um após o outro.

Artur A. Vilares Filho 30

Arduino Básico

Prática 05 – Controle de luminosidade de LED com LDR

Nesta prática iremos utilizar um componente eletrônico denominado LDR (Light Dependent Resistor –
Resistor Dependente de Luz). O LDR é um tipo de resistor cuja resistência varia conforme a intensidade
de luz que incide sobre ele. Quanto maior a intensidade luminosa, menor a resistência. A resposta do
LDR é lenta, ou seja, não é capaz de detectar mudanças rápidas de luz.

Figura 28 – Alguns tipos de LDRs

O LDR não requer cuidados especiais, não há polaridade, isto é não possui um lado certo para ligá-
lo, no entanto devemos respeitar a máxima corrente que ele suporta, como é o caso de resistores comuns.

Figura 29 - Gráfico mostrando a relação inversa e não linear entre a intensidade luminosa e a resistência do LDR

O Arduino possui um conversor Analógico Digital (ADC) com resolução de 10 bits, sendo assim ele pode
converter um sinal analógico que varie de 0 a 5V em um código binário com variação de 0 a 1023 (210 - 1)
respectivamente. Desse modo, para cada variação de um bit temos uma variação de 5/1023 =
0,0048875855...V ou arredondando 0,00489 = 4,89mV, essa é a resolução em volts do conversor.

Se na entrada do conversor AD do Arduino for colocado uma tensão de 3V, qual será o valor convertido
expresso no sistema decimal?

𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡ã𝑜𝑜 3
𝑉𝑉𝑉𝑉𝑉𝑉𝑉𝑉𝑉𝑉_𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐𝑐 = = = 613
0,00489 0,00489

No Arduino Uno temos 6 entradas analógicas denominadas A0, A1, A2, A3, A4 e A5. Essas entradas são
para um único conversor AD e são multiplexadas, ou seja, cada entrada é ativada individualmente para a
conversão, assim um único conversor pode receber vários sinais para serem convertidos um de cada vez.

Artur A. Vilares Filho 31

Arduino Básico

Figura 30 - Entradas analógicas do conversor AD do Arduino

Para fazer a conversão de um sinal analógico colocado em uma das entradas analógicas, utiliza-se a função
analogRead(), essa função lê o valor presente no pino indicado. O valor em qualquer entrada analógica
pode variar entre 0 e 5V e será convertido em valores inteiros de 0 a 1023.
No sketch a sintaxe da função será: analogRead(pino), onde pino corresponde a um dos pinos
analógicos.

Circuito (Hardware)
5V
3V3

Vin
5V

Power
LDR RST
D13
AREF
D12
PWM
D11
PWM A K
D10
ARDUINO

PWM
D9
Digital In/Out - PWM
UNO

LED
D8
D7
PWM
A0
D6
PWM R1
D5 220R
A1
Analog In

D4
A2 PWM
D3
A3
R2 A4
D2
TX
D1
A5 RX
GND

100k D0

Figura 31 - Conexão do LDR à entrada analógica do Arduino

Artur A. Vilares Filho 32

Arduino Básico

Figura 32 - Montagem em protoboard

O sketch
/*
Título: Prática 5 – Controle de Luminosidade de LED com LDR
Data: 08/2022
Autor: Artur A. Vilares Filho
Descrição:
O sketch irá ler a tensão no divisor formado pelo LDR e o resistor R2 através da
entrada analógica A0, converter o valor em digital e utilizar esse valor para gerar um
sinal inversamente proporcional de PWM no pino 10 do Arduino.
*/

const int pinoLED = 10; //Nomeia o pino 10 como pinoLED

const int pinoLDR = 0; //Nomeia o pino A0 como pinoLDR

int valorConv = 0;
int saidaPWM = 0;

void setup()
{
pinMode(pinoLED, OUTPUT);
pinMode(pinoLDR, INPUT);
}

void loop()
{
valorConv = analogRead(pinoLDR);
// com o gerador de PWM do arduno trabalho com 8 bits, temos um duty cycle máximo de
// 2^8-1 = 255, portanto, 1/4 do valor máximo do conversor AD
saidaPWM = 255 – (valorConv/4); //calcula o valor do duty cycle para o PWM
analogWrite(pinoLED, saidaPWM); //gera um PWM inversamente proporcional
}

Entendendo o sketch
As linhas com as declarações das variáveis e o bloco de setup foram explicados nas práticas anteriores.

Artur A. Vilares Filho 33

Arduino Básico

A linha de comando a seguir atribui à variável inteira denominada valorConv o valor convertido da tensão
presente na entrada analógica A0 do Arduino.

valorConv = analogRead(pinoLDR);

A seguir, o valor convertido é dividido por quatro, pois o valor máximo que pode ser obtido na conversão
é 1023 e o valor máximo do PWM é 255, cerca de ¼ do valor máximo do conversor AD. Queremos que o
LED vá acendendo à medida que o LDR receba menos luz, assim, subtraiu-se o valor (valorConv/4) de
255.

saidaPWM = 255 – (valorConv/4);

Note que quando tivermos 1023 (valor máximo da conversão), LDR totalmente iluminado, valorConv/4
= 1023/4 = 255, subtraído de 255 terenos o valor 0 na variável saidaPWM.

O valor contido na variável é utilizado como valor do duty cycle na função que gera PWM no pino 10 do
Arduino.

analogWrite(pinoLED, saidaPWM);

Questões propostas:
1) Quantos bits de resolução tem o conversor do Arduino?
2) Quantas entrada analógicas possui o Arduino UNO?
3) Calcule a variação de tensão na entrada de um conversor AD de 8 bits que provocaria a mudança de
um bit no valor convertido.
4) Se na entrada analógica A0 for colocado uma tensão igual a 1,5V, qual será o valor convertido pelo
conversor AD?
5) Considerando o programa da prática 5, calcule o valor da tensão na entrada A0, se a variável
valorConv estiver com o valor 420.
6) Modifique o programa da prática 5 de modo que ao escurecer o LDR, o LED se apague
progressivamente.

Artur A. Vilares Filho 34

Arduino Básico

Prática 06 – Semáforo para pedestres

Nesta prática iremos simular um semáforo para pedestres, onde ao pressionar um botão tipo “push-
button”, decorrido um intervalo de tempo o semáforo deverá fechar para os automóveis e abrir para os
pedestres, que terão um certo tempo para atravessar a rua, logo após o semáforo deverá voltar a fechar
para os pedestres e abrir para os automóveis, permanecendo assim até que o botão seja pressionado
novamente.

Todos os componentes desta prática bem como os comandos utilizados no sketch já foram abordados em
práticas anteriores. Procure estudar o sketch e prever o seu funcionamento.

Circuito (Hardware)
5V
5V
VD - Pedestre

A K
220R
3V3

Vin
5V

VM - Pedestre
Power
A K
RST
D13
AREF 220R
D12 Push-Button
PWM
D11
PWM
D10
ARDUINO

PWM
D9
Digital In/Out - PWM
UNO

D8
VD
D7
PWM
D6 A K
A0 PWM
10k
D5
A1 220R
Analog In

D4
A2
D3 PWM AM
A3
D2 A K
A4 TX
D1
A5 RX 220R
GND

D0
VM
A K
220R

Figura 33 - Esquema do semáforo para pedestre

Figura 34 - Semáforo montado em protoboard

Artur A. Vilares Filho 35

Arduino Básico

O sketch
/*
Título: Prática 6 – Semáforo para pedestres
Data: 08/2022
Autor: Artur A. Vilares Filho
Descrição:
O sketch simula um semáforo para pedestre, ao se pressionar o push-button um tempo
irá decorrer até que o semáforo para os automóveis feche abrindo o semáforo para os
pedestres. Após algum tempo o semáforo para os pedestres irá fechar, voltando abrir para
os automóveis. O semáforo permanecerá nessa condição até que se pressione o push-buton
novamente.
*/
const int LED_VM = 6;
const int LED_AM = 7;
const int LED_VD = 8;
const int LED_VM_pedestre = 11;
const int LED_VD_pedestre = 12;
const int pinoBotao = 9;

int estadoBotao = 0; //declara uma variável para guardar o estado do botão

void setup()
{
pinMode(LED_VM, OUTPUT);
pinMode(LED_AM, OUTPUT);
pinMode(LED_VD, OUTPUT);
pinMode(LED_VM_pedestre, OUTPUT);
pinMode(LED_VD_pedestre, OUTPUT);
pinMode(pinoBotao, INPUT);
}
void loop()
{
digitalWrite(LED_VM_pedestre, HIGH);//fechado para pedestres
digitalWrite(LED_VD; HIGH); //aberto para automóveis

// le o estado do botão

estadoBotao = digitalRead(pinoBotao);

// verifica se o botão foi pressionado

if (estadoBotao == HIGH)
{
delay(60000);
digitalWrite(LED_VD, LOW);
digitalWrite(LED_AM, HIGH);
delay(15000);
digitalWrite(LED_AM, LOW);
digitalWrite(LED_VM, HIGH);

digitalWrite(LED_VM_pedestre, LOW);
digitalWrite(LED_VD_pedestre, HIGH);

delay(30000);

digitalWrite(LED_VD_pedestre, LOW);

for( int contador = 0; contador <= 3; contador++) //pisca vermelho do pedestre

{
digitalWrite(LED_VM_pedestre, HIGH);
delay(500);
digitalWrite(LED_VM_pedestre, LOW);
delay(500);
}
digitalWrite(LED_VM, LOW);
}
}

Artur A. Vilares Filho 36

Arduino Básico

Entendendo o sketch
Estude o sketch e procure entender o funcionamento do programa.

Questões propostas:
1) Coloque comentários no sketch explicando o que cada linha do programa faz.
2) Escreva um texto explicando o funcionamento do sketch.
3) Faça mudanças no sketch e no circuito de modo que ao invés de um semáforo para pedestres
tenhamos dois semáforos para automóveis (um em cada rua de um cruzamento). Os semáforos
deverão funcionar automaticamente sem intervenções. Desenhe o circuito com as mudanças
necessárias.
4) Para o teste do sketch desenvolvido na questão 3, acesse o site Tinkercad:
https://www.tinkercad.com/ , monte o circuito, gere o código em linguagem C e faça a simulação,
em seguida gere um link e compartilhe seu trabalho com o professor.

Artur A. Vilares Filho 37

Arduino Básico

Prática 07 - Termômetro utilizando NTC

Nesta prática iremos utilizar um NTC (Negative Temperature Coefficient – Coeficiente Negativo de
Temperatura) é um componente chamado de termistor e que é sensível à variação da temperatura. A
resistência elétrica do NTC diminui com o aumento da temperatura, como pode ser visto na curva
característica mostrada na figura.

Figura 35 - Curva de um Termistor NTC de 10kΩ

O termistor que utilizaremos é um NTC de 10kΩ, isso significa que à 25°C ele apresenta uma resistência
de 10kΩ.

Na figura 36 podemos ver alguns tipos de NTC

Figura 36 - Alguns tipos de

Termistores NTC

O algoritmo utilizado para se obter a temperatura a partir da resistência do termistor é uma

implementação da equação de Steinhart-Hart. Detalhes sobre o uso desta equação pode ser obtido em
https://en.wikipedia.org/wiki/Steinhart-Hart_equation.

Para o desenvolvimento da prática deve-se implementar o circuito da figura 37, onde o resistor e o
termistor formam um divisor de tensão e a tensão sobre o resistor é aplicado à entrada analógica do
Arduino.

Artur A. Vilares Filho 38

Arduino Básico

5V

3V3

Vin
5V
Power
RST
NTC AREF
D13
10.0k D12
-tc D11
PWM
PWM
D10

ARDUINO
PWM
D9

Digital In/Out - PWM

UNO
D8
D7
PWM
D6
A0 PWM
D5
A1

Analog In
D4
A2 PWM
D3
A3
D2
R1 A4
D1
TX
A5 RX

GND
10k D0

Figura 37 - Circuito a ser implementado no protoboard

O sketch
#include <math.h>
int pinoNTC = 1;//Pino analógico que vai ler a tensão sobre R
int valorLido = 0;

/***Função para calcular o valor da temperatura***/

double termistorNTC(int valorAnalogico)
{
double temperatura;
temperatura = log(((10240000/valorAnalogico) - 10000));
temperatura = 1 / (0.001129148 + (0.000234125 * temperatura) +
(0.0000000876741 * temperatura * temperatura * temperatura));
//--- converte Kelvin em Celcius ---
temperatura = temperatura - 273.15;
return temperatura;
}

void setup()
{
pinMode(pinoNTC, INPUT);
Serial.begin(9600);
delay(5000);
}
void loop()
{
valorLido = (termistorNTC(analogRead(pinoNTC)));
Serial.print(“Temperatura: “);
Serial.print( valorLido );
Serial.println(“ °C”);
delay(1000);
}

O resultado que se espera com a execução do sketch é obter a temperatura ambiente em graus Celsius e
mostrá-la no monitor serial como indicado abaixo.

Artur A. Vilares Filho 39

Arduino Básico

Figura 38 - Ícone do Monitor serial na IDE Arduino

Figura 39 - Tela do Monitor serial aberta mostrando a temperatura

Entendendo o sketch
#include <math.h>
Sintaxe:

#include<nome do arquivo>

#include é uma diretiva da linguagem Arduino (linguagem C) que instrui a IDE, no momento da

compilação para incluir o arquivo indicado juntamente com o código do sketch. Assim #include
<math.h> inclui o arquivo math.h no sketch possibilitando o uso de funções matemáticas que estão neste

arquivo de biblioteca. O arquivo de biblioteca math.h fornece um conjunto de funções para operações
matemáticas, tais como funções trigonométricas, hiperbólicas, logaritmos, potência e arredondamentos.

double termistorNTC(int valorAnalogico)

A linha acima corresponde ao início de uma função, funções são blocos de códigos que ajudam a
modularizar um programa. Nos sketches que vimos até agora, por padrão, encontramos duas funções:
setup() e loop().

Artur A. Vilares Filho 40

Arduino Básico

As funções também são conhecidas como rotinas ou sub-rotinas, elas servem para que possamos
reaproveitar partes do código que são frequentemente utilizados, assim podemos utilizar parte de um
código, criar uma função e chamá-la sempre que precisarmos executar aquele código.

As funções apresentam as seguintes sintaxes:

<tipo de dado de retorno><nome da função>(<parâmetros de entrada>); { }

Exemplo:
//funcao soma
int soma(int a, int b)
{
return a + b;
}

//Função principal
void main()
{
int m = 4, n= 5, resultado;
resultado = soma(m,n);
}
No exemplo acima, a função “soma” recebe dois parâmetros do tipo inteiro (int) e retorna a soma dos
dois parâmetros (a e b). Na função principal é declarada três variáveis (m, n e resultado) todos do tipo
inteiro. Às variáveis m e n são atribuídos valores e em seguida a função soma é chamada e esses valores
são passados para a função através das variáveis. Ao ser executada a função faz a adição desses valores e
retorna o valor da soma, que é atribuída à variável resultado na função principal.

Vejamos a nossa função

double termistorNTC(int valorAnalogico)

{
.
.
.
return temperatura;
}
A função retorna um valor do tipo double, o nome da função é termistorNTC e o parâmetro que será
passado para a função, será uma variável (valorAnalogico) do tipo inteiro (int). Ao ser executada a
função irá calcular o valor da temperatura e retornará esse valor para a função que a chamou.

Serial.begin(9600);
A linha de comando acima, inicializa o terminal serial com uma taxa de transmissão (baud rate) de 9600
bits por segundo. Isso representa o máximo de bits que pode ser transmitido por segundo.

valorLido = (termistorNTC(analogRead(pinoNTC)));
A linha de comando acima chama a função termistorNTC e passa para a função o valor analógico
convertido em binário (analogRead(pinoNTC)). A função termistorNTC devolve o valor calculado
por ela e esse valor fica armazenado na variável valorLido.

Artur A. Vilares Filho 41

Arduino Básico

Serial.print(“Temperatura: “);
Serial.print( valorLido );
Serial.println(“ °C”);
O trecho de programa acima imprime no Monitor Serial da IDE do Arduino o valor da temperatura.

Execute o programa e acione o Monitor Serial para que se possa ver o valor da
temperatura ambiente. Teste o funcionamento do programa colocando a mão sobre o terminstor de
modo que a temperatura aumente e observe o que ocorre no monitor serial.

Questões propostas:
1) Utilizando a fórmula da função termistorNTC , calcule a temperatura para uma resistência do terminstor
NTC de 6kΩ.
2) Utilizando o Tinkercad, simule o circuito desta prática, salvando o projeto com o nome “Prática_07”. Envie o
linke da simulação para o professor na atividade correspondente.
3) Troque a função Serial.print(valorLido); por Serial.println(valorLido); e observe o
que ocorre. Anote suas observações.
4) Acesse a página: https://www.arduino.cc/reference/pt/language/functions/communication/serial/print/ e
estude as funções Serial.print(), Serial.println() e Serial.begin() e descreva o que cada
uma faz.

Artur A. Vilares Filho 42

Arduino Básico

Anexo 1

Tabela 5 - Valores comerciais de resistores de carbono

Tabela de Valores Comerciais

Série E24 – Resistores de Filme de Carbono – ± 5%
1,0 Ω 10 Ω 100 Ω 1,0 kΩ 10 kΩ 100 kΩ 1,0 MΩ 10 MΩ
1,1 Ω 11 Ω 110 Ω 1,1 kΩ 11 kΩ 110 kΩ 1,1 MΩ 15 MΩ
1,2 Ω 12 Ω 120 Ω 1,2 kΩ 12 kΩ 120 kΩ 1,2 MΩ 22 MΩ
1,3 Ω 13 Ω 130 Ω 1,3 kΩ 13 kΩ 130 kΩ 1,3 MΩ
1,5 Ω 15 Ω 150 Ω 1,5 kΩ 15 kΩ 150 kΩ 1,5 MΩ
1,6 Ω 16 Ω 160 Ω 1,6 kΩ 16 kΩ 160 kΩ 1,6 MΩ
1,8 Ω 18 Ω 180 Ω 1,8 kΩ 18 kΩ 180 kΩ 1,8 MΩ
2,0 Ω 20 Ω 200 Ω 2,0 kΩ 20 kΩ 200 kΩ 2,0 MΩ
2,2 Ω 22 Ω 220 Ω 2,2 kΩ 22 kΩ 220 kΩ 2,2 MΩ
2,4 Ω 24 Ω 240 Ω 2,4 kΩ 24 kΩ 240 kΩ 2,4 MΩ
2,7 Ω 27 Ω 270 Ω 2,7 kΩ 27 kΩ 270 kΩ 2,7 MΩ
3,0 Ω 30 Ω 300 Ω 3,0 kΩ 30 kΩ 300 kΩ 3,0 MΩ
3,3 Ω 33 Ω 330 Ω 3,3 kΩ 33 kΩ 330 kΩ 3,3 MΩ
3,6 Ω 36 Ω 360 Ω 3,6 kΩ 36 kΩ 360 kΩ 3,6 MΩ
3,9 Ω 39 Ω 390 Ω 3,9 kΩ 39 kΩ 390 kΩ 3,9 MΩ
4,3 Ω 43 Ω 430 Ω 4,3 kΩ 43 kΩ 430 kΩ 4,3 MΩ
4,7 Ω 47 Ω 470 Ω 4,7 kΩ 47 kΩ 470 kΩ 4,7 MΩ
5,1 Ω 51 Ω 510 Ω 5,1 kΩ 51 kΩ 510 kΩ 5,1 MΩ
5,6 Ω 56 Ω 560 Ω 5,6 kΩ 56 kΩ 560 kΩ 5,6 MΩ
6,2 Ω 62 Ω 620 Ω 6,2 kΩ 62 kΩ 620 kΩ 6,2 MΩ
6,8 Ω 68 Ω 680 Ω 6,8 kΩ 68 kΩ 680 kΩ 6,8 MΩ
7,5 Ω 75 Ω 750 Ω 7,5 kΩ 75 kΩ 750 kΩ 7,5 MΩ
8,2 Ω 82 Ω 820 Ω 8,2 kΩ 82 kΩ 820 kΩ 8,2 MΩ
9,1 Ω 91 Ω 910 Ω 9,1 kΩ 91 kΩ 910 kΩ 9,1 MΩ

Tabela 6 – Código de cores para resistores de 4 e 5 faixas

Artur A. Vilares Filho 43

Arduino Básico
Tabela 7 - Tabela com simbologia dos componentes eletrônicos

Nome Símbolo Componente

R R
Resistor
ou

Resistor variável
R R
(Potenciômetro)
ou

R R
Resistor ajustável
(Trimpot)
ou

C
Capacitor

C
Capacitor variável

C
Capacitor ajustável
(Trimmer)

Chave táctil B
(push-button)

Chave alavanca S
simples

Chave alavanca 1 S
polo 2 posições
(comutadora)

D
Diodo

LED
LED

Artur A. Vilares Filho 44

Arduino Básico

Nome Símbolo Componente

Transistor Bipolar
Q Q
de Junção
NPN e PNP
NPN PNP TO-92 TO-220

Q
Transistor CMOS
(canal N)

RL
Relé

Fonte DC E
(Pilhas, baterias etc.)

Dínamo de bicicleta
Gerador DC V

Dínamo

Gerador AC V

TR TR

Transformador
Simples e com CT
ou

Artur A. Vilares Filho 45