ARDUINO BÁSICO

4ª SEMANA
MARCELO ALUISIO SILVA DE OLIVEIRA

1
APRESENTAÇÃO

O Curso de Arduino Básico é um curso em que a plataforma

Arduino será vista para que se possa iniciar os estudos. E, com as
orientações iniciais você poderá criar gosto e desenvolver seus
próprios projetos.

O Arduino Básico seguirá o caminho onde você verá um pouco

da história desta importante plataforma, entenderá onde é
aplicado o Arduino, verá como entram no conjunto a eletrônica e
os sensores e por fim verá alguns projetos básicos.

Nesta fase de aprendizado, ainda, não será tão necessário o

conhecimento profundo de lógica e de eletrônica, mas para
estudos mais aprofundados com o Arduino é necessário um bom
conhecimento destes dois assuntos (Lógica de programação e
eletrônica básica).

A SECTI - Secretaria da Ciência, Tecnologia, Inovação e Educação

Profissional vem com o projeto OportunidadES oferecer diversos

2
cursos de formação, dando novas alternativas de trabalho e
formando o cidadão que procura aperfeiçoar seu conhecimento
melhorando sua vida.

A todos um bom estudo, com novas OportunidadES sempre!

3
INTRODUÇÃO

Nosso curso tem duração de 4 semanas e nesta quarta e última

semana veremos um básico em eletrônica e projetos com o
arduino, são projetos comentados que você poderá replicar,
modificar e aperfeiçoar no simulador e mesmo em sua placa
Arduino serão todos mostrados em vídeo aulas.
Lembre-se de estudar mais para se aprofundar nos
conhecimentos ligados à plataforma Arduino, lógica de
programação, linguagem C / C++ e eletrônica básica são
fundamentais para um avanço dos projetos mais simples para
projetos mais complexos.
Siga nossas orientações nesta fase em que vamos mostrar
projetos básicos comentados de Arduino.
Os esquemas são feitos em um software livre chamado fritzing
mais detalhes podem ser encontrados no material
complementar.

4
Fritzing

O Fritzing é um software livre/open source para ajudar você a

modelar circuitos usando Arduino, Raspberry pi, ou mesmo
somente a matriz de contatos e alguns componentes eletrônicos.
Além de te permitir fazer bem mais rápido do que se desenhasse
no papel e de te dar uma impressão visual bem mais fiel, ele
automaticamente transforma o que você desenha nele num
diagrama elétrico ou, melhor ainda, em um layout de PCB,
permitindo que utilize seu projeto para imprimir parte de circuito
profissionalmente.

Segue um print de uma tela onde se desenha o esquema de um

semáforo para carros e pedestres, saiba que o Fritzing não
programa Arduino, ele cria o esquema para a plataforma e
converte para um produto um esquema, em que se abandona o
Arduino e fazemos um circuito completo com o experimento do
Arduino, com isso podemos afirmar que o Arduino é para

5
estudos e projetos, apesar de muita gente usar como produto
final.

O download do Fritzing é gratuito, se trata de um software livre.

Eletrônica Básica

A eletrônica está fundamentada sobre os conceitos de tensão,

corrente e resistência. Podemos entender como tensão a energia
potencial armazenada em uma pilha ou bateria que fluirá
quando um circuito for fechado entre os polos de maior e menor

6
potencial (sentido convencional). Como analogia podemos
pensar na água armazenada em dois recipientes conectados por
um cano. A água irá fluir do recipiente com maior quantidade de
água para o menor.

Em eletrônica o princípio é o mesmo, por exemplo, os polos

positivos e negativos de uma pilha indicam o sentido na qual a
corrente elétrica fluirá. Desta forma, podemos definir que a
corrente elétrica é a movimentação ordenada de cargas elétricas
num condutor. Para efeito de análise, a corrente elétrica poderá
circular em dois sentidos: a) sentido real, que é resultante do
movimento de cargas negativas ou; b) sentido convencional –
resultante do movimento de cargas positivas.

7
A movimentação das cargas elétricas através do condutor pode
encontrar elementos que oferecem certa resistência a passagem
dessas cargas. Na figura acima, por exemplo, a resistência a
passagem da corrente elétrica faz com que a lâmpada gere calor
no seu filamento e fique incandescente. É esse mesmo efeito
que permite que a água de um chuveiro seja aquecida ao passar
pela resistência.

A Lei de Ohm estabelece a relação entre tensão (V), corrente (I) e

resistência (R), onde:

I=V/R

A tensão é expressa em Volts (V), a corrente em Amperes (A)

enquanto a resistência em Ohms (Ω). Desta forma, considerando
um circuito elétrico no qual temos uma tensão de 5V aplicada

8
sobre uma resistência de 220 Ω irá produzir uma corrente de
0,022A ou 22mA.

Principais Componentes

Um circuito eletrônico é formado por diversos componentes com

finalidades distintas, vamos a seguir aprender a identificar os
mais utilizados.

Os resistores, conforme já explicado acima, tem a função limitar

a corrente elétrica, eles são necessários de modo a evitar que
determinados componentes eletrônicos recebam uma tensão ou
corrente maior do que eles podem suportar evitando, desta
forma, que os mesmos sejam danificados.

9
São componentes não polarizados, ou seja, podem ser instalados
em qualquer sentido no circuito elétrico, sem preocupação com
os polos negativos ou positivos. O valor de um resistor pode ser
determinado através de uma tabela código de cores, conforme
ilustrado abaixo.

Os capacitores são componentes que permitem armazenar

energia para uma utilização rápida.

10
Por exemplo, se compararmos um capacitor com uma pilha
temos que o capacitor pode descarregar toda sua carga em uma
pequena fração de segundo, já a pilha demoraria vários minutos
para descarregar. Uma aplicação típica de capacitores e no flash
de câmera, a pilha (ou bateria) carrega o capacitor por vários
segundos, e então o capacitor descarrega toda a carga
armazenada para que a lâmpada do flash seja acionada
imediatamente. Existem diversos tipos de capacitores sendo
alguns polarizados e outros não, a unidade de medida de um
capacitor é o Farad (F).

11
Um diodo é um componente semicondutor que permite que a
corrente flua em apenas um sentido.

O diodo emissor de luz ou simplesmente LED é uma variação do

diodo e apresenta, como principal característica, a emissão de
luz quando uma corrente flui através do mesmo. É um
componente polarizado, desta forma, o catodo (lado chanfrado)
sempre deve estar conectado ao polo negativo (ou terra) do
circuito, se conectado invertido pode ser danificado.

12
Os transistores são componentes semicondutores e foram os
principais responsáveis pela revolução da eletrônica e da
informática na década de 1960, pois, permitiram substituir as
válvulas nos equipamentos. Um transistor é praticamente cem
vezes menor que uma válvula, não necessita de tempo para
aquecimento, consome menos energia, sendo muito mais rápido
e confiável. Apresenta inúmeras aplicações, sendo as principais,
a atuação como uma “chave” eletrônica e amplificador de sinal.

Um transistor possui três terminais, sendo nomeados como base,

coletor e emissor e para identificá-los devemos ter o modelo
utilizado e consultar as respectivas especificações (datasheet).

13
Os circuitos integrados consistem em transistores e vários outros
componentes eletrônicos miniaturizados e montados num único
chip. A integração em larga escala permite colocar cerca de 1
milhão de transistores por mm² proporcionando um alto nível de
miniaturização dos circuitos eletrônicos além de uma grande
redução de custos.

O protoboard permite a montagem provisória de circuitos

eletrônicos permitindo a reutilização dos componentes, consiste
em uma matriz de contatos interconectados através dos quais os
componentes são interligados.

14
Os pinos dos componentes devem ser conectados sempre em
linhas diferentes, enquanto conexões entre componentes
diferentes ocorrem em uma mesma linha.

O Arduino é uma plataforma de hardware open source,

projetada sobre o micro controlador Atmel AVR, apresenta uma
linguagem de programação similar a C/C++, permitindo a
elaboração de projetos com um conhecimento mínimo (ou
nenhum) de eletrônica. Isso já informamos a você, mas vejamos
apenas mais uma vez seu conceito.

15
Apresenta 13 pinos que podem ser utilizados como entradas ou
saídas digitais (pinos 1 a 13), sendo que os pinos 3, 5, 6, 9, 10 e
11 podem ser utilizados para obter saídas analógicas (Pulse
Width Modulation – PWM). Os pinos A0 a A5 correspondem às
entradas analógicas, enquanto os pinos 3,3V, 5V e GND
permitem alimentar os componentes dos circuitos conectados ao
Arduino.

16
Projetos Arduino

Vamos para alguns projetos comentados que serão vistos na

vídeo aula da semana em simulador, podendo assim serem
atualizados e modificados por você como quiser.

Os projetos podem ser aplicado na plataforma Arduino em seu

kit ou como faremos no simulador, é muito importante que você
experimente diversas combinações com os projetos que vamos
colocar aqui, faça alterações e veja novos resultados.

Com o simulador não há problemas de queima de componentes.

Quando você usa sua placa e seus sensores reais o perigo de
choque ou machucados é mínimo, afinal a voltagem é muito
baixa. Mesmo que componentes queimem, não são tão caros, só
a placa Arduino tem um custo maior (mesmo assim é bem em
conta).

Aproveitando que já passamos o blink, faça o proposto que é

piscar de forma mais lenta o LED, ou seja aumentar o tempo que
fica apagado e o tempo que fica aceso.

17
Faça também com que pisque de forma que fique mais tempo
apagado que aceso.

Faça o inverso mais tempo aceso que apagado.

Faça testes para se familiarizar com o Arduino.

Vejamos outros projetos:

01 - LEITURA DE BOTÕES

INGREDIENTES

● ▪ Botão de pressão

● ▪ Resistor 10kΩ

● ▪ 1 Resistor 470 Ω

● ▪ 1 LED 5mm

● ▪ Fios Jumper’s

● ▪ Protoboard

18
 ● ▪ Arduino Uno ou outro

MISTURANDO OS INGREDIENTES

Agora vamos conectar os componentes do projeto. Para isso

monte seu circuito conforme a figura a seguir.

Garanta que seu Arduino esteja desligado durante a montagem,

e que o seu LED esteja conectado corretamente, com a perna
mais longa (Anodo) conectado ao resistor e a perna menor
(catodo) ao GND.

LEVANDO AO FORNO

Conecte seu Arduino ao computador e abra a IDE Arduino. No

menu Tools, certifique que a porta serial (serial port) está

19
selecionada e se a placa configurada é a que você está usando
(board).

PREPARANDO A COBERTURA

Agora temos que dar vida ao Arduino. Para isso, dentro da IDE
Arduino: abra o menu File > Examples > 01. Basics > Button.

Uma nova janela deve ser aberta com o programa conforme é

apresentado a seguir. Clique em Upload para que o programa
seja transferido para seu Arduino.

/*
Button

Utiliza um botão de pressão, conectado ao pino 2, para ligar e

desligar um LED conectado ao pino digital 13.

*/

// Determinamos constantes para os números dos pinos utilizados

const int buttonPin = 2; // Número do pino do botão de pressão
const int ledPin = 13; // Número do pino do led

// Variáveis
int buttonState = 0; // Variável para leitura do estado do botão

// Executa uma vez ao ligar ou reiniciar a placa

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

20
 pinMode(buttonPin, INPUT); // Inicializa o pin do botão como entrada (INPUT)
}

// Executa infinitamente quando liga a placa

void loop() {
// Lê o estado do botão (HIGH -> +5V -> botão press.) (LOW -> 0V)
buttonState = digitalRead(buttonPin);

// Testa se o botão está pressionado

// Se sim, o estado do botão e alto (HIGH)
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH); // Liga o LED
}
// Senão (Botão não pressionado)
else {
digitalWrite(ledPin, LOW); // Desliga o LED
}
}

O código está todo comentado para que você possa entender

como funciona.

EXPERIMENTANDO O PRATO

Caso tenha ocorrido tudo como esperado, quando você apertar o

LED da protoboard caso tenha optado por manter o LED da
experiência blink. Quando você soltar o botão, o LED apagará.

21
ENTENDENDO O PROGRAMA

Boa parte desse programa é semelhante ao usado na experiência

blink. Focaremos, agora, na parte não apresentada
anteriormente.

▪ Constantes

Quando definimos uma variável que não irá mudar ao longo da

execução do programa, definimos ela como uma constante.

Um exemplo de variável constante é o número dos pinos do

Arduino que usaremos, já que eles não mudarão ao longo do
programa.

// Determinamos constantes para os números dos pinos utilizados

const int buttonPin = 2; // Número do pino do botão de pressão
const int ledPin = 13; // Número do pino do led

▪ Comando pinMode

Na função setup podemos encontrar o comando pinMode. Como

já dito na experiência 1, esse comando é muito importante no
uso das entradas e saídas digitais do Arduino. Ele é responsável

22
por definir se um pino é uma entrada (INPUT) ou uma saída
(OUTPUT).

void setup() {
pinMode(ledPin, OUTPUT); //Inicializa o pino do LED como saída (OUTPUT)
pinMode(buttonPin, INPUT); // Inicializa o pin do botão como entrada (INPUT)

Na primeira linha da função setup de nosso exemplo, temos o

pino 13, definido pela constante ledpin, sendo configurado como
saída digital.

pinMode(ledPin, OUTPUT); //Inicializa o pino do LED como saída (OUTPUT)

Na segunda linha temos o pino 2, definido pela constante button

Pin, sendo configurado como uma entrada digital.

pinMode(buttonPin, INPUT); // Inicializa o pin do botão como entrada (INPUT)

▪ Comando digitalRead

23
Na função Loop temos o programa que rodará ciclicamente em
nosso Arduino. Como desejamos acender um LED a partir de um
botão, primeiramente devemos ler o seu estado. Para isso,
usamos o comando digitalRead, que retorna o valor de estado de
uma entrada digital passada como parâmetro.

Nesse comando, caso a tensão na entrada digital seja 5V, ele

retornará 1, caso seja 0V, retornará 0.

Para usar esse resultado devemos armazená-lo em algum lugar,

nada melhor que uma variável para isso. No exemplo,
armazenaremos o valor do botão na variável buttonState.

No nosso caso, quando o botão estiver pressionado, teremos 5V

na porta 2, ou seja, 1 na variável buttonState.

// Comando que lê o estado do botão (HIGH -> +5V -> botão press.) (LOW -> 0V)
buttonState = digitalRead(buttonPin);

▪ Bloco IF

Ao resolver um problema, constantemente teremos que tomar

decisões lógicas a partir dos resultados coletados.

24
Vamos voltar à receita do bolo. Caso esse bolo seja para uma
festa de aniversário, é interessante que se faça uma cobertura,
caso contrário, podemos deixar o bolo sem cobertura. Veja como
ficaria o algoritmo para essa situação:

Função bolo(){
Faça o bolo;
Se o bolo é de aniversário {
Faça uma cobertura;
}Senão
Não faça uma cobertura
}
fim
Veja que usamos um parâmetro para decidir se iremos ou não
executar uma atividade. Veja o fluxograma a seguir.
Dessa forma, em nosso exemplo, caso buttonState seja igual a 1
(botão pressionado), devemos acender o LED, caso contrário,
devemos apagá-lo.
No programa fica assim:

// Testa se o botão está pressionado

// Se sim, o estado do botão e alto (HIGH)
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH); // Liga o LED
}
// Senão (Botão não pressionado)
else {
digitalWrite(ledPin, LOW); // Desliga o LED
}

Operadores Lógicos

25
Para usar blocos lógicos, tal como o bloco IF, usaremos
operadores lógicos. Os operadores lógicos, junto aos
parâmetros, são responsáveis por criar as condições de execução
de um bloco lógico.
Voltando ao bolo, caso você não tenha leite condensado, será
inviável fazer uma cobertura de brigadeiro.
Dessa forma, o número de latas de leite condensado disponíveis
deve ser maior ou igual a 1 latas para que seja viável fazer essa
cobertura.

A condição maior ou igual é um operador lógico, veja os possíveis

operadores lógicos na tabela a seguir.

02 - LENDO UMA ENTRADA ANALÓGICA

Os projetos agora ficam mais diretos, as explicações ainda são

detalhadas, mas não serão todos assim. Pense que várias destas
explicações já atualizam os próximos conteúdos.

26
INGREDIENTES
● Potenciômetro linear 10k Ω
● Fios jumper’s
● Protoboard
MISTURANDO OS INGREDIENTES

Agora vamos conectar os componentes do projeto. Para isso,

monte seu circuito conforme a figura a seguir e garanta que seu
Arduino esteja desligado durante a montagem.

LEVANDO AO FORNO

Conecte seu Arduino ao computador e abra a IDE Arduino. No

menu Tools, certifique de que a porta serial (serial port) está
selecionada e que a placa configurada é a que você está usando
(board).

27
PREPARANDO A COBERTURA

Agora vamos à implementação do programa. Nesse algoritmo

iremos fazer diferente. Você terá que escrever o programa tal
como escrito abaixo, isso é fundamental para que você acostume
com a linguagem e a estrutura da programação do Arduino.

Para isso, dentro da IDE Arduino: abra o menu File > New ou
aperte “ctrl+N”. Uma nova janela, em branco deve ser aberta.

Agora devemos dar um nome ao nosso sketch (esse é o nome

dado aos programas no Arduino), mas podemos chamar de
arquivo de programa ou código. Dessa forma, dentro da IDE
Arduino: Abra o menu File e clique em Save. Uma nova janela
será aberta onde você escolherá onde salvar seu programa e
qual será seu nome. Para facilitar a identificação, dê o nome de
“programa_entrada_anologica”.

Com o seu programa salvo, escreva nele o código conforme

descrito abaixo.

// Esta função "setup" roda uma vez quando a placa e ligada ou resetada

28
unsigned int valorLido;
void setup() {
Serial.begin(9600); //Inicia porta serial e define a velocidade de transmissão
}
// Função que se repete infinitamente quando a placa é ligada
void loop() {
valorLido = analogRead(A0);
Serial.println(valorLido);
delay(1000); // Espera um segundo
}

Depois de escrever o código, clique em Upload para que o

programa seja transferido para seu Arduino.

EXPERIMENTANDO O PRATO

Para essa experiência, você terá que abrir o serial Monitor que
será melhor explicado mais à frente. Para isso, o serial monitor
pode ser aberto pelo ícone mostrado na figura a seguir.

29
Caso tenha ocorrido tudo como esperado, conforme você varie a
resistência do potenciômetro, girando seu eixo, aparecerá no
serial monitor um valor de 0 a 1023.

ENTENDENDO O HARDWARE

Potenciômetro e trimpot

Potenciômetros e trimpot são resistores variáveis e ajustáveis, e

por isso são usados para controle analógico de funcionalidades
de alguns aparelhos eletrônicos, tal como o volume de um
aparelho de som.

Eles costumam possuir três pernas. Dois são ligados às

extremidades da resistência (A e B) e a terceira a um cursor que
anda de ponta a ponta da resistência (C). Dessa forma, podemos
usar o resistor entre A e C ou B e C.

Divisor de tensão

Quando temos n resistência associadas em série temos o nome

de divisor de tensão. Em um circuito divisor de tensão, temos
uma queda de tensão em cada resistência igual ao produto da
resistência com a corrente do circuito.

30
Como a corrente do circuito é calculada pela divisão da tensão
em cima de todos os resistores dividido pela soma dos resistores,
teremos a tensão em cima de um resistor igual a resistência
desse resistor vezes a tensão total dividida pela soma dos
resistores.

O exemplo a seguir mostra como funciona o cálculo o para dois

resistores.

Quando usamos um potenciômetro, podemos usar a

propriedade do divisor de tensão. Sabemos que a tensão total e
a resistência total são fixas. Dessa forma, o divisor de tensão vai
variar com a resistência A0 e GND.

ENTENDENDO O PROGRAMA

Lendo da entrada analógica

31
A leitura da entrada analógica é feita com a função analogRead,
que recebe como parâmetro o pino analógico a ser lido e retorna
o valor digital que representa a tensão no pino. Como o
conversor analógico-digital do Arduino possui uma resolução de
10 bits, o intervalo de tensão de referência, que no nosso caso é
5 V, será dividido em 1024 pedaços (2^10) e o valor retornado
pela função será o valor discreto mais próximo da tensão no
pino.
unsigned int valorLido = analogRead(A0);

O código acima lê o valor analógico de tensão no pino A0 e

guarda o valor digital na variável valor Lido. Supondo que o pino
está com uma tensão de 2V, o valor retornado pela conversão
será:

2 x 1024 / 5 = 409,6

O resultado deve ser inteiro para que nosso conversor consiga

representá-lo, logo o valor 410 será escolhido por ser o degrau
mais próximo. Esse valor representa a tensão 2,001953125,

32
inserindo um erro de 0,001953125 em nossa medida devido a
limitação de nossa resolução.

O uso do comando unsigned na declaração da variável informa

que usaremos apenas números positivos para essa variável.

Comunicação serial

A comunicação serial é amplamente utilizada para comunicar o

Arduino com outros dispositivos como módulos ZigBee,
Bluetooth, entre outros. A comunicação com o computador é
possível através do conversor serial USB presente nas placas. A
biblioteca padrão do Arduino possui algumas funcionalidades
para a comunicação serial de modo a facilitar a utilização desta
função.

▪ Serial Monitor

A possibilidade de visualizar na tela do computador os dados

coletados e processados pelo Arduino é fundamental, visto que é
um forma rápida e prática de visualizar esses dados. Para isso,
usamos o Serial Monitor.

33
O Serial Monitor disponibiliza uma interface gráfica que facilita a
comunicação entre o Arduino e um computador. Após
selecionarmos a porta serial adequada, o serial monitor pode ser
aberto pelo ícone no canto superior direito da janela, onde é
representado por uma lupa.
Serial.begin(9600); //Inicia porta serial e define a velocidade de transmissão

▪ Enviando Dados

Na maioria das vezes, o envio de dados pela porta serial pode ser
feito através das funções print e println. A função print imprime
os dados na serial utilizando o código ASCII. Essa função recebe
dois parâmetros e retorna à quantidade de bytes que foram
escritos.
Serial.print(var); // Imprime a variável var
Serial.print(“olá”);// Imprime o texto olá
O parâmetro “var” recebe o valor a ser impresso. A função é
sobrecarregada de modo a ser capaz de receber qualquer tipo
padrão (char, int, long, float etc).

34
Quando o texto estiver entre aspas, isso simboliza que você
deseja imprimir um texto. Caso contrário, você deseja imprimir
uma variável.

A função println imprime o valor desejado semelhantemente a

função print, porém imprime na sequência os caracteres ‘\r’ e
‘\n’ de modo que crie uma nova linha.

03 - USANDO A SAÍDA PWM

Para escrever um sinal na saída PWM utiliza-se a função

analogWrite, que recebe como parâmetros o pino PWM e o valor
do duty cycle, respectivamente. Esse último parâmetro é
guardado em 8 bits, de modo que esse valor deve estar entre 0
(0% de duty cycle) e 255 (100% de duty cycle).
analogWrite(9,127);//Escreve no pino 9 um sinal PWM com 50% de duty cycle
//(50% de 255=127)
analogWrite(10,64);//Escreve no pino 10 um sinal PWM com 25% de duty cycle
//(25% de 255=64)
Variando o duty cycle altera-se também o valor médio da onda,
de modo que o efeito prático obtido com o PWM em algumas
aplicações é um sinal com amplitude constante e de valor igual

35
ao valor médio da onda. Isso permite que se possa, por exemplo,
controlar a intensidade do brilho de um LED, ou a velocidade de
um motor de corrente contínua.

LED COM CONTROLE DE INTENSIDADE

INGREDIENTES

● Potenciômetro linear 10k Ω

● LED 5mm
● Resistor 470Ω
● Fios jumper’s
● Protoboard
● Arduino Uno ou outro
MISTURANDO OS INGREDIENTES

Agora vamos conectar os componentes do projeto.

Para isso, monte seu circuito conforme a figura a seguir.

36
Garanta que seu Arduino esteja desligado durante a montagem e
que o seu LED esteja conectado corretamente, com a perna mais
longa (Anodo) conectado ao resistor e a perna menor (catodo)
ao GND.

LEVANDO AO FORNO

Conecte seu Arduino ao computador e abra a IDE Arduino. No

menu Tools, certifique que a porta serial (serial port) está
selecionada e se a placa configurada é a que você está usando
(board).

37
PREPARANDO A COBERTURA

Crie um programa (sketch) e salve com o nome de

“programa_pwm”. Com o seu programa salvo, escreva nele o
código conforme descrito abaixo.
// Daremos um nome ao pino que está conectado o LED
int led = 11;
unsigned int valorLido;
unsigned int pwm;
// Esta função "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
pinMode(led, OUTPUT); // Configura o pino do led (digital) como saída
}
// Função que se repete infinitamente quando a placa é ligada
void loop() {
valorLido = analogRead(A0); // valor entre 0 e 1024
pwm = map(valorLido, 0, 1023, 0, 255); // Mudança de escala
analogWrite(led,pwm);//Escreve no led um sinal PWM proporcional ao valorLido
}
Depois de escrever o código, clique em Upload para que o
programa seja transferido para seu Arduino.

EXPERIMENTANDO O PRATO

Se tudo der certo, conforme girarmos o potenciômetro, a

intensidade de luz emitida pelo LED diminuirá ou aumentará.

ENTENDENDO O PROGRAMA

38
Como já explicado no início do capítulo, o PWM pode ser usado
para simular uma saída analógica. Variando um sinal de saída de
PWM de 0 a 255, estamos variando o Duty Cycle, que por sua
vez, resulta numa saída de 0V a 5V.

Como a intensidade de luz no LED está diretamente ligada à

quantidade de corrente que passa por ele e essa corrente é
proporcional a tensão do resistor em série com o LED, conforme
variamos a tensão do pino 11 através do PWM, alteramos a
intensidade de luz emitida pelo LED.
valorLido = analogRead(A0); // valor entre 0 e 1024

Para variarmos o PWM, usamos o valor analógico lido no

potenciômetro e armazenamos na variável valor Lido, que
armazena valores entre 0 e 1023. Porém, para que seja possível
usar essa variável para controlar o PWM, devemos mudar sua
escala para 0 a 255. Para isso usaremos a função. Tal função
recebe uma variável e muda sua escala.
pwm = map(valorLido, 0, 1023, 0, 255); // Mudança de escala

39
Depois de mudarmos de escala, basta escrevermos o valor de
PWM na saída do LED.
analogWrite(led,pwm);//Escreve no led um sinal PWM proporcional ao valorLido

04 - SEMÁFORO

Agora a partir deste projeto vamos ser mais diretos, lembre-se

de que vamos ver nos vídeos no simulado de como fazer cada
um dos projetos. Neste projeto, você criará um semáforo que irá
do verde ao vermelho, passando pelo amarelo, e que retornará
depois de um intervalo de tempo, utilizando o sistema de quatro
estados do Reino Unido. Este projeto poderia ser utilizado para
criar um conjunto funcional de semáforos para uma maquete de
ferrovia ou para uma pequena cidade de brinquedo. Caso você
não seja do Reino Unido, pode modificar o código e as cores de
acordo com os sinais de seu país. Primeiro, entretanto, crie o
projeto como instruído, e faça as alterações apenas depois de
saber como tudo funciona.

40
Componentes necessários

● Protoboard

● LED vermelho difuso

● LED amarelo difuso

● LED verde difuso

● 3 resistores de 150 ohms

Escolha o valor de resistor apropriado para os LEDs utilizados em

seu projeto. O resistor de 150 Ω é para o botão; ele é conhecido
como um resistor pull-down (que será definido posteriormente).
O botão é às vezes chamado pelos fornecedores de interruptor
tátil, e é perfeito para ser utilizado com a protoboard.

Conectando os componentes

Conecte seu circuito como mostra a figura abaixo. Verifique

cuidadosamente a fiação antes de ligar seu Arduino. Lembre-se
de que o Arduino deve estar desconectado da força enquanto
você conecta o circuito.

41
Digite o código

Digite o código da listagem 2.3, verifique-o, e faça o upload para

seu Arduino. Os LEDs, agora, atravessarão quatro estados que
simulam o sistema de semáforos do Reino Unido. Caso você
tenha acompanhado os projetos anteriores, tanto o código
quanto o hardware do projeto atual devem ser evidentes.
Deixarei que você analise o código e descubra como ele
funciona.

42
Código
// Semáforo
int ledDelay = 10000; // espera entre as alterações
int redPin = 10;
int yellowPin = 9;
int greenPin = 8;
void setup() {
pinMode(redPin, OUTPUT);
pinMode(yellowPin, OUTPUT);
pinMode(greenPin, OUTPUT);
}
void loop() {
digitalWrite(redPin, HIGH); // acende a luz vermelha
delay(ledDelay); // espera 5 segundos
digitalWrite(yellowPin, HIGH); // acende a luz amarela
delay(2000); // espera 2 segundos
digitalWrite(greenPin, HIGH); // acende a luz verde
digitalWrite(redPin, LOW); // apaga a luz vermelha
digitalWrite(yellowPin, LOW); // apaga a luz amarela
delay(ledDelay); // espera ledDelay milissegundos
digitalWrite(yellowPin, HIGH); // acende a luz amarela
digitalWrite(greenPin, LOW); // apaga a luz verde
delay(2000); // espera 2 segundos
digitalWrite(yellowPin, LOW); // apaga a luz amarela
// agora nosso loop se repete
}

05 - SEMÁFORO INTERATIVO

Dessa vez, você estenderá o projeto anterior para incluir um

farol de pedestre e um botão, que será pressionado pelos
pedestres para solicitar a travessia da rua. O Arduino reagirá

43
quando o botão for pressionado, alterando o estado das luzes
para que os carros parem e os pedestres possam atravessar em
segurança.

Neste projeto, você também aprenderá como criar suas próprias

funções dentro do código. Daqui em diante, não listarei mais a
protoboard, nem os fios jumper, na lista de componentes
necessários. Note que você sempre terá de utilizá-los.

Componentes necessários

● 2 LEDs vermelhos difusos

● LED amarelo difuso

● 2 LEDs verdes difusos

● Resistor de 150 ohms

● 4 resistores

● Botão

Escolha o valor de resistor apropriado para os LEDs utilizados em

seu projeto. O resistor de 150 Ω é para o botão; ele é conhecido
como um resistor pull-down (que será definido posteriormente).

44
O botão é às vezes chamado pelos fornecedores de interruptor
tátil, e é perfeito para ser utilizado com a protoboard.

Conectando os componentes

Conecte seu circuito como mostra a figura abaixo. Verifique

cuidadosamente a fiação antes de ligar seu Arduino. Lembre-se
de que o Arduino deve estar desconectado da força enquanto
você conecta o circuito.

Digite o código

45
Digite o código abaixo, verifique-o e faça seu upload. Quando
você executar o programa, ele iniciará com o semáforo no verde,
para permitir que os carros passem, e a luz para pedestres no
vermelho.

Quando você pressionar o botão, o programa verificará se, ao

menos, cinco segundos transcorreram desde a última vez em que
o semáforo mudou (para permitir que o trânsito flua) e, se
afirmativo, executará o código para a função que você criou,
changeLights(). Nessa função, o semáforo vai de verde para
amarelo e depois para vermelho, e o semáforo para pedestres
vai para verde. Depois de um intervalo de tempo definido na
variável crossTime (tempo suficiente para que os pedestres
atravessem), a luz verde para pedestres pisca, acendendo e
apagando, para avisar aos pedestres que atravessem
rapidamente antes que o semáforo feche. Então, a luz vermelha
do semáforo para pedestres acende, e a luz para os veículos vai
de vermelho para amarelo, e finalmente para verde, permitindo
novamente o fluxo do tráfego.
// Semáforo interativo

46
int carRed = 12; // estabelece o semáforo para carros
int carYellow = 11;
int carGreen = 10;
int pedRed = 9; // estabelece o semáforo para pedestres
int pedGreen = 8;
int button = 2; // pino do botão
int crossTime = 5000; // tempo para que os pedestres atravessem
unsigned long changeTime; // tempo desde que o botão foi pressionado
void setup() {
pinMode(carRed, OUTPUT);
pinMode(carYellow, OUTPUT);
pinMode(carGreen, OUTPUT);
pinMode(pedRed, OUTPUT);
pinMode(pedGreen, OUTPUT);
pinMode(button, INPUT); // botão no pino 2
// acende a luz verde
digitalWrite(carGreen, HIGH);
digitalWrite(pedRed, HIGH);
}
void loop() {
int state = digitalRead(button);
/* verifica se o botão foi pressionado e se transcorreram 5 segundos desde a última
vez que isso ocorreu */
if (state == HIGH && (millis() - changeTime) > 5000) {

// Chama a função para alterar as luzes

changeLights();
}
}
void changeLights() {
digitalWrite(carGreen, LOW); // apaga o verde
digitalWrite(carYellow, HIGH); // acende o amarelo
delay(2000); // espera 2 segundos
digitalWrite(carYellow, LOW); // apaga o amarelo
digitalWrite(carRed, HIGH); // acende o vermelho
delay(1000); // espera 1 segundo, por segurança
digitalWrite(pedRed, LOW); // apaga o vermelho dos pedestres

47
 digitalWrite(pedGreen, HIGH); // acende o verde dos pedestres
delay(crossTime); // espera por um intervalo de tempo predefinido
// pisca o verde dos pedestres
for (int x=0; x<10; x++) {
digitalWrite(pedGreen, HIGH);
delay(250);
digitalWrite(pedGreen, LOW);
delay(250);
}
// acende o vermelho dos pedestres
digitalWrite(pedRed, HIGH);
delay(500);
digitalWrite(carYellow, HIGH); // acende o amarelo
digitalWrite(carRed, LOW); // apaga o vermelho
delay(1000);
digitalWrite(carGreen, HIGH); // acende o verde
digitalWrite(carYellow, LOW); // apaga o amarelo
// registra o tempo desde a última alteração no semáforo
changeTime = millis();
// depois retorna para o loop principal do programa
}
Análise do código

Com base nos projetos anteriores, você já deve compreender e

reconhecer a maioria do código deste projeto. Destacarei apenas
as novas palavras-chave e conceitos.
unsigned long changeTime;

Aqui temos um novo tipo de dados para uma variável.

Anteriormente, você criou tipos de dados inteiros, capazes de
armazenar um número entre -32.768 e 32.767. Dessa vez, você

48
criou um tipo de dado long, que pode armazenar um número
entre -2.137.483.648 e 2.147.483.647. Entretanto, você
especificou um unsigned long, o que significa que a variável não
pode armazenar números negativos, assim o intervalo vai de 0 a
4.294.967.295. Se você estivesse utilizando um inteiro para
armazenar o intervalo de tempo desde a última troca no
semáforo, teria um tempo máximo de apenas 32 segundos,
antes que a variável atingisse um número maior do que o valor
que ela pode armazenar.

Como é improvável que um pedestre sempre atravesse a cada 32

segundos, você não quer que o programa deixe de funcionar
quando sua variável “transbordar” ao tentar armazenar um
número grande demais para seu tipo de dados. Assim, você
utiliza um tipo de dados unsigned long para obter um grande
intervalo de tempo entre pressionamentos de botão:

• 4.294.967.295 milissegundos = 4.294.967 segundos

• 4.294.967 segundos = 71.582 minutos

• 71.582 minutos = 1.193 horas

49
 • 1.193 horas = 49 dias

É praticamente inevitável que o botão para o semáforo de

pedestres seja pressionado ao menos uma vez a cada 49 dias,
por isso você não deve ter problemas com esse tipo de dado.

Então, por que não há apenas um único tipo de dados, capaz de

sempre armazenar números enormes? Bem, porque variáveis
ocupam espaço na memória; quanto maior o número, mais
memória será utilizada para armazenar as variáveis. Em seu PC
ou laptop, você não terá de se preocupar muito com isso, mas
em um pequeno microcontrolador, como o Atmega32 do
Arduino, é essencial que você utilize apenas o menor tipo de
dado de variável disponível para seu propósito.

A tabela abaixo lista os vários tipos de dados que você pode

utilizar em seus sketches. Lembrando-se de que já vimos estas
variáveis antes.

50
Cada tipo de dado utiliza determinada quantidade de memória:
algumas variáveis utilizam apenas 1 byte de memória, enquanto
outras, 4 bytes ou mais (não se preocupe em saber o que é um
byte por enquanto; discutiremos isso futuramente). Note que
você não pode copiar dados de um tipo de dados para outro. Em
outras palavras, se x for um int e y uma string, x = y não dará
certo, pois os tipos de dados são diferentes.

O Atmega168 tem 1 kB (1.000 bytes) e o Atmega328, 2 kB (2.000

bytes) de SRAM; isso não é muita memória. Em programas de
tamanho considerável, com muitas variáveis, você poderá
facilmente ficar sem memória se não empregar os tipos de dados

51
corretos. Como você utilizou int (que usa até 2 bytes, e pode
armazenar um número de até 32.767) para armazenar o número
de seu pino, que poderia ser no máximo 13 em seu Arduino (e 54
no Arduino Mega), acabou consumindo mais memória do que o
necessário. Poderíamos ter economizado memória utilizando o
tipo de dados byte, que pode armazenar um número entre 0 e
255 — intervalo mais do que suficiente para armazenar o
número de um pino de entrada/saída.

Em seguida, temos
pinMode(button, INPUT);

Isso diz ao Arduino que você deseja utilizar o pino digital 2

(button = 2) como INPUT. Você utilizará o pino digital 2 para
escutar quando o botão é pressionado, por isso seu modo deve
ser definido como entrada.

No loop principal do programa, você verifica o estado do pino 2

com esta instrução:
int state = digitalRead(button);
Isso inicializa um inteiro (sim, é um desperdício, e seria melhor
utilizar um booleano), state, e então define seu valor como o

52
valor do pino digital 2. A instrução digitalRead lê o estado do
pino dentro dos parênteses, retornando esse estado para o valor
inteiro ao qual você o atribuiu. Depois, você pode verificar o
valor em state para ver se o botão foi ou não pressionado:
if (state == HIGH && (millis() - changeTime) > 5000) {
// Chama a função para alterar as luzes
changeLights();
}
A instrução if é um exemplo de uma estrutura de controle, cujo
propósito é verificar se determinada condição foi ou não
atingida. Caso a condição seja verdadeira, a instrução executa o
código dentro de seu bloco de código. Por exemplo, se você
quisesse acender um LED, caso uma variável x atingisse um valor
superior a 500, poderia escrever o seguinte:
if (x>500) {digitalWrite(ledPin, HIGH);

Quando você lê um pino utilizando o comando digitalRead, o

estado do pino será HIGH ou LOW. Assim, o comando if em seu
sketch tem a seguinte apresentação:
if (state == HIGH && (millis() - changeTime) > 5000)

Aqui, verificamos se duas condições foram atingidas. A primeira

é a de que a variável state seja HIGH. Se o botão foi pressionado,

53
state será HIGH, pois você já definiu este como o valor a ser lido
do pino digital 2. Você também está conferindo se o valor de
millis() - changeTime é maior que 5000 (utilizando o comando
lógico E, &&). millis() é uma função integrada à linguagem do
Arduino, que retorna o número de milissegundos desde que o
Arduino iniciou a execução do programa atual. Sua variável
changeTime inicialmente não armazenará nenhum valor, mas
depois que a função changeLights() tiver sido executada,
changeTime será definida como o valor atual de millis().

Subtraindo o valor na variável changeTime do valor atual de

millis(), você pode verificar se transcorreram cinco segundos
desde que changeTime foi definida pela última vez. O cálculo de
millis() - changeTime é colocado dentro de seus próprios
parênteses, para garantir que você compare o valor de state ao
resultado dessa operação, e não ao valor de millis() por si só.

O símbolo && que vemos entre:

state == HIGH

54
e o cálculo é um exemplo de um operador booleano. Nesse caso,
ele significa E. Para entender o que isso quer dizer, vamos
analisar todos os operadores booleanos:

• && E lógico

• || OU lógico;

• ! NÃO

Note que essas são instruções lógicas, podendo ser utilizadas

para testar diversas condições em instruções if.

&& é verdadeiro apenas se ambos os operandos forem

verdadeiros, assim, a instrução if a seguir executará seu código
apenas se x for 5, e y for 10:
if (x==5 && y==10) {....

|| é verdadeiro se um ou mais operandos forem verdadeiros;

por exemplo, a instrução if a seguir será executada se x for 5 ou
se y for 10:
if (x==5 || y==10) {.....

55
A instrução ! (NÃO) é verdadeira apenas se o operando for falso;
assim, a instrução if a seguir será executada se x for falso, ou
seja, igual a zero:
if (!x) {.......

Você também pode aninhar condições entre parênteses, por

exemplo:
if (x==5 && (y==10 || z==25)) {.......

Nesse caso, as condições dentro dos parênteses são processadas

separadamente, e tratadas como uma única condição. Depois,
são comparadas com a condição fora dos parênteses. Assim, se
você esboçar uma simples tabela-verdade abaixo para essa
instrução, poderá ver como isso funciona.

O comando dentro da instrução if é:

changeLights();

56
Esse é um exemplo de uma chamada de função. Uma função é
simplesmente um bloco de código separado que recebeu um
nome. Entretanto, funções também podem receber parâmetros
e/ou retornar dados. Nesse caso, você não passou nenhum dado
à função, nem fez com que ela retornasse dados.

Quando changeLights( ) é chamada, a execução do código pula

da linha atual para a função, executa o código dentro dela, e
depois retorna ao ponto no código, logo depois da chamada à
função.

Nesse caso, se as condições da instrução if forem atendidas, o

programa executará o código dentro da função e retornará para
a linha seguinte, depois de changeLights(), na instrução if.

O código dentro da função simplesmente altera o semáforo dos

veículos para vermelho, passando pelo amarelo, e então acende
a luz verde para pedestres. Depois de um intervalo de tempo
definido pela variável crossTime, a luz dos pedestres pisca
algumas vezes para alertar que o tempo está se esgotando, e
então passa para o vermelho. Enquanto isso, o semáforo dos

57
veículos muda de vermelho para verde, passando pelo amarelo e
retornando, dessa forma, ao seu estado normal.

O loop principal do programa verifica continuamente se o botão

para pedestres foi ou não pressionado. Se isso ocorrer e (&&) o
tempo desde a última alteração do semáforo for maior que 5
segundos, o loop chamará novamente a função changeLights().

Nesse programa, não houve nenhum benefício em colocar o

código dentro de suas próprias funções, além de conseguir uma
melhor apresentação e facilitar a explicação do conceito das
funções. É apenas quando uma função recebe parâmetros e/ou
retorna dados que seus verdadeiros benefícios vêm à tona; você
verá isso quando utilizar funções novamente.

Análise do hardware

O novo componente de hardware apresentado no projeto é o

botão, ou interruptor tátil. Como você pode ver, ao analisar o
circuito, o botão não está diretamente conectado entre a linha
de alimentação e o pino de entrada; há um resistor entre o botão
e o barramento do terra. Isso é o que chamamos de um resistor

58
pull-down, elemento essencial para garantir que botões
funcionem corretamente. Farei uma breve pausa para explicar
resistores pull-up e pull-down.

Estados lógicos

Um circuito lógico é um circuito projetado para emitir uma saída

de ligado ou desligado, representada pelos números binários 1 e
0, respectivamente. O estado desligado (ou zero) é representado
por uma voltagem próxima a zero volt na saída; um estado de
ligado (ou 1) é representado por um nível mais alto, próximo à
tensão de alimentação.

A representação mais simples de um circuito lógico é um

interruptor.

Quando um interruptor está aberto, nenhuma corrente pode

atravessá-lo e nenhuma voltagem pode ser medida na saída.
Quando você fecha o interruptor, a corrente pode fluir e uma
voltagem pode ser medida na saída. O estado aberto pode ser

59
imaginado como 0 e o estado fechado como 1, em um circuito
lógico.

Em um circuito lógico, se a voltagem esperada para representar

o estado ligado (ou 1) é de 5 V, é importante que, quando a saída
do circuito for 1, a voltagem esteja o mais próximo possível
desse valor. Se você não garantir que os estados estejam
próximos das voltagens necessárias, essa parte do circuito pode
ser considerada como flutuante (não representativa de um
estado alto ou baixo). Esse estado também é conhecido como
ruído elétrico, e ruído em um circuito digital pode ser
interpretado como valores aleatórios de 1 e 0.

É aqui que resistores pull-up e pull-down podem ser utilizados

para garantir que o estado seja alto ou baixo. Se você deixar que
esse nó no circuito flutue, ele poderá ser interpretado
aleatoriamente como 0 ou como 1, o que não é desejável. É
preferível forçá-lo para o estado desejado.

Resistores pull-down

60
A figura abaixo mostra um esquema em que um resistor pull-
down é utilizado.

Se o botão for pressionado, a eletricidade tomará o caminho de

menor resistência, e fluirá entre os 5 V e o pino de entrada (há
um resistor de 100 Ω no pino de entrada e um resistor de 10 kΩ
no terra). Entretanto, quando o botão não é pressionado, a
entrada está conectada ao resistor de 100 kΩ e é direcionada
para o terra. Sem isso, o pino de entrada ficaria conectado a
nada quando o botão não estivesse pressionado, e flutuaria
entre 0 V e 5 V. Nesse circuito, a entrada sempre será
direcionada para o terra, ou zero

61
volt, quando o botão não estiver pressionado, e para 5 V quanto
ele estiver pressionado. Em outras palavras, com isso você
impede que o pino flutue entre dois valores.

Resistores pull-up

Nesse circuito você trocou as posições do resistor pull-down e do

interruptor. O resistor agora se torna um resistor pull-up. Como
você pode ver, quando o botão não estiver pressionado, o pino
de entrada será ligado aos 5 V, e estará sempre alto.

Quando o botão for pressionado, o caminho de menor

resistência será em direção ao terra, por isso o pino será ligado
ao terra, ou o estado baixo. Sem o resistor entre os 5 V e o terra,
isso seria um curto-circuito, o que danificaria seu circuito ou sua

62
fonte de alimentação. Graças ao resistor, não temos mais um
curto-circuito, pois o resistor limita a quantidade de corrente. O
resistor pull-up é mais comumente utilizado em circuitos digitais.

Utilizando resistores pull-up e pull-down simples, você pode

garantir que o estado de um pino de entrada seja sempre alto ou
baixo, dependendo de sua aplicação.

Neste projeto, você utiliza um resistor pull-down para garantir

que o botão seja corretamente registrado pelo Arduino. Vamos
analisar novamente o resistor pull-down desse circuito.

Esse circuito contém um botão. Um pino do botão está

conectado diretamente aos 5 V, e outro diretamente ao pino
digital 2. Ele também está conectado diretamente ao terra, por
meio de um resistor pull-down. Isso significa que quando o botão
não está pressionado, o pino é ligado ao terra e, portanto, lê um
estado zero, ou baixo.

Quando o botão é pressionado, 5 volts fluem para o pino, e ele é

lido como um estado 1, ou alto. Detectando se a entrada é alta
ou baixa, você pode detectar se o botão está ou não

63
pressionado. Se o resistor não estivesse presente, o fio do pino
de entrada não estaria conectado a nada e estaria flutuando. O
Arduino poderia ler isso como um estado HIGH ou LOW, o que
poderia resultar em falsos registros de botões apertados.

Resistores pull-up são muitas vezes utilizados em circuitos

digitais para garantir que uma entrada seja mantida alta. Por
exemplo, o Circuito Integrado do Registrador de Deslocamento
74HC595, que você utilizará futuramente neste livro, tem um
pino de Master Reset. Esse pino reinicia o chip quando ele está
em estado baixo. Como resultado, é essencial que o pino seja
mantido alto a todo momento, a menos que você queira
especificamente reinicializar; você pode manter esse pino no
estado alto utilizando sempre um resistor pull-up. Quando quiser
reinicializá-lo, pode alterá-lo para o estado baixo utilizando uma
saída digital definida como LOW; em todos os outros casos, ele
permanecerá alto. Muitos outros Circuitos Integrados têm pinos
que devem ser mantidos no estado alto na maioria dos casos, e
apenas alterados para o estado baixo para ativar diversas
funções.

64
Resistores pull-up internos do Arduino

Convenientemente, o Arduino contém resistores pull-up que

estão conectados aos pinos (os pinos analógicos também têm
resistores pull-up). Esses resistores têm um valor de 20 kΩ e têm
de ser ativados via software para que possam ser utilizados. Para
ativar um resistor pull-up em um pino, você tem de, primeiro,
alterar seu pinMode para INPUT e escrever um HIGH nesse pino,
utilizando um comando digitalWrite:
pinMode(pin, INPUT);
digitalWrite(pin, HIGH);
Caso você altere o pinMode de INPUT para OUTPUT depois de
ativar os resistores pull-up internos, o pino permanecerá em um
estado HIGH. Isso também funciona de forma inversa: um pino
de saída que está em um estado HIGH, e que é posteriormente
trocado para um modo INPUT, terá seus resistores pull-up
internos habilitados.

Finalizando

Estes projetos são básicos mas conferem, com certeza, um bom

conhecimento introdutório em Arduino.

65
Existem diversos projetos que você pode ver no material
complementar, são projetos práticos, divertidos, uteis ou
somente para estudos.

Vejam nas vídeo aulas estes projetos que estão aqui nesta última
semana.

Não se esqueça, para avançar mais nos estudos requer

conhecimentos em Lógica de Programação (com ênfase em
linguagem C/C++) e conhecimento básico de eletrônica, o que
que vai proporcionar um avanço real no mundo da robótica e
automação com a plataforma Arduino.

66
REFERÊNCIAS

Para que é utilizado o Fritzing? Acessado em: http://

clubedosgeeks.com.br/programacao/arduino/para-que-e-usado-
o-fritzing
FATECINO – Clube de Arduino Fatec Jundiaí. Acessado em:
http://fatecjd.edu.br/site/uploads/files/Conceitos-1-Eletronica%
20Basica%20e%20Principais%20Componentes.pdf
Projeto Arduino. Acessado em: https://store.arduino.cc
/usa/arduino-uno-rev3
Guia Arduino Iniciante: Acessado em: https://edisciplinas.usp.br
/pluginfile.php/4110478/mod_resource/content/1/Guia_Arduin
o_Iniciante_Multilogica_Shop.pdf
MCROBERTS, Michael. Arduino básico; [tradução Rafael Zanolli].
-- São Paulo : Novatec Editora, 2011.
Simulador Arduino. Acessado em: https://circuits.io/
Arduino básico volume 1. Acessado em: https://d335luupugsy2.
cloudfront.net/cms/files/5851/1494560630Arduino_Basico_Vol.
1.pdf

67
68