Medição de velocidade, distância e ângulo para robôs móveis usando Arduino e sensor de velocidade lm393 (h206)

Os robôs começaram lentamente a se infiltrar em nossa sociedade para tornar nossa vida mais simples. Já podemos encontrar os robôs de entrega de comida de seis rodas da Starship nas estradas do Reino Unido, navegando de forma inteligente entre os civis para chegar ao seu destino. Todo robô móvel que navega no ambiente deve estar sempre ciente de sua posição e orientação em relação ao mundo real. Existem muitas maneiras de conseguir isso usando diferentes tecnologias como GPS, triangulação RF, acelerômetros, giroscópios, etc. Cada técnica tem sua própria vantagem e é única por si só. Neste tutorial do sensor de velocidade Arduino LM393, usaremos o módulo sensor de velocidade LM393 simples e facilmente disponívelpara medir alguns parâmetros vitais como velocidade, distância percorrida e ângulo do robô usando o Arduino. Com esses parâmetros, o robô será capaz de saber seu status no mundo real e pode usá-lo para navegar com segurança.

O Arduino é a escolha mais popular entre os entusiastas da construção de robôs, desde um simples seguidor de linha até um robô mais complexo de autobalanceamento ou limpeza de piso. Você pode verificar todos os tipos de robôs na seção Robótica.

Vamos construir um pequeno robô movido a bateria de lítio e dirigi-lo por meio de um joystick. Durante o tempo de execução podemos medir a velocidade, distância e ângulo do robô e exibi-los em tempo real no display LCD conectado ao Arduino. Este projeto apenas ajuda você a medir esses parâmetros, uma vez que você tenha feito isso, você pode usar esses parâmetros para operar seu bot autonomamente conforme necessário. Parece interessante, certo? Então vamos começar.

Módulo sensor de velocidade LM393 (H206)

Antes de entrarmos no diagrama de circuito e no código do projeto, vamos entender o módulo sensor de velocidade LM393, pois ele desempenha um papel vital no projeto. O módulo do sensor de velocidade H206 consiste em um sensor de luz infravermelha integrado com um comparador de tensão LM393 IC, daí o nome Sensor de velocidade LM393. O módulo também consiste em uma placa de grade que deve ser montada no eixo rotativo do motor. Todos os componentes estão identificados na imagem abaixo.

O sensor de luz infravermelha consiste em um LED IR e um fototransistor separados por um pequeno gabarito. Todo o arranjo do sensor é colocado em uma caixa preta, conforme mostrado acima. A placa de grade consiste em fendas, a placa é disposta entre a lacuna do sensor de luz infravermelha de tal maneira que o sensor pode detectar as lacunas na placa de grade. Cada lacuna na placa de grade aciona o sensor de IV ao passar pela lacuna; esses disparos são então convertidos em sinais de tensão usando o comparador. O comparador nada mais é do que um LM393 IC de semicondutores ON. O módulo tem três pinos, dois dos quais são usados ​​para alimentar o módulo e um pino de saída é usado para contar o número de gatilhos.

Arranjo de montagem do sensor H206

Montar esses tipos de sensores é um pouco complicado. Ele pode ser montado apenas em motores com eixo projetado em ambos os lados. Um lado do eixo é conectado à roda enquanto o outro lado é usado para montar a placa de grade como mostrado acima.

Visto que a roda e a placa estão conectadas ao mesmo eixo, ambas giram na mesma velocidade e, portanto, medindo a velocidade da placa, podemos medir a velocidade da roda. Certifique-se de que as lacunas na placa de grade passam pelo sensor IR, só então o sensor será capaz de contar o número de lacunas que passaram. Você também pode criar seu próprio arranjo mecânico para montar o sensor, desde que ele satisfaça a condição especificada. O sensor IR é geralmente usado em muitos projetos de robótica para guiar o robô sobre os obstáculos.

A placa de grade mostrada acima tem 20 slots (grades). Isso significa que o sensor encontrará 20 lacunas para uma rotação completa da roda. Ao contar o número de lacunas que o sensor detectou, podemos calcular a distância percorrida pela roda, da mesma forma, medindo a rapidez com que o sensor encontra as lacunas, podemos detectar a velocidade da roda. Em nosso robô teremos esse sensor montado em ambas as rodas e, portanto, também podemos encontrar o ângulo do robô. No entanto, o ângulo de rotação pode ser calculado de forma mais sensata usando o acelerômetro ou giroscópio, aprenda aqui como fazer a interface do acelerômetro e do giroscópio com o Arduino e tente medir o ângulo de rotação usando-os.

Diagrama de circuito do robô do sensor de velocidade DIY Arduino LM393

O diagrama completo do circuito deste robô com detecção de velocidade e distância é mostrado abaixo. O Bot consiste em Arduino Nano como seu cérebro, os dois motores DC para as rodas são acionados pelo módulo Driver de Motor L298N H-Bridge. O Joystick é usado para controlar a velocidade e direção do bot e os dois sensores de velocidade H206 são usados ​​para medir a velocidade, distância e ângulo do bot. Os valores medidos são então exibidos no módulo LCD 16x2. O potenciômetro conectado ao LCD pode ser usado para ajustar o contraste do LCD e o resistor é usado para limitar a corrente que flui para a luz de fundo do LCD.

O circuito completo é alimentado por uma célula de lítio de 7,4V. Este 7,4 V é fornecido ao pino de 12 V do módulo acionador do motor. O regulador de tensão no módulo do driver do motor então converte 7,4 V em + 5 V regulado, que é usado para alimentar o Arduino, LCD, sensores e joystick.

O motor é controlado pelos pinos digitais 8,9,10 e 11 do Arduino. Visto que a velocidade do motor também deve ser controlada, devemos fornecer sinais PWM ao terminal positivo do motor. Portanto, temos os pinos 9 e 10, que são ambos pinos com capacidade de PWM. Os valores X e Y do joystick são lidos usando os pinos analógicos A2 e A3, respectivamente.

Como sabemos, o sensor H206 gera um gatilho quando a lacuna na placa de grade é detectada. Uma vez que esses gatilhos nem sempre devem ser lidos com precisão para calcular a velocidade e a distância corretas, os pinos do gatilho (saída) são conectados aos pinos de interrupção externa 2 e 3 da placa Arduino. Monte todo o circuito em um chassi e monte o sensor de velocidade conforme explicado, meu bot parecia algo assim depois que as conexões foram concluídas. Você também pode assistir ao vídeo no final desta página para saber como o sensor foi montado.

Agora que a parte do hardware está concluída, vamos entrar na lógica de como iremos medir a velocidade, distância e individual do bot e então prosseguir para a seção de programação.

Lógica por trás da velocidade de medição com módulo de sensor de velocidade LM393

A partir da configuração da montagem do sensor, você deve estar ciente de que o módulo do sensor de velocidade LM393 (H206) mede apenas as lacunas presentes na placa de grade. Durante a montagem deve-se ter certeza de que a roda (cuja velocidade deve ser medida) e a placa de grade giram na mesma velocidade. Como aqui, já que montamos a roda e a placa no mesmo eixo, ambas irão girar com a mesma velocidade, obviamente.

Em nossa configuração, montamos dois sensores para cada roda para medir o ângulo do robô. Mas se o seu objetivo é medir apenas a velocidade e a distância, podemos montar o sensor em qualquer roda. A saída do sensor (sinais de gatilho) será mais comumente conectada a um pino de interrupção externa de um microcontrolador. Cada vez que for detectada a lacuna na placa de grade, uma interrupção será acionada e o código no ISR (Rotina de serviço de interrupção) será executado. Se pudermos calcular o intervalo de tempo entre dois desses gatilhos, podemos calcular a velocidade da roda.

No Arduino, podemos calcular facilmente esse intervalo de tempo usando a função millis () . Esta função de milissegundos continuará aumentando em 1 para cada milissegundo a partir do momento de ligar o dispositivo. Então, quando a primeira interrupção ocorrer, podemos salvar o valor de millis () em uma variável fictícia (como pevtime neste código) e, em seguida, quando a segunda interrupção ocorrer, podemos calcular o tempo gasto subtraindo o valor de pevtime de millis ().

Tempo gasto = hora atual - hora anterior timetaken = milis () - pevtime ; // timetaken em milissegundos

Depois de calcular o tempo gasto, podemos simplesmente calcular o valor de rpm usando as fórmulas abaixo, onde (1000 / timetaken) dá o RPS (rotações por segundo) e é multiplicado por 60 para converter RPS em RPM (rotações por minuto).

rpm = (1000 / timetaken) * 60;

Depois de calcular o rpm, podemos calcular a velocidade do veículo usando as fórmulas abaixo, desde que conheçamos o raio da roda.

Velocidade = 2π × RPS × raio da roda. v = radius_of_wheel * rpm * 0,104

Observe que a fórmula acima é para calcular a velocidade em m / s, se você quiser calcular em km / h, substitua 0,0104 por 0,376. Se você está curioso para saber como o valor 0,104 foi obtido, tente simplificar a fórmula V = 2π × RPS × raio da roda.

A mesma técnica é usada mesmo se um sensor Hall for usado para medir a velocidade de um objeto em rotação. Mas para o sensor H206 há um problema, a placa de grade tem 20 slots e, portanto, para medir o tempo entre dois intervalos de slot, o microcontrolador será sobrecarregado. Portanto, medimos a velocidade apenas na rotação completa de uma roda. Visto que duas interrupções serão geradas para cada intervalo (uma no início e outra no final do intervalo) , obteremos um total de 40 interrupções para que a roda faça uma rotação completa. Portanto, esperamos 40 interrupções antes de calcularmos a velocidade da roda. O código para o mesmo é mostrado abaixo

if (rotação> = 40) { timetaken = millis () - pevtime; // timetaken em milissegundos rpm = (1000 / timetaken) * 60; // fórmulas para calcular rpm pevtime = millis (); rotação = 0; }

Outra desvantagem desse método é que, o valor da velocidade não cairá para zero, pois a interrupção sempre estará esperando que a roda complete uma rotação para calcular o valor de rpm. Esta desvantagem pode ser facilmente superada adicionando um código simples que monitora o intervalo de tempo entre duas interrupções e, se exceder o normal, podemos forçar o valor de rpm e velocidade para zero. Link no código abaixo, usamos a variável dtime para verificar a diferença de tempo e se ela exceder 500 mili segundos, o valor da velocidade e rpm é forçado a ser zero.

/ * Para cair para zero se o veículo parar * / if (millis () - dtime> 500) // nenhuma interrupção encontrada para 500ms { rpm = v = 0; // faça rpm e velocidade como zero dtime = millis (); }

Lógica por trás da medição da distância percorrida pela roda

Já sabemos que o Arduino sentirá 40 interrupções quando a roda fizer uma rotação completa. Assim, para cada rotação feita pela roda, é evidente que a distância percorrida pela roda é igual à circunferência da roda. Como já sabemos o raio da roda, podemos calcular facilmente a distância percorrida usando a fórmula abaixo

Distância = 2πr * número de rotações distância = (2 * 3,141 * radius_of_wheel) * (left_intr / 40)

Onde a circunferência da roda é calculada usando a fórmula 2πr e então é multiplicada pelo número de rotações feitas pela roda.

Lógica por trás da medição do ângulo do bot

Existem muitas maneiras de determinar o anjo do robô. Os acelerômetros e giroscópios são normalmente usados ​​para determinar esses valores. Mas outra abordagem barata é usar o sensor H206 em ambas as rodas. Assim saberíamos quantas voltas cada roda deu. A figura abaixo ilustra como o ângulo é calculado.

Quando o robô é inicializado, o ângulo para o qual ele está voltado é considerado 0 °. Daí gira para a esquerda o ângulo é incrementado em negativo e se gira para a direita o anjo é incrementado em positivo. Para compreensão, vamos considerar o intervalo de -90 a +90 conforme mostrado na figura. Em tal arranjo, uma vez que ambas as rodas têm o mesmo diâmetro, se qualquer uma das rodas fizer uma rotação completa, o robô girará em um ângulo de 90 °.

Por exemplo, se a roda esquerda fizer uma rotação completa (80 interrupções), o bot girará 90 ° para a esquerda e, da mesma forma, se a roda direita fizer uma rotação completa (80 interrupções), o bot girará -90 ° para a direita. Agora sabemos que se o Arduino detectar 80 interrupções em uma roda, o bot girou 90 ° e com base em qual roda podemos dizer se o bot girou para positivo (direita) ou negativo (esquerda). Assim, o ângulo esquerdo e direito podem ser calculados usando as fórmulas abaixo

ângulo_esquerdo int = (left_intr% 360) * (90/80); int ângulo_direito = (right_intr% 360) * (90/80);

Onde 90 é o ângulo coberto ao fazer uma interrupção de 80. O valor resultante é o número de interrupções multiplicado. Também usamos um módulo de 360 ​​para que o valor resultante nunca exceda 36. Depois de calcularmos os ângulos esquerdo e direito, o ângulo efetivo para o qual o robô está voltado pode ser obtido simplesmente subtraindo o ângulo esquerdo do ângulo direito.

ângulo = ângulo_ direito - ângulo_esquerdo;

Código do robô Arduino

O código Arduino completo para este robô de medição de velocidade e ângulo pode ser encontrado no final desta página. O objetivo do programa é calcular a velocidade, distância e ângulo do bot usando as lógicas acima e exibi-lo na tela LCD. Além disso, deve fornecer uma opção para controlar o bot usando o Joystick.

Iniciamos o programa definindo os pinos de E / S digital para os dois motores. Observe que também temos que controlar a velocidade do motor e, portanto, temos que usar os pinos PWM no Arduino para controlar os motores. Aqui usamos os pinos 8,9,10 e 11.

# definir LM_pos 9 // motor esquerdo # definir LM_neg 8 // motor esquerdo # definir RM_pos 10 // motor direito # definir RM_neg 11 // motor direito # definir joyX A2 # definir joyY A3

Para medir a velocidade e distância percorrida precisamos saber o raio da roda, medir o valor e entrar em metros conforme mostrado abaixo. Para o meu bot, o raio era de 0,033 metros, mas pode ser diferente para você com base no seu bot.

float radius_of_wheel = 0,033; // Meça o raio de sua roda e insira-o aqui em cm

Dentro da função de configuração , inicializamos todos os valores como zero e exibimos um Texto de introdução no LCD. Também inicializamos o monitor serial para fins de depuração. Em seguida, mencionamos que os sensores de velocidade H206 são conectados aos pinos 2 e 3 como interrupções externas. É onde sempre que a interrupção é detectada, a função ISR Left_ISR e Right_ISR será executada de acordo.

configuração vazia () { rotação = rpm = pevtime = 0; // Inicializa todas as variáveis ​​para zero Serial.begin (9600); lcd.begin (16, 2); // Inicializar LCD 16 * 2 lcd.print ("Monitor de bots"); // Linha 1 da mensagem de introdução lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Mensagem de introdução linha 2 delay (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, OUTPUT); pinMode (LM_neg, OUTPUT); pinMode (RM_pos, OUTPUT); pinMode (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR é chamado quando o sensor da roda esquerda é acionado attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR é chamado quando o sensor da roda direita é acionado }

Dentro da rotina Left_ISR, nós simplesmente incrementamos uma variável chamada left_intr que será usada posteriormente na medição do ângulo do bot. Dentro do Right_ISR fazemos a mesma coisa, mas além disso, também calculamos a velocidade aqui. A rotação da variável é incrementada para cada interrupção e então a lógica acima é usada para calcular a velocidade.

void Left_ISR () { left_intr ++; delay (10); } void Right_ISR () { right_intr ++; atraso (10); rotação ++; dtime = millis (); if (rotação> = 40) { timetaken = millis () - pevtime; // timetaken em milissegundos rpm = (1000 / timetaken) * 60; // fórmulas para calcular rpm pevtime = millis (); rotação = 0; } }

Dentro da função principal de loop infinito, monitoramos os valores de X e Y do joystick. Com base no valor se o joystick for movido, controlamos o bot de acordo. A velocidade do bot depende de quão longe o joystick é empurrado.

int xValue = analogRead (joyX); int yValue = analogRead (joyY); aceleração interna = mapa (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, aceleração); analogWrite (RM_pos, aceleração); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);

Isso ajudará o usuário a mover o bot e verificar se os valores obtidos estão conforme o esperado. Finalmente, podemos calcular a velocidade, distância e ângulo do bot usando a lógica acima e exibi-lo no LCD usando o código abaixo.

v = raio_da_wheel * rpm * 0,104; //0.033 é o raio da roda em metros de distância = (2 * 3.141 * radius_of_wheel) * (left_intr / 40); ângulo_esquerdo int = (entrada_esquerda% 360) * (90/80); int ângulo_right = (right_intr% 360) * (90/80); ângulo = ângulo_ direito - ângulo_esquerdo; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (distância); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (ângulo);

Testando o Arduino Robot para medir distância, velocidade e ângulo

Assim que seu hardware estiver pronto, carregue o código em seu Arduino e use o joystick para mover seu bot. a velocidade do bot, a distância percorrida por ele e o ângulo serão exibidos no LCD conforme mostrado abaixo.

No LCD, os termos Lt e Rt representam a contagem de interrupções à esquerda e a contagem de interrupções à direita, respectivamente. Você pode encontrar esses valores sendo incrementados para cada detecção de lacuna pelo sensor. O tem S indica a velocidade do bot em m / seg e o termo D indica a distância percorrida em metros. O ângulo do bot é exibido no final, onde 0 ° é para reta e fica negativo para rotação anti-horário e positivo para rotação horário.

Você também pode assistir ao vídeo no final desta página para entender como o bot funciona. Espero que você tenha entendido o projeto e gostado de construí-lo. Se você tiver alguma dúvida, deixe-os na seção de comentários e tentarei responder da melhor forma. Você também pode usar os fóruns para obter ajuda técnica rápida.