SUMÁRIO - AD ROBÓTICA - Sua ideia é o que nos move · 2019-08-29 · tensão na placa. A...

1 AD ROBÓTICA - E-commerce de componentes eletrônicos voltados a

robótica com ênfase na plataforma Arduíno. www.adrobotica.com

SUMÁRIO

1 INTRODUÇÃO ......................................................................................... 2

2 O HARDWARE ........................................................................................ 2

2.1 ALIMENTAÇÃO ................................................................................ 4

2.2 NÚCLEO ATMEGA ........................................................................... 5

2.3 ENTRADAS E SAÍDAS ..................................................................... 5

2.4 CONVERSOR SERIAL USB ............................................................. 6

2.5 LEDS ................................................................................................. 7

2.6 BOTÃO RESET ................................................................................. 7

2.7 PINOS ICSP ...................................................................................... 7

3 SOFTWARE ............................................................................................ 8

3.1 ESTRUTURA DO PROGRAMA ........................................................ 9

3.2 LINGUAGEM DE REFERÊNCIA ..................................................... 10

3.3 FUNÇÕES ....................................................................................... 11

3.4 BIBLIOTECAS ................................................................................. 12

3.5 INSTALAÇÃO DE BIBLIOTECAS ................................................... 14

4 PROJETOS ........................................................................................... 15

4.1 BLINK .............................................................................................. 15

4.2 LED COM BOTÃO LIGA/DESLIGA ................................................. 18

4.3 CONTROLE DE LUZ COM LDR ..................................................... 20

4.4 SEMÁFORO PARA FAIXA DE PEDESTRES ................................. 21

4.5 ACENDENDO LÂMPADA COM PALMAS ...................................... 24

5 REFERÊNCIAS ..................................................................................... 28



1 INTRODUÇÃO

Arduino é uma plataforma de computação física (são sistemas digitais ligados

a sensores e atuadores, que permitem construir sistemas que percebam a realidade

e respondem com ações físicas), baseada em uma simples placa de Entrada/Saída

microcontrolada e desenvolvida sobre uma biblioteca que simplifica a escrita da

programação em C/C++.

Criado com o objetivo de permitir o desenvolvimento de controle de sistemas

interativos, de baixo custo e acessível a todos. Além disso, todo material (software,

bibliotecas, hardware) é open-source, ou seja, qualquer pessoa com conhecimento de

programação pode modificá-lo e ampliá-lo de acordo com a necessidade, visando

sempre à melhoria dos produtos que possam ser criados aplicando o Arduino sem a

necessidade de pagamento de direitos autorais.

Ele foi projetado com a finalidade de ser de fácil entendimento, programação

e aplicação, além de ser multiplataforma, ou seja, podemos configurá-lo em ambientes

Windows, GNU/Linux e Mac OS. Assim sendo, pode ser perfeitamente utilizado como

ferramenta educacional sem se preocupar que o usuário tenha um conhecimento

específico de eletrônica, mas pelo fato de ter o seu esquema e software de

programação open, acabou chamando a atenção dos técnicos de eletrônica, que

começaram a aperfeiçoá-la e a criar aplicações mais complexas.

Sua plataforma é composta essencialmente de duas partes: O Hardware e o

Software.

Neste curso, será utilizado o Arduino Uno.

2 O HARDWARE

Antes de analisarmos o hardware, vamos as características básica do arduíno

uno:

Microcontrolador ATmega328

Tensão Operacional 5 V

Tensão de entrada (recomendada) 7-12 V



Tensão de entrada (limites) 6-20 V

Pinos E/S digitais 14 (dos quais 6 podem ser saídas PWM)

Pinos de entrada analógica 6

Corrente CC por pino E/S 40 mA

Corrente CC para o pino 3,3V 50 mA

Flash Memory 32 KB (ATmega328) dos quais 0,5KB são

utilizados pelo bootloader

SRAM 2 KB (ATmega328)

EEPROM 1 KB (ATmega328)

Velocidade de Clock 16 MHz

Tabela 1: Características do Arduino UNO

Vamos analisar o hardware da placa, começaremos visualizando a arquitetura

da mesma, depois veremos a divisão na placa por blocos a qual destrincharemos a

seguir.

Figura 1: Arquitetura do Arduino Esta arquitetura pode ser dividida em blocos de acordo com a seguinte

imagem de uma placa de Arduino SMD.



Figura 2: Arquitetura do Arduino

Nota: Como podemos observar, o arduíno uno utilizado neste minicurso é na versão

SMD genérica, há ainda outras diversas versões do Arduino. Entretanto estas versões pouco

diferem das disposições dos blocos que utilizaremos aqui.

Agora que já vimos as disposições dos blocos, vamos conhecer a função dos

principais blocos desta placa.

2.1 ALIMENTAÇÃO

O Arduino uno pode ser alimentado pela conexão USB ou por qualquer fonte

de alimentação externa. A fonte de alimentação é selecionada automaticamente.

A alimentação externa (não - USB) pode ser tanto de uma fonte ou de uma

bateria. A fonte pode ser conectada com um plug de 2,1 mm (centro positivo) no

conector de alimentação. Cabos vindos de uma bateria podem ser inseridos nos pinos

GND (terra) e Vin (entrada de tensão) do conector de alimentação.

A placa pode operar com uma alimentação externa de 6 a 20 V. Entretanto,

se a alimentação for inferior a 7 V o pino 5 V pode fornecer menos de 5 V e a placa

pode ficar instável. Se a alimentação for superior a 12 V o regulador de tensão pode

superaquecer e avariar a placa. A alimentação recomendada é de 7 a 12 V.



Os pinos de alimentação são:

• Vin: entrada de alimentação para a placa arduino quando uma fonte

externa for utilizada. Você pode fornecer alimentação por este pino ou,

se usar o conector de alimentação, acessar a alimentação por este

pino;

• 5V. Esse é um pino de saída que gera um 5V regulado do regulador de

tensão na placa. A alimentação da placa pode ser proveniente do

conector DC (7 - 12V), do conector USB (5V) ou do pino VIN da placa

(7-12V). O fornecimento de tensão através dos pinos de 5V ou 3,3V

ignora o regulador e pode danificar sua placa. Nós não aconselhamos.

• 3V3. Outro pino de saída de 3,3 volts gerado pelo regulador de interno.

O consumo máximo de corrente é de 50 mA.

• GND (ground): pino terra.

2.2 NÚCLEO ATMEGA

O núcleo de processamento de uma placa Arduino é um microcontrolador,

uma CPU, um computador completo, com memória RAM, memória de programa

(ROM), uma unidade de processamento de aritmética e os dispositivos de entrada e

saída. Tudo em um chip só. E é esse chip que possui todo hardware para obter dados

externos, processar esses dados e devolver para o mundo externo.

Os desenvolvedores do Arduino optaram em usar a linha de

microcontroladores da empresa ATMEL. A linha utilizada é a ATMega. Existem placas

Arduino oficiais com diversos modelos desta linha, mas os mais comuns são as placas

com os chips ATMega8, ATMega162 e ATMega328p. Esses modelos diferem na

quantidade de memória de programa (ROM) e na configuração dos módulos de

entrada e saída disponíveis.

2.3 ENTRADAS E SAÍDAS

Cada um dos 14 pinos digitais do UNO podem ser usados como entradas ou

saídas usando as funções de pinMode (), digitalWrite (), e digitalRead (). Eles operam



com 5 V. Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor

pull-up interno (desconectado por padrão) de 20-50 kΩ. Além disso, alguns pinos têm

funções especializadas:

• Serial: 0 (RX) e 1 (TX). Usados para receber (RX) e transmitir (TX)

dados seriais TTL. Estes pinos são conectados aos pinos

correspondentes do chip serial FTDI USB-to-TTL.

• PWM: 3, 5, 6, 9, 10, e 11. Fornecem uma saída analógica PWM de 8-

bit com a função analogWrite().

• SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estes pinos suportam

comunicação SPI, que embora compatível com o hardware, não está

incluída na linguagem do Arduino.

O UNO tem 6 entradas analógicas, cada uma delas está ligada a um

conversor analógico-digital de 10 bits, ou seja, transformam a leitura analógica em um

valor dentre 1024 possibilidades (exemplo: de 0 a 1023). Por padrão, elas medem de

0 a 5 V, embora seja possível mudar o limite superior usando o pino AREF e um pouco

de código de baixo nível. Adicionalmente alguns pinos têm funcionalidades

especializadas:

• I2C: 4 (SDA) e 5 (SCL). Suportam comunicação I2C (TWI) usando a

biblioteca Wire.

• AREF: referência de tens para entradas analógicas. Usados com

analogReference().

• Reset: Envie o valor LOW para reiniciar o microcontrolador.

Tipicamente utilizados para adicionar um botão de reset aos Shields

(placas que podem ser plugadas ao Arduino para estender suas

capacidades) que bloqueiam o que há na placa

2.4 CONVERSOR SERIAL USB

O microcontrolador ATMEL ATMEGA 16U2 é responsável pela comunicação

da placa Arduino com computador via interface USB.



2.5 LEDS

O Arduino UNO SMD possui alguns LEDs indicativos, neste minicurso

abordaremos os dois básicos.

• LED ON: Este LED indica quando o dispositivo está alimentado;

• LED BULTIN: Este LED é ligado diretamente no pino 13, através deste

LED podemos fazer testes de funcionamento iniciais da placa.

2.6 BOTÃO RESET

A placa pode ser iniciada de duas formas:

• Pelo botão reset presente na placa;

• Pelo pino reset definido no tópico 2.3 ENTRADAS E SAÍDAS

2.7 PINOS ICSP

Esse conjunto de 6 pinos segue um padrão fixo, normalmente chamado

de ISP header de 6 pinos, e costumeiramente indicado com a sigla ICSP nas placas

Arduino. ISP e ICSP são duas siglas que se referem a um mesmo conceito geral: a

capacidade de transferir programas para um componente enquanto ele está instalado

em um sistema (a sigla ICSP se refere especificamente a fazê-lo por meio de

protocolos seriais).

No caso dos Arduinos, o ICSP se refere à capacidade de programar

diretamente os microcontroladores da placa usando o protocolo serial SPI, e é por

isso que – além dos pinos de tensão e controle (VCC, GND e RESET) – estão

presentes nele os 3 pinos necessários para uma conexão ponto-a-ponto usando SPI:

MOSI, MISO e SCK, que são, respectivamente, os pinos pelos quais o mestre envia

dados ao periférico, o mestre recebe dados do periférico e o mestre controla o

pulso/clock da conexão.

O controle remoto e transferência via serial (SPI) é a forma mais comum de

instalar um bootloader no ATmega328 de um Arduino Uno

http://en.wikipedia.org/wiki/In-system_programming

http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus



3 SOFTWARE

Quando tratamos de software na plataforma do Arduino, podemos referir-nos:

ao ambiente de desenvolvimento integrado do Arduino e ao software desenvolvido por

nós para enviar para a nossa placa. O ambiente de desenvolvimento do Arduino é um

compilador gcc (C e C++) que usa uma interface gráfica construída em Java.

Basicamente se resume a um programa IDE muito simples de se utilizar e de estender

com bibliotecas que podem ser facilmente encontradas. As funções da IDE do Arduino

são basicamente duas: Permitir o desenvolvimento de um software e enviá-lo à placa

para que possa ser executado.

Para realizar o download do software basta ir até a página oficial do Arduino

(http://www.arduino.cc/), escolher o seu SO (existe pra Linux, Mac e Windows) e

baixa-lo. Obviamente, por ser open source, é gratuito. Depois de baixado não

necessita de nenhuma instalação, é só abrir o IDE e começar a utilizar.



Figura 3: Ambiente de programação (Integrated Development Environment-IDE)

Para começar a utilizar, devemos escolher qual placa estamos utilizando,

assim vamos em Ferramentas > Placa e à escolhemos. O IDE possui também uma

quantidade imensa de exemplos. Para utilizá-los basta ir a Arquivo > Exemplos e

escolher qual deles você quer testar, de acordo com sua necessidade.

3.1 ESTRUTURA DO PROGRAMA



A estrutura básica de programação é baseada no firework wiring tendo duas

funções principais:

• Setup() – que:

É a primeira função a ser chamada;

Recebe as configurações iniciais;

Roda apenas uma única vez;

Função obrigatória.

• Loop() – que:

Recebe o código fonte;

É um laço infinito;

Função obrigatória.

Exemplo:

void setup()

// recebe as configurações iniciais

void loop()

// recebe o código fonte

Na área de programação você irá escrever o código seguindo a estrutura do

exemplo acima. Depois de escrito você deve escolher a placa a qual você deseja

carregar o código, no nosso caso escolheremos a placa Arduino UNO seguindo os

seguintes passos: Menu principal>Ferramentas>Placa:>Arduino/Genuino Uno.

Logo depois defina a porta serial USB na qual você conectou o a placa Arduino

em seu computador em: Menu principal>Ferramentas>Porta:>...

Agora você precisa compilar seu código clicando em copilar de acordo com a

figura 3, e para carregar o código na placa Arduino é só clicar em carregar.

Antes de iniciarmos nosso primeiro projeto, vamos conhecer a linguagem de

referência, as funções e principais bibliotecas.

3.2 LINGUAGEM DE REFERÊNCIA



Os programas para o Arduino são implementados tendo como referência a

linguagem C++. Preservando sua sintaxe clássica na declaração de variáveis, nos

operadores, nos ponteiros, nos vetores, nas estruturas e em muitas outras

características da linguagem. Com isso temos as referências da linguagem, essas

podem ser divididas em três partes principais: As estruturas, os valores (variáveis e

constantes) e as funções.

As estruturas de referências são:

• Estruturas de controle (if, else, break, ...);

• Sintaxe básica (define, include, ; , ...);

• Operadores aritméticos e de comparação (+, -, =, ==, !=, ...);

• Operadores booleanos (, ||, !);

• Acesso a ponteiros (*, );

• Operadores compostos (++, –, +=, ...).

Os valores de referências são:

• Tipos de dados (byte, array, int , char , ...);

• Conversões (char(), byte(), int(), ...);

• Variável de escopo e de qualificação (variable scope, static, volatile,

...);

• Utilitários (sizeof(), diz o tamanho da variável em bytes).

É bom citar que o software que vem no Arduino já provê várias funções e

constantes para facilitar a programação, além das já referenciadas no tópico 3.1

ESTRUTURA DO PROGRAMA, temos ainda:

• Constantes (HIGH | LOW , INPUT | OUTPUT , ...);

• Bibliotecas (Serial, Servo, Tone, etc.).

3.3 FUNÇÕES

As funções são referências essenciais para o desenvolvimento de um projeto

usando o Arduino, principalmente para os iniciantes no assunto. Essas funções já

implementadas e disponíveis em bibliotecas direcionam e exemplificam as

funcionalidades básicas do microcontrolador. Temos como funções básicas e de

referências as seguintes funções:



• Digital I/O:

pinMode() digitalWrite() digitalRead()

• Analógico I/O:

analogReference() analogRead() analogWrite() – PWM

• Avançado I/O:

tone() noTone() shiftOut() pulseIn()

• Tempo:

millis() micros() delay() delayMicroseconds()

• Matemática:

min() max() abs() constrain() map() pow() ***só do C/C++ sqrt() ***só do C/C++

• Trigonométrica:

sin() ***só do C/C++ cos() ***só do C/C++ tan() ***só do C/C++

• Números aleatórios:

randomSeed() random()

• Bits e Bytes:

lowByte() highByte() bitRead() bitWrite() bitSet() bitClear() bit()

• Interrupções externas:

attachInterrupt() detachInterrupt()

• Interrupções:

Interrupts() noInterrupts()

• Comunicação Serial

3.4 BIBLIOTECAS

O uso de bibliotecas nos proporciona um horizonte de programação mais

amplo e diversos quando comparado a utilização apenas de estruturas, valores e

funções. Isso é perceptível quando analisamos os assuntos que são abordados por

cada biblioteca em específico. Lembrando sempre que, para se fazer uso de uma

biblioteca esta já deve estar instalada e disponível na sua máquina. Temos as

seguintes bibliotecas de referência:

• EEPROM - leitura e escrita de “armazenamento” permanente.



• Ethernet - para se conectar a uma rede Ethernet usando o Arduino

Ethernet Shield.

• Firmata - para se comunicar com os aplicativos no computador usando

o protocolo Fir- mata.

• LiquidCrystal - para controlar telas de cristal líquido (LCDs).

• Servo - para controlar servo motores.

• SPI - para se comunicar com dispositivos que utilizam barramento

Serial Peripheral In- terface (SPI).

• SoftwareSerial - Para a comunicação serial em qualquer um dos pinos

digitais.

• Stepper - para controlar motores de passo.

• Wire - Dois Wire Interface (TWI/I2C) para enviar e receber dados

através de uma rede de dispositivos ou sensores.

Temos como referência também, o uso de bibliotecas mais específicas. O que

é de extrema importância quando se faz o uso do Arduino com um enfoque em uma

determinada área. Como por exemplo:

Comunicação (redes e protocolos)

• Messenger - Para o processamento de mensagens de texto a partir do

computador.

• NewSoftSerial - Uma versão melhorada da biblioteca SoftwareSerial.

• OneWire - Dispositivos de controle que usam o protocolo One Wire.

• PS2Keyboard - Ler caracteres de um PS2 teclado.

• Simple Message System - Enviar mensagens entre Arduino e o

computador.

• SSerial2Mobile - Enviar mensagens de texto ou e-mails usando um

telefone celular.

• Webduino - Biblioteca que cria um servidor Web (para uso com o

Arduino Ethernet Shield).

• X10 - Envio de sinais X10 nas linhas de energia AC.

• XBee - Para se comunicar via protocolo XBee.



• SerialControl - Controle remoto através de uma conexão serial.

Sensoriamento

• Capacitive Sensing - Transformar dois ou mais pinos em sensores

capacitivos.

• Debounce - Leitura de ruídos na entrada digital.

Geração de Frequência e de Áudio

• Tone - Gerar ondas quadradas de frequência de áudio em qualquer

pino do microcontrolador.

Temporização

• DateTime - Uma biblioteca para se manter informado da data e hora

atuais do software.

• Metro - Ajuda ao programador a acionar o tempo em intervalos

regulares.

• MsTimer2 - Utiliza o temporizador de 2 de interrupção para

desencadear uma ação a cada N milissegundos.

Utilidades

• TextString (String) - Manipular strings

• PString - uma classe leve para imprimir em buffers.

• Streaming - Um método para simplificar as declarações de impressão

3.5 INSTALAÇÃO DE BIBLIOTECAS

Para utilizar algumas bibliotecas você deve realizar a instalação das mesmas

na IDE Arduino, para isto há duas formas: Você pode instalar as bibliotecas

disponíveis para a instalação na própria IDE, ou baixar e instalar a partir de um arquivo

.zip, veremos as duas formas.



Instalar bibliotecas já disponíveis para download e instalação no IDE

No menu principal do IDE vá em:

Sketch>Incluir Biblioteca>Gerenciar Bibliotecas...

Procure a biblioteca que você precise é clique em instalar. Pronto! A biblioteca

já está instalada e pronta para uso.

Instalar bibliotecas em .ZIP

Caso a biblioteca que você procure não esteja disponível para download e

instalação no IDE, você pode procurar a biblioteca que você deseja em arquivo .zip

externamente e depois realizar a instalação seguindo os seguintes passos:

Sketch>Incluir Biblioteca>Adicionar Biblioteca .ZIP

Procure a biblioteca em arquivo .ZIP que você baixou nos diretórios de seu

computar e a selecione.

Você pode verificar se a biblioteca foi instalada indo em:

Sketch>Incluir Biblioteca>Contribuído Bibliotecas

Nesta aba você verá todas as bibliotecas que você instalou.

Agora que você já conhece o básico do hardware e software do Arduino,

vamos para alguns projetos práticos.

4 PROJETOS

Neste momento iniciaremos alguns projetos básicos. Começaremos com o

blink utilizando um LED externo, este é o tradicional Hello Word da plataforma Arduino.

4.1 BLINK

O código blink já está disponível como exemplo no IDE Arduino, entretanto o

mesmo está com código para acionar o LED ligado a porta 13 referenciado no tópico

2.5 LEDs, no programa que usaremos, iremos utilizar um LED externo acionado por

outra saída digital da placa Arduino.



Componentes necessário

• 1 protoboard 400 pontos;

• 1 placa Arduino UNO com cabo USB tipo A/B;

• 1 LED verde;

• 1 resistor de 220 Ohm;

• Jumpers.

Sketch (Código)

/*

################################################################

## Programa 1: Blink ##

## Minicurso Arduino: Primeiros passos ##

## Autor: Douglas Santos ##

## Oferecido por: AD Robótica ##

## www.adrobotica.com ##

################################################################

*/

//definimos a configuração de inicialização na função setup()

void setup()

// inicializa a porta digital 4 e indica que será saída/output.

pinMode(4, OUTPUT);

// a função loop é executada repetidamente para sempre

void loop()

digitalWrite(4, HIGH); //liga o LED (HIGH é o nível de tensão)

delay(1000); //Espera por um segundo

digitalWrite(4, LOW); //desliga o LED fazendo a tensão LOW

delay(1000); //Espera por um segundo

Montagem dos componentes

A montagem dos componentes seguirá a seguinte forma:



Figura 4: Montagem dos componentes projeto 1 - Blink

Dica importante:

Você pode utilizar LEDs de outras cores, mas para isto você deve fazer um

cálculo para ajustar o resistor para cada LED especifico. Para realizar este cálculo

você deve utilizar a seguinte formula:

𝑅 =𝑉𝑓𝑜𝑛𝑡𝑒 − 𝑉𝐿𝐸𝐷

𝐼𝐿𝐸𝐷

Em que: R é a resistência do resistor que você procura, 𝑉𝑓𝑜𝑛𝑡𝑒 a tensão da

fonte, 𝑉𝐿𝐸𝐷 a tensão do LED e 𝐼𝐿𝐸𝐷 a corrente do LED.

Quando a placa Arduino muda o status de uma porta digital para HIGH, é

enviado uma tensão de 5V, neste caso a tensão de fonte.

A tensão e corrente de LED você geralmente encontra no datasheet (folha de

dados) do mesmo, entretanto caso não a encontre podemos considerar para casos

mais gerais a corrente de 20mA e a tensão de acordo com a cor do LED indicado na

tabela abaixo:

Cor do LED Tensão aproximada

Vermelho 2 V

Laranja 2 V

Amarelo 2.1 V

Verde 2.2 V

Azul 3.3 V

Branco 3.3 V

Tabela 3: Tensão do LED de acordo com a cor do mesmo



No nosso exemplo, estamos utilizando um LED verde, neste caso o nosso

calculo fica:

𝑅 =5 − 2.2

20 × 10−3= 140 𝑂ℎ𝑚

Como em nosso kit não há um resistor de 140 Ohm exatamente, podemos

aproximar com o que temos disponíveis, geralmente para cima para não ter risco de

queimar o LED. No nosso caso o mais próximo disponível era um de 220 Ohm, neste

caso o que pode ocorrer é o LED emitir o brilho total do mesmo.

4.2 LED COM BOTÃO LIGA/DESLIGA

Agora você aprenderá como fazer o projeto Arduino LED com botão. Este

projeto consiste em controlar o funcionamento de um LED, ligando e desligando o

mesmo através de um push button. Este projeto básico introduz a utilização de botões,

ou push buttons, em projetos Arduino, permitindo a você dar um passo a mais no seu

aprendizado. Então vamos lá.




• 1 LED verde;



• 1 push button;

• Jumpers.

Sketch (Código)

/*

################################################################

## Programa 2:LED COM BOTÃO LIGA/DESLIGA ##





################################################################



*/

//Declaração das constantes

const int led = 8; //constante led refere-se ao pino digital 8.

const int botao = 2; //constante botão refere-se ao pino digital 2.

//Variável que conterá os estados do botão (0 LOW, 1 HIGH).

int estadoBotao = 0;

//Método setup, executado uma vez ao ligar o Arduino.

void setup()

pinMode(led,OUTPUT); //Definindo pino digital 8 como de saída.

pinMode(botao,INPUT); //Definindo pino digital 2 como de entrada.

//Método loop, executado enquanto o Arduino estiver ligado.

void loop()

//Lendo o estado do pino 2, constante botao, e atribuindo

//o resultado a variável estadoBotao.

estadoBotao = digitalRead(botao);

//Verificando o estado do botão para definir se acenderá ou

//apagará o led.

if (estadoBotao == HIGH)

digitalWrite(led,HIGH); //Botão pressionado, acende o led.

else

digitalWrite(led,LOW); //Botão não pressionado, apaga o led.



Figura 5: Montagem dos componentes projeto 2 - LED COM BOTÃO LIGA/DESLIGA



4.3 CONTROLE DE LUZ COM LDR

O LDR (Light Dependent Resistor, ou Resistor Dependente de Luz) como o

próprio nome já diz, é um resistor cuja resistência varia de acordo com incidência da

luz. Ao iluminarmos um LDR ele apresenta valores muito baixos, ao cortarmos essa

iluminação a resistência do mesmo sobe. Assim usaremos este resistor como um

sensor de luminosidade para controlarmos iluminação de um determinado ambiente.




• 1 LED verde;


• 1 resistor de 10 kOhm;

• 1 LDR;

• Jumpers.

Sketch (Código)

/*

################################################################

## Programa 3: CONTROLE DE LUZ COM LDR ##





################################################################

*/

int portaLed = 10; //Porta a ser utilizada para ligar o led

int portaLDR = A5; //Porta analógica utilizada pelo LDR

void setup()

pinMode(portaLed, OUTPUT); //Define a porta do Led como saída

void loop()

int estado = analogRead(portaLDR); //Lê o valor fornecido pelo LDR

// Caso o valor lido na porta analógica seja maior do que

// 500, acende o LED

// Ajuste o valor abaixo de acordo com o seu circuito

if (estado > 500)



digitalWrite(portaLed, HIGH);

else //Caso contrário, apaga o led

digitalWrite(portaLed, LOW);



Figura 6: Montagem dos componentes projeto 3 – CONTROLE DE LUZ COM LDR

4.4 SEMÁFORO PARA FAIXA DE PEDESTRES

Neste projeto, vamos simular o semáforo para pedestres, neste caso

precisaremos simular o sinal para os veículos, precisaremos simular o sinal para os

pedestres sinalizando se pode ou não atravessar a via e precisaremos também dos

botões que ficarão dos dois lados das via para que quando o pedestre chegue acione

o botão e este acione os sinais na devida ordem.






• 2 LEDs verde;

• 2 LEDs Vermelho;

• 1 LED amarelo;

• 5 resistores de 220 Ohm;

• 2 resistores de 100 Ohm;

• 2 push bottons;

• Jumpers.

Sketch (Código)

/*

################################################################

## Programa 4: SINAL DE TRÂNSITO PARA FAIXA DE PEDESTRE ##





################################################################

*/

//Declaração das constantes

const int sinal_v_verde = 4;

const int sinal_v_amarelo = 5;

const int sinal_v_vermelho = 6;

const int sinal_p_verde = 7;

const int sinal_p_vermelho = 8;

const int botao_1 = 2;

const int botao_2 = 3;

//Variável que conterá os estados dos botões (0 LOW, 1 HIGH).

int estadoBotao_1 = 0;

int estadoBotao_2 = 0;

//Variável que manterá o estado dos botões

int botoeiras = 0;

//Método setup, executado uma vez ao ligar o Arduino.

void setup()

pinMode(sinal_v_verde,OUTPUT);

pinMode(sinal_v_amarelo,OUTPUT);

pinMode(sinal_v_vermelho,OUTPUT); //Definindo pinos digitais

pinMode(sinal_p_verde,OUTPUT); //referentes aos sinais como saída

pinMode(sinal_p_vermelho,OUTPUT);

pinMode(botao_1,INPUT); //Definindo pinos digitais

pinMode(botao_2,INPUT); //referentes aos sinais como entradas

//Método loop, executado enquanto o Arduino estiver ligado.

void loop()



digitalWrite(sinal_v_verde,LOW);

digitalWrite(sinal_v_amarelo,LOW);

digitalWrite(sinal_v_vermelho,LOW); //Neste bloco desligamos todos

digitalWrite(sinal_p_verde,LOW); //os sinais do semáfaro

digitalWrite(sinal_p_vermelho,LOW);

while(botoeiras == 0) //enquanto nenhum botão

//apertado entra neste laço

for(int i =0;i<6000 ;i++) //Um laço para garantir um

//ciclo de 60 seg

digitalWrite(sinal_v_verde,HIGH); //Neste ciclo o trânsito //na

via é livre

digitalWrite(sinal_p_vermelho,HIGH); //Enquanto o trânsito de

//pedestre está desabilitado

estadoBotao_1 = digitalRead(botao_1); //nestas linhas são

//realizadas

estadoBotao_2 = digitalRead(botao_2); //as leituras das //botoeiras

//se alguma botoeira tenha sido pressionada...

if(estadoBotao_1 == HIGH || estadoBotao_2 == HIGH)

botoeiras=1; //armazena 1 na variavel botoeiras

delay(10);

//se alguma botoeira foi pressionada, entra no px laço

if (botoeiras==1)

digitalWrite(sinal_v_verde,LOW); //neste bloco desliga o sinal

//verde e

digitalWrite(sinal_v_amarelo,HIGH); //aciona o amarelo por 4 seg //da

via

digitalWrite(sinal_p_vermelho,HIGH);

delay(4000);

digitalWrite(sinal_v_amarelo,LOW); //desliga o sinal amarelo da

//via

digitalWrite(sinal_v_vermelho,HIGH); //liga o sinal vermelho da //via

delay(1000); //e aguarda por 1 seg

digitalWrite(sinal_p_vermelho,LOW); //desliga o sinal vermelho //para

o pedestre

digitalWrite(sinal_p_verde,HIGH); //liga o sinal verde para o

//pedestre

delay(20000); //espera por 20 seg

digitalWrite(sinal_p_verde,LOW); //desliga o sinal verde

for(int j=0;j<20;j++) //entra em um laço de 10

//segundos em que

digitalWrite(sinal_p_vermelho,HIGH);//liga o sinal vermelho para //o

pedestre

delay(500); //aguarda por 0,5 seg

digitalWrite(sinal_p_vermelho,LOW); //desliga o sinal vermelho //para

o pedestre

delay(500); //e aguarda por 0,5 seg

//Fazendo o sinal vermelho

//piscar em intervalos

//de 0,5 seg



//depois que sai do laço, desliga o sinal vermelho para o //pedestre

digitalWrite(sinal_p_vermelho,HIGH);

delay(1000); //e aguarda por 1 seg

botoeiras=0; //atribui valor 0 para a

//variavel botoeiras



Figura 7: Montagem dos componentes projeto 4 – SEMÁFORO PARA FAIXA DE

PEDESTRES

4.5 ACENDENDO LÂMPADA COM PALMAS

Neste projeto iremos realizar o controle de uma lâmpada (simulada por LED

através de palmas), utilizando um sensor de som. O sensor de som que utilizaremos

nada mais é que uma plaquinha contendo um microfone e um controlador. Este sensor

deve ser alimentado por 5V e GND, ele fornecerá dados digitais a partir do pino out

que estará sempre em sinal alto (fornecendo 5V), e no momento em que ele detectar

um som ele enviará um sinal baixo (0V) pela porta out. A Altura deste som pode ser

regulada através do potenciômetro presente no próprio sensor.






• 1 LED verde;


• 1 sensor de som;

• Jumpers.

Sketch (Código)

Neste caso para detectar as palmas precisamos nos atentar ao tempo de

duração de som de uma palma e o intervalo entre as mesmas, pois a intenção do

nosso projeto é que ao bater palmas duas vezes consecutivamente a lâmpada

acenderá ou apagara.

O tempo de duração do som de uma palma é de aproximadamente 150

milissegundos. E iremos considerar um tempo razoável entre palmas de

aproximadamente 500 milissegundos, mas este pode ser ajustado.

A loja que empregaremos aqui é simples, primeiramente o Arduino irá ler os

dados enviados pelo sensor, irá verificar se o som durará 150 milissegundos, depois

vai verificar se no intervalo de 500 milissegundos haverá outra palma novamente. Se

ocorrer estes eventos ele irá executar uma ação de acordo com o numero de palmas

consecutivas ele detectou. Após executar está ação ele irá zerar novamente o numero

de contagem de palmas e iniciará o processo novamente aguardando a detecção de

novas palmas. O código a seguir define basicamente estas instruções:

/*

################################################################

## Programa 4: ACENDENDO LÂMPADA COM PALMAS ##





################################################################

*/

#define pinSom 7



#define pinlampada 2

#define tempoMaximoDeUmaPalma 150 //milisegundos

#define tempoMaximoEntrePalmas 500 //milisegundos

int contaPalmas = 0;

long tempoEspera = 0;

long tempoEsperaEntrePalmas = 0;

void executarAcao();

void setup()

pinMode(pinSom, INPUT);

pinMode(pinlampada, OUTPUT);

void loop()

//verifica o estado do sensor de som (ele fica normalmente com a porta

//ligada.

//Quando ouver uma palma, ele desliga momentaneamente a porta)

int sensorSom = digitalRead(pinSom);

//se o sensor detectou palmas

if (sensorSom == LOW)

//espera um tempo para nao detectar a mesma palma mais de uma vez

if (tempoEspera == 0)

tempoEspera = tempoEsperaEntrePalmas = millis();

contaPalmas++;

else if ((millis() - tempoEspera) >= tempoMaximoDeUmaPalma)

tempoEspera = 0;

//caso exceda o tempo maximo entre palmas, zera o contador de palmas

if ( (contaPalmas != 0) && ((millis() - tempoEsperaEntrePalmas) > 500) )

executarAcao();

contaPalmas = 0;

tempoEsperaEntrePalmas = millis();

void executarAcao()

switch (contaPalmas)

case 2:

digitalWrite(pinlampada, !digitalRead(pinlampada));

break;





Figura 8: Montagem dos componentes projeto 5 – ACENDENDO LÂMPADA COM

PALMAS

Obrigado!

Caso você tenha alguma dúvida, não deixe de entrar em contato pelo site:

www.adrobotica.com ou pelo e-mail: [email protected].

http://www.adrobotica.com/

mailto:[email protected]



5 REFERÊNCIAS

[1] https://www.arduino.cc/

Acesso em: 31/07/19

[2] http://www.eletrica.ufpr.br/~james/Laboratorio%20V/arquivos/Mini%20C

urso%20Arduino.pdf

Acesso em: 31/07/19

[3] http://www.roboliv.re/uploads/documentos/arduino-

basico/ERUS_minicurso%20arduino_2190_1382631240.pdf

Acesso em: 31/07/19

[4] http://siep.ifpe.edu.br/anderson/arquivos/arduino/Curso%20de%20Ardu

ino.pdf

Acesso em: 31/07/19

[5] https://br-arduino.org/2015/05/arduino-icsp-attiny-atmega.html

Acesso em 31/07/19

[6] http://www.comofazerascoisas.com.br/projeto-arduino-led-com-botao-

liga-desliga.html

Acesso em 31/07/19

[7] https://www.arduinoecia.com.br/2013/09/controle-de-luz-com-ldr-e-

arduino.html

[8] Curso de Arduino para Iniciantes - Aula 02 - Partes do Arduino - Controle

por Palmas. Disponível em:

https://www.youtube.com/watch?v=rIdiLlf4vJQ

Acesso em: 02/08/19

https://www.arduino.cc/

http://www.eletrica.ufpr.br/~james/Laboratorio%20V/arquivos/Mini%20Curso%20Arduino.pdf

http://www.eletrica.ufpr.br/~james/Laboratorio%20V/arquivos/Mini%20Curso%20Arduino.pdf

http://www.roboliv.re/uploads/documentos/arduino-basico/ERUS_minicurso%20arduino_2190_1382631240.pdf

http://www.roboliv.re/uploads/documentos/arduino-basico/ERUS_minicurso%20arduino_2190_1382631240.pdf

http://siep.ifpe.edu.br/anderson/arquivos/arduino/Curso%20de%20Arduino.pdf

http://siep.ifpe.edu.br/anderson/arquivos/arduino/Curso%20de%20Arduino.pdf

https://br-arduino.org/2015/05/arduino-icsp-attiny-atmega.html

http://www.comofazerascoisas.com.br/projeto-arduino-led-com-botao-liga-desliga.html

http://www.comofazerascoisas.com.br/projeto-arduino-led-com-botao-liga-desliga.html

https://www.arduinoecia.com.br/2013/09/controle-de-luz-com-ldr-e-arduino.html

https://www.arduinoecia.com.br/2013/09/controle-de-luz-com-ldr-e-arduino.html

https://www.youtube.com/watch?v=rIdiLlf4vJQ

SUMÁRIO - AD ROBÓTICA - Sua ideia é o que nos move · 2019-08-29 · tensão na placa. A...

Documents

Transcript of SUMÁRIO - AD ROBÓTICA - Sua ideia é o que nos move · 2019-08-29 · tensão na placa. A...