Medición de velocidad, distancia y ángulo para robots móviles usando arduino y el sensor de velocidad lm393 (h206)

Los robots han comenzado a introducirse lentamente en nuestra sociedad para hacer nuestra vida más sencilla. Ya podemos encontrar los robots de reparto de alimentos de seis ruedas de Starship en las carreteras del Reino Unido, navegando inteligentemente entre los civiles para llegar a su destino. Todo robot móvil que navegue por el entorno debe estar siempre consciente de su posición y orientación con respecto al mundo real. Hay muchas formas de lograr esto utilizando diferentes tecnologías como GPS, triangulación de RF, acelerómetros, giroscopios, etc. Cada técnica tiene su propia ventaja y es única por sí misma. En este tutorial del sensor de velocidad Arduino LM393 usaremos el módulo de sensor de velocidad LM393 simple y fácilmente disponiblepara medir algunos parámetros vitales como la velocidad, la distancia recorrida y el ángulo del robot usando Arduino. Con estos parámetros el robot podrá conocer su estado en el mundo real y podrá utilizarlo para navegar de forma segura.

Arduino es la opción más popular entre los aficionados a la construcción de robots, desde un simple seguidor de línea hasta un robot de limpieza de pisos o autoequilibrado más complejo. Puedes consultar todo tipo de robots en la sección de Robótica.

Construiremos un pequeño robot que funciona con una batería de litio y lo manejaremos con un joystick. Durante el tiempo de ejecución, podemos medir la velocidad, la distancia y el ángulo del robot y mostrarlo en tiempo real en la pantalla LCD conectada a Arduino. Este proyecto solo lo ayuda a medir estos parámetros, una vez que haya terminado con esto, puede usar estos parámetros para operar su bot de forma autónoma según sea necesario. Suena interesante, ¿verdad? Entonces empecemos.

Módulo de sensor de velocidad LM393 (H206)

Antes de entrar en el diagrama de circuito y el código del proyecto, comprendamos el módulo del sensor de velocidad LM393, ya que juega un papel vital en el proyecto. El módulo del sensor de velocidad H206 consta de un sensor de luz infrarroja integrado con un IC comparador de voltaje LM393, de ahí el nombre de sensor de velocidad LM393. El módulo también consta de una placa de rejilla que debe montarse en el eje giratorio del motor. Todos los componentes están etiquetados en la imagen de abajo.

El sensor de luz infrarroja consta de un LED de infrarrojos y un fototransistor separados por una pequeña charla. Toda la disposición del sensor se coloca en una carcasa negra como se muestra arriba. La placa de rejilla consta de ranuras, la placa está dispuesta entre el espacio del sensor de luz infrarroja de tal manera que el sensor puede detectar los espacios en la placa de rejilla. Cada espacio en la placa de la rejilla activa el sensor de infrarrojos cuando pasa a través del espacio; estos disparadores luego se convierten en señales de voltaje usando el comparador. El comparador no es más que un IC LM393 de semiconductores ON. El módulo tiene tres pines, dos de los cuales se utilizan para alimentar el módulo y un pin de salida se utiliza para contar el número de disparadores.

Disposición de montaje del sensor H206

Montar este tipo de sensores es un poco complicado. Solo se puede montar en motores cuyo eje sobresalga en ambos lados. Un lado del eje está conectado a la rueda mientras que el otro lado se usa para montar la placa de rejilla como se muestra arriba.

Dado que la rueda y la placa están conectadas al mismo eje, ambas giran a la misma velocidad y, por lo tanto, midiendo la velocidad de la placa podemos medir la velocidad de la rueda. Asegúrese de que los espacios en la placa de rejilla pasen a través del sensor de infrarrojos, solo entonces el sensor podrá contar el número de espacios que han pasado. También puede crear su propia disposición mecánica para montar el sensor siempre que satisfaga la condición especificada. El sensor de infrarrojos se utiliza generalmente en muchos proyectos de robótica para guiar al robot sobre los obstáculos.

La placa de rejilla que se muestra arriba tiene 20 ranuras (rejillas). Esto significa que el sensor encontrará 20 espacios para una rotación completa de la rueda. Contando el número de huecos que ha detectado el sensor podemos calcular la distancia recorrida por la rueda, de manera similar midiendo qué tan rápido el sensor encuentra los huecos podemos detectar la velocidad de la rueda. En nuestro robot tendremos este sensor montado en ambas ruedas y, por lo tanto, también podremos encontrar el ángulo del robot. Sin embargo, el ángulo de rotación se puede calcular de manera más sensata usando el acelerómetro o el giroscopio, aprenda aquí a conectar el acelerómetro y el giroscopio con Arduino y pruebe a medir el ángulo de rotación con ellos.

Diagrama de circuito del robot del sensor de velocidad Arduino LM393 de bricolaje

El diagrama de circuito completo de este robot sensor de velocidad y distancia se muestra a continuación. El Bot consta de Arduino Nano como su cerebro, los dos motores de CC para las ruedas son impulsados ​​por el módulo L298N H-Bridge Motor Driver. El Joystick se usa para controlar la velocidad y la dirección del bot y los dos sensores de velocidad H206 se usan para medir la velocidad, la distancia y el ángel del bot. A continuación, los valores medidos se muestran en el módulo LCD de 16x2. El potenciómetro conectado a la pantalla LCD se puede utilizar para ajustar el contraste de la pantalla LCD y la resistencia se utiliza para limitar el flujo de corriente a la luz de fondo de la pantalla LCD.

El circuito completo está alimentado por una celda de litio de 7.4V. Estos 7,4 V se suministran al pin de 12 V del módulo del controlador del motor. El regulador de voltaje en el módulo del controlador del motor convierte los 7,4 V a + 5 V regulados que se utilizan para alimentar el Arduino, LCD, sensores y joystick.

El motor está controlado por los pines digitales 8, 9, 10 y 11 del Arduino. Dado que la velocidad del motor también debe controlarse, debemos suministrar señales PWM al terminal positivo del motor. Por lo tanto, tenemos los pines 9 y 10, que son pines capaces de PWM. Los valores X e Y del joystick se leen utilizando los pines analógicos A2 y A3 respectivamente.

Como sabemos, el sensor H206 genera un disparador cuando se detecta el espacio en la placa de rejilla. Dado que estos disparadores no siempre deben leerse con precisión para calcular la velocidad y la distancia correctas, ambos pines del disparador (salida) están conectados al pin de interrupción externa 2 y 3 de la placa Arduino. Ensamble todo el circuito en un chasis y monte el sensor de velocidad como se explicó, mi bot se veía algo como a continuación después de completar las conexiones. También puede ver el video al final de esta página para saber cómo se montó el sensor.

Ahora que la parte del hardware está completa, entremos en la lógica de cómo mediremos la velocidad, la distancia y la velocidad del bot y luego procedamos a la sección de programación.

Lógica detrás de la medición de velocidad con módulo sensor de velocidad LM393

Desde la configuración de montaje del sensor, debe tener en cuenta que el módulo del sensor de velocidad LM393 (H206) mide solo los espacios presentes en la placa de rejilla. Durante el montaje, debe asegurarse de que la rueda (cuya velocidad debe medirse) y la placa de rejilla giren a la misma velocidad. Como aquí, dado que hemos montado tanto la rueda como la placa en el mismo eje, ambas girarán obviamente con la misma velocidad.

En nuestra configuración hemos montado dos sensores para cada rueda para medir el ángulo del bot. Pero si su objetivo es medir solo la velocidad y la distancia, podemos montar el sensor en cualquier rueda. La salida del sensor (señales de disparo) se conectará más comúnmente a un pin de interrupción externo de un microcontrolador. Cada vez que se detecte un hueco en la placa de la rejilla, se activará una interrupción y se ejecutará el código en el ISR (Rutina de servicio de interrupción). Si somos capaces de calcular el intervalo de tiempo entre dos de estos disparadores, podemos calcular la velocidad de la rueda.

En Arduino podemos calcular fácilmente este intervalo de tiempo usando la función millis () . Esta función de milisegundos seguirá aumentando en 1 por cada milisegundo desde el momento de encender el dispositivo. Entonces, cuando ocurre la primera interrupción, podemos guardar el valor de millis () en una variable ficticia (como pevtime en este código) y luego, cuando ocurre la segunda interrupción, podemos calcular el tiempo necesario restando el valor de pevtime de los milis ().

Tiempo tomado = tiempo actual - tiempo anterior timetaken = millis () - pevtime ; // tiempo tomado en milisegundos

Una vez que hayamos calculado el tiempo necesario, podemos simplemente calcular el valor de rpm usando las fórmulas siguientes, donde (1000 / tiempo tomado) da el RPS (Revoluciones por segundo) y se multiplica por 60 para convertir RPS a RPM (Revoluciones por minuto).

rpm = (1000 / tiempo tomado) * 60;

Después de calcular las rpm, podemos calcular la velocidad del vehículo utilizando las fórmulas siguientes, siempre que sepamos el radio de la rueda.

Velocidad = 2π × RPS × radio de la rueda. v = radio_de_ rueda * rpm * 0,104

Tenga en cuenta que la fórmula anterior es para calcular la velocidad en m / s, si desea calcular en km / h, reemplace 0.0104 con 0.376. Si tiene curiosidad por saber cómo se obtuvo el valor 0.104, intente simplificar la fórmula V = 2π × RPS × radio de la rueda.

Se utiliza la misma técnica incluso si se utiliza un sensor de pasillo para medir la velocidad de un objeto en rotación. Pero para el sensor H206 hay un bloqueo, la placa de rejilla tiene 20 ranuras y, por lo tanto, para medir el tiempo entre dos espacios de ranura sobrecargará el microcontrolador. Por lo tanto, medimos la velocidad solo a una rotación completa de una rueda. Dado que se generarán dos interrupciones por cada espacio (una al inicio y otra al final del espacio) , obtendremos un total de 40 interrupciones para que la rueda haga una rotación completa. Así que esperamos 40 interrupciones antes de calcular realmente la velocidad de la rueda. El código para el mismo se muestra a continuación.

if (rotación> = 40) { timetaken = millis () - pevtime; // tiempo tomado en milisegundos rpm = (1000 / tiempo tomado) * 60; // fórmulas para calcular rpm pevtime = millis (); rotación = 0; }

Otro inconveniente de este método es que el valor de la velocidad no bajará a cero ya que la interrupción siempre estará esperando que la rueda complete una rotación para calcular el valor de rpm. Este inconveniente se puede superar fácilmente agregando un código simple que monitorea el intervalo de tiempo entre dos interrupciones y si excede lo normal, podemos forzar el valor de rpm y la velocidad a cero. Enlace en el siguiente código, hemos utilizado la variable dtime para verificar la diferencia de tiempo y si excede los 500 milisegundos, el valor de velocidad y rpm se fuerza a cero.

/ * Bajar a cero si el vehículo se detiene * / if (millis () - dtime> 500) // no se encontró una interrupción durante 500ms { rpm = v = 0; // hacer que las rpm y la velocidad sean cero dtime = millis (); }

Lógica detrás de medir la distancia recorrida por la rueda

Ya sabemos que el Arduino detectará 40 interrupciones cuando la rueda haga una rotación completa. Entonces, por cada rotación que hace la rueda, es evidente que la distancia recorrida por la rueda es igual a la circunferencia de la rueda. Como ya conocemos el radio de la rueda, podemos calcular fácilmente la distancia recorrida usando la siguiente fórmula

Distancia = 2πr * número de rotaciones distancia = (2 * 3.141 * radio_de_ rueda) * (left_intr / 40)

Donde la circunferencia de la rueda se calcula usando la fórmula 2πr y luego se multiplica por el número de rotaciones hechas por la rueda.

Lógica detrás de medir el ángulo del bot

Hay muchas formas de determinar el ángel del robot. Normalmente se utilizan acelerómetros y giroscopios para determinar estos valores. Pero otro enfoque económico es usar el sensor H206 en ambas ruedas. De esta forma sabríamos cuántas vueltas ha realizado cada rueda. La siguiente figura ilustra cómo se calcula el ángulo.

Cuando se inicializa el robot, el ángulo al que mira se considera de 0 °. Desde allí gira a la izquierda el ángulo se incrementa en negativo y si gira a la derecha el ángel se incrementa en positivo. Para entenderlo, consideremos el rango de -90 a +90 como se muestra en la figura. En tal disposición, dado que ambas ruedas tienen el mismo diámetro, si alguna de las ruedas hace una rotación completa, giramos en un ángulo de 90 °.

Por ejemplo, si la rueda izquierda hace una rotación completa (80 interrupciones), el bot girará 90 ° hacia la izquierda y, de manera similar, si la rueda derecha realiza una rotación completa (80 interrupciones), el bot girará -90 ° hacia la derecha. Ahora sabemos que si el Arduino detecta 80 interrupciones en una rueda, entonces el bot ha girado 90 ° y en función de qué rueda podemos saber si el bot ha girado positivo (derecha) o negativo (izquierda). Entonces, el ángulo izquierdo y derecho se puede calcular usando las fórmulas siguientes

int angle_left = (left_intr% 360) * (90/80); int ángulo_derecha = (derecho_intr% 360) * (90/80);

Donde 90 es el ángulo cubierto cuando se hace una interrupción de 80. El valor resultante es el número de interrupciones multiplicado. También hemos usado un módulo de 360 ​​para que el valor resultante nunca exceda 36. Una vez que hemos calculado tanto el ángulo derecho como el izquierdo, el ángulo efectivo al que se enfrenta el robot se puede obtener simplemente restando el ángulo izquierdo del ángulo derecho.

ángulo = ángulo_derecha - ángulo_izquierdo;

Código del robot Arduino

El código Arduino completo para este robot de medición de velocidad y ángulo se puede encontrar al final de esta página. El objetivo del programa es calcular la velocidad, la distancia y el ángulo del bot utilizando las lógicas anteriores y mostrarlo en la pantalla LCD. Aparte de eso, debería proporcionar una opción para controlar el bot usando el Joystick.

Comenzamos el programa definiendo los pines de E / S digitales para los dos motores. Tenga en cuenta que también tenemos que controlar la velocidad del motor y, por lo tanto, tenemos que usar los pines PWM en Arduino para controlar los motores. Aquí hemos utilizado los pines 8,9,10 y 11.

#define LM_pos 9 // motor izquierdo #define LM_neg 8 // motor izquierdo #define RM_pos 10 // motor derecho #define RM_neg 11 // motor derecho #define joyX A2 #define joyY A3

Para medir la velocidad y la distancia recorrida necesitamos conocer el radio de la rueda, medir el valor e ingresarlo en metros como se muestra a continuación. Para mi bot, el radio era de 0.033 metros, pero podría diferir según tu bot.

flotador radius_of_wheel = 0.033; // Mide el radio de tu rueda e introdúcelo aquí en cm

Dentro de la función de configuración , inicializamos todos los valores para que sean cero y luego mostramos un texto de introducción en la pantalla LCD. También hemos inicializado el monitor en serie con fines de depuración. Luego hemos mencionado que los sensores de velocidad H206 están conectados a los pines 2 y 3 como interrupciones externas. Ahí es donde siempre se detecta la interrupción, la función ISR Left_ISR y Right_ISR se ejecutarán en consecuencia.

configuración vacía () { rotación = rpm = pevtime = 0; // Inicializar todas las variables a cero Serial.begin (9600); lcd. comienzo (16, 2); // Inicializar 16 * 2 LCD lcd.print ("Bot Monitor"); // Mensaje de introducción, línea 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Retraso de la línea 2 del mensaje de introducción (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, SALIDA); pinMode (LM_neg, SALIDA); pinMode (RM_pos, SALIDA); pinMode (RM_neg, SALIDA); digitalWrite (LM_neg, BAJO); digitalWrite (RM_neg, BAJO); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Se llama a Left_ISR cuando se activa el sensor de la rueda izquierda attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Se llama a Right_ISR cuando se activa el sensor de la rueda derecha }

Dentro de la rutina Left_ISR, simplemente incrementamos una variable llamada left_intr que luego se usará para medir el ángulo del bot. Dentro del Right_ISR hacemos lo mismo, pero además también calculamos aquí la velocidad. La rotación variable se incrementa para cada interrupción y luego se usa la lógica anterior para calcular la velocidad.

anular ISR_izquierda () { entrada_izquierda ++; retardo (10); } void Right_ISR () { right_intr ++; retraso (10); rotación ++; dtime = millis (); if (rotación> = 40) { timetaken = millis () - pevtime; // tiempo tomado en milisegundos rpm = (1000 / tiempo tomado) * 60; // fórmulas para calcular rpm pevtime = millis (); rotación = 0; } }

Dentro de la función principal de bucle infinito monitoreamos los valores de X e Y desde el joystick. En función del valor si se mueve el joystick, controlamos el bot en consecuencia. La velocidad del bot depende de cuánto se empuje el joystick.

int xValue = analogRead (joyX); int yValue = analogRead (joyY); int aceleración = mapa (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, aceleración); analogWrite (RM_pos, aceleración); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);

Esto ayudará al usuario a mover el bot y comprobar si los valores obtenidos son los esperados. Finalmente, podemos calcular la velocidad, la distancia y el ángulo del bot usando las lógicas anteriores y mostrarlo en la pantalla LCD usando el siguiente código.

v = radio_de_ rueda * rpm * 0.104; //0.033 es el radio de la rueda en metros de distancia = (2 * 3.141 * radius_of_wheel) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int ángulo_derecho = (derecho_intr% 360) * (90/80); ángulo = ángulo_derecha - ángulo_izquierdo; 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 (distancia); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (ángulo);

Prueba del robot Arduino para medir la distancia, la velocidad y el ángulo

Una vez que su hardware esté listo, cargue el código en su Arduino y use el joystick para mover su bot. la velocidad del bot, la distancia recorrida por él y el ángulo se mostrarán en la pantalla LCD como se muestra a continuación.

En la pantalla LCD, los términos Lt y Rt representan el recuento de interrupciones izquierda y el recuento de interrupciones derecha respectivamente. Puede encontrar que estos valores se incrementan por cada espacio detectado por el sensor. El ítem S indica la Velocidad del bot en m / seg y el término D indica la Distancia recorrida en metros. El ángulo del bot se muestra al final donde 0 ° es recto y se vuelve negativo para la rotación en sentido antihorario y positivo para la rotación en sentido horario.

También puede ver el video al final de esta página para comprender cómo funciona el bot. Espero que haya entendido el proyecto y haya disfrutado construyéndolo. Si tiene alguna inquietud, déjela en la sección de comentarios y haré todo lo posible para responderle. También puede utilizar foros para obtener ayuda técnica rápida.