É um robô muito simples, básico, com o objectivo de seguir linhas e ir desviando-se dos obstáculos.
Depois de ter tudo montado e a funcionar, quero adicionar a opção de escolher:
Seguir linha branca no fundo preto ou seguir linha preta no fundo branco
Ligar e desligar a função de seguir linha
Ligar e desligar a função de desviar obstáculos
Dificuldades Encontradas
Até agora, a dificuldade que encontrei foi na tentativa de construír o sensor de proximidade pelo tutorial do tr3s. Provavelmente os componentes que utilizei não estavam bons. Solução: Usar o sensor PING ))).
Estado Actual
llllllllll 100% - Base (circular)
llllllllll 100% - Montagem dos Motores Mini e Rodas
llllllllll 100% - Montagem do Servo para o Sensor Ultrasons
llllllllll 100% - Montagem dos sensores de reflexão para seguir linha
llllllllll 100% - Programação do Arduino para seguir linha
llllllllll 0% - Montagem do sensor PING)))
llllllllll 0% - Programação do Arduino para evitar obstáculos
Nesse tutorial vamos ver que você não precisa ser um "Anti-Social" para fazer um robô/carro...
Esse Vai ser um Insano Carro Buscador de Fonte de Luz! ahhahá!
-------------------------------------------------- 2 – Antes de Começar
-------------------------------------------------
Você que está pela primeira vez no site de uma olhada em alguns outros posts antes de ir direto para esse tutorial... ai vai alguns exemplos:
--------------------------------------------------- O que é Arduino?
Acesse a Parte de Arduino do Blog para Muito mais tutoriais... -------------------------------------------------------------
3 - Vamos Precisar de:
1 Arduino (UNO/MEGA/DUAMILENOVE...)
1 Protoboard
1 Servo ("Motor de Corrente Contínua Simples")
2 LDR (Resistor Dependente de Luz)
2 Resistores de 10k
2 On / off switchs
5 Resistores de 1 Ohm
Fios, com cores diferente se possível.
Opcionais:
Baterias/Pilhas:
Vai ser usado:
1 Bateria de 9V Ligada no Arduino
3 Pilhas AA NiMh para o motor
Esse Carrinho muito simples de controle remoto que você encontra em qualquer lojinha 1,99...
Custa de 18 a 40 reais dependendo da marca, potência ...
Vão ser ocupadas as rodas e o motor.
-------------------------------------------------------- 4 - Mãos a Obra:
LDR - Light Dependant Resistors
Esse tipo de resistor varia sua resistência apartir da Claridade, fonte de luz...
-----------
Interpretando os LDR no Arduino
Coloque ele com um Resistor de 10k em Série ligado há uma entrada analógica e execute este código : LDR CODE
O Código mandará para tela do PC a leitura de resistência do LDR, teste tapar com sua mão e terá de variar muito, depois coloque algo como lanterna/luz do celular perto e deverá variar denovo mas em função reversa ao que você tapou. Se estiver fazendo algo diferente disto revise o circuito e/ou tente re-enviar o código para seu arduino.
-----------
Agora o Servo :
Primeiro você precisa instalar a biblioteca do servo (se ainda não tem) clicando aqui--> Servotimer1. Descompacte e coloque em hardware/libraries e Para Adicionar ao programa do Arduino somente reinicie o Programa.
Agora pegue os Fio preto e vermelho do servo e conecte ná protoboard separados. E o laranja/amarelo conecte no pino digital 9 do seu arduino.
Pegue mais 2 fios e conecte no 5V do arduino e ligue ao vermelho do servo que está na protoboard, depois pegue o outros e ligue ao GND do arduino e no preto do servo que também está na protoboard.
Aqui está o código para o servo. -->SERVO CODE
O Código fará com que seu servo Gire 90 Graus, depois espere 1 segundo volte para 0 Grau, espere 1 segundo e gire 180 Graus...ficará repitindo isto.
--------------------------------------------------------- 5 – Montando tudo... 5.1 – Primeiro o Carro:
Desmonte o carro, tire tudo exeto o motor e as rodas...
Como nas imagens abaixo:
----------- 5.2 - Direção do Carro (Parte da Frente)
.Este é parte de outro carrinho,...
----------- 5.3 - Servo e as Rodas Frontais.
Bagunça com a cola quente... Atenção: Certifique-se de que está girando a roda e não dará problema...
Cuide como na imagem acima uma das rodas não toca o chão, isso deve ser resolvido também...
Agora sim, as duas no chão. Problema Resolvido.
----------- 5.4 - Baterias
Dei sorte nesse caso o case da bateria de 9V ficou perfeito...
----------- 5.5 - O Circuito Final!
O Arduino é conectado na bateria de 9V, com Switch ON/Off
5V são conectados na protoboard para o Servo.
Deve-se colocar resistores de 1Ohm ou 5Ohms entre o motor e
as Pilhas AA, colocamos 1 Ohm nesse caso para ter mais controle da potência..
Note the Ground wire is connect to another row.
.
----------- 5.6 - O servo
Conecte ele na protoboard.
Como no esquema anterior, (9v para preto e 0v para o vermelho e depois Pin9 Digital para o Amarelo)
----------- 5.7 - LDR
Parte Final.
Coloque os LDR's e os resistores como na imagem acima.
Esses fios Verdes vão conectar o Arduino com os LDR nas entradas
Analógicas Pinos 4 e 5.
------------------
Teste seus LDR como antes...
Essa é a aparência final do nosso circuito...Vamos enviar o código final e depois testá-lo.
------------------------------------------------------- 6 - Programando.
Baixe o Código aqui-->Carbot Code
---------------------------------------------------------
Dica de última hora. Percebi que fica extremamente melhor fazer anteninhas com seus ldr pois senão os "sensores de luz" ficam meio obsoletos ...
-------------------------------------------------------
Eu espero que este tutorial tenha sido útil, (pois demorei horas para traduzir(brinks) ...). Até o Próximo...
Este robô desenvolvido com Arduino e dois servos é uma excelente projeto para os amantes da robótica.
O grande diferencial é que toda a documentação está livre, basta seguir os passos de montagem.
O que é?
Um robô de fácil construção e montagem, que você pode fazer com materiais de baixo custo.
Como surgiu?
Do interesse de professores do IF-SC, Campus Florianópolis, em desenvolver uma plataforma robótica facilmente replicável, como meio de incentivo às ciências exatas e tecnológicas.
O desenvolvimento deste robô foi apoiado pelo Primeiro Edital de Apoio a Projetos de Extensão no IF-SC (I APROEX). A equipe executora é formada pelos professores Joel Lacerda (Coordenador), Fernando S. Pacheco e Charles B. de Lima, do Departamento Acadêmico de Eletrônica (DAELN) do Campus Florianópolis e pelo aluno Luciano Silva do Lago, do Curso Técnico em Eletrônica.
Características
Nessa versão 1.0, a plataforma microcontrolada escolhida, por sua facilidade de aquisição, programação e baixo custo é o Arduino (usa microcontrolador ATmega328, família AVR). O chassis é de material plástico (polietileno) e as conexões elétricas são feitas em uma barra Sindal. Também para manter o baixo custo, usamos pilhas de fácil aquisição (tamanhos AA e 9 V).
a. Imprima o modelo que está disponível acima (observe se escala está em 100%; confira com a marcação de 13,6 cm que existe no modelo). Recorte e marque sobre a placa de polietileno.
b. Usando o arco de serra, recorte a placa (na foto, estou fazendo um teste). Você deve levar aproximadamente 30 min nessa tarefa.
c. Faça os furos previstos com a broca menor.
d. Faça o recorte para as rodas com a broca maior (em uma furadeira de bancada, como mostrado na figura, fica mais fácil).
e. Com o formão, faça o acabamento dos recortes. Cuidado! Nunca direcione a lâmina para o seu corpo!
Se tiver qualquer dúvida ou dificuldade, entre em contato com a gente.
b. Faça as ligações mostradas na figura seguinte para testar o funcionamento dos servos no próximo passo.
c. Carregue o programa seguinte na IDE do Arduino para testar os servos e ajustar a largura de pulso para que eles fiquem parados quando desejado.
/*****************************************************************************
* ajuste_rotacao_direcao_servos
*
* Ajuste dos valores de pulso máximo (max.pulse) e mínimo (min.pulse) para
* que o servo mantenha-se parado quando for enviado o comando de 90 graus
*
* Fernando S. Pacheco - 2011
*****************************************************************************/
#include "SoftwareServo.h"
SoftwareServo servo;
void setup()
{
servo.attach(2); //Num. do pino (Arduino) em que o servo está conectado.
// Teste um servo, anote o valor do max. pulse, e depois teste o outro.
//servoL.setMaximumPulse(XXX);// esse é o valor que será testado no loop.
// Depois de obtê-lo, coloque aqui em cima e tire o comentário.
//servoL.setMinimumPulse(XXX);// para um dos servos que testamos,
// não resolveu mexer só no max. pulse.
// Ficou muito baixo e, assim, a velocidade máxima era pequena.
// Foi necessário, então, ajustar também o min. pulse
Serial.begin(9600);
Serial.println("ServoAdjust/Ajuste do servo");
}
void loop()
{
for (int maxpulse=500; maxpulse!=3000; maxpulse+=10) {
servoL.setMaximumPulse(maxpulse);
servoL.write(90);
Serial.println(maxpulse);
SoftwareServo::refresh();
delay(45);
SoftwareServo::refresh();
delay(45);
}
//Depois de ter um valor aproximado, diminua o incremento do laço e
//os valores inicial e final
delay(500);
}
3. Conecte as rodas aos motores
a. Coloque o suporte do servo em cima da roda e marque o material que será retirado
b. Com a furadeira e/ou formão, retire parte do plástico até que o suporte fique encaixado e centralizado
c. Fure as rodas e fixe o suporte (aqui, para teste, não usei parafusos)
4. Fixe a placa Arduino e as chaves
a. Rosqueie os espaçadores no chassis
b. Coloque a placa do Arduino
c. Cole ou parafuse as chaves na frente do robô. Use a chapa de alumínio para fazer uma haste maior para as chaves
5. Faça as conexões elétricas
a. Siga o esquemático e faça as conexões elétricas na barra Sindal
6. Fixe as pilhas
a. Use os elásticos e o palito para fixar as pilhas
b. Coloque um pequeno pedaço de polietileno embaixo da bateria 9 V
7. Programe o microcontrolador
a. Use o programa exemplo abaixo.
/*****************************************************************************
* robot_segue_luz_e_volta_quando_bate
*
* Robô vai para a direção com mais luminosidade, a partir da leitura de
* dois LDRs (fotorresistores)
* Também tem duas chaves na frente para detectar quando bate
*
* Código usa os resistores internos de pullup do ATmega
*
* Fernando S. Pacheco - 2011
*****************************************************************************/
#include "SoftwareServo.h"
#define invON LOW
#define invOFF HIGH
#define leftColisionPin 11
#define rightColisionPin 10
#define leftLdrPin A0
#define rightLdrPin A1
SoftwareServo servoL;
SoftwareServo servoR;
int leftCol=invOFF;
int rightCol=invOFF;
int leftLight=0;
int rightLight=0;
void setup()
{
Serial.begin(9600);
servoL.attach(2);
servoR.attach(3);
servoL.setMinimumPulse(295); //coloque os valores que você obteve no
// teste dos servos. (Insert here the values obtained during servo testing)
servoL.setMaximumPulse(993);
servoR.setMaximumPulse(1247);
pinMode(leftColisionPin, INPUT);
digitalWrite(leftColisionPin, HIGH); //habilitar os resistores internos de
// pullup. (To enable internal pullup resistor)
pinMode(rightColisionPin, INPUT);
digitalWrite(rightColisionPin, HIGH); //to enable internal pullup resistor
pinMode(rightLdrPin, INPUT);
digitalWrite(rightLdrPin, HIGH); //to enable internal pullup resistor
pinMode(leftLdrPin, INPUT);
digitalWrite(leftLdrPin, HIGH); //to enable internal pullup resistor
//Wait 2 seconds to begin
delay(2000);
//Aumenta velocidade vagarosamente / Increment speed slowly
for (int k=0; k!=90; ++k) {
servoL.write(90+k); //forward/frente em 180
servoR.write(90-k); //forward/frente em 0
SoftwareServo::refresh();
delay(25);
}
}
void loop()
{
//Segue para frente em velocidade máxima / Go forward at full speed
servoL.write(180);
servoR.write(0);
SoftwareServo::refresh();
//Lê LDRs / Read LDRs
leftLight=analogRead(leftLdrPin);
rightLight=analogRead(rightLdrPin);
if (leftLight > rightLight) {
servoL.write(150);
servoR.write(70);
}
else {
servoL.write(110);
servoR.write(30);
}
SoftwareServo::refresh();
delay(45);
//Lê chaves de colisão / Read collision detection switches
leftCol=digitalRead(leftColisionPin);
rightCol=digitalRead(rightColisionPin);
//Detecção de colisão / Collision detected
if (leftCol == invON || rightCol == invON) {
//Robô para trás / Reverse
servoL.write(30); //frente em 180
servoR.write(150); //frente em 0
for (int k=0; k!=10; ++k) {
SoftwareServo::refresh();
delay(45);
}
if (leftCol == invON) {
//Se bateu à esquerda, vira para a direita / Turn right to avoid collision
for (int k=0; k!=17; ++k) {
servoL.write(140);
servoR.write(140);
SoftwareServo::refresh();
delay(45);
}
}
else {
if (rightCol == invON) {
//Se bateu à direta, vira para a esquerda / Turn left to avoid collision
for (int k=0; k!=17; ++k) {
servoL.write(40);
servoR.write(40);
SoftwareServo::refresh();
delay(45);
}
}
}
}
SoftwareServo::refresh();
delay(1);
}
A primeira parte do projeto para vocês entenderem, o que eu demorei muito tempo, é a comunicação que o mouse faz com (no caso) o computador.
O periférico mouse, utiliza do protocolo PS2 para comunicação. O que significa que é uma comunicação bidirecional, com uma frequência na casa de KHz. E é muito simples! Possui 4 fios para conexão: GND, VCC, DATA e CLOCK.
Possui 2 acumuladores absolutos, um para o eixo X e o outro para o eixo Y. O que eles tem que fazer? Conforme movimentamos o mouse, para direita e esquerda, cima e baixo, vai se acumulando valores nestes acumuladores (que na mais são que variáveis contadoras) e assim o computador processa o valor do acumulador, setando o mouse na tela (posição).
Sendo assim, esses acumuladores possuem um range de valores de -255 à 255, e será esta informação que usaremos para controlar o servo. Imaginem só, x: -255 que seria a menor posição do acumulador x na tela do PC! E aonde ele se encontra? No último pixel a direita ou a esquerda do vídeo (depende do processamento da informação). O mesmo vale para o acumulador Y, porém ele estará acumulado (setado) no alto ou abaixo do vídeo.
Pense agora em um servo! ele pode estar em 0° ou 180°, dependendo do sinal injetado. Agora relacionamos esses dados, com os do mouse: 0° = x = -255 , 90° = x = 0 , 180° = x = 255 e assim por diante. Conseguimos então, de acordo com a posição do mouse estabelecer o angulo em que o servo deve se encontrar!
Bacana não!? Tem mais!
O mouse convencional ainda possui 3 botões: direita, esquerda e scroll! Os quais podem também ser utilizados na programação!!
Pinagem PS2:
1 - Dados
2 - Não conectado
3 - GND
4 - Vcc (+5V)
5 - Clock
6 - Não Conectado
disponível em arduino.cc
Circuito:
Conecte o pino Dados (data) no pino digital 5.
Conecte o pino Ground em qualquer GND do arduino.
Conecte o pino Clock no pino digital 6.
Conecte o pino Vcc (5V) no pino +5V na placa do arduino.
A biblioteca PS2, que serve para "interfacear" mouse e teclado conforme protocolo ps2, esta disponivel em biblioteca.ps2, no site arduino.cc.
Bom, antes de usarmos o arduino como host do mouse, e assim controlar o servo, iremos fazer o processamento do sinal do mouse para o arduino via serial (USB) e pelo computador. Utilizaremos o processing, para isto!
Mas agora essa parte fica para outro dia, pois já é fim de ano, e os exames na faculdade estão chegando! Ficar de DP, jamais!
Deixo aqui um vídeo para vocês compreenderem o projeto:
Postagens
