REINALDO HADDAD

INTRODUÇÃO
A
PLATAFORMA
ARDUINO
CURSO TECNICO EM MECATRÔNICA
 Sumário

Por que utilizar a Plataforma Arduino ........................................................ 11

A família Arduino .................................................................................. 12

Microcontrolador ....................................................................................... 15

Características:.................................................................................... 16

Periféricos ........................................................................................... 16

Descrição dos pinos ....................................................................... 17

O conjunto didático da empresa EMPRETEC ......................................... 18

A placa Arduino compatível - EMPRETEC ............................................. 19

Pinos Digitais .................................................................................. 21

Pinos Analógicos ............................................................................ 22

Pinos de alimentação (POWER) ............................................................ 22

LEDs indicativos ............................................................................. 23

A Linguagem utilizada para programação ............................................ 24

Exemplo de programa .......................................................................... 26

Explicando o programa Blink ......................................................... 27

Instalação .................................................................................................. 29

O ambiente de programação ................................................................ 30

Escrevendo um programa ..................................................................... 33

Alterando o programa .......................................................................... 35

EX-1 – Conectando LEDs ................................................................. 37

EX-2 – Conectando LEDs................................................................. 38

EX-3 – Conectando LEDs ................................................................ 39

Adicionando variáveis .............................................................................. 40

EX-4 – Inserindo variável tempo 1...................................................... 42

EX-5 – Inserindo variável tempo 2 ...................................................... 43

Operadores ................................................................................................ 44

Ligando um botão e lendo o estado de um botão ................................ 46

EX-6 – Ligando um botão ............................................................... 47

EX-7 – Ligando um botão II............................................................. 48

EX 8 – Ligando dois botões ............................................................ 49

EX-9 – Ligando botão com Pull up interno ..................................... 50

Usando a biblioteca bounce ................................................................. 51

Resolvendo operações lógicas.............................................................. 52

EX-10 - Operações lógicas ................................................................... 53

EX-11 - Expressões lógicas................................................................... 54

Utilizando o monitor serial ........................................................................ 55

EX-12 – Calculando valores em um retificador ................................... 58

EX-13 – Calculando a quantidade de azulejos ................................ 59

EX-14 - Operações lógicas ................................................................... 61

EX-15 - Expressões lógicas .................................................................. 62

If (forma simples) ....................................................................................63

Estruturas condicionais – comando if - else .............................................. 63

EX-16 - Utilizando comando if ............................................................. 64

EX-17 - Utilizando comando if 2 ......................................................... 65

EX-18 - Utilizando comando if 3 .......................................................... 67

Utilizando if else ................................................................................. 68

EX-19 - Utilizando comando if – else ................................................. 69

 Comando for ...................................................................................... 70

Entradas analógicas .................................................................................. 72

Lendo sensores ..................................................................................... 74

Utilizando a função MAP............................................................................................ 76

EX- 20 – Mapeando o potenciômetro ............................................... 77

EX- 21 – Controlando o Led com o LDR ........................................... 78

PWM .................................................................................................................... 79

EX- 22 – Controlando o Led com PWM ............................................. 80

O sensor de temperatura ...........................................................................81

EX- 23 – Mapeando o sensor de temperatura ................................... 83

Utilizando o relé ........................................................................................ 84

EX- 24 – Acionando o relé em uma determina temperatura ............ 87

Utilizando o sensor reflexivo..................................................................... 88

EX- 25 – Reconhecendo cores............................................................ 90

Controle de motor DC ........................................................................... 91

EX- 26 – Controle de velocidade e direção de um motor DC através

de ponte H com transistores .......................................................... 95

Utilizando o L293D ................................................................................... 96

EX- 27 – Controle de velocidade e

direção de um motor DC com CI L293D .................................... 98

Motor de passo ......................................................................................... 99

EX- 28 – Controle de motor de passo com ULN2003.......................102

Por que utilizar a Plataforma Arduino.

Arduino é o nome dado a uma plataforma de desenvolvimento de

microcontroladores feita para simplificar o projeto eletrônico, prototipagem e
experimentação para artistas, hackers, amadores, pessoas que tenham pouco
conhecimento de eletrônica e/ou de programação.

Arduino contêm um microcontrolador Atmega - que é um “computador” completo

com CPU, RAM, memória Flash, e pinos de I/O todos em um único chip e foi
projetado para que possa ser ligado diretamente nos pinos de I/O, diversos tipos
de sensores, LEDs, pequenos motores, relés etc. Através desses pinos, é possível
ler tensões de entrada (digital ou analógico) entre 0 e 5 volts.

O Arduino se conecta ao seu computador via USB e pode ser programado de

forma simples, utilizando uma linguagem bem parecida com a linguagem C
/ C ++ em uma IDE desenvolvida para esse fim.

O projeto Arduino que conhecemos hoje, foi iniciado no ano de 2005 com a
finalidade de ser uma opção barata para que alunos pudessem realizar seus 05
projetos com microcontroladores. Foi desde o início desenvolvida para ser uma
plataforma (um conjunto de soluções) open-source composto por uma placa, cujo
esquemas estão disponíveis no site oficial, um ambiente de desenvolvimento (IDE)
disponível gratuitamente e por uma linguagem de programação simples e fácil de
utilizar, além de ser multiplataforma, podendo rodar em ambientes Windows,
Linux e MAC.

A plataforma Arduino foi feita para aprender mexendo! Pode-se ensinar desde
lógica de programação simples até avançada. É possível ensinar vários conceitos
de eletrônica, como diversos componentes são ligados às saídas de
microcontroladores e como o microcontrolador entende esses componentes.

A plataforma Arduino é, sem exageros, um excelente recurso educacional.

 Capítulo 2

A família Arduino.

Atualmente, o projeto UNO é a placa de referência adotada pela equipe Arduino que
mantém na página oficial – www.arduino.cc, toda a documentação atualizada com
referências e exemplos de códigos de aplicação.

Figura 1- Vista da frente e de traz da placa UNO-R3.

Existem outras placas disponíveis como o DUE que é uma placa que possui um número
maior de I/O,

06

Figura 2 - Placa DUE

Os outros produtos disponíveis podem ser vistos no site :

http://arduino.cc/en/Main/Products
Existem ainda placas que são adicionadas a placa do Arduino que acrescentam
funcionalidades à plataforma. Essas placas são conhecidas com Shields. Um
exemplo disso é o shield ethernet. Com ele o Arduino poderá ser conectado à
internet a partir de qualquer tomada RJ45.

Figura 3 - Shield Ethernet

Outros modelos de Shields podem ser vistos em:

http://arduino.cc/en/Main/Products

Além dos modelos oficiais, como o projeto é aberto, existem diversas empresas
e grupos que a partir da documentação disponível, desenvolvem produtos e em 07
muitos casos também o comercializam. Uma lista com todos os modelos
similares reconhecidos pode ser encontrada no endereço seguinte:

http://playground.arduino.cc/Main/SimilarBoards

Um ótimo exemplo de um produto nacional e reconhecido pela equipe Arduino

é o Severino.

O Severino é um projeto nacional que pode ser livremente reproduzido e toda a

documentação pode ser encontrada nesta página:

Figura 4 - Severino

http://www.arduino.cc/en/Main/ArduinoBoardSerialSingleSided3
 Capítulo 3

Microcontrolador.

O microcontrolador utilizado é o ATmega328P, um µC AVR integrante da série

ATmegaXX8 da Atmel. Atualmente são os melhores µC de 8 bits disponibilizados
pela Atmel em encapsulamento DIP de 28 pinos. O XX da série indica a
quantidade de memória FLASH disponível. Portanto, o ATmega328P possui
32KBytes de memória FLASH com barramento de 8 bits. A letra P significa que
este micro trabalha consumindo menos energia do que outros processadores.
GND

VOC

Watchdog
debugWIRE
Timer
Power
Watchdog Supervision PROGRAM
Oscillator POR/BOD & LOGIC
RESET

Oscillator
Flash SRAM
Circuits/
Clock
Generation

EEPROM

08 AVCC
AREF
GND

8bit T/C 0 16bit T/C 1 A/D Conv.

DATABUS

Analog Internan
8bit T/C 2 Comp. Bandcap

USART 0 SP1 TW1

PORT D (8) PORT B (8) PORT C (7)

RESET

XTAL[1.2]

PD[0.7] PB[0.7] PC[0.6] ADC[6.7]

Figura 6 - Diagrama em blocos ATMEGA

Características:
• Arquitetura RISC.
• 130 instruções otimizadas para trabalhar com compiladores de alto nível em
especial o C, a maioria executada em apenas 1 ciclo de relógio.
• Possui 32 registradores de propósito geral de 8 bits (R0 a R31)
• Operação de até16MIPS (milhões de instruções por segundo) a 16MHz
• 8 KBytes me memória de programa FLASH de autoprogramação In-System.
• 512 Bytes de Memoria EEPROM.
• 1KByte de Memoria SRAM.
• Ciclos de escrita e apagamento: memória FLASH 10.000 vezes, EEPROM
100.000 vezes.

Periféricos:
• 23 I/O programáveis.
• 2 temporizadores/contadores de 8 bits com Prescaler separado, 1 modo de
comparação.
• 1 temporizadores/contadores de 16 bits com Prescaler separado, modo de
comparação e captura.
• Contador de tempo real (com cristal externo de 32.768 Hz) conta 09
precisamente 1s.
• 3 canais PWM.
• 6 canais A/D com precisão de 10 bits
• Interface serial para dois fios orientada a Byte (TWI), compatível com o
protocolo I2C.
• Interface serial USART.
• Interface serial SPI Master/Slave
• Watchdog Timer com oscilador interno separado
• Oscilador RC interno (não há necessidade de cristal externo ou outra fonte
de clock).
• 5 modos de Sleep: Idle; Redução de ruído do A/D; Power-Down; Power Safe
e Standby.
 Descrição dos pinos

10

.
 Capítulo 4

A placa Arduino compatível -

EMPRETEC.

A figura a seguir, mostra a placa

desenvolvida pela EMPRETEC, similar a
placa Uno R3. Faremos uma pequena
descrição de suas partes.

Figura 9 - Placa Arduino compatível

11
Esta placa será conectada ao computador
através da entrada USB. Por essa conexão, a
placa será alimentada com 5V e se
comunicará com o computador.

Figura 10 - Conexão USB

Após a gravação do programa na memória do

microcontrolador, a placa pode ser desligada do
computador e conectada à uma fonte de
alimentação externa através de um pino tipo P2.
Ela pode ser alimentada com tensões de 7,5V até
no máximo 12V. O projeto contém um regulador
de tensão de 5V.

Figura 11 - Conexão para fonte externa.

 A conexão entre o microcontrolador e os
diversos componentes, sensores e demais
dispositivos é feita através de blocos de
terminais disponíveis nas laterais da placa.
Este é o diferencial do projeto da EMPRETEC
para as demais placas compatíveis.

Figura 12 - Blocos de terminais.

Os terminais mais externos são destina-

dos à distribuição do GND.

O GND também pode ser encontrado na

linha de terminais que estão diretamente
conectados à saída do microcontrolador e
nos terminais destinados à distribuição da
fonte de alimentação – POWER.

Figura 13 - Distribuição GND.

12

A segunda fileira de terminais é destinada

à distribuição de 5V, que também pode ser
encontrada nos terminais POWER.

Figura 14 - Distribuição Vcc.

Os terminais internos que estão na terceira

fileira do conector, estão conectados aos
pinos do microcontrolador e serão descritos
a seguir.

Figura 15 - Pinos conectados ao Microcontrolador.

Pinos Digitais.
Nesta placa, existem 14 pinos digitais numerados de 0 até 13.

Para estes pinos, o limite máximo de corrente é de 40mA (I/O), sendo

recomendado utilizar valores até 20mA. Estes pinos têm também um resistor
pull-up interno que vem desligado de fábrica e é ativado por software.

Figura 16 - Pinos Digitais.

Além de serem pinos de I/O, alguns tem funcionalidades específicas que estão
descritas a seguir.
Terminais Denominação Descrição
13
Estes terminais além de
RX – Utilizado para receber dados seriais estarem conectados aos
0 pinos TXD e RXD do
TTL
microcontrolador, também
estão ligados ao CI FTDI que
faz a comunicação serial
TX – Utilizado para transmitir dados entre o microcontrolador e o
1
seriais TTL computador.

Estes pinos podem ser

2 ,3 ISR (Interrupt Service Routine) configurados para chamar
uma interrupção

Fornecem uma saída PWM

3, 5, 6, 9, 10 e 11. PWM (Pulse Width Modulation)
de 8 bits.

10 (SS) (Slave Select)

Estes pinos são utilizados
11 MOSI (Master Out Slave In) para permitir a comunicação
do microcontrolador com
um ou mais periféricos
12 MISO (Master In Slave Out) utilizando o protocolo SPI
(Serial Peripheral Interface).
13 SCK (Serial Clock)

O pino 13 também está

13 LED conectado à um LED que
está montado na placa.

Tabela 1 - Função dos pinos digitais.

 Pinos Analógicos.
O Arduino tem 6 pinos analógicos – A0
até A5 - todos pinos de entrada com
resolução de 10 bits (0 a 1023).

Por padrão, estas entradas recebem

tensões de 0 até 5V. Através do pino
AREF, o limite superior da tensão pode
ser alterado.

Figura 17- Pinos Analógicos.

Assim como nos pinos digitais, alguns pinos têm funções especiais.

Terminais Denominação Descrição

A4 DAS (Serial Data Line)

Estes pinos suportam
comunicação I2C (TWI –
Two- Wire Interface).
A5 SCL (Serial Clock Line)

14
Tabela 2- Pinos Analógicos.

Pinos de alimentação (POWER)

Os pinos de alimentação fornecem
tensões para placas externas como os
Shields. Estão disponíveis 2 tensões
diferentes, 5V e 3,3V sendo esta
limitada à 50mA. Além deles são
fornecidos também dois pinos GND.

Neste barramento, existem ainda dois

outros pinos.

Figura 18 - Pinos POWER.

- RESET: fornece o comando RESET para uma placa externa.

- VIN: Encaminha tensão de alimentação externa.

LEDs indicativos.
A placa contém ainda 4 LEDs indicativos.

Figura 19 - LEDS indicativos.

15
Capítulo 5

A Linguagem utilizada para

programação.

A plataforma Arduino utiliza a linguagem de programação Arduino baseada em Wiring que é uma
linguagem de programação open-source para microcontroladores. A estrutura desta linguagem é
muito parecida com a linguagem C sendo que aqueles que dominam a linguagem de programação C
terão pouquíssima dificuldade para programar um Arduino. A estrutura básica da linguagem de
programação do Arduino é bastante simples e é composta de pelo menos duas partes, que são os
blocos setup e loop.

O primeiro bloco é o setup. Nele serão declaradas as variáveis e as configurações dos pinos utilizados,
se serão de entrada ou de saída. Nele também será inicializada a comunicação serial se for utilizada.

O bloco setup, é executado apenas uma única vez, quando o programa é inicializado.

No bloco loop, os pinos de entrada e saída serão constantemente “lidos”, sendo os estados
processados pelo µC (de acordo com as instruções do programa) e alterados quando for o caso. O
processo é contínuo e será encerrado apenas quando uma interrupção acontecer ou o µC for
desligado.

Para escrever um programa, entre outros elementos, são utilizadas funções que são pequenos blocos de
programas usados para montar o programa principal. São como sub-rotinas, procedimentos ou
bibliotecas, escritas para realizar tarefas repetitivas.

Toda a função deve der declarada antes de ser chamada, atribuindo-lhe um tipo e um nome seguido de
parênteses onde serão colocados os parâmetros da função. Entre chaves { }, serão escritos os
procedimentos que a função deverá executar.

A função setup()

É chamada apenas uma única vez e é responsável por iniciar os modos de trabalho dos pinos, e a porta
serial. Deve ser incluído no programa mesmo que não exista alguma declaração para ser feita.

Como em qualquer linguagem de programação a forma como a palavra é escrita, determina se será ou
não reconhecida dando então o necessário significado ao programa que está sendo feito. A palavra
setup (e as outras utilizadas na linguagem de programação do Arduino) devem ser escritas como
determina a referência da linguagem. Os dois parênteses escritos logo a seguir, nesta função, serão
vazios, sem parâmetros, porém não poderão ser suprimidos.

A função loop()

Logo após a função setup, a função loop é escrita e dentro desse bloco é que estará distribuído o
conjunto de instruções que caracterizarão o programa. Este bloco será lido sequencialmente e cada
linha executada a partir da primeira até a última. Após isso, o programa volta para a primeira linha e
executa novamente cada uma das linhas do programa, ciclicamente.
Capítulo 6

Exemplo de programa.

Vamos então utilizar um programa básico do Arduino que é o que faz o Led que está
conectado ao pino 13 da placa piscar para exemplificar a estrutura de programação do
Arduino.

17

Figura 20 - Programa 1- Blink.

O código escrito acima é de domínio público e pode ser encontrado na própria IDE do
Arduino no menu exemplos. Como em todo programa, o recurso de comentar o texto,
explicando o que ele faz e o que cada linha deve executar está presente.
/* */ é utilizado para escrever um comentário de duas ou mais linhas.

// é utilizado em comentários de uma linha.

O uso de comentários é importante para registrar a intenção do programador e

servindo também para resgatá-la. Não serve apenas para traduzir o significado da
função ou parâmetro, más sim para explicar o que se espera que aconteça.
 Neste texto, vamos retirar os comentários do programa a fim de enfatizar a
sequência de instruções.

Figura 21 - Programa 2 - Blink sem comentários.

18

Explicando o programa Blink.

Antes do bloco setup, é necessário declarar as variáveis que serão

utilizadas no programa.

int se refere ao tipo de números que a variável pode manipular.

No caso, a variável é do tipo inteiro e pode armazenar números
de até 16 bits com um range de -32.768 até 32.767.

led se refere ao nome da variável. Pode ser qualquer nome,

int led = 13; utilizando caracteres alfanuméricos.

= operador de atribuição. 13 se refere a saída 13 da placa.

Então, nesta linha, foi criada uma variável chamada led do tipo int
(que armazena números na faixa de 2^-10 até 2^10 – 1) e que
está fisicamente conectada ao pino 13 da placa, e que neste caso,
também está conectado ao led da placa.

No final existe o sinal ; (ponto e vírgula) que encerra um

procedimento.
 Este é o bloco setup.

A função setup, não retorna valor algum e por isso, é do tipo void.

Logo após, entre chaves { }, são apresentadas as funções e suas

void setup() declarações. As chaves limitam um procedimento.

{ Vários procedimentos podem ser escritos dentro da função setup sempre

separados por chaves.
pinMode(led, OUTPUT);
pinMode – Esta função determina o modo do pino, se ele será um pino de
} entrada (INPUT) ou de saída (OUTPUT).

Logo após a função, entre parênteses, é necessário informar o pino, no caso

– led - e a palavra OUTPUT. Isto quer dizer que o pino led é uma saída.

Este é o bloco loop.

Assim como no setup, loop é uma função do tipo void.

digitalWrite é a função que escreve no pino digital, um determinado 19

valor, um estado. Logo a seguir da função, entre parênteses, segue o
void loop() nome do pino – led – e o estado que é HIGH. Ou seja, o pino led foi setado
para 1.

{ Em seguida, a função delay é iniciada. Esta função atrasa a execução do

programa pelo tempo especificado a seguir, entre parentes. O valor
declarado é 1000. Como a base desta função é o milissegundos, o
digitalWrite(led, HIGH); programa ficará parado por 1000 ms, ou 1 segundo. Assim o led ficará
aceso por 1 segundo.
delay(1000);
digitalWrite é novamente iniciado. Isto é necessário pois o primeiro
digitalWrite(led, LOW); digitalWrite, acendeu o led. Então é necessário apaga- lo (a finalidade do
programa é fazer o led piscar).
delay(1000);
Então, o estado do led é definido como LOW ou 0. O led ficará apagado
} então por 1 segundo.

O programa ficará executando o loop, linha por linha, até que o

equipamento seja desligado.

Tabela 3 - Explicando o programa.

 Capítulo 7

Instalação.

Para utilizar qualquer placa Arduino oficial, basta ir até a página de download
-http://arduino.cc/en/Main/Software - e escolher a opção do sistema
operacional instalado em seu computador. No caso da versão para Windows,
o arquivo estará compactado. Basta então fazer a descompactação do arquivo
e executar os procedimentos comuns utilizados para instalação de qualquer
software. Para os outros sistemas operacionais, o procedimento é
semelhante.
Este arquivo que será baixado e instalado em seu computador é o ambiente
de programação do Arduino, ou IDE. Atualmente, a versão da IDE é a 1.0.5.
Em placas Arduino compatíveis, como é o caso da placa da EMPRETEC, as vezes
é necessário instalar um driver de comunicação próprio da placa. No CD que
acompanha o kit, existe um instalador com um atalho para a instalação desse
driver.

Uma vez feito isso, a plataforma está praticamente pronta para uso.

20
Capítulo 8

O ambiente de programação.

É no IDE do Arduino que o programa será escrito e, também transferido para a placa a fim de
ser gravado no µC. Para isso, é necessário conectar a placa do µC através de um cabo USB ao
computador. Inicie então a IDE que terá a aparência mostrada abaixo.

Nome provisório
do código e
versão da IDE

Barra de menus

Barra de botões Área onde o programa

será escrito

21

Área de mensagens
Modelo da placa
e porta serial
COM utilizada

Figura 22 - IDE do Arduino.

 É possível alterar a linguagem do ambiente para português. Isso é feito selecionando
preferencias no menu Arquivo.

Figura 23 - Menu Arquivo.

Na caixa aberta, selecione a língua e depois reinicie o IDE.

Capacitação técnica na plataforma Arduino

22

Figura 24 - Preferencias.

O próximo passo é configurar o tipo de placa que será utilizado. A placa da EMPRETEC é do
tipo Duelmilanove. Então no menu Ferramentas, selecione Placa. Da lista de opções aberta,
selecione o modelo Arduino Duemilanove w/ ATme- ga328.

Figura 25 - Configurando o modelo de placa.

Após definir o modelo da placa é necessário verificar em qual porta COM a placa está
conectada.

Vá até o painel de controle e em Sistema, selecione Gerenciador de Dispositivos.

Procure em Portas (COM E LPT) qual é a COM que a placa está conectada.

Figura 26 - Localizando a COM.

Voltando a IDE, confirme o número da COM selecionada. Ela deve ser a mesma que a
23
indicada no painel de controle. No exemplo, a porta COM deve ser a 6. Então vá no menu
Ferramentas e selecione Porta Serial. Na lista de COM selecione a indicada no painel de
controle.

Capacitação técnica na plataforma Arduino

Figura 27 - Conferindo a porta COM.

Pronto! Agora é necessário escrever o programa. Vamos utilizar o programa “Piscar” que já
detalhamos.
 Capítulo 9

Escrevendo um programa.

Escreva na IDE o programa blink (piscar) como mostrado abaixo.

Perceba que ao escrever o programa na

IDE, as palavras assumem cores,

Cinza para comentários;

Laranja para funções;
Azul para constantes;
Preto para nome de variáveis e
demais símbolos.
Quando uma palavra que remete a uma
função ou a um estado for escrita errada,
24 ele aparecerá preta.

Figura 28 - Blink escrito no IDE.

Não se esqueça de salvar o programa. Isso pode ser feito no menu Arquivo.

Após a escrita é necessário compilar o

código. Nesta etapa, o código escrito
será “conferido” e caso algo esteja er-
rado, uma mensagem será mostrada.
Caso tudo esteja correto, o código será
reescrito em linguagem de máquina
pela própria IDE. Para fazer isso, clique
no botão verificar disponível na barra
de botões.

Ao terminar, o programa está pronto

para ser transferido para o µC.

Figura 29 - Compilando.
 Figura 30 - Gravando o programa no micro.

Para transferir o programa para o µC, é necessário pressionar o botão carregar disponível
na barra de botões.

Observando a placa, perceba que os dois leds TX e RX piscam rapidamente. Este é o sinal
de que o programa está sendo trans ferido e gravado no µC.

Ao terminar a transferência, o LED 13 começa a piscar, ficando 1 segundo aceso e 1 segundo

apagado. Caso isso não aconteça, reveja os passos anteriores e repita a operação.

25

Capacitação técnica na plataforma Arduino

Capítulo 10

Alterando o programa.

O que pode ser alterado neste último programa, o “piscar”.

Para alterar o programa, basta fazer as mudanças na própria IDE, escrevendo ou

reescrevendo o programa que está lá. Vamos mudar o tempo em que o LED permanece
aceso ou apagado e para isso, altere o programa para que o LED permaneça aceso por
100ms e apagado por 500ms.

Figura 31 - Alterando o programa.

Após fazer as alterações, salve este programa com um nome diferente e repita os passos
de verificar e carregar. Observe o LED da placa. Ele pisca mais rapidamente.

Mas, e se for necessário ligar dois LEDs? Como fazer?

Fácil, é só utilizar a velha matriz de contatos e alguns componentes.

Relembrando alguns conceitos...

Para ligar um LED em uma das portas de saída é necessário ligar um resistor em
série com o LED. A tensão na porta no estado 1 é 5V e portanto um resistor entre
150Ω a 330Ω deve satisfazer essa condição.

Vamos primeiro montar o circuito.

Ligue na matriz de contatos dois LEDs, cada um com o seu resistor em série como
mostra o esquema a seguir.

27

Figura 32 - Ligando dois LEDs.

Uma vez montado o circuito, é necessário alterar o programa. Então vamos para a IDE.

Capacitação técnica na plataforma Arduino

Declarando as variáveis: int led1 = 2;
tipo e onde estão ligadas. int led2 = 3;
Setup void setup() {
pinMode(led1, OUTPUT);
Agora configurar o pino
pinMode(led2, OUTPUT);
como saída.
}
A função loop. void loop() {
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
delay(500);
O estado (aceso ou
apagado) e o tempo que digitalWrite (led1, LOW);
cada LED ficará aceso.
digitalWrite (led2, HIGH);
delay(500);
}
Tabela 4 - Programa 2 LEDs.

Salve o programa, compile e grave-o no µC e observe o funcionamento.

 EX-1 – Acendendo 4 LEDs sequencialmente.

Figura 33 - Circuito com 4 LEDs.

int led1 = 2;
int led2 = 3;
int led3 = ;
int led4 = ;
void setup() {
pinMode(led1, OUTPUT);
28
pinMode(led2, OUTPUT);
pinMode(led…, );

pinMode(led…, OUTPUT);
Capacitação técnica na plataforma Arduino

void loop() {
digitalWrite (led1, HIGH);
delay(500);
digitalWrite (led2, HIGH);
delay( );
digitalWrite (led_, );
delay( );

}
Figura 34 - Completando o programa.
 EX-2 – Acendendo 4 LEDs e apagando na mesma sequencia.

Figura 35 - Conectando Leds 2. 29

Neste espaço, escreva programa solicitado.

Capacitação técnica na plataforma Arduino
 EX-3 – Acendendo e apagando cada led sequencialmente.
3

Conectando LEDs 3.

30
Neste espaço, escreva programa solicitado.
Capacitação técnica na plataforma Arduino
DESAFIO

Utilizando 7 leds desenvolva um programa que os faça acender do

centro para as extremidades e apagar das extremidades para o centro,
com um intervalo de 300ms entre leds.
 Capítulo 11

Adicionando variáveis.

Nos programas anteriores, o tempo que determinava quando cada LED acendia ou apagava era escrito
dentro da função delay. Isto significa que cada vez que for necessário modificar o tempo, é necessário
alterar cada um dos valores. Em vez disso, uma variável “tempo” pode ser criada e será esta variável
que ficará dentro da função delay. Assim, para alterar o valor do “tempo” basta alterar apenas esta
variável.
Para criar uma variável o primeiro passo é determinar qual deve ser o tipo da variável. O tipo
determina qual o tipo de dado e sua extensão além de diretamente influenciar no tamanho do arquivo.

Tipo Descrição
A palavra reservada void é usada em declarações de funções. Este tipo indica que a função não
void
retorna nenhum valor quando é executada.
O tipo boolean pode representar valores booleanos, verdadeiro (true) ou falso(false). Um tipo boolean
Boolean
ocupa um byte da Memoria.
O tipo char armazena valores de 1 byte. Caracteres são codificados em um único byte e são especificados
na tabela ASCII. O tipo char é sinalizado e representa números de -128 a 127. Para números não
32 char sinalizados usa-se o tipo byte.

unsigned unsigned char armazena valores de 1 byte não sinalizados, é mesmo que utiliza o tipo byte. A faixa de
Capacitação técnica na plataforma Arduino

char valores vai de 0 a 255.

byte Armazena valores de 8 bits não sinalizados de 0 a 255.
Inteiros são tipos primários de armazenamento. No Arduino Uno( e em outras placas baseadas em
int ATMEGA) um int armazena valores de 16 bits(2 bytes). Esse tipo compreende valores de -32768 a 32767.

No Arduino UNO e em outras placas baseadas em ATMEGA armazenam valores de 16 bits não sinalizados,
unsigned int ou seja, apenas valores positivos de 0 a 65535.

O tipo armazena valores de 16 bis não sinalizados que compreendem valores de 0 a 65535.
word

O tipo de dado Long armazena valores inteiros sinalizados de 32 bits (4 bytes) que
long
compreendem a faixa de -2147483648 a 2147483647.

unsigned O tipo unsigned long armazena valores de 32 bits (4 bytes) não sinalizados que compreendem a faixa
long de 0 a 429967295.

short O tipo short armazena valores de 16 bits (2 bytes) sinalizados.

O tipo float armazena valor em ponto flutuante, ou seja, um valor que possui casas decimais. O tipo
float float armazena valores de 32 bits (4 bytes) e compreendem a faixa de -3,4028235 E+38 a 3,4028235
E+38.4.

double O tipo double também armazena valores de ponto flutuante, porém no Arduino Uno e outras placas
baseadas em ATMEGA esse tipo é exatamente o mesmo que o tipo float, sem ganho de precisão,

De acordo com a tabela, é preferível utilizar o tipo byte para a variável tempo e, também, para as variáveis
led. Isto resultará em um programa que ocupa menos espaço de memória.
EX-4 – Inserindo variável tempo 1.

Figura 38 - Ligando 4 LEDs.

byte led1 = 2;
byte led2 = 3;
byte led3 = 4; 33
byte led4 = 5;
byte tempo = 0;

Capacitação técnica na plataforma Arduino

void setup() {

}
void loop() {
digitalWrite (led1, HIGH);
delay(tempo);

}
 EX-5 – Inserindo variável tempo 2.

Figura 39 - Ligando 4 LEDS.

Neste espaço, escreva programa solicitado.

34
Capacitação técnica na plataforma Arduino
Capítulo 12

Operadores.

Operadores são símbolos utilizados para construir expressões aritméticas, lógicas e

comparação. A tabela a seguir mostra os tipos e exemplifica o uso.

Tipo Operador Símbolo Exemplo Retorno

Atribuição = a=x “x” guarda o valor de a

Resto da
% x= 7%5 “x” guarda 2, o resto da divisão
divisão
Aritméticos

Soma + x=a+3 “x” guarda o resultado da soma

35
“x” guarda o resultado da
Subtração - x=a-3
subtração

“x” guarda o resultado da

Produto * x=a*3
multiplicação

Divisão / x=a/3 “x” guarda o resultado da divisão

Comparação == y == b 1 se “y” é igual a “b”, se não 0

Diferença != y! = b 1 se “b” é diferente de“y”, se não 0

1 se “y” é menor do que“b”, se não

Comparação

Menor que < y<b

0

1 se “y” é maior do que“b”, se não

Maior que > y>b
0

Menor ou 1 se “y” é menor ou igual a “b”, se

<= y <= b
igual não 0

Maior ou 1 se “y” é maior ou igual a “b”, se não

>= y >= b
igual 0
 z > 0 && c
AND && 1 se a expressão for verdadeira
<2
Lógicos

OR || z > 0 || c < 2 1 se a expressão for verdadeira

NOT ! !x > 0 1 se a expressão for falsa

Tabela 5 - Operadores

Além desses, existem também os operadores bit a bit que realizam operações de
bit e os operadores compostos.

Tipo Operador Símbolo Exemplo Retorno

AND bit a bit & 0011 & 0001 0001

OR bit a bit | 0011 | 0001 0011

XOR bit a bit ^ 0011 ^ 0001 0010

Bit a bit

NOT bit a bit ~ ~1100 0011

36
Desloca para Se w = 000011, após o
<< w << 3
a esquerda deslocamento w = 111000
Capacitação técnica na plataforma Arduino

Desloca para Se w = 111000, após o

>> w >> 3
a direita deslocamento w = 000111

Soma += w+ = d w = w+d

Subtração -= w- = d w = w-d

Produto *= w* = d w = w*d
Compostos

Divisão /= w/ = d w = w/d

Incremento ++ w ++ w = w+1

Decremento -- w -- w = w-1

AND bit a bit &= w &=d w=w&d

OR bit a bit |= w !=d w=w!d

Tabela 6 - Operadores bit a bit.

Capítulo 13

Ligando um botão e lendo o estado de

um botão.

Botões, chaves ou interruptores estão presentes em diversas situações nos circuitos digitais. A
configuração básica para montar um botão é associando-o a um resistor cuja finalidade é fixar um
valor de tensão ao pino digital que terá seu nível lógico invertido ao ser pressionado o botão. O
nome dado a estes resistores depende do nível de tensão que eles fixam no pino digital, observe:

37

A alimentação do conjunto ( resistor de 10KΩ / chave) deve ser a mesma que alimenta o µC.

Já na parte de programação, é necessário que a porta em que o botão foi ligado seja
constantemente lida para saber se o valor é igual à 1 ou igual à 0. A função digitalRead(pino)
é utilizada para ler o estado do botão que retornará HIGH ou LOW dependendo do estado lido.
 O programa abaixo, será utilizado para ler o estado de um botão que controlará o LED que está
no pino 5 da placa Arduino.

int LED = 5;
Inicie declarando as variáveis globais LED e BOTAO.
int BOTAO = 6;

É necessário criar uma outra variável para determinar o estado inicial

int val = 0; do botão. Chamaremos de “val” e o estado “0” inicial é atribuído.

void setup() {

pinMode(LED, OUTPUT);

pinMode(BOTAO, INPUT); Definem-se os modos dos pinos.

void loop(){

val = digitalRead(BOTAO); Nesta linha, a variável “val” recebe o valor lido no botão.

digitalWrite(led, val);
Nesta linha, o valor escrito na variável “val” é atribuído ao LED
}

Tabela 7- Programa para ler um botão.

38
EX-6 – Ligando um botão na configuração Pull-down.

- Esquema de ligação com 1 LED e 1 botão na configuração pull-down.

Após observar o funcionamento do circuito, complete o quadro abaixo:

Estado Lógico Estado lógico

Como está a chave? Estado do LED
da chave do LED

Sem ser pressionada

Sendo Pressionada

Tabela 8 - Registro do funcionamento do circuito.

O que você observa ao comparar os estados lógicos da chave e do led?

R:
EX-7 – Ligando um botão na configuração Pull-up.

- Esquema de ligação com 1 LED e 1 botão na configuração pull-up.

Após observar o funcionamento do circuito, complete o quadro abaixo: 39

Estado Lógico Estado lógico
Como está a chave? Estado do LED
da chave do LED

Sem ser pressionada

Sendo Pressionada

O que você observa ao comparar os estados lógicos da chave e do led?

R:

Existe a possibilidade de não utilizar resistores de Pull up ao utilizar chaves, pois

o AtMega 328 possui resistores de Pull up internos e são ligados através de uma
linha de comando. Para acionar o resistor de Pull up interno basta acrescentar a
seguinte linha de código:

digitalWrite(nº pino, HIGH);

Outra forma de ativar o pull up interno é utilizar a seguinte expressão:

pinMode(nº pino , INPUT_PULLUP);

 EX-8 – Ligando botão com Pull up interno

Modifique o circuito utilizado no EX-7, retirando o resistor de Pull up da entrada 6.

Modifique o programa indicando o uso do resistor de Pull up interno.

40

EX-9 – Ligando botão com Pull up interno e inversão do estado logico do led.

Mantendo o resistor de pull-up interno modifique o programa do ex. anterior, buscando a

inversão do estado logico do Led, usando para isso algum dos operadores lógicos estudados.
EX 10 – Ligando dois botões.
• Acrescente ao circuito mais um led e mais um botão.
• Modifique o programa para que cada um dos botões controle um dos LEDs.

Capacitação técnica na plataforma Arduino

 Capítulo 14

Usando a biblioteca bounce.

Sabemos que uma chave ao ser acionada, cria uma série de ruídos que poderão ser
“entendidos” pelas entradas do microcontrolador e erroneamente interpreta- dos
pelo programa. Esses “ruídos” são denominados de bounce e em alguns casos, é
necessário eliminá-los para que o programa não interprete um valor errado. Uma
das maneiras de eliminar esse ruído, é proporcionando um atraso entre o primeiro
acionamento do interruptor e a leitura na entrada do microcontrolador.

Existem algumas maneiras de reduzir ou mesmo eliminar a influência desse tipo

42 de ruído. Vamos abordar a maneira que emprega o uso de uma biblioteca pronta
e feita exatamente para isso que está disponível na página:

http://arduino.cc/playground/Code/Bounce
Capacitação técnica na plataforma Arduino

Nesta página, é possível através do link baixar a biblioteca que está compactada.
Os passos seguintes mostrarão como instalar esta biblioteca no IDE do Arduino.

1 – Comece baixando o arquivo.

2 – Salve o arquivo na área de trabalho.
3 – Descompacte o arquivo. Uma pasta com o nome do arquivo será criada.
4 – Agora é necessário levar esta pasta para a pasta no computador, criada
durante a instalação do programa, onde estão as bibliotecas denominada
de libraries.
5 – Reinicie o IDE e pronto, a nova biblioteca está disponível.
Capítulo 15

Resolvendo operações lógicas.

Utilizando operadores lógicos, podemos escrever expressões lógicas. Monte um circuito

com 1 Led e dois botões, vamos escrever o programa que faça a operação lógica AND entre
os botões ligados aos pinos 6 e 7.

Escreva o programa abaixo na IDE e teste o funcionamento.

int Botao1 = 6;
int Botao2 = 7;
int LED = 2;
int val1 = 0;
int val2 = 0;
int resultado = 0;
43

void setup () {
pinMode (LED,OUTPUT);
pinMode(Botao1,INPUT);
pinMode(Botao2,INPUT);

}
void loop(){
val1=digitalRead(Botao1);
val2=digitalRead(Botao2);
resultado = val1&&val2;
digitalWrite(LED,resultado);
}
 EX-11 - Operações lógicas.
• Acrescente mais dois leds ao programa anterior e as operações lógicas OR e
NOR que serão realizadas entre os botões 1 e 2 e o resultado de cada uma,
mostrado nos LEDS 3, 4 e 5.
• Utilize o espaço abaixo para registrar o programa.

44

Capacitação técnica na plataforma Arduino

Capítulo 16

Utilizando o monitor serial.

Toda a placa da família Arduino, possui pelo menos uma porta serial que serve para
comunicação entre a placa Arduino e o PC ou entre outros dispositivos seriais. A UART -
Universal Asynchronous Receiver Trasmitter – no Arduino está disponível tanto na
própria entrada USB como também nos pinos 0 e 1 da placa. A interface é utilizada para
comunicação com o PC e outros dispositivos que contenham saídas USB e os pinos 0 e 1
para comunicação entre outros dispositivos como outras placas Arduino ou Shields que
trabalham em conjunto com o Arduino.

A comunicação serial no Arduino é do tipo Full Duplex assíncrona e a taxa de

transmissão mais utilizada é de 9600bps, más esta taxa pode ser alterada em função da
velocidade que o dispositivo que se quer conectar trabalhe.

A visualização da comunicação entre o Arduino e o PC, por exemplo, será feita no

Monitor Serial, que pode ser acessado de duas formas:

- através do menu Ferramentas:

Figura 42 - Menu Ferramentas.

- através do botão monitor serial.

Figura 43 – Localização do botão do monitor serial.

 Ao iniciar o monitor de uma das duas maneiras, será aberta uma caixa, onde é possível
enviar dados para o Arduino como também receber dados processados por ele.

46
Figura 44 - Monitor serial.
Capacitação técnica na plataforma Arduino

Funções básicas utilizadas na comunicação serial.

Serial.begin(9600);
Função empregada para configurar a comunicação serial. A taxa de comunicação Serial
[Arduino x PC], padrão é de 9600 bps. Sempre que a comunicação serial for utilizada, esta
função será escrita dentro do setup e quando ativa a comunicação serial, os pinos 0 e 1 da
placa Arduino não podem ser utilizados como entrada.

Serial.available();
Esta função fica constantemente lendo a porta serial do Arduino. Caso algum valor estiver
sendo mandado, ela enviará um valor maior do que 0, retornando o número de Bytes
disponíveis para leitura. Caso nada estiver sendo enviado, a porta retornará 0.

Serial.read();
Lê o primeiro byte que está no buffer que se comporta como uma FIFO. Quando retornar
-1, significa que não existem dados a serem resgatados.

Serial.write();
Esta função será utilizada para escrever na Serial, ou seja, envia algo para o computador
que se estiver disponível, receberá a informação.

Serial.print();
Escreve na serial texto em formato ASCII.
Serial.print ( 123 ); // Envia “123”
Serial.print ( 1.234567 ); // Envia “1.23”
Serial.print ( ‘N’ ); // envia “N”.
Serial.print ( “Hello world” ); // envia “Hello world”.

Obs.: caracteres são enviados com aspas simples e strings com aspas duplas.

Serial.println();

Esta função, escreve o caractere em ASCII e ao final, transmite o caractere Carrier Return
(retorno ao início da linha) e o caractere New Line (mudança para a próxima linha).
Vamos escrever uma mensagem de boas-vindas. Escreva o programa a seguir no IDE e
grave no Arduino.

void setup()

Serial.begin(9600);

void loop()

Serial.print (“ Olá, seja bem-vindo(a) ao “);

Serial.println (“Curso de Arduino. “);

}
47
Abrindo o monitor serial será possível ler a frase escrita.

Observe que ao usar a função Serial.print , se o conteúdo dentro dos parênteses estiver
entre aspas ele será reproduzido fielmente, como uma foto. Caso não sejam utilizadas
aspas a função só reconhecerá o conteúdo se este for alguma instrução ou operação
utilizado pelo Arduino e neste caso ao invés de ser printado, o conteúdo será executado,
observe o exemplo:

void setup()

Serial.begin(9600);

void loop()

Serial.print (“3+2 = “);

Serial.println (3+2);

}
 EX-12 – Calculando valores em um retificador.

Escreva um programa que mostre no monitor serial os valores de tensão em um circuito

retificador como o mostrado na figura abaixo. O valor da tensão aplicado ao primário do
Trafo é a única variável que poderá ser alterada no programa. Considere: relação de
transformação - 10:1 e Vd = 700mV. O monitor serial deve mostrar os valores de:
• 1 – Tensão eficaz do primário do Trafo;
• 2 – Tensão de pico no primário do Trafo;
• 3 – Tensão eficaz no secundário do Trafo;
• 4 – Tensão de pico no secundário do Trafo;
• 5 – Tensão máxima presente na saída do retificador;
• 6 – Tensão na carga considerando que o capacitor está fora do circuito;
• 7 – Tensão na carga considerando o capacitor de filtro.
O esquema do circuito está mostrado na figura abaixo.

48
Capacitação técnica na plataforma Arduino

Figura 45 - Circuito retificador em ponte com filtro capacitivo.

Capítulo 17

Estruturas condicionais –
comando if - else

O comando if – else é utilizado para controle de fluxo. Existem três formas de utilização :
a forma simples, composta e a forma encadeada.

If (forma simples)

O comando if será utilizado quando, em um programa, quisermos que determinada parte

deste seja executada apenas se uma condição for alcançada.

A estrutura onde o comando if é utilizado é a seguinte:

If(teste logico)
49
{
Bloco de código a ser executado se teste logico retornar
verdadeiro

Capacitação técnica na plataforma Arduino

}
Se a condição testada não for verdadeira, o bloco de código entre chaves será desprezado
e o loop continua. Vejamos o programa exemplo a seguir:

É possível acender LEDs utilizando o teclado do computador através do Monitor Serial. O

programa abaixo mostra como fazer isso. Escreva-o no IDE e faça o teste.

int LED =2;

void setup()
{
Serial.begin(9600);
pinMode(LED,OUTPUT);
}
void loop()
{
char tecla;
tecla = Serial.read();
if(tecla == ‘L’)
{
digitalWrite(LED, HIGH);
}
delay(1000);
}
 If-else (forma composta).

O comando if else, permite o teste de uma condição e realizar duas coisas. Se o teste for
verdadeiro, executa a parte 1 e se o teste for falso, realiza a parte 2.

A estrutura onde o comando if – else é utilizado é a seguinte:

If (teste lógico)
{
Bloco de código a ser executado se teste logico retornar
verdadeiro
}
Else
{
Bloco de código a ser executado se teste logico retornar
falso
}

Observe o exemplo:

50 int LED =2;

void setup()
{
Serial.begin(9600);
pinMode(LED,OUTPUT);
}
void loop()
Capacitação técnica na plataforma Arduino

{
char tecla;
tecla = Serial.read();
if(tecla == ‘L’)
{
digitalWrite(LED, HIGH);
}
else
{
if(tecla == ‘D’)
{
digitalWrite(LED, LOW);
}
delay(1000);
}
}
If-else (forma encadeada).

O condicional encadeado nada mais é do que o encadeamento de

estruturas de decisão compostas em um algoritmo. Essa estrutura é
empregada em situações nas quais é preciso verificar condições de teste
sucessivas, onde uma ação será executada caso um conjunto anterior de
ações seja satisfeito.

Sintaxe: else if

if (teste lógico 01)

{
Bloco de código executado se teste lógico 01 retornar
verdadeiro
}
else if (teste lógico 02)
{
bloco de código executado se teste lógico 02 retornar
verdadeiro
}
else
{
bloco de código final, executado se nenhum teste
retornar verdadeiro
} 51

Note que podemos ter quantos blocos else if forem necessários. Porém, se

Capacitação técnica na plataforma Arduino

o algoritmo começar a se tornar muito complicado, recomenda-se empregar
uma estrutura switch case em seu lugar.

Exemplo de Condicional Encadeado no Arduino

E agora uma aplicação do condicional encadeado em Arduino.

Construiremos um circuito com quatro LEDs conectados às saídas digitais
do microcontrolador, os quais serão acesos de acordo com um valor
numérico distinto fornecido por meio do monitor serial (de 1 a 4). Se um
valor diferente for digitado, nenhum LED permanecerá aceso.
 const int LED1 = 7;
const int LED2 = 8;
const int LED3 = 9;
const int LED4 = 10;

void setup()
{
Serial.begin(9600);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(LED4, OUTPUT);
}

void loop()
{
if (Serial.available())
{
char LED = Serial.read();
if (LED == '1')
{
digitalWrite(LED1, HIGH);
digitalWrite(LED2, LOW);
digitalWrite(LED3, LOW);
digitalWrite(LED4, LOW);
}
else if (LED == '2')
52 {
digitalWrite(LED1, LOW);
digitalWrite(LED2, HIGH);
digitalWrite(LED3, LOW);
digitalWrite(LED4, LOW);
}
Capacitação técnica na plataforma Arduino

else if (LED == '3')

{
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
digitalWrite(LED3, HIGH);
digitalWrite(LED4, LOW);
}
else if (LED == '4')
{
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
digitalWrite(LED3, LOW);
digitalWrite(LED4, HIGH);
}
else
{
Serial.print("Valor ");
Serial.print(LED);
Serial.println(" incorreto.");
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
digitalWrite(LED3, LOW);
digitalWrite(LED4, LOW);
} } }
Estrutura de decisão Switch / Case no Arduino

A estrutura de decisão condicional Switch / Case é utilizada para que seja

possível escolher uma opção dentre várias existentes, eliminando a
necessidade de se usar diversos if .. else encadeados. Isso simplifica a
codificação do algoritmo, e facilita sua depuração e atualização.

Sintaxe do Switch / Case :

switch (variável)
{
case (valor1):
comandos a executar
break;
case (valor2):
comandos a executar
break;
case (valor3):
comandos a executar
break;
case (valorN): 53
comandos a executar
break;
default:
comandos-padrão
break;
}

O conteúdo da variável passada para a instrução switch é testado, sendo

comparado com os valores de cada caso, e quando uma correspondência
for encontrada (variável igual ao caso), os comandos referentes ao caso são
executados. Se o primeiro caso não corresponder à variável, então o
próximo é avaliado, e assim sucessivamente até que uma correspondência
de valores seja encontrada. Caso nenhum caso corresponda, então os
comandos do bloco default serão executados, por padrão.

Note o uso da instrução break; em cada caso. Ela é utilizada para encerrar
as comparações caso um valor correspondente seja encontrado. Se essa
instrução não for utilizada, mesmo que uma correspondência seja
encontrada, o comando switch continuará a fazer comparações da variável
com os casos seguintes, o que é desnecessário.

Exemplo

Vejamos um exemplo de aplicação da estrutura switch / case no Arduino.

Vamos construir um circuito que consiste em quatro LEDs conectados às
saídas digitais do microcontrolador, que serão acesos de acordo com um
valor numérico fornecido por meio do monitor serial. Usaremos o switch /
case para ativar o LED correspondente, dependendo do valor fornecido.
 const int Led1 = 7;
const int Led2 = 8;
const int Led3 = 9;
const int Led4 = 10;

void setup() {
Serial.begin(9600);
pinMode(Led1, OUTPUT);
pinMode(Led2, OUTPUT);
pinMode(Led3, OUTPUT);
pinMode(Led4, OUTPUT);
}

void loop() {
if (Serial.available()) {
char Led = Serial.read();
switch (Led) {
case '1':
digitalWrite(Led1, HIGH);
digitalWrite(Led2, LOW);
digitalWrite(Led3, LOW);
digitalWrite(Led4, LOW);
break;
case '2':
digitalWrite(Led1, LOW);
digitalWrite(Led2, HIGH);
digitalWrite(Led3, LOW);
digitalWrite(Led4, LOW);
54 break;
case '3':
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
digitalWrite(Led3, HIGH);
digitalWrite(Led4, LOW);
break;
case '4':
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
digitalWrite(Led3, LOW);
digitalWrite(Led4, HIGH);
break;
default:
Serial.print("Valor ");
Serial.print(Led);
Serial.println(" incorreto.");
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
digitalWrite(Led3, LOW);
digitalWrite(Led4, LOW);
}
}
}
EX-13 - Utilizando comando if
• Elabore um programa utilizando o comando if de maneira que os botões controlem os
LEDs da seguinte forma:
• LED ligado ao pino 2 pisca a um ritmo de 100ms se nenhum botão estiver
pressionado.
• LED ligado ao pino 3 pisca a um ritmo de 100ms se o botão ligado ao pino 6 for
pressionado.
• LED ligado ao pino 4 pisca a um ritmo de 100ms se o botão ligado ao pino 7 for
pressionado.
• LED ligado ao pino 5 pisca a um ritmo de 100ms se os botões ligados aos pinos 6 e 7
forem pressionados simultaneamente.

55

Capacitação técnica na plataforma Arduino

EX-14 - Utilizando comando if – else.
• Modifique o programa exemplo anterior de modo que cada um dos 4 LEDS possam
ser acesos e apagados nas seguintes condições:
• Atribuir uma tecla para cada LED. Cada LED será aceso pela tecla relacionada à ele.
• Atribuir uma tecla para cada LED. Cada LED será apagado pela tecla relacionada à ele.
• Atribuir uma tecla que faça todos os LEDS acenderem;
• Atribuir uma tecla que apague todos os LEDS.
 Comando for.
O comando for é utilizado em estruturas de repetição quando queremos que uma operação
seja realizada algumas vezes, como por exemplo, fazer um led piscar um certo número de
vezes. A estrutura do comando for é a seguinte:

for (condição inicial; teste; incremento ou decremento)

{
Comandos;
}
Para entender melhor a utilização do comando for, vamos estudar o programa abaixo que
deve fazer o LED ligado ao pino 2 piscar exatamente 15 vezes.

int LED = 2;
int tempo = 100;
void setup()
{
pinMode(LED, OUTPUT);
}
56
Void loop()
{
digitalWrite(LED, HIGH);
delay(tempo);
Capacitação técnica na plataforma Arduino

digitalWrite(LED, LOW);
delay(tempo);
digitalWrite(LED, HIGH);
delay(tempo);
digitalWrite(LED, LOW);
delay(tempo);

REPETIR AS ÚLTIMAS 4 LINHAS POR MAIS

13 VEZES.

delay(1000);
}

Então, para fazer o LED piscar exatamente 15 vezes, é necessário escrever 15 vezes os
comandos para acender e apagar o LED.
Uma maneira mais simples e curta de fazer o mesmo utilizando o comando for pode
ser visto no exemplo a seguir:

int LED = 2;
int tempo = 100;
void setup()
{
pinMode(LED, OUTPUT);
}
Void loop()
{
for(int i = 0; i<15; i ++)
{
digitalWrite (LED, HIGH);
delay(tempo);
digitalWrite (LED, LOW);
delay(tempo);
}
delay(1000);
57
}

Capacitação técnica na plataforma Arduino

 Capítulo 18

Entradas analógicas.

Na plataforma Arduino, existem 6 entradas analógicas, A0 até A5, que são utilizadas para a
leitura dos valores de tensão analógica provenientes de sensores analógicos. Estas entradas
podem receber tensões entre 0 à 5V VDC.

A tensão proveniente do sensor (sinal, informação), será entregue à um circuito

conversor analógico – digital (A/D) que converterá o valor analógico do sinal em um valor
digital (binário) de 10 bits.

A resolução do conversor será:

Equação 1- Cálculo da resolução.

58 Então a cada 5mV aproximadamente, a palavra binária será modificada.

De (V) Até (V) Valor binário

0,00 0,00488 0000000000

0,00488 0,00976 0000000001

0,00976 0,01464 0000000010

... ...

4,9776 4,98248 1111111101

4,98248 4,98736 1111111110

4,98736 4,99712 1111111111

Tabela 9 - Valores da converção.

A função utilizada para ler os pinos analógicos é analogRead().

Vamos entender tudo isso de uma forma mais fácil, realizando um passo a passo desde o
início.
 GRANDEZAS DIGITAIS
Os sinais digitais são caracterizados por possuírem dois estados lógicos bem definidos,
observe:

OU

OU

59

Exemplos de estados logicos: Capacitação técnica na plataforma Arduino

 GRANDEZAS ANALÓGICAS
Os sinais analógicos são caracterizados por possuírem infinitos valores. Tomemos como
exemplo a temperatura:

Os sensores possuem a finalidade de realizar a medição de grandezas e converter estes

valores em sinais elétricos padronizados para que possam ser interpretados por sistemas
eletrônicos, observe:

60

Estes sinais são condicionados e padronizados para que possam ser interpretados por
sistemas digitais como microcontroladores e CLPs.
Exemplos de grandezas analógicas e sensores utilizados:

61
 Vamos, por exemplo, considerar uma resolução de 2 bits:

62

Cada estado corresponderá a uma parcela do valor da tensão total:

Imagine que seja colocado nesta entrada analógica, um valor de 3 Volts.

Qual seria o valor lido pela entrada analógica?

Três volts está dentro do pedaço 2, portanto o valor lido por essa entrada analógica será 2.
Perceba que uma resolução de dois bits pode não ser muito exata. Ao ler o valor dois,
sabemos que a tensão recebida naquela entrada pode ser qualquer valor entre 2,5V e
3,75V, ou seja, temos 1,25V de incerteza.

63

Por este motivo, é comum que as entradas analógicas utilizem resoluções mais altas, com
mais bits. Uma das resoluções mais comum utilizada na eletrônica é a de 10 bits o que nos
possibilita obter 1024 diferentes estados, observe:

Uma entrada analógica com Range de 0 a 5 volts com resolução de 10 bits, terá uma
exatidão muito maior do que aquela com 2 bits .
Dividindo 5v em 1024 pedaços obteremos 4,88mV (0,00488V) para cada divisão, bem
melhor do que os 1,75V obtidos anteriormente; Desta maneira, esta entrada analógica
poderá ler valores de 0 a 1023 sendo que 0 corresponde a zero volt e 1023 corresponde a
cinco volts. Podemos observar, portanto, que quanto maior nº de bits, maior será a
exatidão obtida.
 Na pagina oficial do Arduino quando buscamos o comando AnalogRead(), responsável por
realizar a leitura nas portas analógicas, encontramos a seguinte tabela com os valores da
tensão de operação e resolução máxima em cada tipo de placa.

Portanto, quando colocamos um valor de tensão na entrada analógica , o Arduino nos

responde um valor que vai de 0 a 1023, correspondente ao valor de tensão na entrada.

Para simular um sensor analógico, podemos utilizar um potenciômetro. Ele formará um

divisor de tensão e a tensão do cursor em relação ao negativo será aplicada à entrada
analógica. Desta forma, quando a posição do cursor do potenciômetro for alterada, a tensão
em relação ao cursor também irá variar.

64

ATIVIDADE PRÁTICA

Vamos utilizar um potenciômetro para obter uma tensão variável e observar, utilizando o
monitor serial, como o Arduino vai ler esta variação da tensão na entrada analógica.

Fig.46
Capítulo 19

Lendo sensores.

Outra função interessante no monitor serial é poder ver a leitura dos valores lidos em uma
entrada analógica. Desta forma, podemos “ver” o comportamento de um sensor e a partir
daí, aperfeiçoar o código. Vamos aperfeiçoar o programa anterior para testar isso.

// Monitor 6 Nome do programa.

// monitorando sensores:
int sensor = 0; Cria uma variável chamada sensor que está
ligada ao pino 0 (A0) do tipo int.
void setup() { Inicia-se o setup.
Serial.begin(9600); Inicia-se a comunicação serial.

}
void loop() { Inicia-se o método setup;
sensor = analogRead(A0); Atribui-se à variável sensor, o valor lido na
porta A0 analógica.
Serial.print(“Valor lido=”); Escreve na serial “Valor lido =”
65
Serial.println(sensor); Escreve o valor contido na variável sensor,
pula linha e retorna ao início da linha.
delay(1000); Atraso de 1 segundo.

} Capacitação técnica na plataforma Arduino

Figura 47- Lendo a variável analógica no monitor serial.

Grave o programa no microcontrolador; ligue o cursor do potenciômetro ao pino A0 e

os extremos ao Vcc e GND. Abra o monitor serial e varie a posição do cursor do
potenciômetro. Os valores dos extremos do potenciômetro correspondem aos valores
mostrados 0 e 1023.

Figura 48 - Valores mostrados no monitor serial.

Capítulo 20

Utilizando a função MAP.

A função map( ) permite efetuar o mapeamento de um intervalo numérico em outro intervalo numérico
desejado. Isso significa que em um intervalo numérico que vai de um valor mínimo até um valor máximo,
o valor mínimo será mapeado em um novo mínimo, e o valor máximo será mapeado em um novo máximo,
e os valores intermediários serão remapeados em novos valores intermediários, de forma
correspondente.

Sintaxe:

map (variável, Mínimo Atual, Máximo Atual, Novo Mínimo, Novo Máximo);

onde:
▪ Variável: Contém o valor do número a ser mapeado.
▪ Mínimo Atual: Limite inferior do intervalo de valores atual
▪ Máximo Atual: Limite superior do intervalo de valores atual
▪ Novo Mínimo: Limite inferior do novo intervalo de valores mapeados
▪ Novo Máximo: Limite superior do novo intervalo de valores mapeados

Exemplo: Queremos mapear os valores em um intervalo que vai de 0 a 1023 para um novo intervalo entre
0 e 200. Os valores atuais serão lidos a partir de uma variável chamada valor, e os novos valores mapeados
serão gravados em uma variável de nome novo valor:

Novo valor = map(valor,0,1023,0,200);

Desta forma, toda vez que um valor entre 0 e 1023 for gravado na variável valor, ele será mapeado
para seu correspondente no intervalo entre 0 e 200, e esse novo valor será atribuído à variável novo
valor.
A função também pode mapear valores de forma inversa, bastando para isso trocar a posição
dos valores mínimo e máximo novos:

Novo valor = map(valor,0,1023,200,0);

A função map() opera somente com números inteiros, não retornando valores de ponto flutuante
(fracionários). Se um número fracionário for gerado, ele será truncado antes de ser retornado. A função
não arredonda os valores mapeados.

Na prática

Vamos aplicar a função map() em um projeto simples. Usando um potenciômetro como um divisor
resistivo de tensão e aplicando sua saída a um pino analógico, os valores retornados, que por padrão estão
no intervalo entre 0 e 1023 (resolução de 10 bits dos pinos analógicos), serão remapeados para um outro
intervalo, de 8 bits (valores entre 0 e 255). Os valores lidos serão exibidos no monitor serial.
Para isso, vamos conectar o potenciômetro entre os pinos 5V e GND e seu terminal central (divisor de
tensão) será conectado ao pino analógico A0, a partir de onde será feita a leitura do valor da tensão
elétrica.
Observe o circuito na figura a seguir:

67

const int potenciometro = 0;

int valor = 0.0;
int valor_mapeado;
void setup() {
Serial.begin(9600);
}
void loop() {
valor = analogRead(potenciometro);
valor_mapeado = map(valor,0,1023,0,255);
Serial.print("valor = ");
Serial.print(valor);
Serial.print("............");
Serial.print("valor_mapeado = ");
Serial.println(valor_mapeado);
delay(200);
}
 Controlando brilho de LED com o Potenciômetro
O dimmer é um dispositivo que controla a luminosidade de uma lâmpada através de um
potenciômetro. Neste exemplo vamos mostrar como este conceito pode ser aplicado à programação
do Arduino controlando o brilho de um LED usando a função analogWrite().

68

#define pot 0
#define led 9
int valPot = 0;
int brilho = 0;
void setup() {
pinMode(led,OUTPUT);
}
void loop() {
valPot = analogRead(pot);
brilho = map(valPot,0,1023,0,255);
analogWrite(led,brilho);
}
EX- 15 – Mapeando o potenciômetro.

• Monte um circuito com 5 LEDs, sendo dois verdes, um vermelho e dois amarelos
conectados nas saídas 2,3,4, 5 e 6 do Arduino, respectivamente.
• Faça o mapeamento do potenciômetro.
• Elabore um programa que faça o LED vermelho acender quando o potenciômetro
estiver na metade do seu curso. O LED verde conectado ao pino 2 deve acender com o
potenciômetro em 230°. O LED verde ligado ao pino 3, acende quando o
potenciômetro estiver em 185°. O LED amarelo conectado ao pino 6 acende com o
potenciômetro em 50° e o LED ligado ao pino 5 acende com o potenciômetro em 95°.
Use o espaço abaixo para fazer suas anotações.

69
 O LDR (Light Dependent Resistor) resistor dependente da luz, é um dispositivo cujo valor
da resistência entre os seus terminais, depende da quantidade de luz que chaga até o seu
corpo. Quanto mais luz chega até o dispositivo, menor será o valor da resistência. E
quanto menos luz chega até o dispositivo, maior será a resistência entre os seus
terminais. Para ligar um LDR à uma porta analógica do Arduino, é necessário montar um
circuito divisor de tensão.

Caso o resistor ligado esteja conectado ao positivo da

fonte de alimentação (pull-up), quanto menos luz
chegar até o LDR, maior será a tensão aplicada à entra-
da analógica. Então o circuito se comportará como um
sensor de sombra.

Figura 50 - Sensor de sombra.

70 Já se o LDR é que for diretamente conectado ao positivo

da fonte de alimentação, então quando mais luz chegar
ao LDR, maior tensão será aplicada à porta analógica e o
circuito se comportará como um sensor de luz.
Capacitação técnica na Plataforma Arduino

Figura 51 - Sensor de sombra.

EX- 16 – Controlando o Led com o LDR.

Desenvolva um programa onde um LDR controle o ritmo das piscadas do LED que deve
ser proporcional a intensidade da luz que o atinge.
Capítulo 21

PWM.

PWM (Pulse Width Modulation) – modulação por largura de pulso – é uma técnica utilizada
para obter um valor analógico a partir de uma variação digital. Em uma saída digital, a
tensão poderá variar entre +5V e 0. Se o nível lógico da saída for sempre 1 ou sempre 0, o
resultado será um valor constante. Porém se em vez de fixar a saída em um valor único e
sim fazer variá-lo entre 1 e 0 (+5V e 0), a tensão resultante não será mais constante e sim
uma proporção do valor máximo da tensão, ou seja uma porcentagem de +5V.

Independentemente da frequência, se uma saída variar o entre 1 e 0 de tal forma que

em cada período, o valor da tensão (+5V) perdure por exatos 50% do tempo total do
período (o nível 0 terá a mesma duração), o valor médio da tensão será exato 2,5V.

A relação entre o tempo em que temos o pulso (t1) e a duração de um ciclo completo
do sinal (T) define o ciclo ativo, conforme é mostrado na figura abaixo.

71

Capacitação técnica na plataforma Arduino

Figura 52 - Onda quadrada.

O valor médio da tensão poderá ser obtido multiplicando o máximo valor da tensão
pelo valor do ciclo ativo, conforme a fórmula:

Equação 2 - Cálculo do valor médio.

Assim, se o tempo de duração do nível alto for alterado, será possível obter um valor
médio de tensão entre 0 e 5V.

Na placa do Arduino UNO e equivalentes, apenas algumas saídas digitais podem ser
utilizadas como saídas PWM, são as saídas dos pinos 3, 5, 6 ,9, 10 e 11, sendo que a
frequência da tensão nessas saídas quando utilizadas como PWM é de 490Hz.

A função analogWrite(pino,valor) configura o pino indicado como sendo uma saída PWM
e portanto, nele existirá um sinal com frequência igual a 490HZ, com o ciclo ativo definido
pelo valor dentro do parênteses. O parâmetro valor corresponde a variação de 0 até 255.
Se valor = 0, a tensão na saída será 0V, se valor = 255, a tensão na saída será 5V.
.
 Em resumo:
PWM, do inglês Pulse Width Modulation, é uma técnica utilizada por sistemas digitais para
variação do valor médio de uma forma de onda periódica. A técnica consiste em manter a
frequência de uma onda quadrada fixa e variar o tempo que o sinal fica em nível lógico alto.
Esse tempo é chamado de duty cycle (ciclo ativo) da forma de onda. No gráfico abaixo são
exibidas algumas modulações de PWM:

EXEMPLO : Controlando o brilho do led através de um sinal PWM

72
Capacitação técnica na Plataforma Arduino

// Controla o brilho de um LED através de um sinal PWM.

int ledPin = 9; // LED no pino PWM 9
void setup() {
}
void loop() {
// aumenta o brilho do LED de 0 a 255, num incremento de valor +5
for(int Valor = 0 ; Valor <= 255; Valor +=5) {
analogWrite(ledPin, Valor);
// aguarda 30 milissegundos para o efeito de fading
delay(30);
}
// diminui o brilho do LED de 255 a 0, num incremento de valor -5
for(int Valor = 255 ; Valor >= 0; Valor -=5) {
analogWrite(ledPin, Valor);
delay(30);
}}
EX- 17 – Controlando o Led com PWM.

O objetivo é controlar o brilho de um LED utilizando a técnica de PWM. Para isso, ligue
um potenciômetro à uma entrada analógica e o LED a uma das I/O digitais que podem
executar a função PWM.
Elabore o código utilizando as funções analogRead para ler o valor do potenciômetro e
transformar em um valor binário, e a função analogWrite que escreve na saída digital, o
valor indicado.

int led = 11;

unsigned int valorLido;
unsigned int pwm; 73
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
valorLido = analogRead(A0);
pwm = map(valorLido, 0, 1023, 0, 255);
analogWrite(led,pwm);
}
 Capítulo 22

O sensor de temperatura.

O CI LM35 é um circuito integrado com a função de trabalhar como sensor temperatura

de precisão, com tensão de saída linearmente proporcional à temperatura dada em ºC.
O LM35 não necessita de qualquer calibração externa e pode proporcionar precisão de
± 0,5 ° C à temperatura ambiente. De baixo custo está classificado para operar em uma
faixa de -55 ° C a +150 ° C.

Como o CI fornece uma tensão de ~10mV a cada ºC de variação de temperatura ele não
percorre toda a gama possível de valores disponíveis na entrada analógica (0 – 5), então, é
comum aplicar uma fórmula para melhorar a faixa de leituras que é a seguinte:

Temperatura = AVcc* analogRead(pinoanalógico)*100/1024

Equação 3 - fórmula de ajuste para temperatura.

O programa que pode ser utilizado para a leitura da temperatura no terminal serial é o
seguinte:

74 int pinoSensor = 0; Declaração da variável pinoSensor onde

será ligado o terminal de saída do
LM35 e deve ser conectado no pino A0
da placa.
Capacitação técnica na Plataforma Arduino

int valorLido = 0; Declaração da variável valorLido e

float temperatura = 0; temperatura.

void setup() { Inicia-se o método setup e a

Serial.begin(9600); comunicação serial.
}
void loop() { Inicia-se o método loop.

valorLido = analogRead(pinoSensor); Atribui-se à variável “valorLido” o valor

que está na variável “pinoSensor”.

temperatura = 5.0*analogRead(pinoSensor)*100.0/1024; Aplica-se a fórmula para ampliação da

faixa de leitura.

Serial.print(“Temperatura atual: “); Escreve na serial o valor da temperatura

Serial.println(temperatura); lido.

delay(1000); Atrasa o programa em 1 segundo.

}

Verifique se o código escrito está correto e grave-o no micro. Abra o monitor serial e veja a
indicação da temperatura. Para variar o valor da temperatura, basta segurar com os dedos
o corpo do LM35.
Fazer o mapeamento deste sensor permite atribuir ao valor lido, uma outra gama de
leituras.

//temperatura com map. Nome do programa

int pinoSensor = 0; Declarando as variáveis

pinoSensor atribuindo o
int valorLido = 0; valor 0 que corresponde ao
pino A0 da placa Arduino.
float temperatura = 0;
valorLido é uma variável
onde será guardado o valor
já transformado em binário
apresentado à entrada A0.

Temperatura é a variável
que guardará o valor lido
e aplicada a função map
da temperatura lida.

void setup() { Início do método setup

Serial.begin(9600); Inicia-se a comunicação serial

75
}

void loop() { Método loop

valorLido = analogRead(pinoSensor); Atribui-se à variável valorLido,

o valor existente em
pinoSensor, ou seja, em A0.

temperatura = 5.0* analogRead(pinoSensor)*100.0/1024; Aplica a fórmula no valor

lido do pinoSensor (A0).

temperatura = map (temperatura, 25,31,0,100); Aplica a função map

Serial.print(“Temperatura atual: “); Imprime a frase e o valor lido.

Serial.println(temperatura);

delay(1000); Retarda em 1 segundo.

Figura 54 - Mapeando o LM35.

 EX- 23 – Mapeando o sensor de temperatura.
• Monte um circuito com 5 LEDs, sendo dois vermelhos, dois amarelos e um
verde conectados nas saídas 3,4,5, 6 e 7 do Arduino, respectivamente.
• Faça o mapeamento do sensor de temperatura.
• Elabore um programa que faça o LED verde acender entre 0 e 50%. Os LEDs
amarelos, devem acender entre 50 e 60% e entre 60 e 70% respectivamente.
Os LEDs vermelhos, acendem entre 70 e 80% e entre 80 e 100%.
• Os LEDs devem permanecer acesos e só apagarão quando a condição não for
verdadeira.

76
Capacitação técnica na plataforma Arduino
Capítulo 26

Utilizando o relé.

Sempre que a tensão requerida pela carga e/ou a corrente solicitada pela carga
forem maiores do que a tensão de alimentação da placa Arduino (5V) ou maior do
que a máxima corrente que uma saída pode fornecer (40mA), é necessário utilizar
um dispositivo de interface entre a plataforma Arduino e o que se quer utilizar.

O Relé é um dispositivo muito utilizado quando a tensão da carga não é com-

patível com a utilizada na plataforma Arduino e em especial, quando a carga for
por exemplo uma lâmpada ou um dispositivo eletrônico alimentado pela rede
elétrica.

Não é recomendado, embora possa ser possível a ligação direta da bobina do relé
na saída da plataforma Arduino e por isso, utiliza-se um transistor que terá a fun-
ção de trabalhar como uma chave eletrônica, recebendo em sua base, um sinal de
tensão em baixíssima potência e podendo acionar com folga a bobina do relé.

O esquema abaixo mostra como o relé está interligado como o transistor. Existe
ainda um LED e um resistor, não mostrados no esquema que tem a função de
indicar quando o módulo recebe um sinal na entrada.

O diodo em paralelo com a bobina do relé, serve para eliminar os efeitos da des-
carga da bobina no momento do seu desligamento.

O acionamento do relé pode ser parecido com o tipo de acionamento utilizado

para o LED. Basta estabelecer uma condição relacionada ao estado do botão. Se o
botão estiver em 1, o relé deve permanecer desligado e se o botão estiver em 0,
o relé deve ser acionado.

Figura 55 - Relê acionado por transistor.

O código a seguir mostra isso.

//Acionando rele com botão. Nome do programa

int BOTAO = 5 ; Variável botão relacionada ao pino 5

int RELE = 7 ; Variável relé relacionada ao pino 7

int val = 0; Variável val que armazenara valores intermediários

void setup(){ Método setup.

pinMode(RELE,OUTPUT); Estabelece o pino 7 como saída digital.

pinMode(BOTAO,INPUT); Estabelece o pino 5 como entrada digital.

void loop(){ Método loop

val=digitalRead(BOTAO); Atribui a variável val, o valor lido na variável botão.

if(val==HIGH) Testa o valor de val se igual a 1

digitalWrite(RELE,LOW); Se verdadeiro, a variável relé vai para 0

else Se não
85
{

digitalWrite(RELE,HIGH); A variável relé vai para 1.

Capacitação técnica na plataforma Arduino

}

Figura 56 - Código para acionar um relé.

Para montar o circuito utilize um botão com o seu resistor pull-up conectado ao
pino 5 e o módulo do relé que será conectado ao pino 7 da placa Arduino.

As vezes utilizamos um botão para ligar e outro botão para desligar o circuito. O
programa a seguir faz isso.

//Botao liga e botao desliga Nome do programa

const int bliga = 5; Declara a variável bliga e atribui o pino 5.

const int bdesliga = 4; Declara a variável bdesliga e atribui o pino 4.

const int ledPin = 3; Declara a variável ledPin e atribui o pino 3.

int bliga1 = 1; Declara a variável bliga1 e atribui o valor inicial igual a

1..

int bdesliga1 = 1; Declara a variável bdesliga1 e atribui o valor inicial igual

a 1.

void setup() { Inicia o setup

pinMode(ledPin, OUTPUT); Estabelece a variável ledPin como saída

 pinMode(bliga, INPUT); Estabelece a variável bliga como entrada

pinMode(bdesliga,INPUT); Estabelece a variável bdesliga como entrada.

void loop(){ Método loop

bliga1 = digitalRead(bliga); Atribui a variável bliga1 o valor lido em bliga

bdesliga1 = digitalRead(bdesliga); Atribui a variável bdesliga1 o valor lido em bdesliga

if (bliga1 == LOW) { Lê e compara o estado de bliga1 se igual a 0

digitalWrite(ledPin, HIGH); Se verdadeiro, a variável ledPin assume 1

if (bdesliga1 == LOW) { Lê e compara a variável bdesliga se igual a 0

digitalWrite(ledPin,LOW); Se verdadeiro, a variável bdesliga assume 0

Figura 57 - Botão Liga e botão desliga.

86
Capacitação técnica na plataforma Arduino
EX- 24 – Acionando o relé em uma determina temperatura.
Utilize o mesmo circuito e programa utilizado no exercício anterior.

• Monte um circuito com 5 LEDs, sendo dois vermelhos, dois amarelos e um

verde conectados nas saídas 3,4,5, 6 e 7 do Arduino, respectivamente.
• Faça o mapeamento do sensor de temperatura.
• Elabore um programa que faça o LED verde acender entre 0 e 50%. Os LEDs
amarelos, devem acender entre 50 e 60% e entre 60 e 70% respectivamente.
Os LEDs vermelhos, acendem entre 70 e 80% e entre 80 e 100%.
• Os LEDs devem permanecer acesos e só apagarão quando a condição não for
verdadeira.
• Acrescente um relé ao circuito e que este seja acionado quando o primeiro LED
vermelho for aceso.

87

Capacitação técnica na plataforma Arduino

Capítulo 27

Utilizando o sensor reflexivo.

O sensor reflexivo TCRT5000 da Vishay, é composto por um LED emissor infraver-

melho e um foto transistor receptor de infravermelho, utilizado para leitura de
encoder, detecção de material reflexivo entre outras aplicações. O princípio de
funcionamento baseia-se em que o foto transistor receberá a quantidade de luz
refletida em um objeto posicionado à frente do foto diodo. Como a emissão é na
faixa de infravermelho, a luz ambiente pouco influencia na leitura feita pelo foto
transistor.

Figura 58 - Sensor reflexivo.

Para utilizar o sensor é necessário acrescentar um resistor para limitar a corrente

do LED (R1) e um para polarizar o coletor do foto transistor.

Inicialmente vamos utilizar o programa abaixo para ler na entrada analógica, na

plataforma Arduino, o valor de tensão fornecida pelo sensor e utilizaremos o ter-
minal serial para visualizar o valor.

// Lendo sensor IR Nome do programa

Declarando a variável sensorIR que

int sensorIR= 0;
está associada ao pino A0.

void setup(){ Método setup

 Serial.begin(9600);
Inicia a comunicação serial
}

void loop(){ Método loop

Escreve no terminal o valor lido em

Serial.println(analogRead(sensorIR));
sensorIR, já convertido e de 0 até 1023.

delay(250);
Atraso de 250m segundos
}

Figura 59 - Lendo o sensor reflexivo.

89

Capacitação técnica na plataforma Arduino

 EX- 25 – Reconhecendo cores.
Monte o circuito para que o sensor seja lido e elabore um programa para que o
sensor possa reconhecer cores.

90
Capacitação técnica na plataforma Arduino
Capítulo 28

Controle de motor DC.

Existem várias maneiras de controlar um motor DC. Veremos algumas delas e é

necessário ter em mente que utilizaremos apenas motores de baixa potência

O esquema mostra um transistor controlado pela base que está conectada à saída
PWM do microcontrolador. Conforme a saída PWM é variada, a velocidade do motor
também é alterada e consegue-se assim um bom e simples controle de velocidade.

Figura 60 - Controle de velocidade de motor DC.

O código para controlar este circuito é o seguinte:

Figura 61 - Código para controle de velocidade de motor DC.

 Porém, este circuito não permite o controle de direção do motor, apenas a velo-
cidade. Existem muitas aplicações onde o controle de direção é importante e isto
será possível se for utilizada uma ponte H.

O funcionamento da ponte H é baseado no acionamento de 2 transistores de

tipos diferentes simultaneamente, criando um caminho para a corrente de forma
a controlar o sentido da rotação do motor

A figura ao lado permite ter uma ideia do fun-

cionamento do circuito.

Considerando que cada interruptor Sn é um

transistor, pode-se perceber que o motor gira-
rá em um ou em outro sentido quando um dos
interruptores de número ímpar e outro de nú-
mero par estiverem fechados.

Figura 62 - Ponte H com interruptores.

92 A figura abaixo, mostra as possibilidades de combinação dos interruptores. Nota-

-se que no segundo e no terceiro esquema, o motor gira em um sentido. No quarto
e quinto, o motor fica parado.
Capacitação técnica na plataforma Arduino

Figura 63 - Sentido da rotação do motor.

Porém, é importante impedir o acionamento conjunto de um dos lados da pon- te.

Isto causará um curto circuito e o inevitável dano do microcontrolador. A figu- ra
abaixo, mostra isso.

Figura 64 - Acionamentos não permitidos.

O circuito que utilizaremos para controlar a direção da rotação do motor
é o seguinte:

Figura 65 - Circuito ponte H com transistores.

Os transistores do tipo NPN são BC548 ou equivalentes.

Os transistores do tipo PNP são BC558 ou equivalentes.

Os diodos são do tipo 1n4148 ou equivalentes.

93
Nos resistores de base serão conectadas as saídas digitais da placa Arduino.

Capacitação técnica na plataforma Arduino

As entradas InA e InB controlarão o sentido da rotação do motor. Desta forma, só
serão possíveis 4 combinações, sendo:

InA InB Resultado

0 0 Motor parado
0 1 Esquerda para a direita
1 0 Direita para a esquerda
1 1 Motor parado
Tabela 10 - Controle do motor.

Para testar o funcionamento do circuito, podemos utilizar o programa abaixo

que fará ao acionamento intermitente do motor.

//Controle DC
void setup(){
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
digitalWrite(10, HIGH); // para o motor
digitalWrite(11, HIGH);
 }
void loop(){
digitalWrite(10, HIGH); // primeira direção
digitalWrite(11, LOW);
delay(1000); // espera 1 segundo
digitalWrite(10, LOW); // segunda direção
digitalWrite(11, HIGH);
delay(1000); // espera 1 segundo
}
Figura 66 - Programa para teste do circuito da ponte H.

94
Capacitação técnica na plataforma Arduino
EX- 26 – Controle de velocidade e direção de um motor DC através
de ponte H com transistores.
• Elabore um programa contendo 3 botões e um potenciômetro. Os botões terão
as seguintes funções: Quando o botão 1 for pressionado, o motor deve girar
para a direita. Quando o botão 2 for pressionado, o motor deve girar para a
esquerda e quando o botão 3 for pressionado, o motor deve parar. A velocidade
do motor deve ser ajustada com o auxílio de um potenciômetro.

95

Capacitação técnica na plataforma Arduino

Capítulo 29

Utilizando o L293D.

O CI L293D é constituído por 4 drivers de cor-

rente com capacidade de fornecer corrente bi-
direcional de até 600mA em tensões de 4,5 a
36V. Tem capacidade de acionar cargas induti-
vas como relés, solenoides, motor bipolar e de
passo, bem como outras cargas de alta corren-
te ou tensão.

Figura 67 - Pinagem L293D

Todas as entradas são compatíveis com padrão TTL

e as saídas contém um circuito totem-pole com
transistor Darlington. Cada driver, tem funciona-
mento independente, más são acionados em con-
junto pela entrada EN (ENABLE) que habilitará ou
não cada uma dos drivers associados.

Figura 68 - Ligações internas do L293D.

A tabela ao lado, mostra como cada driver é

acionado.

Tabela 11- Comportamento do Driver do L293D.

Para verificar o funcionamento, vamos montar o circuito que possibilite o contro-
le de direção do motor, Para determinar o sentido de rotação do motor, utilizare-
mos um botão, que será ligado ao pino 2 da plataforma Arduino. O código para
controlar o circuito está mostrado a seguir.

// Controle L293D Nome do programa.

int botao = 2; Declara a variável botão e atribui a ela o pino 2.

int motor1Pin1 = 3; Declara a variável motor1Pin1 e atribui

o pino 3 da plataforma Arduino que será
conectado ao pino 2 do L293D

int motor1Pin2 = 4; Declara a variável motor2Pin2 e atribui

o pino 4 da plataforma Arduino que será
conectado ao pino 7 do L293D.

int enablePin = 9; Declara a variável enablePin e atribui o

pino 9 da plataforma Arduino, que será
conectada ao pino 1 do L293D.

void setup() { Método setup.

pinMode(botao, INPUT); Define a variável botao como entrada.

pinMode(motor1Pin1, OUTPUT); Define as variáveis como saída

pinMode(motor1Pin2, OUTPUT);

pinMode(enablePin, OUTPUT);
97
digitalWrite(enablePin, HIGH); Escreve na variável enable, o valor 1

Capacitação técnica na plataforma Arduino

void loop() { Método setup

if (digitalRead(botao) == HIGH) { Compara se o valor lido na variável botão é igual a 1.

digitalWrite(motor1Pin1, LOW); Se sim, escreve em motorPin1, o valor 0 e em

motorPin2, o valor 1. O motor girará em um sentido.
digitalWrite(motor1Pin2, HIGH);

else { Se não,

digitalWrite(motor1Pin1, HIGH); Se sim, escreve em motorPin1, o valor 1 e em

motorPin2, o valor 0. O motor girará no sentido oposto.
digitalWrite(motor1Pin2, LOW

}
Figura 69 - Programa para controle de motor com L293D.
 EX- 27 – Controle de velocidade e direção de um motor DC com CI
L293D
Elaborar o programa para controle de direção e de velocidade de um motor DC
utilizando o CI L293D.

98
Capacitação técnica na plataforma Arduino
Capítulo 30

Motor de passo.

Motores de passo são utilizados em uma ampla variedade de aplicações na indús-

tria, incluindo periféricos de computador, controle de movimento e robótica.É um
tipo de motor elétrico que pode ser controlado por circuitos digitais.

A diferença entre um motor de passo e um motor dc é que ao ser energizado, a

cada pulso de corrente, ocorre um movimento discreto do eixo de motor (passo)
enquanto que um motor dc, ao ser energizado, o movimento é contínuo.

Figura 70 - Diferença entre motor DC e motor de passo.

Um dos tipos de motor de passo disponível é o unipolar que pode ter 5 fios dispo-
níveis. 4 fios são os extremos das bobinas do motor e o quinto é o GND.

Figura 71- Motor de passo unipolar.

 Para saber qual o ângulo de deslocamento do motor (passo) realizamos a divisão
de 360º pelo número de passos do motor.

Existem três tipos básicos de movimentos o de passo inteiro, o de meio passo e

o micropasso.

Para o movimento passo inteiro, a sequência de acionamento das bobinas deve

obedecer a tabela mostrada a seguir:

Considerando 1 igual à Vcc, o eixo do motor será deslocado a razão de 1 passo

por vez.

(8 -4 -2 -1)

Repetindo-se esta sequência, o eixo do motor fará um giro de 360º.

100
Tabela 12 - Acionamento do motor de passo.
Capacitação técnica na plataforma Arduino

Para fazer o movimento contrário, basta fazer a mesma sequência, más na ordem
inversa. (1 – 2 – 4 – 8).

O programa para controlar o motor pode ser o seguinte:

int motorPin1 = 8;
int motorPin2 = 9;

int motorPin3 = 10;

int motorPin4 = 11;

int delayTime = 500;

void setup() {

pinMode(motorPin1, OUTPUT);

pinMode(motorPin2, OUTPUT);

pinMode(motorPin3, OUTPUT);
 pinMode(motorPin4, OUTPUT);

void loop() {
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, LOW);
delay(delayTime);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, LOW);
delay(delayTime);

digitalWrite(motorPin1, LOW);

digitalWrite(motorPin2, LOW);

digitalWrite(motorPin3, HIGH);

digitalWrite(motorPin4, LOW);

delay(delayTime);

digitalWrite(motorPin1, LOW); 101

digitalWrite(motorPin2, LOW);

Capacitação técnica na plataforma Arduino

digitalWrite(motorPin3, LOW);

digitalWrite(motorPin4, HIGH);

delay(delayTime);

}
Figura 72- Programa para teste do motor de passo.

Para acionarmos o motor de passo, utilizamos por exemplo CI ULN 2003.que con-
siste basicamente de 7 inversores (Darlington) com capacidade de corrente de
500mA cada um.

Figura 73 - Ci ULN2002A
 EX- 28 – Controle de motor de passo com ULN2003.
• Elaborar o programa para controle de motor de passo com ULN2003.

102
Capacitação técnica na plataforma Arduino
Capacitação realizada entre os dias 7 de agosto a 13 se setembro, na
ETEC Aristóteles Ferreira em Santos – SP.
Esta publicação foi impressa em papel offset 90g/m2 (miolo) e
papel couché 230g/m2 (capa).

Fontes utilizadas: Colaborate título 25pt, subtítulo 14pt, Palatino

texto 10pt, Helvetica neue (quarta capa) 8pt.
 CARLOS BARREIRA DA SILVA FARINHAS

Licenciado em Eletrônica, ministra aulas desde 1986. Interessado por sistemas

microcontrolados, desde 2011 realiza estudos sobre a utilização da plataforma Arduino
como recurso didático para ensino de programação associada aos circuitos eletrônicos.
Atualmente ministra aulas cujos temas estão relacionados com sistemas digitais, tanto na
ETEC Aristóteles Ferreira como no IFSP - Campus Cubatão.