Você está na página 1de 83

Capacitação técnica:

Automação utilizando a
plataforma Arduino.
OUTONO 2015
PROFESSOR CARLOS BARREIRA
CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
" Há três métodos para ganhar sabedoria: primeiro, por
reflexão, que é o mais nobre; segundo, por imitação, que é
o mais fácil; e terceiro, por experiência, que é o mais
amargo.” (Confúcio)

3
1 – 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 (Input/Output) em um único chip projetado para que possam ser
conectados diretamente aos pinos de I/O, diversos tipos de sensores, LEDs, pequenos motores, relés, etc
e, através desses mesmos pinos, é possível ler tensões (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 projetos com microcontroladores. Foi desde o início
desenvolvido 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.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
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.

Existem outras placas disponíveis como a DUE que possui por exemplo, um número maior de I/O
e também algumas placas que podem ser adicionadas a placa do Arduino e acrescentam funcionalidades
à plataforma, conhecidas com shields. Um exemplo disso é o shield ethernet que permitirá que o Arduino
se conecte à internet a partir de qualquer tomada RJ45.
Esses e outros produtos disponíveis podem ser vistos no site: arduino.cc/en/main/products

Como o projeto é aberto, além dos modelos oficiais, existem diversas empresas e grupos que a
partir da documentação disponível, desenvolvem produtos e em muitos casos também os 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 que é um
projeto nacional que pode ser livremente reproduzido e toda
a documentação pode ser encontrada nesta página:

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

Outro exemplo é o projeto que será utilizado nesta


capacitação comercializado pela empresa EMPRETEC que é
uma placa Arduino compatível baseada no modelo
Duemilanove.
Detalhes sobre a placa e outros produtos podem ser
vistos no site da empresa no link abaixo.

http://www.empretecnet.com.br/Produto/53/arduino_(compativel_com_uno_e_duemilanove) 5
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.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
Características:
- Arquitetura RISC.
- 130 instruções otimizadas para trabalhar com compiladores de alto nível em especial o C, a
maioria executada em apenas 1 ciclo de relógio.
- Possui 32 registradores de propósito geral de 8 bits (R0 a R31)
- Operação de até16MIPS (milhões de instruções por segundo) a 16MHz
- 8 KBytes me memória de programa FLASH de auto programação In-System.
- 512 Bytes de memória EEPROM.
- 1KByte de memória SRAM.
- Ciclos de escrita e apagamento: memória FLASH 10.000 vezes, EEPROM 100.000 vezes.

Periféricos:
- 23 I/O programáveis;
- 2 temporizadores/contadores de 8 bits com Prescaler separado, 1 modo de comparação.
- 1 temporizadores/contadores de 16 bits com Prescaler separado, modo de comparação e
captura.
- contador de tempo real (com cristal externo de 32.768 Hz) conta 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.

7
Descrição dos pinos:

Esta imagem e muitas outras informações uteis podem ser acessadas no site:

http://www.pighixxx.com/test/

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
4 – O conjunto didático da empresa EMPRETEC.
A EMPRETEC é uma empresa nacional que desenvolveu um projeto próprio baseado na
plataforma Arduino. Utilizando o modelo Duelmilanove como base, a placa é compatível com o modelo
UNO, observando-se que as funcionalidades agregadas ao projeto UNO – R3 (última versão), não estão
disponíveis.
O kit consiste basicamente de uma placa Arduino – compatível e um conjunto de peças
disponíveis em pequenas placas de PCI contendo barramentos para conexões de fios, além de matriz de
contatos e componentes soltos como LEDs e resistores.

Informações sobre o kit podem ser obtidas neste endereço:

http://www.empretecnet.com.br/Produto/54/kit_arduino

9
5 – A placa Arduino compatível - EMPRETEC.

A figura a seguir, mostra a placa desenvolvida pela


EMPRETEC. Faremos uma pequena descrição de suas partes.

Esta placa será conectada ao computador através da


entrada USB. Por essa conexão, a placa será alimentada com
5V e também se comunicará com o computador.

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 com tensão entre
7,5V e 12V através de um pino tipo P2.

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.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
Os terminais mais externos do são destinados à 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.

A segunda fileira de terminais é destinada à distribuição de


5V, que também pode ser encontrada nos terminais POWER.

Os terminais internos que estão na terceira fileira do conector,


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

11
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.

Além de serem pinos de I/O, alguns tem funcionalidades


específicas que estão descritas a seguir.

Terminais Denominação Descrição

RX – Utilizado para receber dados Estes terminais além de estarem


0 conectados aos pinos TXD e RXD do
seriais TTL
microcontrolador, também estão
ligados ao CI FTDI que faz a
TX – Utilizado para transmitir comunicação serial entre o
1
dados seriais TTL microcontrolador e o computador.

Estes pinos podem ser configurados


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

3, 5, 6, 9, 10 e 11. PWM (Pulse Width Modulation) Fornecem uma saída PWM de 8 bits.

10 (SS) (Slave Select)


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

O pino 13 também está conectado à


13 LED
um LED que está montado na placa.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
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.

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-
A5 SCL (Serial Clock Line) Wire Interface).

13
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 17 - 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.

Comunicação com o PC. Estes LEDs


indicarão quando um programa está sendo
transferido do computador para o
microcontrolador.

LED
conectado
ao pino13

POWER indica que


a placa ligada

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
6 – A Linguagem utilizada para programação.
A plataforma Arduino utiliza a linguagem de programação Arduino baseada em Wiring ,linguagem
de programação open-source para microcontroladores. http://wiring.org.co/
A estrutura desta linguagem é muito parecida com a linguagem C sendo que aqueles que
dominam 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 feitas 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 e executada 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á sem do feito. A
palavra setup (e as outras utilizadas na linguagem de programação do Arduino) devem ser escritas como
determina a referência da linguagem. Os dois parênteses escritos logo a seguir, nesta função, serão
vazios, sem parâmetros, porém não poderão ser suprimidos.
A função loop()
Logo após a função setup, a função loop é chamada 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.
Variáveis:
Chama-se variável a tudo o que tem mais do que um estado. Por exemplo, o LED possui dois
estados definidos, o aceso e o apagado. Uma variável serve então para armazenar um estado e para fazer
isso, é necessário reservar um espaço na memória do microntrolador. Na programação, o estado da
variável será lido ou modificado em função sempre na posição da memória em que foi guardado.
Variáveis podem ser globais ou locais. As globais, servem para o programa todo. Podem ser
chamadas, lidas e alteradas em qualquer momento e para isso, ocupam uma posição física definitiva na
memória. As variáveis globais são criadas antes do bloco setup. As locais, servem apenas ao trecho do 15
programa em que elas estão e da mesma forma podem ser lidas e alteradas, porém, precisam ser criadas
no local onde serão necessárias e existirão apenas nele. Assim, ocupam menos espaço, pois o local onde
existirão será criado ou alocada a posição de memória apenas no momento em que serão utilizadas.
Para criar uma variável o primeiro passo é dar um nome a ela e depois, determinar qual o seu
tipo. Isso determinará quais valores a variável receberá (números ou caracteres) e o espaço que será
reservado na memória do microcontrolador para armazenar os valores que ela receberá. A tabela resumo
abaixo, mostra os tipos de variáveis e suas características.

Tipo Descrição
A palavra reservada void é usada em declarações de funções. Este tipo indica que
void
a função não retorna nenhum valor quando é executada.
O tipo boolean pode representar valores booleanos, verdadeiro (true) ou
Boolean
falso(false). Um tipo boolean ocupa um byte da memória.
O tipo char armazena valores de 1 byte. Caracteres são codificados em um único
char byte e são especificados na tabela ASCII. O tipo char é sinalizado e representa
números de -128 a 127. Para números não sinalizados usa-se o tipo byte.
unsigned char armazena valores de 1 byte não sinalizados, é mesmo que utiliza o
unsigned char tipo byte. A faixa de 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
int placas baseadas em 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
unsigned int
16 bits não sinalizados, ou seja, apenas valores positivos de 0 a 65535.
O tipo armazena valores de 16 bis não sinalizados que compreendem valores de 0
word a 65535.
O tipo de dado Long armazena valores inteiros sinalizados de 32 bits (4 bytes)
long
que compreendem a faixa de -2147483648 a 2147483647.
O tipo unsigned long armazena valores de 32 bits (4 bytes) não sinalizados que
unsigned long
compreendem a faixa 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
float decimais. O tipo float armazena valores de 32 bits (4 bytes) e compreendem a
faixa de -3,4028235 E+38 a 3,4028235 E+38.4.
O tipo double também armazena valores de ponto flutuante, porém no Arduino
double
Uno e outras placas baseadas em ATMEGA esse tipo é exatamente o mesmo que o
tipo float, sem ganho de precisão,

Atribuir um nome à variável é o mesmo que declarar a variável. É uma boa prática dar um nome
para a varável que faça sentido. Por exemplo, Se a variável fizer referência à um LED podemos utilizar
como nome da variável, LEDn sendo n o número do LED. Assim, se no circuito existir um LED, deve existir
uma variável LED e o número 1 pode ser inserido no nome da variável. É lógico que quem escreve está
livre para usar nomear do jeito que quiser.

Depois do nome da variável, o segundo passo é definir qual o tipo da variável que pode ser
“escolhido” a partir da tabela 3 acima. O tipo servirá para definir qual tipo de dado a variável poderá
receber e quanto de espaço na memória será reservado para ela.

Veja o exemplo: int LED1;

int se refere ao tipo da variável – inteiro, isso quer dizer que um espaço de 2 Bytes (16 bits) da memória
serão reservados.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
LED1 é o nome da variável.

O nome da variável não pode mudar. LED, Led, led, leD são nomes de variáveis diferentes.

É possível também atribuir uma saída do microntrolador à variável. Veja abaixo:

int LED1 = 3;

O símbolo = chama-se atribuição e significa que estamos atribuindo o nome LED1 à saída 3 do
Arduino. Assim, sempre que no programa a variável LED1 aparecer, sabemos que estamos nos referindo a
saída 3 do Arduino.

Uma outra maneira de tratar variáveis é dando-lhe um valor inicial;

int resultado =0;

A variável resultado tem o valor inicial igual a zero.

int multiplicação = 250;

O valor inicial da variável multiplicação será 250.

17
7 – 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.

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/

// Pin 13 has an LED connected on most Arduino boards.


// give it a name:
int led = 13;

// the setup routine runs once when you press reset:


void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:


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

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.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
Explicando o programa.
Antes do bloco setup, é necessário declarar as variáveis do programa.
int se refere ao tipo de números que a variável pode manipular. No caso, a
variável é do tipo inteiro e pode armazenar números de até 16 bits com um
range de -32.768 até 32.767.
led se refere ao nome da variável. Pode ser qualquer nome, utilizando
caracteres alfanuméricos.
int led = 13;
= 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.
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.
void setup() { Logo após, entre chaves { }, são apresentadas as funções e suas declarações.
pinMode(led, OUTPUT); As chaves limitam um procedimento.
} pinMode – Esta função determina o modo do pino. Se 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 valor, um
estado. Logo a seguir da função, entre parênteses, segue o nome do pino – led
– e o estado que é HIGH. Ou seja, o pino led foi setado para 1.
void loop() {
Em seguida, a função delay é iniciada. Esta função atrasa a execução do
digitalWrite(led, HIGH);
programa pelo tempo especificado a seguir, entre parentes. O valor declarado
delay(1000);
é 1000. Como a base desta função é o milissegundos, o programa ficará parado
digitalWrite(led, LOW);
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, acendeu o led. Então é necessário apaga-lo (a finalidade do
programa é fazer o led piscar).
Então, o estado do led é definido como LOW ou 0. O led ficará apagado então
por 1 segundo.
O programa ficará executando o loop, linha por linha, até que o equipamento
seja desligado.

19
8 – 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.6.1
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.

9 – 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.

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

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
É possível alterar a linguagem do ambiente para
português. Isso é feito selecionando preferencias no menu
Arquivo.

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

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/ ATmega328.

21
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.

Voltando a IDE, confirme o número da


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

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

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
10 – 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, ele aparecerá preta.

Após a escrita é necessário compilar o código.


Nesta etapa, o código escrito será “conferido” e caso algo
esteja errado, 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.

23
Não esqueça de salvar o programa. Isso pode ser feito no menu Arquivo.
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 transferido 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.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
11 – 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.

int led = 13;


void setup() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(100);
digitalWrite(led, LOW);
delay(500);
}

Após fazer as alterações, salve este programa com um nome diferente e repita os passos de
verificar e carregar. Observe que o LED da placa agora pisca mais rapidamente.
Outra modificação possível é utilizar uma das outras saídas ou portas digitais disponíveis. Assim,
em vez de utilizar a porta 13 e o LED que está conectado à ela, podem ser utilizadas quase todas as portas
digitais disponíveis com exceção às portas 0 e 1, pois elas estão diretamente relacionadas com o processo
de comunicação serial entre o microcontrolador (Arduino) e o computador (onde o programa que será
gravado no Arduino será escrito). Então, qualquer uma das portas da de número 2 até à de número 10
pode ser utilizada para acender um LED.

Vamos então, utilizar a porta 2 para comandar o estado de


um LED conectado à ela. Primeiro vamos ver o diagrama
esquemático, ou esquema de ligações, que mostra as interligações
necessárias entre o Arduino, o resistor e o LED.

Uma vez montado o circuito, é necessário alterar a


programação pois o programa gravado no Arduino utiliza o pino 13
como saída e agora, queremos utilizar o pino 2, que é onde o LED
estará conectado. Abaixo, o programa com a alteração do pino 13
para 2.
int led = 2;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(100); 25
digitalWrite(led, LOW);
delay(500);
}
Más, e se for necessário ligar dois LEDs? O que fazer?
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 ao lado.

Uma vez montado o circuito, é necessário alterar o


programa. Então vamos para a IDE.
int led1 = 2;
int led2 = 3;
void setup() {
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
void loop() {
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
delay(500);
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
delay(500);
}
Salve o programa, compile e grave-o no µC. Observe o funcionamento.

CAPACITAÇÃO TÉCNICA – AUTOMATIZAÇÃO UTILIZANDO APLATAFORMA ARDUINO – OUTONO 2015 – PROFESSOR CARLOS BARREIRA
Controle a sequência de acionamento de um circuito composto por 4 LEDs de modo que
EXERCÍCIO 1
acendam um de cada vez e assim permanecendo até que todos os LEDs estejam acesos, iniciando
pelo LED 1 e terminando no LED 4. Os LEDs devem permanecer acesos e a sequência só será
realizada novamente se ocorrer o RESET do microcontrolador. O esquema abaixo mostra como
interligar os componentes.

Primeiro monte o circuito e para isso utilize o


esquema mostrado na figura ao lado.

O próximo passo é escrever o programa. Transcreva para a IDE o programa abaixo, completando o
que está faltando.
 Comece escolhendo o tipo de int led1 = 2;
variável, dando um nome para int led2 = 3;
ela e depois relacionando ou int ____ =_________;
atribuindo à variável, um pino do int ____ =_________;
microcontrolador.

 Feito isso inicie o setup e void setup() {


configure os pinos como saída. pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led_____ , OUTPUT);
pinMode(led_____ , ____________);
}

 Agora, escreva o Loop ou laço void loop() {


contínuo que é a parte do digitalWrite (led1, HIGH);
programa que vai determinar delay(500);
como e quando os LEDs irão digitalWrite (led2, HIGH);
acender.
delay(_______);
digitalWrite (led ______ , HIGH);
____________________;
______________________________;
________________________;
Após terminar de escrever o programa na IDE, verifique se não existem erros de escrita e
então grave-o no microcontrolador.
 Veja se o programa faz com que os LEDs acenderem um de cada vez, a partir do 27
LED 1 para o LED 4.
 Teste os métodos de RESET.
EXERCÍCIO 2 Para este exercício, utilize o circuito montado no exercício 1.
Altere o programa anterior de forma que cada LED acenda e permaneça aceso por
500ms. Após este tempo, o LED que está aceso, deve apagar para que o seguinte acenda.
Os LEDs devem acender do LED 1 para o LED 4. Esta sequência deve ser repetida
indefinidamente.

A seguir, parte do programa para solucionar o problema. Complete o que está faltando. O
início e o mesmo utilizado para a solução do problema anterior.
int led1 = 2;
int led2 = 3;
int ____ =_________;
int ____ =_________;
void setup() {
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led_____ , OUTPUT);
pinMode(led_____ , ____________);
}
Agora, escreva o Loop ou laço infinito que é a parte do programa que deve atender ao solicitado.
void loop() {
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
digitalWrite (led3, LOW);
digitalWrite (led4, LOW);
delay(500);
Até aqui, o programa indica que o LED 1 permanecerá aceso e os outros apagados. Agora é
necessário escrever a segunda parte que é a que determinará que o LED 2 acenderá.
digitalWrite (led1, LOW);
digitalWrite (led2, ______);
digitalWrite (led3, ______);
digitalWrite (led4, ______);
delay(500);
Agora a terceira parte que é a que determinará que o LED 3 acenderá.
digitalWrite (led1, LOW);
digitalWrite (led2, ______);
digitalWrite (led3, ______);
digitalWrite (led4, ______);
delay(500);
E finalmente a quarta e última parte para o LED 4.
digitalWrite (led1, LOW);
digitalWrite (led2, ______);
digitalWrite (led3, ______);
digitalWrite (led4, ______);
delay(500);
Teste e grave o programa no Arduino.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


Para este exercício, utilize o circuito montado no exercício 1.
Altere o programa anterior de forma que cada LED acenda e assim permaneça. O
EXERCÍCIO 3

intervalo para cada LED acender deve ser de 200ms. Quando todos os LEDs estiverem
acesos, faça com que voltem apagando, também utilizando um intervalo de 200ms. Os LEDs
devem acender do LED 1 para o LED 4 e apagar a partir do LED 4 para o LED 1. Esta
sequência deve ser repetida indefinidamente.
Utilize o espaço abaixo para registrar o programa que elaborou.

29
Para este exercício, utilize o circuito montado no exercício 1.
EXERCÍCIO 4

Saber o tamanho do programa é uma informação muito útil pois saberemos assim,
quanto de memória está sendo usada. Neste exercício, vamos identificar onde pode ser
visto a quantidade de memória utilizada em um programa também, quanta influência o tipo
de variável pode exercer no tamanho do programa.

1 – Abra no IDE, programa utilizado no exercício 3. Não faça nenhuma alteração.


2 – Proceda a compilação do programa.
3 – Após isso, leia a última linha que está escrita na área de mensagens (área preta na
parte de baixo da IDE).
4 – Anote o tamanho do programa.
- Tamanho do arquivo binário sketch: ____________________ (de no máximo 32,256
bytes)
Este é o tamanho do programa que corresponde ao espaço de memória utilizado. Assim,
podemos saber quanto espaço ainda resta para programas até o limite de 32KB.
5 – Altere agora o tipo das variáveis de int para byte.
6 – Compile novamente o programa.
7 – Anote o tamanho do programa.
- Tamanho do arquivo binário sketch: ____________________ (de no máximo 32,256
bytes)
Certamente, o valor agora obtido é menor do que o anterior. Isto se justifica pelo tipo de
variável. O tipo int reserva mais espaço do que a do tipo byte.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 5 Para este exercício, utilize o circuito montado no exercício 1.
Neste exercício, uma variável “tempo” será inserida, facilitando assim a troca do
valor utilizado na função delay mais simples. Faça tempo = 300ms

Nos exercícios anteriores, o tempo que determinava quando cada LED acendia ou
apagava e por quanto tempo permanecia em um dos estados 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 o valor de uma
variável. Depois de testar, gravar e executar o programa, modifique o valor da variável “tempo”.

byte led1 = 2;
byte led2 = 3;
byte led3 = 4;
byte led4 = 5;
byte tempo = 300;
void setup() {
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3 , OUTPUT);
pinMode(led4 , OUTPUT);
}
void loop() {
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
digitalWrite (led3, LOW);
digitalWrite (led4, LOW);
delay(tempo);
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
digitalWrite (led3, LOW);
digitalWrite (led4, LOW);
delay(tempo);
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
digitalWrite (led3, LOW);
digitalWrite (led4, LOW);
delay(tempo);
digitalWrite (led1, HIGH);
digitalWrite (led2, LOW);
31
digitalWrite (led3, LOW);
digitalWrite (led4, LOW);
delay(tempo);}
EXERCÍCIO 6
Para este exercício, utilize o circuito montado no exercício 1.
Modifique o programa anterior, acrescentando mais uma variável “tempo”. Uma,
será utilizada para determinar quanto tempo o LED fica aceso e a outra, quanto tempo
todos os LEDs ficarão apagados. Faça o LED permanecer mais tempo apagado do que aceso.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


12 – A função tone.
A função tone() gera uma onda quadrada com 50% de ciclo-ativo de frequência definida.

Para que o buzzer oscile continuamente, usa-se função é escrita como mostrado abaixo.

tone(pino,frequência)
onde:

Pino corresponde ao número da saída do Arduino que será utilizada.

Frequência é o valor da frequência em Hertz que se quer que o buzzer emita.

Para que o som emitido tenha uma duração específica, a função deve ser escrita da
seguinte forma:

tone(pino,frequência,duração)
onde:

Pino corresponde ao número da saída do Arduino que será utilizada.

Frequência é o valor da frequência em Hertz que se quer que o buzzer emita.

Duração é o tempo em milissegundos, que se quer que o som emitido dure.

33
EXERCÍCIO 7

Para este exercício, utilize o circuito montado no exercício 1.


Elabore um programa utilizando a função tone para que um buzzer emita sons com
frequências diferentes sempre que cada LED estiver aceso.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 8
Para este exercício, utilize o circuito montado no exercício 1.
Elabore um programa utilizando a função tone para que um buzzer emita um bip
toda vez que um LED acender.

35
13 – Operadores.
Operadores são símbolos utilizados para construir expressões aritméticas, lógicas e de
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

Subtração - x=a-3 “x” guarda o resultado da 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


Comparação

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

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

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


Menor ou igual <= y <= b
não 0
1 se “y” é maior ou igual a “b”, se não
Maior ou igual >= y >= b
0

AND && z > 0 && c < 2 1 se a expressão for verdadeira


Lógicos

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

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

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


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

0011 &
AND bit a bit & 0001
0001
OR bit a bit | 0011 | 0001 0011
0011 ^
Bit a bit

XOR bit a bit ^ 0010


0001
NOT bit a bit ~ ~1100 0011
Desloca para Se w = 000011, após o
<< w << 3
a esquerda deslocamento w = 111000
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

37
14 – 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 é utilizando um resistor de pull-up. Desta forma, o pino do µC
receberá sempre nível lógico 1. Ao pressionar o botão, o pino será levado
ao referencial de terra, recebendo nível lógico zero. O resistor de 10KΩ
sempre será ligado ao positivo da fonte de alimentação (pull-up) e esta
deve ser a mesma conectada 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 recebido é
igual à 1 ou igual à 0. A função digitalRead(pino) é utilizada para ler o
estado do pino que está conectado ao botão, retornando HIGH ou LOW dependendo se o botão
está ou não pressionado.
O programa abaixo é um exemplo de como ler o estado de um botão para controlar o LED
ligado ao pino 5 da placa Arduino.

int LED = 5; // variável para guardar o estado do LED


int BOTAO = 6; // variável para guardar o estado do LED
int val = 0; //o estado inicial desta variável é zero e ela servirá para
guardar
//o valor lido do estado do botão.
void setup() {
pinMode(LED, OUTPUT); // Definindo o LED como saída
pinMode(BOTAO, INPUT); // Definindo o botão como entrada
}
void loop(){
val = digitalRead(BOTAO); // lendo o botão e guardando o estado na variável “val”
digitalWrite(led, val); // escrevendo no LED o valor guardado na variável “val”
}
Aproveitando o circuito montado com os 4
LEDS, vamos acrescentar um botão. Veja na figura
abaixo o esquema de ligações.
É comum relacionar a condição do botão –
pressionado ou não pressionado – a estados
lógicos 1 ou 0 (HIGH ou LOW) da mesma forma
que relacionamos a condição do LED – aceso ou
apagado – aos estados lógicos 1 ou 0 (HIGH ou
LOW). Após observar o funcionamento do circuito,
complete o quadro abaixo:

Estado Lógico do Estado lógico do


Condição do botão Condição do LED
botão LED
Sem ser pressionada 0

Sendo Pressionada 1

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


Possivelmente, uma incoerência foi percebida. Qual foi e como resolvê-la?

Modifique o programa anterior para que o LED acenda quando o botão for
EXERCÍCIO 9

pressionado.

Utilize o espaço abaixo para registrar a solução dada.

39
Acrescente mais um botão ao circuito e reescreva o programa para que
EXERCÍCIO 10

cada botão controle um LED diferente.

Utilize o espaço abaixo para fazer os registros necessários.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 11 Modifique o circuito retirando os resistores de pull-up. Veja como ligar os
botões no esquema a seguir.

Modifique o programa ativando os resistores de pull-up.

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


AtMega328 possui resistores de Pull up internos que são ativados através de uma linha de
comando. Para acionar o resistor de Pull up interno basta acrescentar a seguinte linha de código:

digitalWrite(nome_da_variavel_pino, HIGH);

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

pinMode(numero_do_pino , INPUT_PULLUP);

41
15 – Resolvendo operações lógicas.
Utilizando operadores lógicos, podemos escrever expressões lógicas. Aproveitando o
circuito montado com 4 LEDs e duas chaves, vamos escrever o programa que faça a operação
lógica AND entre as chaves ligadas aos pinos 6 e 7.

Escreva o programa abaixo na IDE e teste o funcionamento.

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

void setup () {
pinMode (LED,OUTPUT);
pinMode(Botao1,INPUT);
pinMode(Botao2,INPUT);
}
void loop(){
val1=digitalRead(Botao1);
val2=digitalRead(Botao2);
resultado = val1&&val2;
digitalWrite(LED,resultado);
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 12 Acrescente ao programa anterior, as operações lógicas OR, XOR e NOT que serão
realizadas entre os botões 1 e 2 e o resultado de cada uma, mostrado nos LEDS 3, 4 e 5.
Utilize o espaço abaixo para registrar o programa.

43
Elabore um programa para resolver cada uma das expressões lógicas seguintes:
EXERCÍCIO 13

S1 = (A.B) + (/A . /B)


S2 = /B + (/A . B)
S3 = {/(A + B) + (/A . B)}
S4 = A ^ B + /A
Utilize o espaço a seguir para registrar os programas.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


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:

45
- através do botão 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.

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

Serial.begin(9600);

Função empregada para configurar a comunicação serial. A taxa de comunicação Serial


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

Serial.available();

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

Serial.read();

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

Serial.write();

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

Serial.println();

Esta função, escreve o caractere em ASCII e ao final, transmite o caractere Carrier Return
(retorno ao início da linha) e o caractere New Line (mudança para a próxima linha).

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


Vamos escrever uma mensagem de boas-vindas. Escreva o programa a seguir no IDE e
grave no Arduino.

void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print (“ Ola, ESCREVA O SEU PRIMEIRO NOME ! Seja bem-vindo(a) a “);
Serial.println (Capacitação Técnica na Plataforma Arduino. “);
}

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

47
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 variável inserida pelo terminal serial. Cpnsidere:
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;


EXERCÍCIO 14

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.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


Escreva um programa para ler as dimensões de uma cozinha retangular com altura
de 3m, largura de 5m e o comprimento é a variável de entrada pelo monitor serial. Calcule e
EXERCÍCIO 15

mostre a área total da cozinha a quantidade de caixas de azulejos para se colocar em todas
as suas paredes sem descontar a área ocupada por portas e janelas e com o desconto de
5m2 para a área ocupada por portas e janelas. Informe a quantidade de caixas de azulejos
necessária para as situações descritas acima com e sem uma sobra de 10% do total.
Considere que cada caixa de azulejos pode preencher 1,5m2 de parede.

Mostre os valores solicitados no monitor serial.

49
17 – Estruturas condicionais – comando if
O comando if – else é utilizado para controle de fluxo ou de repetição.

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 (condição de teste “argumento”)

Função que será executada se for verdadeiro;

Se a condição testada não for verdadeira, então é entendido que é falsa e o loop
continua. Escreva o programa abaixo e veja o que acontece.

int LED = 2;
int tempo = 100
void setup() {
pinMode (LED , HIGH);
}
void loop(){
pinMode (LED , HIGH);
delay (tempo);
pinMode (LED , LOW);
delay (tempo);
tempo = tempo + 100;
if(tempo > 3000)
{
tempo =100;
}
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 16 Modifique o programa exemplo anterior para controlar 4 LEDS de maneira que sejam
acesos, nas seguintes condições:
LED ligado ao pino 2 pisque desde o início do programa.
LED ligado ao pino 3 pisque a partir de 500ms;
LED ligado ao pino 4 pisque a partir de 1000ms;
LED ligado ao pino 5 pisque a partir de 2000ms;

51
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
EXERCÍCIO 17

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.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


É possível acender LEDs utilizando o teclado do computador através do Monitor Serial. O
programa abaixo mostra como fazer isso. Escreva-o no IDE e faça o teste.

int LED = 2;
void setup() {
Serial.begin(9600);
pinMode(LED, OUTPUT);
}
void loop() {
char tecla;
tecla = Serial.read();
if(tecla == 'V')
{
digitalWrite(LED, HIGH);
}
delay(1000);
}

53
EXERCÍCIO 18
No programa exemplo anterior, só é possível acender o LED. Modifique-o para que seja
possível acender e apagar o LED.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 19 Elabore o programa que permita controlar 4 LED fazendo-os acender e apagar ao
serem pressionadas teclas do teclado do computador.

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

A utilização seria a seguinte:

If(condição de teste)
{
Funções que serão executadas se a condição de teste for verdadeira
}
Else
{
Funções que serão executadas se a condição de teste for falsa
}
Digite e teste o programa exemplo abaixo.
int LED = 2;
void setup() {
Serial.begin(9600);
pinMode(LED, OUTPUT);
}

void loop() {
char tecla;
tecla = Serial.read();
if(tecla == “V”)
{
digitalWrite(LED, HIGH);
}
else
{
if(tecla == “v”)
{
digitalWrite(LED, LOW);
}
}
delay(1000);
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


Modifique o programa exemplo anterior de modo que cada um dos 4 LEDS
possam se r acesos e apagados nas seguintes condições:
EXERCÍCIO 20
Atribuir uma tecla para cada LED. Cada LED será aceso pela tecla relacionada à
ele.
Atribuir uma tecla para cada LED. Cada LED sera apagado pela tecla relacionada
à ele.
Atribuir uma tecla que faça todos os LEDS acenderem;
Atribuir uma tecla que apague todos os LEDS.

57
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 escrever um programa para
fazer com que um LED acenda e apague exatamente 15 vezes. Uma sugestão é a seguinte:

int LED = 2;
int tempo = 100;

void setup() {
pinMode(LED, OUTPUT);
}
Void loop() {
digitalWrite(LED, HIGH);
delay(tempo);
digitalWrite(LED, LOW);
delay(tempo);

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

REPETIR ESTAS ÚLTIMAS 4 LINHAS POR MAIS 13 VEZES.

Tendo com certo o programa acima, 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: Vamos entende-lo:

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


int LED = 2; Declaração das variáveis LED e tempo.
int tempo = 100;

void setup()
{ Setup – configurando o pino 2 (LED) como
pinMode(LED, OUTPUT); saída
}

void loop() Iniciando o loop


{

for(int i = 0; i<15; i ++) int i = 0 => cria a variável local i com valor
inicial 0
i<15 => condição de teste - verifica se i é
maior do que 15;
i ++ => se for menor, incrementa 1 na
variável i e continua o programa executando
as condições abaixo.
Se for maior, encerra o programa.

{
digitalWrite (LED, HIGH);
delay(tempo);
digitalWrite (LED, LOW); Fazendo o LED piscar
delay(1000);
}
delay(tempo);
}

59
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á:

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


Resolução = = 4,88mV 0,00 0,00488 00000000002
0,00488 0,00976 00000000012
Então a cada 5mV aproximadamente, a palavra binária 0,00976 0,01464 00000000102
será modificada. Os pinos analógicos serão constantemente
lidos, sendo o tempo de leitura aproximado de 100 ... ...
microssegundos o que leva a uma taxa de leitura próxima de
10.000 leituras por segundo.
4,9776 4,98248 11111111012
A função utilizada para ler os pinos analógicos é 4,98248 4,98736 11111111102
analogRead(). Tabela 1 4,98736 4,99712 11111111112
- Valores da conversão.

O valor de retorno, é um número int de 0 a 1023.

Utilizando o potenciômetro.
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. O programa para isso pode ser escrito da seguinte forma:

int pot = A0;


int led = 10;
int valmed = 0;
void setup() {
pinMode(led,OUTPUT);
}
void loop() {
valmed = analogRead(pot);
digitalWrite(led, HIGH);
delay(valmed);
digitalWrite(led, LOW);
delay(valmed);
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


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

Caso o resistor ligado esteja conectado ao positivo da fonte de alimentação


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

Já se o LDR é que for diretamente conectado ao positivo da fonte de


alimentação, então quando mais luz chegar ao LDR, maior tensão será aplicada à
porta analógica e o circuito se comportará como um sensor de luz.

Substitua o potenciômetro pelo LDR e verifique se o ritmo das piscadas do LED é alterado.

61
É possível ver no monitor serial os valores lidos em uma entrada. Desta forma, podemos “ver” o
comportamento de um sensor e a partir daí, aperfeiçoar o código. Veja o exemplo a seguir. Antes de
escrever o programa, ligue o cursor do potenciômetro ao pino A0 e os extremos ao Vcc e GND.

int sensor = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
sensor = analogRead(A0);
Serial.print(“Valor lido=");
Serial.println(sensor);
delay(1000);
}
Grave o programa no microcontrolador;

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.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


19 – Utilizando a função MAP.
A função map(), é uma função matemática que pode ser utilizada para transformar uma
sequência de números em uma outra. Para utilizá-la é necessário inserir a primeira faixa numérica, que é
a obtida a partir de uma medição utilizando as entradas analógicas, o número menor e o maior medido. A
seguir, a faixa que se quer transformar com o seu número menor e maior correspondente. A sintaxe da
função map é a seguinte:

map(variável, do valor menor , do valor maior , para menor valor , para o maior valor);

O programa abaixo, faz isso.

int sensor = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
sensor = map (analogRead(A0),0,1023,0,100);
Serial.print("Valor=");
Serial.println(sensor);
delay(1000);
}

63
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.
EXERCÍCIO 21

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.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


20 – Utilizando o sensor reflexivo.
O sensor reflexivo TCRT5000 da Vishay, é composto por um LED emissor infravermelho 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.

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
terminal serial para visualizar o valor.

int sensorIR= 0;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(analogRead(sensorIR));
delay(250);
}

65
EXERCÍCIO 22

Elabore um programa de reconhecimento de cores utilizando o sensor reflexivo.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


21 – 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

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

int pinoSensor = 0;
int valorLido = 0;
float temperatura = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
valorLido = analogRead(pinoSensor);
temperatura = 5.0*analogRead(pinoSensor)*100.0)/1024;
Serial.print("Temperatura atual: ");
Serial.println(temperatura);
delay(1000);
}

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.

67
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.
EXERCÍCIO 23

Faça o mapeamento do sensor de temperatura para obter o maior valor e o


menor valor de temperatura (t).
Elabore um programa que faça o LED verde acender entre 0 e 50%(t).
Os LEDs amarelos, devem acender entre 50 e 60% (t) e entre 60 e 70% (t).
Os LEDs vermelhos, acendem entre 70 e 80% (t) e entre 80 e 100% (t).
Cada LED deve permanecer aceso enquanto durar a condição que o fez
acender.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


22 – 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 é compatí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 ao
lado mostra como o relé está interligado com 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
descarga da bobina no momento do seu desligamento.

O acionamento do relé é 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. O código a
seguir mostra isso.

int BOTAO = 5 ;
int RELE = 7 ;
int val = 0;
void setup(){
pinMode(RELE,OUTPUT);
pinMode(BOTAO,INPUT);
}
void loop(){
val=digitalRead(BOTAO);
if(val==HIGH)
{
digitalWrite(RELE,LOW);
}
else
{
digitalWrite(RELE,HIGH);
69
}
}
As vezes utilizamos um botão para ligar e outro botão para desligar o circuito. O programa a
seguir faz isso.

const int bliga = 5;


const int bdesliga = 4;
const int LED = 3;
int bliga1 = 1;
int bdesliga1 = 1;
void setup() {
pinMode(LED, OUTPUT);
pinMode(bliga, INPUT);
pinMode(bdesliga,INPUT);
}
void loop(){
bliga1 = digitalRead(bliga);
bdesliga1 = digitalRead(bdesliga);
if (bliga1 == LOW) {
digitalWrite(LED, HIGH);
}
if (bdesliga1 == LOW) {
digitalWrite(LED,LOW);
}
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 24 Acrescente ao circuito e ao programa do exercício 22, os botões e o relé do
circuito e programa anterior sendo o LED deste último programa excluído.
Crie então um novo programa, juntando todos os elementos e acrescente
mais uma condição ao relé que deverá ser acionado quando o primeiro LED
vermelho acender.

71
23 – 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 seja +5V perdure por exatos 50% do tempo total do período (o nível 0 terá a
mesma duração), o valor médio da tensão serão exatos 2,5V.

Observando a figura ao lado. t1 equivale ao tempo de


duração do nível lógico 1 e t2 corresponde ao tempo de
duração do nível lógico 0. T vale portanto t1 + t2.

Figura 1 - Onda quadrada.

O valor médio da tensão poderá ser obtido usando a seguinte fórmula:

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

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

Na placa do Arduino UNO e equivalentes, apenas algumas saídas digitais podem ser utilizadas
como saídas PWM, são as saídas dos pinos 3, 5, 6 ,9, 10 e 11, 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 um número 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.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


O objetivo é controlar o brilho de um LED utilizando a técnica de PWM.
EXERCÍCIO 25
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.

73
24 – 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.

O código para controlar este circuito é o


seguinte:

void setup() {}

void loop() {

analogWrite((10,analogRead(5))/4);

Porém, este circuito não permite o controle de direção do motor, apenas a velocidade. 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 funcionamento


do circuito.

Considerando que cada interruptor Sn é um transistor,


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

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


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

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.
Nos resistores de base serão conectadas as saídas digitais da placa 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
Para testar o funcionamento do circuito, podemos utilizar o programa abaixo que fará ao
acionamento intermitente do motor.

void setup(){
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
digitalWrite(10, HIGH);
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); 75
delay(1000); // espera 1 segundo
}
Elabore um programa contendo 3 botões e um potenciômetro. Os botões
terão as seguintes funções:
 Botão 1 permite ou não que o motor seja acionado. Quando pressionado
EXERCÍCIO 26

uma vez, permitirá que o motor obedeça o comando dado pelos outros dois
botões de direção. Ao ser pressionado, não faz o motor girar. Se pressionado
novamente, inibe o acionamento do motor pelos outros dois botões.
 Botão 2 quando for pressionado, o motor deve girar para a direita.
 Botão 3 quando for pressionado, o motor deve girar para a esquerda.
 A velocidade do motor deve ser ajustada com o auxílio de um
potenciômetro.

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


25 – Utilizando o L293D.
O CI L293D é constituído por 4 drivers de corrente
com capacidade de fornecer corrente bidirecional de até
600mA em tensões de 4,5 a 36V. Tem capacidade de acionar
cargas indutivas como relés, solenoides, motor bipolar e de
passo, bem como outras cargas de alta corrente ou tensão.

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 funcionamento
independente, más são acionados em conjunto pela entrada EN
(ENABLE) que habilitará ou não cada uma dos drivers associados.

A tabela ao
lado, mostra como
cada driver é
acionado. Para verificar o funcionamento, vamos montar o
circuito que possibilite o controle de direção do motor, Para
determinar o sentido de rotação do motor, utilizaremos um
botão, que será ligado ao pino 2 da plataforma Arduino.

A figura ao lado, mostra o diagrama das interligações necessárias para que ligar o CI L293D ao
Arduino e aos outros componentes do circuito.

77
O código para controlar o circuito está mostrado a seguir.

int botao = 2;
int pino1motor = 3;
int pino2motor = 4;
int enable = 9;
void setup() {
pinMode(botao, INPUT);
pinMode(pino1motor, OUTPUT);
pinMode(pino2motor, OUTPUT);
pinMode(enable, OUTPUT);
digitalWrite(enable, HIGH);
}
void loop() {
if (digitalRead(botao) == HIGH) {
digitalWrite(pino1motor, LOW);
digitalWrite(pino2motor, HIGH);
}
else {
digitalWrite(pino1motor, HIGH);
digitalWrite(pino2motor, LOW
}
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


Elaborar o programa para controle de direção e de velocidade de um motor
EXERCÍCIO 27

DC utilizando o CI L293D. Para o controle de velocidade, acrescente um


potenciômetro ao circuito e faça o controle da saída PWM que está ligada ao pino 9
do CI.

79
26 – Motor de passo.

Motores de passo são utilizados em uma ampla variedade de aplicações na indústria, incluindo
periféricos de computador, controle de movimento e robótica. E 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.

Um dos tipos de motor de passo disponível é o unipolar que


pode ter 5 fios disponíveis. 4 fios são os extremos das bobinas do motor
e o quinto é o GND.

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. Repetindo-
se esta sequência, o eixo do motor fará um giro de
360º.(8 -4 -2 -1) Para fazer o movimento contrário,
basta fazer a mesma sequência, más na ordem inversa.
(1 – 2 – 4 – 8).

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


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

O esquema ao lado,
mostra as interligações
necessárias para conectar o
ULN2002A ao Arduino.

81
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);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, HIGH);
delay(delayTime);
}

CAPACITAÇÃO TÉCNICA PLATAFORMA ARDUINO – INVERNO 2014 – PROFESSOR CARLOS BARREIRA


EXERCÍCIO 28
Elabore o programa para, através do acionamento de um botão, controlar a
direção da rotação do motor de passo.

83

Você também pode gostar