Robô Jabutino

Ola, boa noite. Estou "desenvolvendo" um robozinho, a partir de um comprado já pronto e com um programa-base agindo em 2 motores DC, 1 servo-motor, 1 ultrassom. Só que ele assim costuma se agarrar lateralmente em paredes, etc. Preciso incluir uma rotina para ler 2 sensores-chaves (micro-swiches) tipo bigode-de-gato, para que o robô saia desse "encosto".
Produzí e tentei várias rotinas (uma já veio com o kit do robô, mas usando apenas uma chave), sem sucesso: Ou funcionam os motores+ultrassom, ou as chaves. Testei colocar a minha rotina em vários pontos do sketch. Atualmente dividi essa rotina para ver se funcionavam os dois sensores (2 chaves e o ultrassom). Não deu certo.
Abaixo cópia do sketch mais atual. Este tem 4 páginas em A4, sem espaços entre linhas. Vou copiar aqui é o sketch mesmo, tirado da IDE, ok?

//--------------- Programa JABUTINO sketch 20140510 -----------
#include 
#include

//Instancia o objeto referente aos motores DC
AF_DCMotor motorEsquerdo(1); //Motor esquerdo na conexão "M1"
AF_DCMotor motorDireito(2); //Motor direito na conexão "M2"

//Definições de velocidade em PWM de 0 a 255
const char VEL_MAX = 255;
const char VEL_MIN = 0;
const char VEL_MED = 200;

//Pinos para controle do Ultrassom HC-SR04
//usar as portas analógicas A0 e A1 como digitais
const int pinoTrigger = 14; // A0 = 14
const int pinoEcho = 15; // A1 = 15

//Servo Motor
Servo meuServo;
const int pinoServo = 10; //o pino 10 é o pino de sinal da conexão "SERVO_2"

//Define as posições de calibragem do servo
//Valores para conseguir um melhor alinhamento do servo, cada motor responde de forma diferente.
//Os valores devem variar de 0 a 180 graus, ajuste de acordo com seu motor na tentativa e erro.

const int OLHA_ESQ = 180;
const int OLHA_DIR = 0;
const int OLHA_FRT = 90;

// Pino em que o BUZZER está conectado: 
const int pinoBuzzer = 9;

// PINOS que vão conectar as 2 CHAVES (sensores de colisão):
const int ChaveE = 18;
const int ChaveD = 19;

//Método obrigatório
//Realiza as definições dos pinos e faz a inicialização da biblioteca de servo.

void setup(void)
{
// Inicializa os motores com velocidade máxima
motorEsquerdo.setSpeed(VEL_MAX);
motorDireito.setSpeed(VEL_MAX);

//atribui os pinos do ultrassom
pinMode(pinoTrigger, OUTPUT);
pinMode(pinoEcho, INPUT);

Serial.begin(9600); /* função provisória, para controle da rotina das chaves.*/
/* define os pinos como entrada ligando um resistor pullup a eles */
pinMode(ChaveE, INPUT_PULLUP); // MUITO IMPORTANTE
pinMode(ChaveD, INPUT_PULLUP);

//inicia o Servo
meuServo.attach(pinoServo);
//Coloca o servo virado para posicao frontal
meuServo.write(OLHA_FRT);

} // fim do setup
//================================================
//Corpo principal do programa, repete infinitamente
void loop()
{
// Inicia andando para frente
   andarpFrente(VEL_MAX);

    // Faz a leitura dos sensores de CHAVES = colisão:
    int lerChaveE = digitalRead(ChaveE);
    int lerChaveD = digitalRead(ChaveD);

        //Enquanto não encontrar um obstáculo a menos de 10cm
          while(medeDistancia() > 10)
          {  delay(100); //Faz uma leitura da distancia a cada 0,1 segundo 
          }

             { // chave Esq:
               if (lerChaveE == HIGH) 
                  { Serial.println("Esquerda");

                    tone(pinoBuzzer, 840); //envia um sinal de 740Hz para o pino 9
                     delay(100); //aguarda 0,1 segundo
                    noTone(pinoBuzzer); //interrompe o som no pino 9
                    girarpDireita(VEL_MED);
                     delay(500); //aguarda 1 segundo
                  }
                else 
                  { // chave Direita:
                    if (lerChaveD == HIGH)
                      { Serial.println("Direita");

                        tone(pinoBuzzer, 840); //envia um sinal de 840Hz para o pino 9
                         delay(100); //aguarda 0,1 segundo
                       noTone(pinoBuzzer); //interrompe o som no pino 9
                      girarpEsquerda(VEL_MED);
                       delay(500); //aguarda 0,5 segundo
                     }
                   } 
          //Se encontrou um obstáculo recua por 1 segundo e pára
             andarpTras(VEL_MED);
             delay(1000);
              pararMotores();

           //Verifica qual lado tem maior distância até um obstáculo
              int esquerda = 0, direita = 0;

              meuServo.write(OLHA_ESQ); //vira o servo para a esquerda
              delay(500); //aguarda o servo completar o movimento
              esquerda = medeDistancia(); //mede a distância na esquerda
                 meuServo.write(OLHA_DIR); //vira o servo para a direita
                 delay(500); //aguarda o servo completar o movimento

              direita = medeDistancia(); //mede a distância na direita
              meuServo.write(OLHA_FRT); //olha pra frente novamente
                 delay(500); //aguarda o servo completar o movimento

              if(esquerda > direita) /*se a distancia do obstáculo na esquerda for maior que na direita
                  vira para esquerda */
                   {
                    girarpEsquerda(VEL_MAX);
                    }
                     else /* se a distância do obstáculo na direita for maior ou igual que na esquerda
                            vira para a direita */
                    {
                      girarpDireita(VEL_MAX);
                     }
                       //Aguarda alguns instantes para o robô virar
                      delay(500); // modifique esse tempo se desejar que ele vire por mais ou menos tempo              // Fim da rotina de obstáculos

             // Inicio da rotina das CHAVES / colisão: // ==> tirado daqui e dividido, para tentar o funcionamento.

              // aguarda minimamente para eliminar ruidos:

                 delay(5);
                    int lerChaveE = LOW; // Garante que a chave Esq estará em LOW.
                     int lerChaveD = LOW; // Garante que a chave Dir estará em LOW.
                 }
             // final da rotina das CHAVES

} // Fim do LOOP

//Utiliza o sensor de Ultrassom HC-SR04 para medir a distância em centímetros
int medeDistancia()
{
//Garante que o pino de Trigger está LOW
digitalWrite(pinoTrigger, LOW);
delayMicroseconds(2);
//cria um pulso de 5 microssegundos no Trigger
digitalWrite(pinoTrigger, HIGH);
delayMicroseconds(5);
digitalWrite(pinoTrigger, LOW);

//aguarda o echo
long microssegundos = pulseIn(pinoEcho, HIGH);
// A velocidade do som é 340 m/s ou aproximadamente 29 microssegundos por centimetro.
// O pulso faz uma viagem de ida e volta do sensor até o obstáculo
// assim, para calcular a distancia temos que dividir esse tempo pela metade
// desta forma...
return int(microssegundos / 29 / 2);
} // Fim do CalcularDistancia

// ======== void's dos motores: =============

//Gira as duas rodas para frente
//Como os motores estão virados para lados opostos eles devem
//girar em sentidos opostos para que as rodas girem na mesma direção

void andarpFrente(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas para trás
//Como os motores estão virados para lados opostos eles devem
//girar em sentidos opostos para que as rodas girem na mesma direção
void andarpTras(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(FORWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo
void girarpEsquerda (char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo
void girarpDireita(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(FORWARD);
}

//Pára os motores definindo os dois pinos Enable em estado Low
void pararMotores()
{
motorEsquerdo.run(RELEASE);
motorDireito.run(RELEASE);
}

Exibições: 3320

Anexos

▶ Responder esta

Respostas a este tópico

Permalink Responder até Ilgner Aparecido Becheleni em 14 maio 2014 at 8:06

Show de bola ! 

Só uma dúvida .

Onde encontrou esta esteira para comprar?

Permalink Responder até Maurílio Carneiro Coura em 14 maio 2014 at 10:53

AlyExpress. LINK REMOVIDO POR DESCUMPRIR OS TERMOS DE USO

Se gostar de outros, veja:

LINK REMOVIDO POR DESCUMPRIR OS TERMOS DE USO

Mas, qto aos sensores chave não está funcionando conjuntamente: Ou funciona um ou o outro. Tentei colocar dentro do while do do ultrassom... mas tb não deu certo. Ah, a foto já tem mudanças. O ultrassom joguei-o para baixo, pq não estava enxergando e batina nos obstáculos (distância calculada parece ser pqna para isso, né? Mas aumentar... vai ficar esquisito, muito longe.

Novas fotos, tiradas agora, reduzidas a 20%:

Anexos
Permalink Responder até Pecklauros em 15 maio 2014 at 1:12

Eu já estava de olho nesses chassis a um tempo. So tinha dúvida quanto à alimentação do motor pois no site não tinham muita informação (embora esse que você comprou tenha mais). Também achei que fossem maiores. Demorou muito para chegar? Foi tachado na alfândega?

Permalink Responder até Maurílio Carneiro Coura em 15 maio 2014 at 14:37

Demorou até pouco: 44 dias corridos. Não foi taxado. Mas é sorte.

Permalink Responder até Wilmar Cassiano Degobbi em 19 maio 2014 at 16:48

Maurílio,

Dei uma olhada rápida no início do código, e baseado no seu relato que ou funciona o ultrasom ou os micro-switches, acho que deve mover o bloco de verificação dos micros para dentro do loop de verificação se há obstáculo a 10 cm.

Ficaria mais ou menos assim:

while(medeDistancia() > 10)
{

if (lerChaveE == HIGH)
{
Serial.println("Esquerda");
tone(pinoBuzzer, 840); //envia um sinal de 740Hz para o pino 9
delay(100); //aguarda 0,1 segundo
noTone(pinoBuzzer); //interrompe o som no pino 9
girarpDireita(VEL_MED);
delay(500); //aguarda 1 segundo
}
else
{ // chave Direita:
if (lerChaveD == HIGH)
{
Serial.println("Direita");
tone(pinoBuzzer, 840); //envia um sinal de 840Hz para o pino 9
delay(100); //aguarda 0,1 segundo
noTone(pinoBuzzer); //interrompe o som no pino 9
girarpEsquerda(VEL_MED);
delay(500); //aguarda 0,5 segundo
}
}
delay(100); //Faz uma leitura da distancia a cada 0,1 segundo
}

Dessa forma, mesmo que a distância seja maior que 10 cm os micros serão verificados.

Não sei se assim haverá conflito nos comandos para os motores (não conheço essa biblioteca), talvez precise alterar alguma coisa.

Wilmar

Permalink Responder até Maurílio Carneiro Coura em 19 maio 2014 at 20:03

Foi quase, rs...

Ele lê as chaves e indica o lado, buzina, mas pára não anda mais. O Ultrasom continua funcionando, mas sem acionar os motores depois do primeiro toque das chaves. Nenhuma das funções de motor funciona depois que pára. Depois que pára, continua a ler as chaves e mostrar o lado e continua ver com o ultrassom, mas não decide / funciona qto aos motores. PS: custei pra acertar as posições das chaves e a rotina de zerar para reler.

Veja como ficou (agara vou copiar todo o sketch,ok?):

//--------------- Programa JABUTINO sketch 20140510 -----------
#include <Servo.h>
#include <AFMotor.h>

//Instancia o objeto referente aos motores DC
AF_DCMotor motorEsquerdo(1); //Motor esquerdo na conexão "M1"
AF_DCMotor motorDireito(2); //Motor direito na conexão "M2"

//Definições de velocidade em PWM de 0 a 255
const char VEL_MAX = 255;
const char VEL_MIN = 0;
const char VEL_MED = 200;

//Pinos para controle do Ultrassom HC-SR04
//usar as portas analógicas A0 e A1 como digitais
const int pinoTrigger = 14; // A0 = 14
const int pinoEcho = 15; // A1 = 15

//Servo Motor
Servo meuServo;
const int pinoServo = 10; //o pino 10 é o pino de sinal da conexão "SERVO_2"

//Define as posições de calibragem do servo
//Valores para conseguir um melhor alinhamento do servo, cada motor responde de forma diferente.
//Os valores devem variar de 0 a 180 graus, ajuste de acordo com seu motor na tentativa e erro.

const int OLHA_ESQ = 180;
const int OLHA_DIR = 0;
const int OLHA_FRT = 90;

// Pino em que o BUZZER está conectado:
const int pinoBuzzer = 9;

// PINOS que vão conectar as 2 CHAVES (sensores de colisão):
const int ChaveE = 18;
const int ChaveD = 19;

//Método obrigatório
//Realiza as definições dos pinos e faz a inicialização da biblioteca de servo.

void setup(void)
{
// Inicializa os motores com velocidade máxima
motorEsquerdo.setSpeed(VEL_MAX);
motorDireito.setSpeed(VEL_MAX);

//atribui os pinos do ultrassom
pinMode(pinoTrigger, OUTPUT);
pinMode(pinoEcho, INPUT);

Serial.begin(9600); /* função provisória, para controle da rotina das chaves.*/
/* define os pinos como entrada ligando um resistor pullup a eles */
pinMode(ChaveE, INPUT_PULLUP); // MUITO IMPORTANTE
pinMode(ChaveD, INPUT_PULLUP);

//inicia o Servo
meuServo.attach(pinoServo);
//Coloca o servo virado para posicao frontal
meuServo.write(OLHA_FRT);

} // fim do setup
//================================================
//Corpo principal do programa, repete infinitamente
void loop()
{
   // Inicia andando para frente

    andarpFrente(VEL_MAX);
     int lerChaveE = LOW; // Garante que a chave Esq estará em LOW.
     int lerChaveD = LOW; // Garante que a chave Dir estará em LOW.


        //Enquanto não encontrar um obstáculo a menos de 10cm
         while(medeDistancia() > 10)
           { // Lê a Chave Esquerda: 
              int lerChaveE = digitalRead(ChaveE);
              int lerChaveD = digitalRead(ChaveD);

                 if (lerChaveE == HIGH)
                  { Serial.println("Esquerda");
                     tone(pinoBuzzer, 840); //envia um sinal de 740Hz para o pino 9
                      delay(100); //aguarda 0,1 segundo
                     noTone(pinoBuzzer); //interrompe o som no pino 9
              girarpDireita(VEL_MED);
                 delay(500); //aguarda 0,5 segundo
            }
            else    // Lê chave Direita:
              if (lerChaveD == HIGH)
                 {  Serial.println("Direita");
                    tone(pinoBuzzer, 840); //envia um sinal de 840Hz para o pino 9
                      delay(100); //aguarda 0,1 segundo
                   noTone(pinoBuzzer); //interrompe o som no pino 9
             girarpEsquerda(VEL_MED);
               delay(500); //aguarda 0,5 segundo
                  }

         delay(100); //Faz uma leitura da distancia a cada 0,1 segundo
          }

     //Se encontrou um obstáculo recua por 1 segundo e pára
         andarpTras(VEL_MED);
         delay(1000);
         pararMotores();

    //Verifica qual lado tem maior distância até um obstáculo
        int esquerda = 0, direita = 0;

         meuServo.write(OLHA_ESQ); //vira o servo para a esquerda
          delay(500); //aguarda o servo completar o movimento
          esquerda = medeDistancia(); //mede a distância na esquerda
         meuServo.write(OLHA_DIR); //vira o servo para a direita
          delay(500); //aguarda o servo completar o movimento

           direita = medeDistancia(); //mede a distância na direita
             meuServo.write(OLHA_FRT); //olha pra frente novamente
              delay(500); //aguarda o servo completar o movimento

                 if(esquerda > direita) /*se a distancia do obstáculo na esquerda for maior que na direita
                                                vira para esquerda */
                 { girarpEsquerda(VEL_MAX);
                 }
                else /* se a distância do obstáculo na direita for maior ou igual que na esquerda
                         vira para a direita */
                  {  girarpDireita(VEL_MAX);
                  }
                   //Aguarda alguns instantes para o robô virar
                  delay(500); // modifique esse tempo se desejar que ele vire por mais ou menos tempo
                    // Fim da rotina de obstáculos

               // aguarda minimamente para eliminar ruídos das chaves:
               delay(5);


} // Fim do LOOP

       //Utiliza o sensor de Ultrassom HC-SR04 para medir a distância em centímetros
        int medeDistancia()
        {
          //Garante que o pino de Trigger está LOW
          digitalWrite(pinoTrigger, LOW);
           delayMicroseconds(2);
             //cria um pulso de 5 microssegundos no Trigger
           digitalWrite(pinoTrigger, HIGH);
           delayMicroseconds(5);
             digitalWrite(pinoTrigger, LOW);

             //aguarda o echo
            long microssegundos = pulseIn(pinoEcho, HIGH);
              // A velocidade do som é 340 m/s ou aproximadamente 29 microssegundos por centimetro.
              // O pulso faz uma viagem de ida e volta do sensor até o obstáculo
             // assim, para calcular a distancia temos que dividir esse tempo pela metade
             // desta forma...
            return int(microssegundos / 29 / 2);
} // Fim do medeDistancia

// ======== void's dos motores: =============

//Gira as duas rodas para frente
//Como os motores estão virados para lados opostos eles devem
//girar em sentidos opostos para que as rodas girem na mesma direção

void andarpFrente(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas para trás
//Como os motores estão virados para lados opostos eles devem
//girar em sentidos opostos para que as rodas girem na mesma direção
void andarpTras(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(FORWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo
void girarpEsquerda (char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo
void girarpDireita(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(FORWARD);
}

//Pára os motores definindo os dois pinos Enable em estado Low
void pararMotores()
{
motorEsquerdo.run(RELEASE);
motorDireito.run(RELEASE);
}

Permalink Responder até Wilmar Cassiano Degobbi em 19 maio 2014 at 21:05

Maurílio,

Realmente como ficou não vai funcionar, porque depois de um desvio pela atuação de um micro-switch o comando de andarpFrente não é mais executado, além de que a posição dos dois micros também não são mais atualizadas.

Teste trocar o início do loop dessa forma:

(o robô só vai se movimentar no início do loop se a distância medida pela ultrasom for maior que 10cm)

// Inicia andando para frente
//andarpFrente(VEL_MAX);
//int lerChaveE = LOW; // Garante que a chave Esq estará em LOW.
//int lerChaveD = LOW; // Garante que a chave Dir estará em LOW.

//Enquanto não encontrar um obstáculo a menos de 10cm
while(medeDistancia() > 10)
{
andarpFrente(VEL_MAX);
// Lê a Chave Esquerda:
//int lerChaveE = digitalRead(ChaveE);
//int lerChaveD = digitalRead(ChaveD);
//if (lerChaveE == HIGH)
if (digitalRead(ChaveE) == HIGH)
{
Serial.println("Esquerda");
tone(pinoBuzzer, 840); //envia um sinal de 740Hz para o pino 9
delay(100); //aguarda 0,1 segundo
noTone(pinoBuzzer); //interrompe o som no pino 9
girarpDireita(VEL_MED);
delay(500); //aguarda 0,5 segundo
}
else // Lê chave Direita:
//if (lerChaveD == HIGH)
if (digitalRead(ChaveD) == HIGH)
{
Serial.println("Direita");
tone(pinoBuzzer, 840); //envia um sinal de 840Hz para o pino 9
delay(100); //aguarda 0,1 segundo
noTone(pinoBuzzer); //interrompe o som no pino 9
girarpEsquerda(VEL_MED);
delay(500); //aguarda 0,5 segundo
}
delay(100); //Faz uma leitura da distancia a cada 0,1 segundo
}

//Se encontrou um obstáculo recua por 1 segundo e pára ... (continua)

Permalink Responder até Maurílio Carneiro Coura em 19 maio 2014 at 21:23

OPS: Tem 2 while aí. Um com nome de variável errada (o 1º). Já consertei aqui.

Testei e não melhorou nada, aparentemente.

Permalink Responder até Wilmar Cassiano Degobbi em 19 maio 2014 at 21:33

Maurílio,

É preciso substituir o bloco inicial do loop() pois eu apenas comentei algumas linhas e incluí outras no seu código (não deve ficar com dois while).

Permalink Responder até Maurílio Carneiro Coura em 21 maio 2014 at 19:16

Já retirei o while errado. Continua parando qdo pressionada a chave, mas emite o lado e o som. Só o motor é que pára e não continua de jeito nenhum - mesmo provocando o ultrassom - que reage, mas os motores... néca!

Tentei colocar no inicio da chave do IF, nada!

Tentei colocar o andarpFrente, nada!

Tentei uma biblioteca de Botton.h... deu zebra nela ou no sketch de exemplo.

Tentei uma biblioteca de Switch.h, idem.

Permalink Responder até Wilmar Cassiano Degobbi em 21 maio 2014 at 20:29

Maurílio, 

Ele chega a virar quando um dos micros é acionado ou não ?

Será que a biblioteca dos motores não exige um "Stop" antes de novo comando (acho difícil isso mas...).

A inclusão do comando andarpFrente dentro do while seria justamente para colocar novamente o robô em marcha depois de um acionamento de qualquer dos micros.

Também só para confirmar, os micros-swiches que está usando são do tipo que retornam a condição inicial quando o pressionamento é retirado, certo ?

Permalink Responder até Maurílio Carneiro Coura em 21 maio 2014 at 21:50

Sim, são desas chavinhas com pescoço comprido, tipo 

Não, ele não vira. Apenas pára os motores. E só volta a girar se der reset ou recarregar o sketch.

Acho que não tem o stop, pois não o usa - veja o "void" de parar, no final do sketch. É biblioteca do fabricante do robozinho Jabutino, vendido no Mercado LIvre: Veja ele com as chaves:

Sem as chaves, só com o ultrassom:

Página onde vende, com fotos:LINK REMOVIDO POR DESCUMPRIR OS TERMOS DE USO DO SITE

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço