# data[].attributes.attachment_link.title
Yellow and Green Illustrated Features Comparison Chart Graph

# data[].attributes.attachment_link.readable_text
Programação


/ 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 = 6;
const int PIN_MOTOR_IN4 = 7;

// 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);
}







# data[].attributes.attachment_link.title
Robô que desvia de Obstáculos - Passo a passo

# data[].attributes.attachment_link.readable_text
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

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.

Circuito Elétrico

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.

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.

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

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.

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.

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).

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.

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.

// Seu navegador não suporta vídeos em HTML5. Atualize seu navegador para ver este vídeo. //
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.

# data[].attributes.attachment_link.title
Robô Pali - Desviando de Obstáculos - RoboCore

# data[].attributes.attachment_link.description
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 d

# data[].attributes.attachment_link.title
Cópia de Cópia de Cópia de artigo mmr (2) (1) (2)

# data[].attributes.body
Maria Clara;

Maria Heloisa;

Maria Julia.