Custom Search

segunda-feira, 25 de junho de 2012

Arduino + Sensor de Estacionamento




Olá pessoal, comprei alguns componentes novos para melhorar o robô e resolvi fazer alguns tutoriais para mostrar o melhor funcionamento de cada componente.

O componente que irei mostrar hoje é o sensor infra vermelho sharp. Ele é nada mais e nada menos que um detector de obstáculos, com isso vou tentar "simular" um sensor de estacionamento.

Estou usando:

1 - Arduino Duemilanove
2 - Sensor Sharp
3 - Led
4 - Resistor 220
5 - Buzzer
6 - Botão Liga/Desliga
7 - Fio e Protoboard

Componentes


Primeiro vamos verificar como funciona o Sensor Sharp. Utilizaremos uma chave on/off para simular a marcha ré, o sensor e um led para mostrar a presença do obstáculo.

Segue o modelo do circuito.

Circuito

Em seguida faça o upload do código


/*
    **************************************
        Teste do Sensor Sharp
        José Maria DVD
        http://josemdvdf.blogspot.com.br/
    --------------------------------------

*/
int pinLed = 12;
int pinSensor = 0;
int pinChave = 2;
void setup(){
  pinMode(pinLed, OUTPUT);
  pinMode(pinSensor, INPUT);
  pinMode(pinChave, INPUT);
}
void loop() {
  int vlChave = digitalRead(pinChave);

  if(vlChave == HIGH)
  {
    int vlSensor = analogRead(pinSensor);
    int sleep = map(vlSensor, 0, 800, 250,0);
    digitalWrite(pinLed,HIGH);
    delay(sleep);
    digitalWrite(pinLed,LOW);
    delay(sleep);
  }
}


Veja o vídeo do funcionamento.


Próximo passo é inserir o buzzer para fazer aquele barulho conhecido :D


Buzzer

O buzzer possui 2 pinos, um negativo e outro de dados. Portanto basta ligar o pino negativo no terra e o positivo em uma porta digital do arduino. Veja na figura abaixo.

Circuito Completo

Em seguida faça o upload do seguinte código:


/*
    **************************************
        Simulação de um Sensor de Estacionamento
        José Maria DVD
        http://josemdvdf.blogspot.com.br/
    --------------------------------------

*/
int pinLed = 12;
int pinSensor = 0;
int pinChave = 2;
int pinBuzzer = 4;
void setup(){
  pinMode(pinLed, OUTPUT);
  pinMode(pinSensor, INPUT);
  pinMode(pinChave, INPUT);
  pinMode(pinBuzzer, OUTPUT);
}
void loop() {
  int vlChave = digitalRead(pinChave);

  if(vlChave == HIGH)
  {
    int vlSensor = analogRead(pinSensor);
    int sleep = map(vlSensor, 0, 800, 250, 1);
    digitalWrite(pinLed, HIGH);
    tone(pinBuzzer, 2637, sleep);
    delay(sleep);
    digitalWrite(pinLed,LOW);
    delay(sleep);
  }
}


Quem quiser saber um pouco mais como funciona a função tone.

Versão Final

Veja o vídeo de funcionamento.





sexta-feira, 11 de maio de 2012

Tutorial : Arduino + Robô seguidor de luz ( Light follower Robot )



Olá pessoal após os pequenos projetos Arduino LDR e Arduino Servo Motor resolvi criar um projeto um pouco maior: Robô seguidor de luz.
Se alguém quiser entender um pouco melhor sobre pequenas partes como LDR e Servo Motor, sugiro que vejam o link referenciado acima.

Gostaria de avisar que o robô apenas segue a luz, ou seja caso a luz incidente seja maior no lado direito ele segue para a direita, caso  a luz incidente seja maior no lado esquerdo segue para a esquerda senão segue em frente (caso não tenha luz ou a luminosidade seja homogênea). 

E como eu sei onde tem mais luz ?
Para verificar a incidência de luz utilizei os LDR´s

E como mudar a direção ?
Para mudar a direção utilizei um Sero Motor.

Antes de começar o tutorial propriamente dito, gostaria de fazer um agradecimento a um amigo e grande jogador de StarCraft 2: Mateus Makarov Souza pelo apelido de Hellion ao robô. Só falta o jato de Fogo... rsrsrs

Robô Seguidor de Luz

Hellion - StarCraft 2

Vamos começar.

Lista de componentes:
1 - Arduino Duemilanove
2 - Servo
3 - 2 * LDR 5mm
4 - 2 * Resistor de 10k
5 - Bateria
6 - Protoboard
7 - Fios
8 - 2 carrinhos de brinquedo + pilhas

Passo 1

Fazer uma extensão para os LDRs. Isso faz com que as variações de luz sejam mais evidentes, além de criar um visual com a forma de um inseto, como se o robô tivesse antenas.

Se você tiver um cabo de rede velho ou que não irá usar, corte e retire dois pares de fios.

Cabo de rede

Em seguida solde os fios aos LDRs e use fita isolante. 

Soldar os fios a LDR

Antena LDR

Obs.: Tente deixar os fios trançados como mostra a foto acima.

Pra quem quiser e tiver material pode deixar as antenas um pouco mais amigáveis utilizando o tubo termo retrátil.

Inserindo o tubo
Aquecendo para fixar

Resultado final

Faça para os dois LDR´s

Passo 2

Assim que estiver pronto podemos fazer o nosso primeiro circuito. A figura abaixo mostra o circuito  do LDR. Caso você queira ver como funciona um LDR pode ver nesse link.

Circuito LDR

Foto - Circuito LDR

Foto - Circuito LDR

Em seguida rode o seguinte código e veja se está funcionando normalmente. O resultado será apenas via serial.

int pinLDRDir = 5; // pino analógico 5 direita
float LDRDir = 0;  // receberá o valor do LDR da direita
int pinLDREsq = 0; // pino analógico 0 esquerda
float LDREsq = 0;  // receberá o valor do LDR da esquerda

void setup() {
  Serial.begin(9600);
}
void loop(){
  //O valor lido da porta será no intervalo (0 a 1023)
  LDRDir = analogRead(pinLDRDir);
  LDREsq = analogRead(pinLDREsq);

  //Mostra na serial
  Serial.print("LDR Dir= ");
  Serial.println(LDRDir);
  Serial.print("LDR Esq= ");
  Serial.println(LDREsq);

  //Se 75% de LDREsq >= LDRDir - Vira a esquerda
  if( LDREsq*0.75 >= LDRDir)
    Serial.println("Vira a esquerda");
  //Senão se 75% de LDRDir >= LDREsq - Vira a direita
  else if( LDRDir*0.75 >= LDREsq)
    Serial.println("Vira a direita");
  else
    Serial.println("Centro");
  delay(500);
}

Passo 3

Após montar o circuito LDR, partimos para as ligações do Servo Motor. Essa parte é a mais fácil pois o Servo não precisa de nenhum circuito adicional, apenas das ligações com os pinos do arduino.

O servo motor possui 3 fios:

Amarelo : Fio de dados
Vermelho: VCC (5v)
Marrom: GND (terra)

Portanto devemos apenas ligar um fio ao pino 9 do arduino, que será o de dados, outro ao vcc e outro ao terra. A figura abaixo mostra essas ligações. Caso você queira ver como funciona um Servo Motor, clique no link.

Fios Para o Servo

Passo 4

Chegou o grande momento de montarmos o nosso robô. Pegue o primeiro carrinho e desmonte, utilizaremos suas rodas da frente para controlar a direção do nosso robô.

Carro 1 - Normal

Carro 1 - Desmontado

Carro 1 - Retire as rodas da frente.

Passo 5

Em seguida, de alguma maneira (rsrs), cole as rodas ao servo motor.

OBS.: Antes de colar as rodas ao Servo, certifique-se que ele esteja posicionado em 90º. Você tem duas maneiras de fazer isso. A primeira é girar o eixo até o final para ambos os lados e tentar achar o centro. A segunda eh fazer via software.

No software você deve fazer as seguinte ligações:

Servo
OBS.: Não esqueça de usar uma bateria para alimentar o arduino. Caso você não tenha uma bateria com o plug para o arduino, esse link mostra como fazer.

Em seguida rode o código:

/*
**************************************
Colocando o Servo em 90º
José Maria DVD
http://josemdvdf.blogspot.com.br/
--------------------------------------


*/
#include <servo.h>
Servo servo1;
void setup() {
servo1.attach(9);
servo1.write(90);
}
void loop(){}

Com o Servo posicionado de maneira correta, fixe-o de alguma forma. Peço desculpas pois não sou muito habilidoso nesses detalhes, o trabalho ficou um pouco feio porque usei fitas e abraçadeiras.

Servo + Rodas


Passo 6


Agora chegou a vez do segundo carro. Faça o mesmo processo, a diferença é que agora você ficará com as rodas traseiras que servirá de tração, com a base do carrinho que servirá de suporte para o protoboard (circuito completo) e chassis, além do motor e as pilhas que farão o nosso robô andar.

No meu caso, tive que desmontar todo o carrinho pois ele tinha outras funções que não me serviriam. Também estava com sorte pois o carrinho já tinha duas chaves, uma para ligar/desligar e outra para fazer o carro ir para frente ou ré. Caso o seu não tenha, basta ele andar mesmo :D.

Carro 2 - Desmontado


Passo 7


Após desmontar o carrinho, verifique se o motor e as chaves estão funcionando normalmente. Na hora de testar o ideal é usar as pilhas (observe que não usei :/ ), pois com elas podemos ter certeza que o suporte está normal.Veja o vídeo.



Passo 8


Após os testes, remonte e deixe as rodas traseiras, o suporte para a pilha, e toda a parte de tração.


Carro 2 - Remontado

Carro 2 - Remontado, com tração completa



Passo 9


Bom, agora que tudo está funcionando vamos começar a integração. Junte o servo/rodas dianteiras ao chassis. Nesse passo tive vários problemas por falta de material rsrsrs, mas no fim deu tudo certo.

Integração - Rodas dianteiras

Integração - Rodas Dianteiras


Passo 10


Agora vamos testar o servo integrado ao chassis. Use as mesmas ligações da figura servo no passo 5 e rode o seguinte programa:


/*
    **************************************
        Teste do Servo
        José Maria DVD
        http://josemdvdf.blogspot.com.br/
    --------------------------------------
 
*/
#include  <servo.h>
Servo servo1;
int pos = 90;
char lado = 'n';
void setup()
{
servo1.attach(9); // Porta de dados do servo
Serial.begin(9600); // inicializa porta serial
servo1.write(pos);
}
void loop(){
lado = Serial.read();
if (lado == 'l') ){
  pos = 10;
}else if (lado == 'r'){
  pos = 170;
} else pos = 90
lado = 'n';
servo1.write(pos);
delay(350);
}

OBS.: É necessário abrir o serial monitor do skd e digitar a letra 'l' para esquerda e 'r' para a direita.

Veja o vídeo de demonstração.



Passo 11


Próximo passo é integrar o circuito do passo 3 ao servo, lembrando que o fio AMARELO é de dados, o  VERMELHO é o VCC (5v) e o MARROM o GND (terra). Em seguida rodar o código:


#include <servo.h>
int pinLDRDir = 5; // pino analógico 5 direita
float LDRDir = 0;  // receberá o valor do LDR da direita
int pinLDREsq = 0; // pino analógico 0 esquerda
float LDREsq = 0;  // receberá o valor do LDR da esquerda
Servo servo1;
int pos = 90;
void setup() {
  servo1.attach(9);
  servo1.write(pos);
}
void loop(){
  //O valor lido da porta será no intervalo (0 a 1023)
  LDRDir = analogRead(pinLDRDir);
  LDREsq = analogRead(pinLDREsq);
  //Se 75% de LDREsq >= LDRDir - Vira a esquerda
  if( LDREsq*0.75 >= LDRDir){
    pos = 10;
  }
  //Senão se 75% de LDRDir >= LDREsq - Vira a direita
  else if( LDRDir*0.75 >= LDREsq){
    pos = 170;
  }
  //Senão - centro
  else{
    pos = 90;
  }
  servo1.write(pos);
  delay(350);
}

Veja os vídeos.






Passo 12

Agora integre o circuito completo ao chassis do robô. Usei uma liga pra fixar o arduino ao protoboard e uma abraçadeira plástica para fixar o protoboard ao chassis.

Robô seguidor de luz - final

Robô seguidor de luz - final

Agora com o robô completo refaça os testes.



Perceba que o robô tem uma reação um pouco demorada, portanto mude a última linha de código do passo 11 para delay(100); e veja como a resposta aos comandos fica mais rápido.




Passo 13 - FINAL


Após alguns testes em campo, percebi que o robô não conseguia fazer as curvas direito. Isso acontecia porque o ângulo que o servo rotacionava era muito alto, então fiz alguns ajustes e cheguei a um ponto bom. Você pode fazer isso com o seu também, faça vários testes e veja qual o melhor ângulo de posicionamento possível. Segue o código final:


#include <servo.h>
int pinLDRDir = 5; // pino analógico 5 direita
float LDRDir = 0;  // receberá o valor do LDR da direita
int pinLDREsq = 0; // pino analógico 0 esquerda
float LDREsq = 0;  // receberá o valor do LDR da esquerda
Servo servo1;
int pos = 90;
void setup() {
  servo1.attach(9);
  servo1.write(pos);
}
void loop(){
  LDRDir = analogRead(pinLDRDir);
  LDREsq = analogRead(pinLDREsq);

  //Se 75% de LDREsq >= LDRDir - Vira a esquerda
  if( LDREsq*0.75 >= LDRDir){
    pos = 60;
  }
  //Senão se 75% de LDRDir >= LDREsq - Vira a direita
  else if( LDRDir*0.75 >= LDREsq){
    pos = 120;
  }
  else{
    pos = 90;
  }
  servo1.write(pos);
  delay(100);
}


Veja o Making Off






Outras fotos....










terça-feira, 10 de abril de 2012

Arduino + LDR (Light Dependent Resistor)



Olá povo, hoje vou fazer um pequeno exemplo de como usar um LDR (Light Dependent Resistor, ou em português Resistor Dependente de Luz).

Um LDR é um tipo de resistor cuja resistência varia conforme a intensidade de luz que incide sobre sua superfície. Portanto o LDR "transforma luz em valores de resistência".

A idéia é poder controlar a intensidade de um LED de acordo com a intensidade de luz que incide sobre o LDR, ou seja, quanto mais luz tivermos no local, menor será o brilho do LED e quanto mais escuro, maior será o brilho do LED.

Bom... então segue a lista de componentes:

1 - Arduino Duemilanove
2 - LDR 5mm
3 - LED
4 - Resistor de 10K
5 - Resistor 220
6 - Fios

O primeiro passo é fazer as devidas ligações como no circuito abaixo:




em seguida o código:

/*
***Arduino + LDR***
José Maria DVD
*/
int pinoLED = 9; // pino digital 9
int pinoLDR = 5; // pino analógico 5
int LDR = 0; // receberá o valor do LDR
int LED = 0; // valor do LED
void setup() {
Serial.begin(9600);
}
void loop(){
//O valor lido da porta será no intervalo (0 a 1023)
LDR = analogRead(pinoLDR);
//Mostra na serial
Serial.print("LDR = ");
Serial.println(LDR);
//Ajuste de valores para um melhor filtro
if(LDR > 600) LDR = 600;
else if(LDR < 100) LDR = 100;
//Tranforma uma escala de valores em outra (255 a 0).
LED = map(LDR, 100, 600, 255, 0);
analogWrite(pinoLED, LED);
delay(50);
}
Resultado final:





Veja o vídeo do funcionamento.




Observações e Comentários: 


1 - Você deverá fazer alguns ajustes dependendo da intensidade de luz no ambiente. No meu caso precisei ajustar a seguinte linha de código:


 //Ajuste de valores para um melhor filtro
  if(LDR > 600) LDR = 600;
  else if(LDR < 100) LDR = 100;
  //Tranforma uma escala de valores em outra (255 a 0).
  LED = map(LDR, 100, 600, 255, 0);
Normalmente o valor do LDR é de 0 a 1023 no entanto com os testes feito no ambiente, observei que o valor variava de 50 a 700. Portanto optei por diminuir o intervalo (100 a 600) e com isso obtive um resultado final mais concreto(o LED chegava a apagar totalmente).

 2 - Aconselho estudar um pouco sobre a função map, com ela boa parte de seus problemas serão resolvidos.

3 - O resistor de 10k é para o LDR e o de 220 é para o LED. Aconselho também estudar um pouco sobre Divisor de Tensão.

Até a próxima.



segunda-feira, 2 de abril de 2012

Arduino + Servo Motor




Olá pessoal, hoje vou mostrar como utilizei o meu arduino para controlar um servo motor.

Estou usando:
1 - Arduino Duemilanove
2 - Servo Motor HX5010
3 - Bateria
4 - Fios

O primeiro passo é montar o circuito abaixo:



OBS.: Dependendo do servo que esteja trabalhando, será necessário utilizar uma fonte externa para alimentação, o círculo vermelho indica onde deverá ser inserido. No meu caso usei uma bateria.

Bom, a ideia é que o servo se mova para a direita ou para a esquerda, usando a porta serial como parâmetro de entrada. Para fazer o controle do servo utilizaremos um biblioteca nativa do arduino chamada Servo.


OBS.: Para quem não sabe, o servo possui 180º de movimento(0 até 179 = 180 posições). Portanto usaremos uma variável chamada pos para fazer esse controle. Utilizaremos também uma outra chamada graus, que será o nosso incremento de posição.


Nesse caso a variável pos possui valor inicial 90 e a varável graus possui valor 10. Com isso teremos para a varável pos um valor mínimo de 0 e máximo de 170. Caso queira ter uma melhor precisão, basta diminuir o valor de graus.

Segue o código:

/*
** Servo **
José Maria DVD
*/
#include <Servo.h>
Servo servo1;
//variavel de posicao do servo, inicialmente com 90(meio), já que o servo varia entre 0-179 graus
int pos = 90;
int graus = 10;
char lado;
void setup()
{
servo1.attach(9); // Porta de dados do servo
Serial.begin(9600); // inicializa porta serial
}
void loop(){
lado = Serial.read();
//verifica a letra e se chegou ao valor máximp da posição, senão incrementa x graus
if (lado == 'l' && pos < (180-graus) ){
pos += graus;
}
//verifica a letra e se chegou ao mínimo da posição, senão diminiu x graus
else if (lado == 'r' && pos >= graus){
pos -= graus;
}
lado = 'n';
//muda de posicao
servo1.write(pos);
//delay de 350ms;
delay(350);
}

Em seguida salve e digite Ctrl + U ...

Trabalho Final:


Um vídeo para melhor visualização:


Até a próxima.





sexta-feira, 23 de março de 2012

Arduino + LCD



Olá pessoal, hoje vou mostrar um Hello World ! usando Arduino + LCD (16x2).

Estou usando:

1 - Arduino Duemilanove;
2 - LCD 16x2;
3 - Potenciômetro B10K
4 - Protoboard
5 - Fios

Bom, O primeiro passo é montar o circuito, para isso use a imagem abaixo.
















O segundo passo é a codificação


/*
** DISPLAY LCD 16X2 **
José Maria DVD
*/

#include

//Inicializar o LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  //Setup do LCD com o númnero de colunas x linhas
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Hello World!");
  //Pular para a coluna 1 linha 1
  lcd.setCursor(1, 1);
  lcd.print("o");
  lcd.setCursor(0, 1);
  lcd.print("_");
}

void loop(){
  delay(1000);
  lcd.setCursor(2, 1);
  lcd.print('/');
  delay(1000);
  lcd.setCursor(2, 1);
  lcd.print("_");
}

Em seguinda salve e digite Ctrl + U ...

Caso não consiga visualizar nada, basta ajustar o potenciômetro.

Trabalho final :
















Até a próxima.

quarta-feira, 1 de fevereiro de 2012