Um dos problemas que temos quando se desenvolve um projeto de robótica é dimensionar o funcionamento dos motores: os cálculos para gerar as especificações técnicas como torque, velocidade e outras variáveis, que envolvem um número gigante de fórmulas. Pensando nisso, Marcos Passos junto com a equipe da Robocore montaram uma página na internet com as fórmulas, basta ter as informações dos motores. Ajuda e muita a fazer as contas. Para quem quiser testar, procure a especificação do motor na internet e coloque os dados:
Aqui estão os rascunhos de construção da estrutura do robô de sumô e viagem ao centro da Terra e as fotos da montagem, de responsabilidade do Daniel. Estas estruturas estão sem medidas pois se baseiam no projeto original e as adaptações foram feitas conforme os problemas foram surgindo. As fotos foram realizadas pelo celular do Daniel.
Base do chassi e suporte para os servo-motores
Suporte do Arduíno e Protoboard
Rodas
Rampa de proteção
Bom depois de elaborar os rascunhos começou a construção:
Arduino sobre o suporte e Protoboard:
Montagem final do robô com a base, rodas, suporte e rampa de defesa. Agora só falta os sensores:
Programa usado no pré-teste dos motores, para testar o L297N (ponte H) e os servo motores:
/* Este código permite o passo de 2 motores*/
//motor direito
int motorPin1 = 7;
int motorPin2 = 8;
//motor esquerdo
int motorPin3 = 3;
int motorPin4 = 4;
int delayTime = 3000;
void setup() {
//configura os pinos digitais do motor direito
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
//configura os pinos digitais do motor esquerdo
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
}
void loop() {
//motor direito
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, HIGH);
digitalWrite(motorPin4, LOW);
delay(delayTime);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, HIGH);
delay(delayTime);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin3, HIGH);
digitalWrite(motorPin4, LOW);
delay(delayTime);
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, HIGH);
delay(delayTime);
}
Vídeo do teste dos motores com L297:
Vídeos da montagem final com baterias, falta apenas a instalação dos sensores. O programa usado foi o mesmo do teste anterior mas agora somente
Vídeo do sistema completo embarcado, sem alimentação por fonte ligada a tomada.
Boas notícias:
- O chassi está quase pronto, faltando detalhes de regulagem
- Temos 7 sensores e falta apenas 7 sensores que ficam prontos nesta quarta-feira
- A bateria que montamos de 2 baterias chumbo-ácidas doadas estão "pegando" carga o que quer dizer uma economia de R$ 30 reais e uma bateria de 8V com 400 mAh
- Conseguimos, graças ao Paulo da Equipe Orion, uma broca de 1,5 mm que pode funcionar para fazer as placas de sensores que faltam, testaremos amanhã, por um módico preço de R$2,60.
- Estamos no prazo com todas as equipes.
Problemas a resolver ainda:
- Comprar L298N para a equipe Orion.
- Instalar os sensores de linha e distância e testar.
- Melhorar os sensores de distância pois o alcance está limitado a 5 cm.
- Testar as 2 configurações novas de sensores - aumentando a distância entre os led´s emissores e receptores para 2cm e usando resistores de 170 ohm no emissor e 4k7 no receptor.
Em breve postaremos as fotos dos sensores IR e o chassi com eles embarcados.
Estamos quase lá, força pessoal.
PS: Ainda não postamos nada da equipe Orion pois o material está no celular da Coordenadora Vani do Elza Facca.
Para construir o chassi da equipe pequenos cientistas, conforme o esquema e o vídeo abaixo, recomendamos a leitura dos seguintes artigos:
Como fazer as rodas: http://lusorobotica.com/index.php/topic,1808.0.html
Material: 2 impressoras HP 6X0 - total 6 rodas mais o eixo
Uma opção é procurar casas de manutenção de impressoras ou quem arrume e ver se ele tem as peças lá.
Sugerimos substituir o Horne de papel por Horne feito com placa de circuito impresso usada, funciona bem. Coloque o Horne dos dois lados da roda pois isso mantém melhor a estabilidade.
O projeto:
A versão original deste projeto foi usada no 6° Grande Desafio com rodas feitas de CD que causava o deslizamento do chassi. Esta segunda versão utiliza as rodas de impressora, que melhorou muito o deslizar, além da estabilidade.
Esta versão usa madeira e conseguiu carregar 2,5 kg, com velocidade de 0,1 m/s, conforme especificações do projeto.
Olha o vídeo do robô funcionando (não usamos baterias, ligamos uma fonte 6V/400mA):
Um dos problemas que foram detectados durante uma simulação para um seguidor de linha que estava desenvolvendo no Simulino foi a presença de transientes, assim definidos no Wikipédia (http://pt.wikipedia.org/wiki/Transiente, acesso em 31/07):
"...é um surto de tensão elétrica que ocorre num intervalo de tempo muito pequeno...
O chaveamento de cargas fortemente indutivas, como os motores elétricos, gera transientes que são causados pela força contra eletro-motriz. Isso ocorre porque um indutor opõe-se à variação de corrente elétrica. Quando ocorre o desligamento de uma chave - eletrônica ou não - a energia armazenada sob a forma de campo magnético força a passagem de corrente em sentido inverso ao sentido original. O resultado é um pulso rápido de alta tensão, conhecido como "spike".
Os transientes são um dos maiores causadores da queima de equipamentos eletrônicos..."
Bom, o código segue abaixo:
/* Programa para leitura de 2 sensores IR - Projeto Robô Lutador de Sumô
Equipe Pequenos Cientistas 2012
Este programa é a base para um robo seguidor de linha e pode ser aplicado em arenas de fundo branco com linha preta ou fundo preto linha branca A variável maximo estipula o limite de tensão entre o estado ligado e desligado do sensor, ou seja, se a tensão lida no sensor for inferior não há reflexão ou, caso contrário, há reflexão. Para controle se faz uso de uma ponte H - O L298N. Foi escolhido por suportar correntes maiores do que L293 e, ser mais barato.
*/
//Variáveis de pino analógico
int IR1=0;
int IR2=1;
//variáveis de pino digital
int L1 = 5;
int L2 = 6;
int L3 = 7;
int L4 = 8;
//variável dos sensores
int maximo = 3; // tensão de corte - sensor ativo ou desligado
int VR1;
int VR2;
//variável de acionamento dos motores
int m1 = 3;
int m2 = 4;
void setup() {
// configura o pino como saida
pinMode(L1, OUTPUT); //pino 5
pinMode(L2, OUTPUT); //pino 6
pinMode(L3, OUTPUT); //pino 7
pinMode(L4, OUTPUT); //pino 8
//configura acionamento de motores
pinMode(m1, OUTPUT);
pinMode(m2, OUTPUT);
// configura o pino como entrada
pinMode(IR1, INPUT); //pino A0
pinMode(IR1, INPUT); //pino A1
}
void loop(){
// le o estado do sensor e converte para volts
VR1 = analogRead(IR1) * 0.0049;
VR2 = analogRead(IR2) * 0.0049;
digitalWrite(m1, HIGH);//aciona o MOTOR 1
digitalWrite(m2, HIGH);//desliga o MOTOR 2
// verifica se o sensor está ativo
if (VR1 > maximo) { // se ativo:
digitalWrite(L1, HIGH);//aciona o pino digital 5
digitalWrite(L2, LOW);//desliga o pino digital 6
}
else {// se desligado:
digitalWrite(L1, LOW);//desliga o pino digital 5
digitalWrite(L2, HIGH);//aciona o pino digital 6
}
//verifica se o sensor está ativo
if (VR2 > maximo){ // se ativo:
digitalWrite(L3, HIGH);//aciona o pino digital 7
digitalWrite(L4, LOW);//desliga o pino digital 8
}
else {//se desligado:
digitalWrite(L3, LOW);//aciona o pino 7
digitalWrite(L4, HIGH);//aciona o pino 8
}
//L1 – MOTOR DIREITO LIGADO
//L2 – MOTOR DIREITO INVERTIDO
//L3 – MOTOR ESQUERDO LIGADO
//L4 – MOTOR ESQUERDO INVERTIDO
}
Aqui segue o circuito elétrico que utilizei na simulação:
Bom, notaram que usei diodos de proteção na tentativa inútil de remover os transientes detectados durante a simulação. Resultado: não funcionou. Consultando o site do Newton Braga (http://www.newtoncbraga.com.br/index.php/robotica/1396-mec018.html) ele sugere: "Os capacitores em oposição em paralelo com o motor são importantes para eliminar transientes que tanto podem afetar os transistores como também o próprio circuito integrado, a partir da fonte de alimentação."
Bom não testei ainda mas em breve posto o resultados dos testes.
Um dos problemas observados com a programação que estamos utilizando é a sincronização de motores. Quando utilizamos este código:
/* Este código permite o passo de 2 motores
*/
//motor direito
int motorPin1 = 5;
int motorPin2 = 6;
int motorPin3 = 7;
int motorPin4 = 8;
//motor esquerdo
int motorPin5 = 9;
int motorPin6 = 10;
int motorPin7 = 11;
int motorPin8 = 12;
int delayTime = 500;
void setup() {
//configura os pinos digitais do motor direito
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
//configura os pinos digitais do motor esquerdo
pinMode(motorPin5, OUTPUT);
pinMode(motorPin6, OUTPUT);
pinMode(motorPin7, OUTPUT);
pinMode(motorPin8, OUTPUT);
}
Você vai notar no vídeo abaixo que os leds piscam fora de sincronia, ou seja, os motores girariam primeiro o direito e depois o esquerdo.
Uma das soluções foi ligar os dois motores nos pinos digitais de 8 a 12 e ligar o comando "Enable A/B" dos l297 em outros dois pinos digitais.
O grande problema reside no fato que somente um motor giraria e o outro ficaria parado. Não é possível por exemplo, girar o motor direito num sentido e o motor esquerdo em outro sentido. Isso causa no robô o comportamento de girar aberto. Com um motor num sentido e outro no sentido inverso, além de girar aberto, você pode girar fechado, o que aumenta as possibilidades de manobras evasivas.
O código abaixo foi testado com leds mas ilustra o giro em sentidos opostos dos motores, bastando pequenas correções no código acima, além de ocupar menos bytes.
/*Testes de Passo - Código utilizado para 2 motores de passo*/
//motor direito
int motorPin1 = 5;
int motorPin2 = 6;
int motorPin3 = 7;
int motorPin4 = 8;
//motor esquerdo
int motorPin5 = 9;
int motorPin6 = 10;
int motorPin7 = 11;
int motorPin8 = 12;
//tempo de passo
int passo = 50;
void setup() {
//define os pinos digitais do motor direito
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
//define os pinos digitais do motor esquerdo
pinMode(motorPin5, OUTPUT);
pinMode(motorPin6, OUTPUT);
pinMode(motorPin7, OUTPUT);
pinMode(motorPin8, OUTPUT);
}
void loop() {
//motor de passo direito e esquerdo, sincronizado
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin5, HIGH);
delay(passo);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin5, LOW);
digitalWrite(motorPin6, HIGH);
delay(passo);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, HIGH);
digitalWrite(motorPin6, LOW);
digitalWrite(motorPin7, HIGH);
delay(passo);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, HIGH);
digitalWrite(motorPin7, LOW);
digitalWrite(motorPin8, HIGH);
delay(passo);
digitalWrite(motorPin4, LOW);
digitalWrite(motorPin8, LOW);
}
O vídeo do resultado no Simulino.
Este código ainda não utiliza funções até pelos testes mas, como base de estudo, ajuda muito.
06/03/2013
Começamos a desenvolver pontes H com TIP 110/115 para uso nos robôs que tem motores de escova. A vantagem desta ponte é a corrente que suporta, chegando a 4A.
Fotos da montagem:
17/07/2012
No projeto do Grupo Orion (Elza Facca) e do grupo Fenix (Frei Dagoberto) estamos pensando em trabalhar com servo motores de parabólica, adaptados para rotação contínua (veja exemplo aqui - http://www.roboticasimples.com/artigos.php?acao=16), usando o arduino 2009 controlando os motores por meio de pontes H.
Na ponte H, estudamos o TIP120, conforme esquema acima e, para o arduino controlar os motores, vamos utilizar o seguinte código fonte:
// Comando de motores usando ponte H
// ————————————————————————— Motores
int motor_esquerdo[] = {2, 3}; //pinos do motor1
int motor_direito[] = {7, 8}; //pinos do motor2
// ————————————————————————— Setup
void setup() {
Serial.begin(9600);
// Seleciona motores
int i;
for(i = 0; i < 2; i++){
pinMode(motor_esquerdo[i], OUTPUT);
pinMode(motor_direito[i], OUTPUT);
}
}
// ————————————————————————— Loop
void loop() {
motor_frente();
delay(1000);
//mudança de sentido
motor_parar();
motor_re();
delay(1000);
//mudança de sentido
motor_parar();
vire_esquerda();
delay(1000);
//mudança de sentido
motor_parar();
vire_direita();
delay(1000);
//mudança de sentido
motor_parar();
motor_parar();
delay(1000);
//mudança de sentido
motor_parar();
}
// ————————————————————————— Drive do motor: coordena as funções de parada, frente, direita e esquerda
void motor_parar(){
digitalWrite(motor_esquerdo[0], LOW);
digitalWrite(motor_esquerdo[1], LOW);
digitalWrite(motor_direito[0], LOW);
digitalWrite(motor_direito[1], LOW);
delay(25);
}
void motor_frente(){
digitalWrite(motor_esquerdo[0], HIGH);
digitalWrite(motor_esquerdo[1], LOW);
digitalWrite(motor_direito[0], HIGH);
digitalWrite(motor_direito[1], LOW);
}
void motor_re(){
digitalWrite(motor_esquerdo[0], LOW);
digitalWrite(motor_esquerdo[1], HIGH);
digitalWrite(motor_direito[0], LOW);
digitalWrite(motor_direito[1], HIGH);
}
void vire_esquerda(){
digitalWrite(motor_esquerdo[0], LOW);
digitalWrite(motor_esquerdo[1], HIGH);
digitalWrite(motor_direito[0], HIGH);
digitalWrite(motor_direito[1], LOW);
}
void vire_direita(){
digitalWrite(motor_esquerdo[0], HIGH);
digitalWrite(motor_esquerdo[1], LOW);
digitalWrite(motor_direito[0], LOW);
digitalWrite(motor_direito[1], HIGH);
}
fonte: Não lembro mais, sorry!!!
Este código fonte foi revisado pela equipe EADUINO - Robson Machado (www.eaduino.com.br), valeu gente pela ajuda.
Em breve, postaremos os vídeos do trabalho em funcionamento.
