Programação e Robótica II - Parte 3

Voltar ao Sumário

Sensor de Distância

A próxima etapa é evitar que o carro se choque contra obstáculos à sua frente.

Para resolver este problema, montamos no carro o sensor de distância. Este componente funciona por ultrassom, da mesma forma como, na natureza, os morcegos localizam insetos e obstáculos: Eles emitem um som bem agudo. Quando este som encontra um objeto, ele é refletido, como em um espelho, e volta na direção do emissor.  Registrando o tempo que o som levou para chegar ao objeto e voltar aos seus ouvidos, é possível calcular a que distância ele está. A distância percorrida pelo som emitido pode ser calculada multiplicando este tempo pela velocidade do som (340m/s). Como esta é a distância para o som ir e voltar, temos que dividir o resultado por 2 para ter a distância até o obstáculo.

O componente usado para emitir e detectar esses pulsos de ultrassom é o sensor ultrassônico HC-SR04. Ele consiste de dois transdutores. Um emite os pulsos de som, como um alto-falante, e o outro recebe os pulsos, como um microfone. Um artigo mais detalhado sobre esse sensor pode ser encontrado em: https://blog.eletrogate.com/sensor-ultrassonico-hc-sr04-com-arduino/

O diagrama elétrico foi editado com o Fritzing, e realizamos a montagem do componente. O pino 2 do Arduino foi ligado ao emissor de som do componente, e o pino 3, ao receptor, que captura o eco.

Usamos o Ardublockly para criar uma função distancia(), que calcula a distância de um obstáculo em cm. A lógica foi criada com a ajuda do instrutor.

Como foi explicado acima, logo no início da função, fazemos o sinal do pino 2 do Arduino, ligado ao pino Trig do componente, passar do nível lógico 0 ao nível 1, e de volta ao nível 0, por um intervalo de tempo de 12 microssegundos (um microssegundo é um segundo dividido por um milhão). Isto gera um pequeno estalo, que não escutamos, porque a frequência gerada pelo componente é na faixa de 40.000Hz, e nosso ouvido só consegue registrar sons até 20.000Hz (dizemos 20KHz). Em seguida, ficamos esperando que o eco seja detectado pelo sensor. Quando isso acontece, o pino Echo do componente muda do nível 0 para o nível 1, e esse sinal é transmitido ao pino 3 do Arduino. O bloco 'Read HIGH pulse on pin #3...' retorna o tempo em microssegundos que o pulso demora para ser detectado. Se demorar mais do que 12 milissegundos que correspondem a uma distância de cerca de 2 metros, consideramos que não há obstáculos adiante. Senão, uma conta determina a distância.

Aqui vai a explicação da conta. Se não se interessar pelos detalhes, você pode pular essa explicação sem prejuízo para compreensão deste artigo. Para cada segundo, a distância seria de metade de 340 metros, que dá 170m. Mas os tempos que temos são em microssegundos. Multiplicados pelos mesmos 170, vamos obter milionésimos de metros, ou milésimos de milímetros. Para obter um valor em milímetros, temos que ajustar nosso multiplicador 3 casas decimais: 0,17. Para um valor em centímetros, vai-se mais uma casa decimal, e o multiplicador passa a ser 0,017. Este é um número fracionário, e bem pequeno. A aritmética do Arduino é mais eficiente quando opera com números inteiros. Para conseguir isso, convertemos a multiplicação em uma divisão, e o valor do divisor a utilizar é 1 dividido por 0,017, que dá aproximadamente 59. Se prestou atenção, você vai ver que o valor usado no programa foi 58, por um erro de arredondamento.

O código da função distancia está listado abaixo:

// Calcula distancia para obstaculo em cm.
int distancia() {
  // Envia um pulso de 12 microssegundos pelo pino 2.
  digitalWrite(2, HIGH);
  delayMicroseconds(12);
  digitalWrite(2, LOW);

  // Conta o tempo que leva para receber o eco.
  tempo_eco = pulseIn(3, HIGH, 12000);

  if (tempo_eco > 0) {
    // Multiplicando o tempo pela velocidade (340m/s),
    // temos a distancia percorrida pelo som.
    // Dividimos o resultado por dois, porque o som vai e volta.
    dist = tempo_eco / 58;
    if (dist > 0) {
      return dist;
    }
  }
  return 0;
}



Alteramos o código principal do programa para utilizar a função distancia(), e evitar colisões. A lógica é simples: o carro avança, mas quando encontra algum obstáculo a menos de 30cm, desvia para a esquerda. Reduzimos a velocidade do carro para 150, porque ele estava muito rápido:

Código principal em C/C++:

void loop() {
  velocidade = 150;
  if (distancia() < 30) {
    parar();
    esquerda();
    delay(1000);
    parar();
  } else {
    avancar();
  }
  delay(500);

}

Nota: Neste ponto, você deve ter notado que nem todos os blocos gerados pelo Ardublockly foram traduzidos para o Português. O programa original foi criado em Inglês, e quem o traduziu esqueceu alguns blocos. Existe muito material sobre programação e robótica escrito em Inglês. Os blocos 'wait' são blocos que fazem o programa parar e esperar pelo tempo indicado, em milissegundos. O termo 'loop forever' no bloco principal significa repetir para sempre. Os blocos 'set digital pin' da função distancia() podem ser traduzidos como ajuste pino digital, e fazem o pino indicado assumir um valor lógico (0 para False e 1 para True).

Seguir para a Parte 4