Robô Pali - Desviando de Obstáculos

Introdução

Se você possui um robô Pali, você deve querer vê-lo andar. Por que não aproveitar o sensor ultrassônico do kit para deixá-lo autônomo e desviar dos obstáculos? Neste tutorial você verá como fazer o seu Pali circular pelo ambiente sem bater nas coisas.

Lista de Materiais

Lista completa de produtos

comprar

Kit Robô Pali

R$359.90

Montagem

O primeiro passo para ter um robô Pali que desvia de obstáculos é montar a sua estrutura. Para isso, acesse o manual de montagem no botão abaixo e siga as instruções.

Manual de Montagem Mecânica

Circuito

Depois de montar a estrutura, monte o circuito elétrico de acordo com a figura abaixo.

Não conecte ainda o conector P4 (conector do suporte de pilhas) na placa. Antes de energizar o robô, carregue o código para ele seguindo os passos abaixo.

Instalação do Driver da Placa

Após finalizar a montagem mecânica, é necessário instalar o driver da placa BlackBoard UNO R3 para que ela seja reconhecida em seu computador. Veja como instalar o driver em seu computador acessando o tutorial abaixo.

Instalação do Driver da BlackBoard

Instalação da Arduino IDE

Para gravar o código na placa, iremos utilizar a Arduino IDE, um programa gratuito e de código aberto que pode ser instalado em qualquer sistema operacional. Acesse o tutorial abaixo para saber como baixar e instalar a Arduino IDE em seu computador.

Instalando a Arduino IDE

Código

O seu robô precisa de um programa para ganhar vida, então carregue o código abaixo para a BlackBoard dele.

/* 
 * Kit Robo Paligo - Anticolisao 
 * (v1.0 - 30/09/21)
 *  
 * Transforme o seu robo Paligo em um
 * veiculo autonomo que desvia de obstaculos.
 */

// ---------------------------------------------------

// declaracao dos pinos do sensor ultrassonico
const int PINO_SENSOR_ECHO = 13;
const int PINO_SENSOR_TRIGGER = 12;

// declaracao dos pinos do driver de motor
const int PIN_MOTOR_IN1 = 2;
const int PIN_MOTOR_IN2 = 3;
const int PIN_MOTOR_IN3 = 4;
const int PIN_MOTOR_IN4 = 5;

// declaracao das constantes auxiliares para controlar os motores
const int DISTANCIA_SEGURA = 25; // [cm]
const int PAUSA = 100; // [ms]

// ---------------------------------------------------

int ler_distancia(void);
void mover_frente(void);
void mover_tras(void);
void parar(void);

// ---------------------------------------------------

void setup() {
  // configura os pinos do sensor ultrassonico
  pinMode(PINO_SENSOR_ECHO, INPUT); // entrada
  pinMode(PINO_SENSOR_TRIGGER, OUTPUT); // saida
  digitalWrite(PINO_SENSOR_TRIGGER, LOW); // por padrao em nivel baixo (sem sinal)

  // configura os pinos do driver de motor
  pinMode(PIN_MOTOR_IN1, OUTPUT); // saida
  pinMode(PIN_MOTOR_IN2, OUTPUT); // saida
  pinMode(PIN_MOTOR_IN3, OUTPUT); // saida
  pinMode(PIN_MOTOR_IN4, OUTPUT); // saida
  parar(); // robo parado por padrao
}

// ---------------------------------------------------

void loop() {
  // le a distancia
  int distancia = ler_distancia();

  // verifica se ha um obstaculo na frente
  if(distancia < DISTANCIA_SEGURA){
    // para o robo
    parar();
    delay(500); // pausa para o proximo movimento

    // move o robo para tras
    mover_tras();

    // para o robo apos um curto intervalo
    delay(1000);
    parar();

    // escolhe um dos lados para girar
    bool par = (millis() % 2 == 0) ? true : false;
    if(par){
      // gira o motor 1 para a frente
      digitalWrite(PIN_MOTOR_IN1, HIGH);
      digitalWrite(PIN_MOTOR_IN2, LOW);
    } else {
      // gira o motor 2 para a frente
      digitalWrite(PIN_MOTOR_IN3, HIGH);
      digitalWrite(PIN_MOTOR_IN4, LOW);
    }

    // para o robo apos um curto intervalo
    delay(500);
    parar();
  } else { // senao
    // move o robo para a frente
    mover_frente();
  }

  // pausa para a proxima leitura
  delay(PAUSA);
}

// ---------------------------------------------------
// ---------------------------------------------------

// Ler a distancia com o sensor ultrassonico
int ler_distancia(void){
  // realiza o pulso de 10 microsegundos no trigger do sensor
  digitalWrite(PINO_SENSOR_TRIGGER,HIGH);
  delayMicroseconds(10);
  digitalWrite(PINO_SENSOR_TRIGGER,LOW);

  // mede o pulso em microsegundos retornado para o echo do sensor
  // e converte o tempo para distancia ao dividir por 58
  return pulseIn(PINO_SENSOR_ECHO, HIGH) / 58; // [cm]
}

// ---------------------------------------------------

// Mover o robo para a frente
void mover_frente(void){
  digitalWrite(PIN_MOTOR_IN1, HIGH);
  digitalWrite(PIN_MOTOR_IN2, LOW);
  digitalWrite(PIN_MOTOR_IN3, HIGH);
  digitalWrite(PIN_MOTOR_IN4, LOW);
}

// ---------------------------------------------------

// Mover o robo para tras
void mover_tras(void){
  digitalWrite(PIN_MOTOR_IN1, LOW);
  digitalWrite(PIN_MOTOR_IN2, HIGH);
  digitalWrite(PIN_MOTOR_IN3, LOW);
  digitalWrite(PIN_MOTOR_IN4, HIGH);
}

// ---------------------------------------------------

// Parar o robo
void parar(void){
  digitalWrite(PIN_MOTOR_IN1, LOW);
  digitalWrite(PIN_MOTOR_IN2, LOW);
  digitalWrite(PIN_MOTOR_IN3, LOW);
  digitalWrite(PIN_MOTOR_IN4, LOW);
}

// ---------------------------------------------------

Entendendo o Código

A primeira parte do código é a declaração das variáveis globais que são usadas. O primeiro bloco define os pinos que são utilizados para o sensor ultrassônico. O segundo bloco define os pinos que são utilizados para o driver L298 que controla os dois motores. Já o último bloco define as constantes que nos ajudam na lógica do robô. DISTANCIA_SEGURA é a distância, em centímetros, que o Pali considera como segura. Se ele detectar um obstáculo mais perto do que isso, ele entrará na rotina de desvio. Por fim, a constante PAUSA define o intervalo de tempo entre cada laço, pois o sensor ultrassônico exige uma pausa entre duas leituras consecutivas.

// declaracao dos pinos do sensor ultrassonico
const int PINO_SENSOR_ECHO = 13;
const int PINO_SENSOR_TRIGGER = 12;

// declaracao dos pinos do driver de motor
const int PIN_MOTOR_IN1 = 2;
const int PIN_MOTOR_IN2 = 3;
const int PIN_MOTOR_IN3 = 4;
const int PIN_MOTOR_IN4 = 5;

// declaracao das constantes auxiliares para controlar os motores
const int DISTANCIA_SEGURA = 25; // [cm]
const int PAUSA = 100; // [ms]

Na sequência, declaramos as três funções que facilitam a lógica principal. Veremos como cada uma funciona mais para frente.

int ler_distancia(void);
void mover_frente(void);
void mover_tras(void);
void parar(void);

Na rotina de configuração (setup()), configuramos em primeiro lugar os pinos do sensor ultrassônico, lembrando que o pino Trigger deve ficar em nível lógico baixo (digitalWrite(PINO_SENSOR_TRIGGER, LOW)) para não emitir os pulsos de som. Em seguida, configuramos os pinos usados no driver dos motores. Terminamos essa rotina chamando a função de para o robô (parar()), já que, por padrão, não queremos que ele saia andando.

void setup() {
  // configura os pinos do sensor ultrassonico
  pinMode(PINO_SENSOR_ECHO, INPUT); // entrada
  pinMode(PINO_SENSOR_TRIGGER, OUTPUT); // saida
  digitalWrite(PINO_SENSOR_TRIGGER, LOW); // por padrao em nivel baixo (sem sinal)

  // configura os pinos do driver de motor
  pinMode(PIN_MOTOR_IN1, OUTPUT); // saida
  pinMode(PIN_MOTOR_IN2, OUTPUT); // saida
  pinMode(PIN_MOTOR_IN3, OUTPUT); // saida
  pinMode(PIN_MOTOR_IN4, OUTPUT); // saida
  parar(); // robo parado por padrao
}

A seguir, temos o laço loop(), que será executado infinitamente. Primeiro lemos a distância para um obstáculo na frente com o comando distancia = ler_distancia(). Depois verificamos se essa distância é menor do que a distância segura que configuramos no início, com o laço if(distancia < DISTANCIA_SEGURA). Se isso for verdade, a primeira instrução é parar o robô (parar()). Após uma breve pausa (delay(500)), o Pali se move para trás com o comando mover_tras(). Esse procedimento é útil para afastar o robô do obstáculo e facilitar o desvio. Depois de outra pausa, paramos o Pali novamente.

Agora que o robô está parado, iniciamos o giro para desviar do obstáculo. Para escolher o lado do giro, verificamos se o tempo de execução do programa é par ou ímpar (bool par = (millis() % 2 == 0) ? true : false;). Se esse tempo for par, ou seja, se a variável par for verdadeira, giramos o motor 1 para a frente. Caso contrário, giramos o motor 2 para a frente. Depois de uma pausa, paramos o robô.

No final da rotina loop(), temos um laço else que é responsável por mover o robô para a frente se nenhum obstáculo for detectado. Em outras palavras, se a distância lida no início da rotina for maior ou igual à distância segura, chamamos a função mover_frente() para ir para a frente. Finalmente, terminamos com uma pausa até a próxima execução.

void loop() {
  // le a distancia
  int distancia = ler_distancia();

  // verifica se ha um obstaculo na frente
  if(distancia < DISTANCIA_SEGURA){
    // para o robo
    parar();
    delay(500); // pausa para o proximo movimento

    // move o robo para tras
    mover_tras();

    // para o robo apos um curto intervalo
    delay(1000);
    parar();

    // escolhe um dos lados para girar
    bool par = (millis() % 2 == 0) ? true : false;
    if(par){
      // gira o motor 1 para a frente
      digitalWrite(PIN_MOTOR_IN1, HIGH);
      digitalWrite(PIN_MOTOR_IN2, LOW);
    } else {
      // gira o motor 2 para a frente
      digitalWrite(PIN_MOTOR_IN3, HIGH);
      digitalWrite(PIN_MOTOR_IN4, LOW);
    }

    // para o robo apos um curto intervalo
    delay(500);
    parar();
  } else { // senao
    // move o robo para a frente
    mover_frente();
  }

  // pausa para a proxima leitura
  delay(PAUSA);
}

Na parte inferior do código, temos as quatro funções auxiliares. A primeira delas é a ler_distancia(). Nela, pulsamos o pino Trigger de dez microsegundos, que é o tempo recomendado pelo fabricante do sensor. Para saber qual é a distância lida em centímetros, dividimos o tempo em que o pino Echo ficou em nível lógico alto por 58 (pulseIn(PINO_SENSOR_ECHO, HIGH) / 58).

int ler_distancia(void){
  // realiza o pulso de 10 microsegundos no trigger do sensor
  digitalWrite(PINO_SENSOR_TRIGGER,HIGH);
  delayMicroseconds(10);
  digitalWrite(PINO_SENSOR_TRIGGER,LOW);

  // mede o pulso em microsegundos retornado para o echo do sensor
  // e converte o tempo para distancia ao dividir por 58
  return pulseIn(PINO_SENSOR_ECHO, HIGH) / 58; // [cm]
}

Abaixo temos as funções mover_frente(), mover_tras() e parar(). Todas atuam sobre os quatro pinos de controle do driver dos motores. Os pinos IN1 e IN2 controlam o motor 1 e os pinos IN3 e IN4 controlam o motor 2. Quando um par de pinos está em nível lógico baixo (LOW), significa que o motor correspondente está parado. Quando um pino do par está em nível lógico baixo e o outro em nível lógico alto (HIGH), o motor está girando. O sentido do giro depende de qual pino está acionado e é possível observar essa diferença ao comparar as duas funções de movimento.

// Mover o robo para a frente
void mover_frente(void){
  digitalWrite(PIN_MOTOR_IN1, HIGH);
  digitalWrite(PIN_MOTOR_IN2, LOW);
  digitalWrite(PIN_MOTOR_IN3, HIGH);
  digitalWrite(PIN_MOTOR_IN4, LOW);
}

// Mover o robo para tras
void mover_tras(void){
  digitalWrite(PIN_MOTOR_IN1, LOW);
  digitalWrite(PIN_MOTOR_IN2, HIGH);
  digitalWrite(PIN_MOTOR_IN3, LOW);
  digitalWrite(PIN_MOTOR_IN4, HIGH);
}

// Parar o robo
void parar(void){
  digitalWrite(PIN_MOTOR_IN1, LOW);
  digitalWrite(PIN_MOTOR_IN2, LOW);
  digitalWrite(PIN_MOTOR_IN3, LOW);
  digitalWrite(PIN_MOTOR_IN4, LOW);
}

O Que Deve Acontecer

Depois de montar o circuito e programar o seu robô Pali, coloque-o no chão e conecte a alimentação. Você verá ele começar a andar e desviar dos obstáculos que ele encontrar pela frente, como no GIF a seguir.

Resultado do Projeto

Conclusão

Neste tutorial vimos como transformar o Pali em um robô autônomo que desvia de obstáculos. Agora você pode adicionar outras peças no seu kit para fazer um projeto ainda mais completo.

Solução de Problemas

Um Motor Não Gira para o Sentido Correto

Se um motor não gira para o sentido correto, ou seja, se o robô não se move para a frente quando deveria, inverta os cabos do motor que apresenta esse comportamento.

O Sensor Não Retorna Distância e/ou Robô bate em Obstáculos

Se o sensor não estiver retornando valores de distância válidos e fazendo com que o robô bata em obstáculos, verifique as conexões dos pinos Echo e Trigger do sensor, pois é possível que eles estejam invertidos.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

rep.demoura
date

Enviado 2023-03-28 13:14:58

Boa tarde, fiz este projeto com uma placa Arduino uno e bateria de 9 v. mas o robô tem força somente numa roda . já verifique as ligações e os motores, será que é a bateria de 9 v? qual é a voltagem das pilhas no projeto?

luan.ferreira
date

Enviado 2023-03-28 13:46:45
rep.demoura

A tensão total das pilhas é de 9V. No entanto, as pilhas comuns (alcalinas) têm uma taxa de descarga (corrente final) maior que as baterias de 9V, inclusive baterias de 9V não são muito indicadas para esses robôs, devido a sua baixíssima taxa de descarga de corrente, que não é suficiente para partir os motores.

valeriaalvesifpi
date

Enviado 2022-08-27 12:57:54

Olá! Esse código se aplica ao arduino uno?

luan.ferreira
date

Enviado 2022-08-29 08:19:03
valeriaalvesifpi

Olá! Sim, esse código pode ser usado na placa Arduino Uno.

adilson.pontual
date

Enviado 2022-08-15 19:12:35

Bom dia, montei o carro com a ponte h. Funciona corretamente. Fiquei muito satisfeito, funcionou tudo certinho se quiser envio um video com o feito

luan.ferreira
date

Enviado 2022-08-16 08:41:53
adilson.pontual

Olá! Ficamos muito felizes em saber que você gostou desse projeto. Se quiser, você pode postar um vídeo do seu projeto em suas redes sociais, só lembre de nos marcar, assim iremos poder ver o seu vídeo.

wandrywlc2
date

Enviado 2022-07-05 11:39:54

Bom dia, montei o carro com o driver L9110. Funciona corretamente enquanto está ligado ao USB no computador, mas ao alimentar através do P4 com uma bateria de 9v não funciona os motores somente a placa fica ligada. Será que a corrente da bateria não está suficiente?

luan.ferreira
date

Enviado 2022-07-05 12:58:31
wandrywlc2

Olá! O uso de baterias de 9V não é muito recomendado para a alimentação de robôs, devido a sua baixíssima taxa de descarga de corrente, que não é suficiente para partir o motor. Tendo isso em vista, recomendamos que esse projeto seja alimentado pelo menos por pilhas.

narcelio.jr
date

Enviado 2022-03-04 19:24:13

Se eu ligar uma Bateria de 12V no arduino e ligar o L298N no Vin para ligar um motor de 12V, corre algum risco de queimar meu arduino ?

Giovanni5

Enviado 2022-03-07 08:06:47
narcelio.jr

As placas da plataforma Arduino UNO, como a BlackBoard UNO inclusa no Kit Robô Pali podem ser alimentadas com uma tensão externa entre 7 e 12V, portanto não há risco de danos ao alimentá-la com uma bateria de 12V.

MarcosMoreira
date

Enviado 2024-02-26 14:53:52
narcelio.jr

Paz e boa tarde. Me permita intervir, esperando ajudar, claro. Os limites do Arduino estão indicados entre 7 e 12. Portanto NÃO  é aconselhável usar mais que os 12 V indicados no limite normal de uso, ou seja, se sua bateria de 12 volts estiver com carga plena, chega até 13,8, neste caso PODE prejudicar o Arduino. Dado o problema uma possível solução, que usei aqui no meu BotSolar foi fazer reguladores: 1) para 5 volts para alimentar os demais sistemas lógicos (sensores e drivers), 2) 8 volts para alimentar o Arduino 3) demais com a bateria direta.

jpiccino
date

Enviado 2022-01-08 23:39:01

Esse código também funciona para o kit explorer?

Giovanni5

Enviado 2022-01-10 08:06:42
jpiccino

São necessárias algumas adaptações para que este código possa ser utilizado com o Robô Explorer, mas vale lembrar que o material didático do Kit Robô Explorer já possui um código para um robô anticolisão (https://www.robocore.net/tutoriais/kit-robo-explorer-robo-anticolisao).

colengabriela3
date

Enviado 2021-12-02 16:17:49

meu robozinho fica girando loucamente, qual parte devo ter errado?

Giovanni5

Enviado 2021-12-02 16:29:41
colengabriela3

Verifique a conexão dos pinos "Trigger" e "Echo" do sensor ultrassônico, pois se eles estiverem invertidos, a leitura de distancia será sempre zero, e o robô ficará constantemente tentando desviar de um obstáculo que não existe. Além disso, verifique se a polaridade de um dos motores não está invertida, quando o robô tenta se mover para frente.

emersondma
date

Enviado 2021-10-08 09:57:03

Este robô é um Self-Balanciing? Suporta peso em cima até quantos gramas? E qual a voltagem dos motores? Grato.

detoledo.victor
date

Enviado 2021-10-08 10:48:22
emersondma

O robô Pali não possui sistema de Self-Balancing, pois o mesmo não possui nenhum acelerômetro integrado, a estrutura se mantém de pé por sua própria base mecânica. Caso tenha interesse, seria um projeto bem legal de fazer, adicionar um sistema Self-Balancing para ele e assim adicionar mais "andares" para o robô.
Em relação ao peso, não temos essa informação. Pode-se acrescentar coisas no robô, porém não devem ser muito pesadas, pois é um robô pequeno e mais voltado para fins educacionais.
Os motores são de 6 V, só que o kit é usado com 9 V porque são pilhas que alimentam também a BlackBoard.