Robô de seguimento de parede eficiente com sensor ultrassônico que funciona em ambientes internos e externos

Assim como os robôs que seguem linhas são divertidos, fazer um robô que segue paredes é ainda mais emocionante. Um robô que segue paredes é projetado para se mover ao longo de uma parede sem bater nela. Possui sensores de detecção de obstáculos montados no corpo que detectam paredes e acionam motores DC fixados nas rodas para que o robô continue se movendo ao longo da parede.
O robô pode ser projetado orientado para a direita ou para a esquerda ou ainda pode ser projetado para seguir qualquer um dos lados. Um seguidor de parede orientado para a direita ou para a esquerda pode ser projetado facilmente com a ajuda de apenas dois sensores. Embora mais sensores possam ser usados ​​na fabricação de tal robô, o que acabará por melhorar a precisão do caminho do robô. Para fazer um seguidor de parede que pode ser lateral em qualquer direção, pelo menos três sensores são necessários e a lógica do programa é um pouco complexa e sofisticada. Se for projetado um seguidor de parede orientado para a direita, os sensores de detecção de obstáculos precisam ser montados na parte frontal e direita do robô. Se for projetado um seguidor de parede orientado para a esquerda, os sensores detectores de obstáculos precisam ser montados na parte frontal e esquerda do robô. Se o robô for projetado para seguir qualquer um dos lados, sensores detectores de obstáculos deverão ser montados na parte frontal, esquerda e direita do robô. Neste projeto é projetada uma parede lateral esquerda seguindo o robô.
Protótipo de Robô Seguidor de Parede
Fig. 1: Protótipo de Robô Seguidor de Parede
O sensor detector de obstáculos usado em um seguidor de parede pode ser um sensor IR ou um sensor ultrassônico. Os sensores IR podem ser usados ​​para detectar uma distância pré-determinada e calibrada da parede e assim, ao usar sensores IR, o robô é projetado para manter uma distância fixa da parede. Nesse caso, uma alta precisão de percurso não pode ser alcançada. Em segundo lugar, na presença de luz solar ou reflexo de uma mancha preta na parede, o robô pode não funcionar conforme desejado devido às limitações do sensor IR nesses casos. Embora se o sensor ultrassônico for usado como detector de obstáculos, o robô pode ser projetado para manter uma distância com a parede, o que melhora não apenas a flexibilidade do caminho, mas também melhora sua precisão. Como os sensores ultrassônicos operam com base na reflexão de ondas ultrassônicas (sonoras), eles podem ser usados ​​em ambientes onde há luz solar ou obstáculos pretos no caminho. Considerando essas vantagens dos sensores ultrassônicos sobre os sensores IR, os sensores ultrassônicos são utilizados para detecção de obstáculos ou paredes neste projeto.
A placa microcontroladora que fornece inteligência ao robô é o Arduino Pro Mini. O robô também pode ser projetado em qualquer outra placa microcontroladora. O código do programa desenvolvido para este robô também é compatível com Arduino UNO e funcionará bem se a interface dos sensores e do driver do motor IC for feita da mesma forma que o programa opera. O Arduino Pro Mini é utilizado devido ao seu tamanho pequeno e peso leve. Além disso, o Pro Mini possui pinos GPIO suficientes, necessários para fazer este robô. O código do programa é escrito e gravado usando Arduino IDE.
Componentes necessários –
Lista de componentes necessários para o robô seguidor de parede
Figura 2: Lista de componentes necessários para o robô seguidor de parede
Diagrama de bloco –
Diagrama de blocos do robô seguidor de parede
Figura 3: Diagrama de blocos do robô seguidor de parede
Conexões de Circuito –
Este robô que segue parede é construído em torno do Arduino Pro Mini. Os sensores ultrassônicos e o IC do driver do motor L293D fazem interface com a placa controladora para torná-lo um robô funcional.
Imagem do circuito eletrônico montado no robô seguidor de parede
Fig. 4: Imagem do circuito eletrônico montado no robô seguidor de parede
O circuito eletrônico montado no robô e controlando seu movimento pode ser detalhado nas seguintes seções –
Fonte de alimentação – No circuito, o Arduino Pro Mini e os sensores ultrassônicos precisam de 5V DC regulado para seu funcionamento, enquanto o IC do driver do motor precisa de 12V DC. Uma bateria NIMH de 12V é usada como fonte primária de energia. A alimentação da bateria é regulada para 5V e 12V usando CIs 7805 e 7812. O pino 1 de ambos os CIs reguladores de tensão está conectado ao ânodo da bateria e o pino 2 de ambos os CIs está conectado ao terra. As respectivas saídas de tensão são extraídas do pino 3 dos respectivos CIs reguladores de tensão. Um LED junto com um resistor pull-up de 10K Ω também é conectado entre o terra comum e o pino de saída para obter uma dica visual da continuidade da alimentação. Apesar de usar bateria de 12 V, o 7812 é usado para fornecer uma alimentação regulada e estável ao IC do driver do motor.
Arduino Pro Mini – Arduino Pro Mini é uma placa microcontroladora baseada em Atmega 168. Possui 14 pinos GPIO, 6 entradas analógicas, 6 pinos PWM, 2 interrupções externas e UART, SPI e I2C integrados. A placa tem apenas 1,3 polegada por 0,7 polegada de tamanho, seis vezes menor que o Arduino UNO. Com esses recursos em tamanho pequeno, esta placa é ideal para qualquer projeto robótico. Neste projeto, são utilizados 8 pinos de entrada e saída do Pro Mini, quatro pinos para interface com sensores ultrassônicos e quatro pinos para interface com o IC do driver do motor.
Sensor ultrassônico HC-SR04 – O sensor ultrassônico HC-SR04 usa sonar para determinar a distância até um objeto, como fazem os morcegos ou golfinhos. Oferece excelente detecção de faixa sem contato com alta precisão e leituras estáveis ​​na faixa de 2 cm a 400 cm.
Existem dois sensores ultrassônicos usados ​​no circuito, um montado na frente do robô e outro montado no lado esquerdo do robô. O sensor ultrassônico montado na frente está conectado aos pinos 5 e 6 da placa Arduino e o sensor montado no lado esquerdo está conectado aos pinos 10 e 11 da placa Arduino. O sensor ultrassônico possui quatro pinos – Terra (Pino 1), Eco (Pino 2), Trigger (Pino 3) e Trigger. Os pinos VCC e terra são conectados ao VCC e terra comuns, respectivamente. Os pinos Echo do sensor frontal e esquerdo são conectados aos pinos 5 e 11 da placa Arduino, respectivamente, enquanto os pinos de disparo dos sensores frontal e esquerdo são conectados aos pinos 6 e 10 da placa Arduino.
O sensor ultrassônico funciona segundo o princípio do eco das ondas sonoras. Quando um pulso ALTO de 10 μs é passado para o pino de disparo do sensor, ele transmite oito ondas de 40 KHz de disparos de pulso sônico ALTO consecutivamente. Um sinal de pulso alto sai do pino de eco conforme a onda ultrassônica é transmitida. Esta onda ao colidir com um obstáculo é refletida de volta e detectada pelo sensor. Ao detectar a onda novamente, o sinal de pulso alto do pino de eco do sensor é encerrado. O sinal recebido do pino de eco é de natureza analógica. A distância do obstáculo pode ser medida medindo o tempo máximo do pino de eco. Este é o tempo entre a transmissão e a reflexão da onda sonora. A distância é dada pelas fórmulas –
Distância de teste = (tempo de alto nível × velocidade do som (340M/S)) / 2
O tempo multiplicado pela velocidade é dividido por 2, pois o tempo necessário para a onda sônica atingir o obstáculo e retornar. Portanto a medida da distância em cm pode ser dada pelas fórmulas –
Distância de teste = (tempo de alto nível × velocidade do som (340M/S)) / 2
= (tempo de alto nível (microssegundo) × velocidade do som (340M/S)) / 2
= tempo de nível alto x 340/2000000 m
= tempo de alto nível x 34.000/2.000.000 cm
= tempo de alto nível x 34/2000 cm
Os sensores ultrassônicos emitem o pulso alto de seu pino 2, que é detectado nos pinos 5 e 11 da placa Arduino. O código do programa mede as durações dos pulsos e as digitaliza em valores de distância usando as fórmulas indicadas acima. Esses valores de distância são utilizados para manter uma distância definida com a parede lateral esquerda e desviar de um obstáculo na frente do robô a partir de uma distância predefinida. Os motores são acionados para manter uma distância pré-determinada da parede lateral esquerda.
L293D DC Motor Driver IC – O L293D é um circuito integrado (IC) de driver de motor de ponte H dupla. Os drivers do motor atuam como amplificadores de corrente, pois recebem um sinal de controle de baixa corrente e fornecem um sinal de corrente mais alta. Este sinal de corrente mais alto é usado para acionar os motores. Possui 16 pinos com a seguinte configuração de pinos:
Tabela de listagem de configuração de pinos do IC do driver do motor L293D
Fig. 5: Tabela listando a configuração dos pinos do IC do driver do motor L293D
Existem dois motores DC usados ​​para fazer o carro robótico. Os motores DC fazem interface entre os pinos 3 e 6 e os pinos 14 e 11 do IC do driver do motor.
O IC L293D controla os motores DC de acordo com as seguintes tabelas verdade:
Tabela verdade do IC do driver do motor L293D
Fig. 6: Tabela verdade do IC do driver do motor L293D
Tabela verdade do IC do driver do motor L293D
Fig. 7: Tabela verdade do IC do driver do motor L293D
Os pinos 4, 5, 13 e 12 do L293D são aterrados enquanto os pinos 1, 16 e 9 estão conectados a 5 Vcc e o pino 8 está conectado a 12 Vcc. Os pinos 15, 2, 7 e 10 do IC do driver do motor estão conectados aos pinos 8, 2, 3 e 7 da placa Arduino. O motor DC conectado à roda direita está conectado aos pinos 11 e 14, enquanto o motor conectado à roda esquerda está conectado aos pinos 3 e 6 do Arduino.
Motores DC com engrenagens – Neste robô, motores DC com engrenagens de 12 V são acoplados às rodas. Os motores DC com engrenagens estão disponíveis com uma ampla faixa de RPM e Torque, o que permite que um robô se mova com base no sinal de controle que recebe do IC do driver do motor.
Como funciona o circuito –
Quando o robô é ligado, ele é inicializado para avançar e continuar virando à esquerda até atingir uma distância mínima com a parede esquerda. Para isso, o robô é feito para iniciar o movimento para frente e iniciar a leitura dos valores dos sensores ultrassônicos. O robô também continua girando para a esquerda girando o motor CC do lado direito mais rapidamente até que a leitura do sensor esquerdo se aproxime do valor mínimo. A partir de agora, o robô pode enfrentar duas condições – ou algum obstáculo aparece na frente do robô ou a distância com a parede pode diminuir devido à estrutura ou layout da parede. Se um obstáculo for detectado na frente do robô a uma distância predefinida, o robô será virado para a direita até superar o obstáculo. Se não houver nenhum obstáculo na frente do robô, o robô continuará se movendo para frente. Caso a distância entre a parede esquerda e o robô seja reduzida abaixo do valor mínimo, o robô será movido novamente na direção certa acionando o motor do lado esquerdo mais rapidamente até que a distância atinja um valor máximo. O Arduino implementa o mesmo algoritmo. Este algoritmo está resumido no seguinte fluxograma –
Fluxograma do código Arduino usado para robô seguidor de parede
Fig. 8: Fluxograma do código Arduino usado para robô seguidor de parede
O esboço do Arduino move o robô de acordo com a tabela a seguir –
Tabela Lógica do Robô Seguidor de Parede
Fig. 9: Tabela Lógica do Robô Seguidor de Parede
As ações de acompanhamento podem ser implementadas acionando os motores da seguinte maneira –
Tabela Resumindo o Plano de Ação para Robô Seguidor de Parede
Fig. 10: Tabela resumindo o Plano de Ação para o Robô Seguidor de Parede
O robô pode ser movido para frente, para trás, para a esquerda ou para a direita implementando a seguinte lógica de entrada nos pinos do driver do motor –
Tabela lógica do IC do driver do motor L293D para robô seguidor de parede
Fig. 11: Tabela lógica do IC do driver do motor L293D para robô seguidor de parede
Para desacelerar ou acelerar movimentos robóticos específicos, o PWM pode ser aplicado nos pinos de entrada do driver L293D. Assim, os sensores ultrassônicos detectam a distância da parede ou obstáculo e os motores CC são acionados para responder à mudança de situação. É assim que o robô se move seguindo a parede e superando quaisquer obstáculos.
Em um seguidor de parede orientado à direita, o algoritmo será quase semelhante, exceto que o robô será projetado para seguir a parede à direita e girar de acordo com diferentes situações. O projeto de um robô seguindo qualquer uma das paredes pode ser um pouco complexo, pois enfrentará novas situações e terá que decidir qual parede deve ser seguida em determinadas circunstâncias.
Imagem do robô seguidor de parede baseado em Arduino
Fig. 12: Imagem do robô seguidor de parede baseado em Arduino
Confira o código do programa para ver como o algoritmo é implementado no esboço do Arduino. Confira como o Arduino lê os dados dos sensores ultrassônicos, compara as leituras com os deslocamentos mínimo e máximo e altera a rotação do motor em resposta às situações percebidas.
Guia de programação –
O código usa a nova biblioteca ping para o sensor ultrassônico. Saiba mais sobre a biblioteca ping do Arduino.CC e baixe NewPing.h.
#include
A diretiva #define é usada para declarar alguns valores constantes que serão atribuídos às variáveis ​​usadas no código. Essas constantes indicam quantos sensores ultrassônicos são usados, a distância máxima que o sensor deve responder e o intervalo de ping é o tempo entre os pings de dois sensores em milissegundos.
#define SONAR_NUM 2
#define MAX_DISTANCE 500
#define PING_INTERVAL 33
As seguintes diretivas #define são usadas para determinar os números dos pinos do Arduino usados ​​para conectar o sensor ultrassônico (pino de disparo e pino de eco) e os pinos que devem ser conectados ao IC do driver do motor.
#define trigPin1 5
#define echoPin1 6
#define trigPin2 10
#define echoPin2 11
#define LM1 2
#define LM23
#define RM1 7
#define RM2 8
O bloco a seguir descreve o objeto sensor que define os dois sensores na matriz. Ele instancia o objeto da biblioteca NewPing que descreve o pino de disparo e os pinos de eco conectados ao arduino e a distância máxima que eles devem medir.
Novo sonar Ping (SONAR_NUM) = {
NovoPing(trigPin1, echoPin1, MAX_DISTANCE),
NovoPing(trigPin2, echoPin2, MAX_DISTANCE)
};
O bloco a seguir descreve a função setup , que é usada para definir as taxas de transmissão e define se o pino do Arduino deve ser usado como entrada ou saída digital. É usado para definir a taxa de transmissão para a comunicação serial entre o arduino e o pc.
Serial.begin(9600);
int eu;
As instruções a seguir usam a função PinMode para declarar os pinos conectados ao driver do motor do Arduino como saída digital.
pinMode(LM1, SAÍDA);
pinMode(LM2, SAÍDA);
pinMode(RM1, SAÍDA);
pinMode(RM2, SAÍDA);
As instruções a seguir usam a função PinMode para declarar os pinos de gatilho como saída e os pinos de eco como entrada em relação à placa Arduino.
pinMode(trigPin1, SAÍDA);
pinMode(echoPin1, INPUT);
digitalWrite(trigPin1, BAIXO);
pinMode(trigPin2, SAÍDA);
pinMode(echoPin2, INPUT);
digitalWrite(trigPin2, BAIXO);
O bloco de código a seguir inicializa a faixa de valores que o Arduino deve sinalizar ao driver do motor para virar à direita ou à esquerda ou seguir em frente dependendo da distância medida pelo sensor ultrassônico.
int toCloseWall = 1000;
int para FarWall = 1500;
int toCloseFront = 1000;
A operação principal no código é implementada por um loop de tomada de decisão que é chamado na função main . Deve-se observar que no código-fonte, as funções serial.print são usadas para verificar o alcance dos sensores ultrassônicos durante a depuração e calibração do código. A função main chama a função readRangeFront para medir a distância detectada pelo sensor ultrassônico frontal.
rangeFront = readRangeFront ;
Ele chama a função readRangeWall para medir a distância entre a parede pela qual o robô está se movendo.
rangeWall = readRangeWall ;
A seguinte condição if é usada para verificar a distância entre o sensor frontal e o objeto, se o objeto estiver mais próximo de acordo com um intervalo pré-determinado, ele chama a função drive_backward , drive_forward e turn_left com algum atraso entre .
if (rangeFront
{
atraso(500);
drive_backward ;
atraso(500);
atraso(800);
segue em frente ;
Vire à esquerda ;
atraso(1000);
vá para Principal;
}
A seguinte condição é usada para verificar a distância entre o sensor frontal e a parede frontal e o sensor da parede lateral e a parede lateral. Se a distância medida pelos dois sensores estiver na faixa desejada, ele chama a função drive_forward .
if(rangeWall > toCloseWall && rangeWall < toFarWall)
{
segue em frente ;
vá para Principal;
}
As seguintes condições são usadas para verificar a distância entre a parede lateral e o sensor e verificar o valor mais próximo e mais distante. Se a distância ficar próxima, ele chama a função drive_left e a função drive_forward e se a distância ficar longe ele chama a função drive_right e a função drive_forward .
if (rangeWall
{
atraso(100);
Vire à esquerda ;
atraso(100);
segue em frente ;
vá para Principal;
}
if (rangeWall > toFarWall)
{
atraso(100);
Vire à direita ;
atraso(100);
segue em frente ;
vá para Principal;
}
As instruções Goto são usadas para executar o loop continuamente. Confira o código completo do projeto e grave em um Arduino para fazer o robô funcionar. Isso completa o esboço do Arduino para o robô que segue parede (lado esquerdo).

Código-fonte do projeto

###

//Program to 

#incluir

#define SONAR_NUM 2 //define o número de sensores ultrassônicos usados

#define MAX_DISTANCE 800 //Distância máxima entre o objeto e o robô

#define PING_INTERVAL 33

#define trigPin1 6 // define conexões de pinos para sensor e motor

#define echoPin1 5

#define trigPin2 11

#define echoPin2 10

#define LM1 2

#define LM23

#define RM1 7

#define RM2 8

int rangeFront = 0;

int rangeWall = 0;

Sonar NewPing(SONAR_NUM) = { // Defina um array Newping para medir a distância

NovoPing(trigPin1, echoPin1, MAX_DISTANCE),

NovoPing(trigPin2, echoPin2, MAX_DISTANCE)

};

void setup // função de configuração para fazer a configuração do pino para definir se é entrada ou saída

{

Serial.begin(9600);

int eu;

pinMode(LM1, SAÍDA);

pinMode(LM2, SAÍDA);

pinMode(RM1, SAÍDA);

pinMode(RM2, SAÍDA);

pinMode(en1, SAÍDA);

pinMode(pt2, SAÍDA);

pinMode(trigPin1, SAÍDA);

pinMode(echoPin1, INPUT);

digitalWrite(trigPin1, BAIXO);

pinMode(trigPin2, SAÍDA);

pinMode(echoPin2, INPUT);

digitalWrite(trigPin2, BAIXO);

}

int toCloseWall = 1800; //Inicializa e define os valores da distância entre a parede e o robô

int para FarWall = 2500;

int toCloseFront = 1000;

loop vazio

{

Principal:

rangeFront = readRangeFront ; // Ler o valor do sensor pela chamada da função

Serial.print(rangeFront);

Serial.print("Frente");

Serial.println ;

rangeWall = readRangeWall ;

Serial.print(rangeWall);

Serial.print("Parede");

Serial.println ;

if (rangeFront <= 400) //À medida que o valor do sensor lê os valores pequenos, estamos manipulando para valores altos

{

intervaloFrente = 3000;

}

if(intervaloWall <= 400)

{

intervaloParede = 3000;

}

if (rangeFront < toCloseFront) //Condição para verificar se o sensor frontal está próximo do robô

{

atraso(500);

drive_backward ;

atraso(500);

Serial.print("Voltar");

//Vire à direita ;

Serial.print("Virar à direita");

Serial.println ;

atraso(800);

segue em frente ;

Vire à esquerda ;

atraso(1700);

vá para Principal;

}

if(rangeWall > toCloseWall && rangeWall < toFarWall) //condição para verificar se a distância medida pelo sensor frontal e lateral é mantida corretamente

{

segue em frente ;

Serial.print("Avançar");

Serial.println ;

vá para Principal;

}

if (rangeWall < toCloseWall) //condição para verificar se a parede lateral está próxima do robô

{

atraso(100);

//Vire à esquerda ;

Vire à direita ;

atraso(500);

Serial.print("Vire à Esquerda");

segue em frente ;

Serial.print("Avançar");

Serial.println ;

vá para Principal;

}

if (rangeWall > toFarWall) //condição para verificar se o robô está longe da parede lateral

{

atraso(100);

//Vire à direita ;

Vire à esquerda ;

Serial.print("Vire à direita");

atraso(500);

segue em frente ;

Serial.print("Avançar");

Serial.println ;

vá para Principal;

}

}

void motor_stop // função para parar o robô

{

digitalWrite(LM1, BAIXO);

digitalWrite(LM2, BAIXO);

digitalWrite(RM1, BAIXO);

digitalWrite(RM2, BAIXO);

}

void drive_forward // função para impulsionar o robô para frente

{

digitalWrite(LM1, ALTO);

digitalWrite(LM2, BAIXO);

digitalWrite(RM1, ALTO);

digitalWrite(RM2, BAIXO);

}

void drive_backward // função para conduzir o robô para trás

{

digitalWrite(LM1, BAIXO);

digitalWrite(LM2, ALTO);

digitalWrite(RM1, BAIXO);

digitalWrite(RM2, ALTO);

}

void turn_left // função para virar o robô para a esquerda

{

digitalWrite(LM1, ALTO);

digitalWrite(LM2, BAIXO);

digitalWrite(RM1, BAIXO);

digitalWrite(RM2, BAIXO);

}

void turn_right //função para virar o robô para a direita

{

digitalWrite(LM1, BAIXO);

digitalWrite(LM2, BAIXO);

digitalWrite(RM1, ALTO);

digitalWrite(RM2, BAIXO);

}

int readRangeFront //função para ler o valor do sensor frontal

{

atraso(50);

rangeFront não assinado = sonar(0).ping ;

sonar(0).timer_stop ;

retornar rangeFront;

}

int readRangeWall // função para ler o valor do sensor esquerdo

{

atraso(50);

rangeWall não assinado = sonar(1).ping ;

sonar(1).timer_stop ;

retornar intervaloWall;

}


###

Diagramas de circuito

Diagrama de Circuito-Arduino-Seguidor de Parede-Robô

Vídeo do projeto

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.