Metodologia:
Foram testados dois tipos de circuito sensor:
Um sensor simples usando divisor de tensão entre um ldr e um resistor de 10kohm (ldr)
Um sensor com amplificação usando o mesmo divisor e um bc548 como amplificador (ldr com bc) e um resistor de 330 ohm (laranja laranja marrom) na base
Os sensores foram colocados sobre o branco, e após 3 segundos inicia a leitura, 10 leituras com intervalo de 0,1 seg entre elas. Após as 10 leituras, o programa calcula a média e envia os dados para o serial monitor. O processo foi repetido 5 vezes, totalizando 50 leituras e 5 médias.
O mesmo processo foi repetido colocando o sensor sobre uma etiqueta de 2,5x2,5 recoberta com fita transparente: 10 leituras com 5 repetições = 50 leituras e 5 médias.
Após este processo foi subtraído do valor de branco o valor do verde de cada teste (ldr e ldr com bc) e tirado a média das 5 repetições. O resultado indica qual processo apresentou a melhor amplitude.
Este processo foi repetido 2 vezes: na primeira vez o sensor estava em uma posição mais alta que o LED e no segundo experimento o sensor estava na mesma altura que o led.
Resultados
Conclusão
Pelos resultados apresentados podemos concluir que o sensor com maior amplitude entre o branco e o verde é o sensor com BC548 na mesma altura do led branco.
Anexos - programação utilizada
int x = 0;
int y = 0;
int ldr=0;
int ldr2=0;
void setup() {
// put your setup code here, to run once:
Serial.begin (9600);
delay (3000);
for (x=0; x<5; x++){
for (y=0; y<10; y++){
delay (100);
int leitura1 = analogRead (A0);
int leitura2= analogRead (A1);
ldr = leitura1+ldr;
ldr2=leitura2+ldr;
Serial.print (x);
Serial.print (", sem bc= ");
Serial.print (ldr);
Serial.print (", com bc= ");
Serial.print (ldr2);
Serial.println ();
}
ldr=ldr/10;
ldr2=ldr2/10;
Serial.print (y);
Serial.print (", media ldr= ");
Serial.print (ldr);
Serial.print (", media com bc= ");
Serial.print (ldr2);
Serial.println ();
ldr=0;
ldr2=0;
}
}
void loop() {
// put youry main code here, to run repeatedly:
Dionísio: "... (em grego: Διώνυσος ou Διόνυσος, transl.Diōnisos ou Diónisos) era o deusgrego equivalente ao deus romanoBaco, dos ciclos vitais, das festas, do vinho, da insânia, mas, sobretudo, da intoxicação que funde o bebedor com a deidade. Filho denZeus e da princesa Semele, foi o único deus olimpiano filho de uma mortal, o que faz dele uma divindade grega atípica..." Fonte: Wikipédia
Este projeto começou a ser desenvolvido pelo Jhonatan (Jhow), toda a sua estrutura em acrílico e suporte de motores foi feita por ele. Inicialmente suas rodas seriam de madeira emborrachada, depois recebeu rodízios de carrinho de supermercado e, finalmente, rodas de um kit que foi doado para nossa equipe de robótica. A estrutura final, com a adaptação do botão liga/desliga, baterias de NiMn de 7V/2A, Arduino UNO rev.3, 2 sensores de IR analógicos TCRT5000 "caseiros", um sensor de ultrassom HC-SR04 e um display de LCD ficou sob responsabilidade do Roselito.
Este projeto, por enquanto, é nosso reserva para OBR na área de resgate, podendo receber a placa de alerta, com buzzers e led´s, ou a garra robótica. Caso algum projeto não esteja concluído ele será o substituto tanto para fundamental e médio. Possui dois servos motores de parabólica adaptado a rotação contínua controlados por um drive de L298n, resultando num torque teórico de aproximadamente 4 kgf/cm. Não é um robô de força mas um robô com boa capacidade de controle e fácil dirigibilidade.
Ainda faltam as informações de dimensões mas segue uma prévia do projeto:
Pensando no desafio recente que teremos será necessário no desenvolvimento do robô do Ensino Médio, preparar o robô para o cruzamento de linhas. Para tanto, o robô deve, segundo a leitura do sensor, determinar quando está sobre a linha branca, preta, cinza e sobre o cruzamento de linhas que é antecedido por um círculo verde. Ou seja, os sensores tem que determinar faixas de cores diferentes. Para tanto segue abaixo o programa base que será utilizado nesta situação específica:
/* PROGRAMA DESENVOLVIDO PELA EQUIPE DE ROBÓTICA PARA DETECÇÃO DE CORES USANDO UM LDR OU UM SENSOR IR ANALÓGICO*/
void loop() {
//DESLIGAR TODOS OS LED´S
digitalWrite (13, LOW);
digitalWrite (12, LOW);
digitalWrite (11, LOW);
int sensor = analogRead(A0); //LEITURA DO SENSOR ANALÓGICO
Serial.println(sensor); //IMPRIME OS VALORES LIDOS
//SE O SENSOR ESTIVER EM 300 - BRANCO ACENDE O LED AMARELO
if (sensor<300){
digitalWrite (13, HIGH);
digitalWrite (12, LOW);
digitalWrite (11, LOW);
Serial.println("BRANCO");
delay(100);
}
//SE O SENSOR ESTIVER ENTRE 300 E 700 - COLORIDO ACENDE O LED AZUL
if (sensor>=300&&sensor<700){
digitalWrite (13, LOW);
digitalWrite (12, HIGH);
digitalWrite (11, LOW);
Serial.println("COLORIDO");
delay(100);
}
//SE O SENSOR ESTIVER ACIMA DE 700 - PRETO ACENDE O LED VERDE
if (sensor>=700){
digitalWrite (13, LOW);
digitalWrite (12, LOW);
digitalWrite (11, HIGH);
Serial.println("PRETO");
delay(100);
}
}// FIM DO PROGRAMA
Neste post, em ordem cronológica, do mais novo para o mais velho, colocaremos nossas disputas internas...
A começar pelo Torneio Juvenil de Robótica (USP) 2013 a luta de sumô Inácio vs Osiris. Talvez a luta mais lenta de todo o torneio pois os robôs já estavam sem baterias:
Quem viu o primeiro vídeo não vai acreditar no segundo: Após carregar as baterias, a luta entre o Inácio vs Artemis, a grande surpresa da nossa equipe, no cabo de guerra.
Antes do Torneio tivemos a luta Osiris vs Artemis que terminou 4 a 4. Quem viu o primeiro vídeo nem acredita que é o mesmo robô, isso porque nessa luta a bateria estava com 70% da capacidade.
Esta postagem refere-se a uma dificuldade surgida no projeto a partir de dados reais de trabalho: precisamos saber qual é o tempo para colocar no delay e, qual o ângulo correspondente deste delay. Em resumo, precisamos que o robô vire num ângulo pré-determinado. Isso afeta as manobras não só no sumô mas no resgate também.
Primeiro precisamos de algumas informações:
1- Como o robô vira?
Para responder a esta questão temos 2 situações distintas- se o robô vira um lado de cada vez (acionamento apenas de um lado do motor) ou se vira os dois lados ao mesmo tempo (um lado para frente e o outro de ré). Se ele vira uma lado de cada vez a curva sairia mais aberta, conforme a figura 1, senão, os dois lados ao mesmo tempo, o robô viraria no próprio eixo, conforme a figura 2 e, portanto, a medida (x) seria diferente.
Figura 1 - Robô virando acionando apenas um lado
Figura 2- Robô virando acionando os dois lados
A partir desta afirmações podemos concluir que, se o robô virar com apenas um motor, a curva descreverá uma circunferência igual a 2 vezes a distância de largura do robô (largura = raio), enquanto, acionando os dois motores, a distância será igual a largura do robô (largura = diâmetro).
2- Qual a velocidade do robô?
Velocidade é o espaço percorrido em função do tempo gasto para percorrer o trajeto, portanto pode-se determinar a velocidade do robô fazendo-o percorrer um espaço de 1 metro e medindo o tempo, em segundos, com um cronometro, obtendo o valor da velocidade em metros por segundo (m/s), unidade do Sistema Internacional.
3- O ângulo desejado.
A partir destas informações em fazendo o uso da equação que mede o comprimento da circunferência - (fonte:wikipedia) e regra de três simples, conseguimos determinar o delay a ser inserido no robô para que ele vire no ângulo desejado.
Para tanto vamos estudar 2 casos:
Caso 1- Robô virando de um lado apenas
Dados:
Velocidade: 0,102 m/s
Ângulo: 60º
Largura do robô: 20 cm
Convertendo velocidade de m/s em cm/s:
0,102 x 100=10,2cm/s
Comprimento da circunferência:
20 x 2 x 3,14 = 125,6 cm.
Ou seja, para dar uma volta completa na circunferência (360º), o robô terá de percorrer 125,6 cm, entra a regra de 3 para determinar, qual distância ele precisa percorrer para o ângulo desejado (60º):
ângulo (º) Distância (cm)
360 125,6
60 x
x = (125,6 x 60)/360
x = 20,93 cm
Desta forma o robô deve percorrer 20,93cm para fazer uma curva de 60º. Basta então, dividir o a distância pela velocidade para obter o tempo e, multiplicar por mil para obter em milissegundos. Desta forma temos:
delay = (20,93/10,2) x 1000
delay = 2,052*1000
delay = 2052 ms
Ou seja, no programa deste robô, para fazer ele virar num ângulo de 60°, basta colocar um delay de 2052 ms.
Caso 2 - Robô que vira os lados
Dados:
Velocidade: 0,102 m/s
Ângulo: 60º
Largura do robô: 20 cm
Convertendo velocidade de m/s em cm/s:
0,102 x 100=10,2cm/s
Comprimento da circunferência: (lembrando que aqui o valor de diâmetro é igual a largura do robô)
20 x 3,14 = 62,8 cm.
Ou seja, para dar uma volta completa na circunferência (360º), o robô terá de percorrer 125,6 cm, entra a regra de 3 para determinar, qual distância ele precisa percorrer para o ângulo desejado (60º):
ângulo (º) Distância (cm)
360 62,8
60 x
x = (62,8 x 60)/360
x = 10,46 cm
Desta forma o robô deve percorrer 10,46cm para fazer uma curva de 60º. Basta então, dividir o a distância pela velocidade para obter o tempo e, multiplicar por mil para obter em milissegundos. Desta forma temos:
delay = (10,46/10,2) x 1000
delay = 1,026 *1000
delay = 1026 ms
Ou seja, no programa deste robô, para fazer ele virar num ângulo de 60°, basta colocar um delay de 1026 ms.
Comparando os delays podemos concluir que um robô que aciona os dois lados para virar é mais rápido e que, em algumas situações, um ou outro sistema de curva, pode ser mais adequado.
09/09/2013 - Teste do radar
Após os testes teóricos realizamos os testes práticos. O primeiro teste consistiu no sensor de ultrassom fixo e o servo motor marcando a posição. O led verde acende quando o objeto está a menos de 20 cm e a posição do servo aumenta de 10 em 10º sem delay entre os ângulos.
A fonte de alimentação do servo foi ligada separado para evitar interferência (ruído).
No segundo teste instalamos o sensor de ultrassom sobre o servo motor (deu um trabalhão pois o suporte reciclado está com problemas) e continuamos usando o mesmo aumento e a mesma distância. Resultado extremamente positivo, com o led acendendo quando o sonar encontra o objeto.
Próximo teste será no chassi com busca do objeto e ataque.
30/08/2013
Continuando o sistema de desenvolvimento de um radar para nossos robôs usando um servo de posição e um sensor de ultrassom, desenvolvemos um programa baseado nos testes anteriores usando apenas o if como base de decisão.
Primeiro determinamos 2 variáveis que trarão as informações do servo-motor:
...
int posicao;
int m;
...
(m) corresponde a posição que o motor vai ficar (servo.write) e (posicao) a leitura de posição atual do motor. Em segundo lugar determinamos como o servo vai aumentar a posição através do comando:
Ou seja, o servo aumentará de 10 em 10 graus seu ângulo até 170 graus. Por que não 180? Porque o modelo que usamos no simulador do proteus (simulino) vai só até 180. O servo que usamos vai até 225º e portanto poderemos até aumentar estes valores na prática.
Depois inserimos a variável que irá "zerar" o motor se nada for encontrado no radar:
...
if (m==180){
radar.write (0);
Serial.println ("Zerando a posicao");
m=0;
delay (500);
}
Essa foi a mais díficil pois estávamos usando (m==0) e não (m=0) o que fazia com que o motor voltasse mas não zerasse. Opcionalmente pode-se usar:
...
if (m==180){
m=0;
radar.write (m);
Serial.println ("Zerando a posicao");
delay (500);
}
...
Os (delay) utilizados foram apenas para que pudéssemos visualizar na gravação da simulação o que ocorria pois a velocidade de processamento e do (Serial.print) não deixava claro o que estava acontecendo. No programa no final desta atualização removeremos.
Depois inserimos as variáveis de controle baseados na leitura do ultrassom:
...
if (cm1>20){
....// comandos para movimentação e zerar servo anteriores
}
if (cm1<=20){
//comandos para atacar alvo
Serial.println ("Atacar alvo");
delay (1000);
}
...
Novamente colocamos o (delay) para facilitar a visualização na gravação no proteus.
Finalmente inserimos o comando de leitura do sensor de ultrassom (sonar) e criamos uma função para leitura do sensor logo após o (void loop) para assim limitar o movimento do servo se baseando na distância do alvo, conforme o programa abaixo:
//Programa Pequenos Cientistas para sistema de radar
#include <Servo.h>//biblioteca do servo motor
//Variáveis do sensor de ultrasssom
int emissor=11;// trigger pinos do sensor de ultrassom
int receptor=10; //echo pinos do sensor de ultrassom
long cm1,duracao;
//Variáveis do servo-motor
Servo radar;
int posicao;
int m;
void setup(){
//aciona os pinos do sensor de ultrassom
pinMode (emissor, OUTPUT);
pinMode (receptor, INPUT);
//pino do servo-motor
radar.attach (9);
Serial.begin (9600);
}//fim do void setup
void loop(){
//leitura do sensor de ultrassom
sonar();
//leitura da posição do servo
posicao=radar.read();
//imprime as leituras
Serial.print (cm1);
Serial.print (", ");
Serial.print (posicao);
Serial.print (", ");
Serial.println (m);
//Se o objeto estiver a mais de 20 cm
if (cm1>20){
if (m<180){
m+=10;
radar.write (m);
Serial.println ("Procurando alvo");
delay(10);
}//fim do if para movimentar o servo
if (m==180){
radar.write (0);
Serial.println ("Zerando a posicao");
m=0;
delay (500);
}// fim do if para zerar o servo
}// fim do if de distância do alvo
//Se o objeto estiver a menos de 20 cm
if (cm1<=20){
//comandos de ataque
Serial.println ("Atacar alvo");
delay (1000);
}//fim do if atacar alvo
}//fim do void loop
//Função de leitura do sensor de ultrassom
long sonar(){
digitalWrite (emissor, LOW);
delayMicroseconds (2);
digitalWrite (emissor, HIGH);
delayMicroseconds (10);
digitalWrite (emissor, LOW);
duracao=pulseIn(receptor,HIGH);
cm1=microsecondstocentimeters(duracao);
return cm1;
}
//Converte microssegundos em centímetros - velocidade do som = 1cm/29ms
long microsecondstocentimeters(long microseconds){
return microseconds/29/2;
}
_________________________________________________________________________________
Vídeo de teste:
O primeiro número é a leitura do ultrassom, o segundo a leitura da variável (posicao) - servo.read, e o terceiro número é a leitura da variável (m) que controla a posição do servo. No teste primeiro deixamos o servo buscar até o final e retornar a zero, aí simulamos um objeto e, depois, esse objeto sai da frente do sensor de ultrassom, retornando a busca normal pelo objeto.
20/06/2013 - Início do Projeto
Objetivo: desenvolver um sistema de sensor de ultrassom que localize um objeto, sem mover o chassi e, depois, o chassi se move em direção ao objeto.
Materiais:
Servo de posição HB
Sensor de ultrassom HC-SR04
Arduino Uno
Protoboard para testes
Fios wire macho macho
Chassi de teste : robô Osíris
Planejamento dos testes
1- Teste do servo motor usando o comando for (0 a 180º)
2- Teste de programa usando o sonar e o servo-motor: o servo deve se mover parando quando encontrar o objeto.
3- Teste de programa simulando o motor: o servo deve se mover até encontrar o objeto. Após encontrar o objeto luzes se acenderão simulando os motores do robô e, depois, o servo deve se posicionar em 90º, acionando um outro conjunto de luzes.
4- Teste final: o sonar será instalado no chassi Osíris e será realizado os testes de simulação de combate contra o robô Artemis.
Fase 1- Teste de uso do servo motor
Objetivo: determinar um programa de controle do servo-motor
Neste caso usamos o comando for e as instruções contidas no modelo de programa da pasta "Examples" do Arduino.
Resultado - O motor funcionou, movendo-se de 1 em 1º.
Vídeo abaixo:
Teste 2- Montagem do radar
Neste teste fizemos 9 programas diferentes sendo que, usamos o comando for, comandos if e outros para ver se conseguíamos fazer o servo localizar o objeto e parar de se mover. O teste 1, 3 e 9 foram os únicos que chegaram próximos disso, conforme vídeos abaixo:
Teste 1
Teste 3
Teste 9
Chegamos a conclusão que o melhor programa era o do "Teste 1" e, portanto trabalharíamos em aprimorá-lo para conseguir chegar ao objetivo desta etapa. Abaixo segue imagem com o fluxograma utilizado, e os links para o programa já na linguagem do Arduino.
Teste 11 - Neste teste usamos o comando if para fazer a função dos comandos que estavam distribuídos ao longo do sketch do programa 1, deixando mais próximo do fluxograma de programa que julgamos ideal, atingindo nosso objetivo nesta etapa que era do radar se mover até encontrar o objeto. Caso o objeto saísse da frente ele voltava a rotina de busca e localização. Como padrão usamos a distância de 30 cm que era a distância ideal da mesa de teste.
A biblioteca do motor de passo do Arduino apresenta o passo completo 2 conforme abaixo:
Passo completo 1 (Full-step) -Somente uma bobina é energizada a cada passo; -Menor torque; -Pouco consumo de energia; -Maior velocidade.
Passo completo 2 (Full-step) -Duas bobinas são energizadas a cada passo; -Maior torque; -Consome mais energia que o Passo completo 1; -Maior velocidade.
Meio passo (Half-step) -A combinação do passo completo1 e do passo completo 2 gera um efeito de meio passo; -Consome mais energia que os passo anteriores; -É muito mais preciso que os passos anteriores; -O torque é próximo ao do Passo completo 2; -A velocidade é menor que as dos passos anteriores.
Neste caso temos sempre 2 bobinas acionadas, o que consome mais energia durante o funcionamento. Para evitar este consumo é preciso reduzir os passos ao passo completo 1:
Mas para isso se faz necessário a criação de um programa de passos para acionamento do motor, conforme modelo abaixo:
/* Este código permite o passo de 1 motor - PASSO 1*/
//motor direito
int motorPin1 = 7;
int motorPin2 = 8;
int motorPin3 = 3;
int motorPin4 = 4;
int tempopasso = 3000;
void setup() {
//configura os pinos digitais do motor direito
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
}
void loop() {
//motor direito
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, LOW);
delay (tempopasso);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, LOW);
delay (tempopasso);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, HIGH);
digitalWrite(motorPin4, LOW);
delay (tempopasso);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, HIGH);
delay (tempopasso);
}
O problema está no cálculo do tempo de passo, que não pode ser menor que 10ms. Sabendo os valores máximos de RPM e step do motor, que podem ser obtidos usando o programa stepper_oneStepAtATime (examples - stepper) basta usar a fórmula abaixo para o cálculo:
Exemplo:
RPM = 100
Passos = 48 (Step 7,5º)
Para tanto pode-se construir uma função:
int rpm = 100;
int passos = 48;
int tempo;
tempo passo = rpm/(passos*60)
Com essa função podemos usar todos os tipos de passo (passo 1, 2 e meio passo, basta modificar os HIGH e LOW dos pinos abaixo. O código final fica assim:
/* Este código permite o passo de 1 motor - PASSO 1*/
21/04/2013
Drive de motor com l298 simples
https://skydrive.live.com/redir?resid=AC8ECA0DCFBBC517!447&authkey=!ABoltnIaQz27muk
será feito na quarta 24/04
27/03/2013
Teste de motores - 1 volta para frente e 1 volta para trás
20/03/2013
Instalação dos motores e primeiro teste: usamos a ponte H feita em protoboard pela equipe do ensino fundamental para testar o suporte dos motores e verificar a tração do robô. Os motores estavam com mesmo sentido e, por ter apenas uma par de pontes H, não é possível virar o motor. Agora iniciamos o processo de montagem das placas.
Fotos da montagem do suporte: 2 parafusos prendem uma placa de alumínio ao motor, pressionando-o para baixo, apoiados no chassi
O robô montado - ficou feio mas funciona!
Vídeos dos testes
13/03/2013
Estrutura finalmente completada. O 2º eixo foi cortado e adicionado as rodas, foi terminada a estrutura do chassi. Agora vamos instalar os motores e colocar os drives para testar a velocidade do chassi e a tração - que será feita por uma correia de borracha.
06/03/2013
Estrutura construída. Ainda faltam as rodas dianteiras e a fixação do motor, mas a estrutura já está terminada. O eixo de aço pesou um pouco mas estamos confiantes que o motor será suficiente. Ferramentas fazem a diferença: passar o esmeril nos furos favoreceu a "lubrificação" das rodas. Ainda falta a placa controladora de motores.
20/02/2013
Segue abaixo as primeiras fotos da estrutura do chassi cortado, com o suporte das rodas e o chanfro do suporte do motor, bem como detalhes construtivos do robô:
Sistema todo montado: 2 chapas (macho e fêmea) e detalhe do motor pressionando gravitacionalmente a roda.
16/02/2013 Código do projeto: EMF1520
Ideia: um robô que utiliza motores de passo bipolar retirados de impressoras Epson matricial com alto torque (pelo menos é o que parece). Esses motores coordenam correias que puxam a cabeça de impressão. Os motores serão colocados na parte superior do robô, diferente do que fazemos, apoiados sobre as rodas, com uma esteira de borracha passando entre eles.
As rodas serão retiradas de roletes de impressora HP série 600, com eixo cortado (função do Paulo), serão colocados na parte inferior do chassi. Usamos anéis de borracha para fixar as rodas e eixos nos furos, arruelas para diminuir o atrito do eixo com o chassi.
O chassi foi montado da carcaça de um dvd velho cortado e furado sem brocas de metal, com 2 placas superpostas para conferir maior resistência e leveza, visto que a carcaça é um tipo de liga de alumínio, que é resistente mas bem leve, conforme as figuras abaixo:
O Thiago trouxe um esmeril para furadeira que ajudou a lixar e evitar cortes porém as brocas ainda são um problema - tente furar uma chapa de metal com brocas para madeira e alvenaria e você vai entender.
Em breve colocaremos as fotos das outras partes do chassi.
Fotos dos motores retirados de impressora com as borrachas de teste.
Impressora matricial sendo desmontada e detalhe do motor
12 de Dezembro de 2012
Hoje nós fizemos a medida da sensibilidade do LDR variando os resistores.
O Teste foi feito com os LEDS das cores:
Branco, vermelho e verde.
Calculando os valores máximos e mínimos.
Os resultados foram:
Resultados com resistor de 10K ohm:
Branco
Verde
Vermelho
Max.
Min.
Max.
Min.
Max.
Min.
1003
676
1018
806
1012
789
1004
678
1019
808
1013
791
1012
680
1017
810
1014
792
1014
681
1016
804
1015
793
1016
682
1015
807
1016
795
Resultados com resistor de 1K ohm:
Branco
Verde
Vermelho
Max.
Min.
Max.
Min.
Max.
Min.
987
452
1005
646
1020
986
988
460
1010
646
1023
985
988
460
1011
647
1019
983
913
457
1009
648
1021
984
926
458
1008
649
1016
985
Valor de mínimo e máximo do ldr usando led azul
Vídeo do teste
05 de Dezembro de 2012
Conversão de luz em som
PS: o barulho é irritante
Tabela 1- Sensibilidade do LDR variando os resistores
5 cms de distancia do LDR ao LEDs
1k ohm
4k7 ohm
10k ohm
Cor
Min
Max
Min
Max
Min
Max
Branco
189
210
649
701
Verde
121
173
Vermelho
Tabela 2- Sensibilidade do LDR variando os resistores
5 cms de distancia do LDR ao led
1k ohm
4k7 ohm
10k ohm
Cor
Min
Max
Min
Max
Min
Max
Branco
913
1004
314
582
Verde
Vermelho
Tabela 3- Sensibilidade do LDR variando os resistores
0,5 cms
1k ohm
4k7 ohm
10k ohm
Cor
Min
Max
Min
Max
Min
Max
Branco
Verde
705
715
Vermelho
410
423
Descrição
Elaboração de um sensor de cor usando LDR e Arduino, com objetivo de utilizar na Olimpíada Brasileira de Robótica, no nível fundamental para reconhecer a cor verde e para o nível médio para reconhecer uma lata de refrigerante vermelha.
Teste 1- Simulação
Este teste foi feito através do SIMULINO - simulador do Arduino, usando o programa acima e variando os resistores. Não é preciso pois não usa led de 2 cores mas, o led tem controle de intensidade permitindo a determinação dos valores máximos e mínimos de cada resistor, permitindo uma prévia seleção do mesmo.
Conclusão
Segundo a análise dos resultados do Simulino, o sensor de 10k ohm obteve a maior faixa de valores de leitura e portanto, é considerado o mais sensível em relação aos outros resistores. Se faz necessário testes reais com os resistores para confirmar os dados. A programação utilizada é a mesma do teste 2.
Teste 2- Sensibilidade do LDR
Usaremos resistores de valores diferentes e faremos a leitura no Arduino dos valores para cor verde e vermelha (valor máximo e mínimo), usando um fade (PWM) fazendo com que o led bicolor reduza a intensidade, simulando a distância ótima do sensor em relação ao objeto. Colocaremos uma proteção tubo de caneta com fita isolante ou canudinho - para evitar a influência da luz ambiente.
Programação do Arduino:
/* Programa de leitura do LDR usando 2 led´s e fade
Este programa tem a função de calibrar o LDR e ajudar a decidir qual resistor é o mais indicado
*/
void setup(){
pinMode (8, OUTPUT);
pinMode (7, OUTPUT);
pinMode (A0, INPUT);
Serial.begin (9600);
}
void loop (){
float LDR; //variável para leitura do LDR
LDR = analogRead (A0); //Leitura do LDR
//envia o valor para o monitor serial
Serial.print ("leitura do LDR= ");
Serial.println (LDR);
//Pino Vermelho
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) // seleciona o valor numa escola de 0 a 255, aumentando de 5 em 5
analogWrite(8, fadeValue);
// espera 30 milissegundos para acabar o efeito
delay(30);
//Pino Verde
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) // seleciona o valor numa escola de 0 a 255
analogWrite(7, fadeValue);
// espera 30 milissegundos para acabar o efeito
delay(30);
}
Montagem - Fritzing
Material
3 resistores de 220 ohm
1 led bicolor - vermelho/verde
1 led alto brilho branco
1 ldr
1 resistor de 10kohm
1 resistor de 4k7 ohm
1 resistor de 1kohm
Arduino UNO
Fios
Resultados
Tabela 1- Sensibilidade do LDR variando os resistores
1k ohm
4k7 ohm
10k ohm
Cor
Min
Max
Min
Max
Min
Max
Branco
Verde
Vermelho
Teste 3 - Sensor de cor
Após a calibração dos sensores, determinando qual resistor é mais adequado e qual o valor máximo e mínimo para cada cor o programa abaixo será complementado e testado em protoboard. O objetivo é que o led que acenda vermelho produza um ruído com frequência maior que o led que acenda verde.
Montagem - Fritzing
Material
2 resistores de 220 ohm
1 resistor de 100 ohm
1 led bicolor - vermelho/verde
1 ldr
1 buzzer
1 resistor de ___kohm (depende do resultado do teste 2)
Arduino UNO
Fios
/* Programa para detecção de cores usando um ldr - sensor de cor para projeto OBR - Ensino Fundamental
O Led Vermelho acende alterando a frequência do Buzzer, o mesmo ocorrendo para o led verde
*/
void loop(){
float LDR; //variável do LDR
LDR = analogRead (A0);//leitura do ldr
Serial.print ("valor do LDR =/t");
Serial.println (LDR);
//acende o led verde por 2 segundos
digitalWrite (8, HIGH);
delay (2000);
//acende o led vermelho por 2 segundos
digitalWrite (8, LOW);
digitalWrite (7, HIGH);
delay (2000);
//apaga o led vermelho
digitalWrite (7, LOW);
if ( ? <LDR< ?){ //se o led vermelho acender o buzzer oscila numa frequência maior
tone (6, LDR*1000);
}
if ( ? <LDR< ? ){
tone (6, LDR*1000);//se o led verde acender, o buzzer oscila numa frequência menor
}
}
? - faixa de valores depende do resultado do teste 2.
(fonte:wikipedia) e regra de três simples, conseguimos determinar o delay a ser inserido no robô para que ele vire no ângulo desejado. 
