Robot de autoequilibrio de bricolaje usando arduino

Después de inspirarme en los motores RYNO y otros scooters autoequilibrados de Segway, siempre quise construir algo, mi propio Arduino Segway Robot. Pensando por un tiempo, decidí construir un robot autoequilibrante usando Arduino. De esta manera, podría comprender el concepto subyacente detrás de todos estos scooters y también aprender cómo funciona el algoritmo PID.

Una vez que comencé a construir, me di cuenta de que construir este bot es un desafío. Hay tantas opciones para seleccionar y, por lo tanto, las confusiones comienzan desde la selección de los motores y permanecen hasta ajustar los valores PID. Y hay tantas cosas a considerar como el tipo de batería, la posición de la batería, el agarre de la rueda, el tipo de controlador del motor, el mantenimiento del CoG (centro de gravedad) y mucho más.

Pero déjame decírtelo, una vez que lo construyas, estarás de acuerdo en que no es tan difícil como parece. Así que seamos realistas, en este tutorial documentaré mi experiencia en la construcción del robot autoequilibrante. Es posible que seas un principiante absoluto que recién está comenzando o que hayas llegado aquí después de una larga frustración por no hacer que tu bot funcione. Este lugar pretende ser su destino final. Entonces empecemos……

Selección de las piezas para el robot autoequilibrante

Antes de contarles todas las opciones para construir el bot, permítanme enumerar los elementos que he usado en este proyecto de robot autoequilibrado.

Arduino UNO
Motores DC con engranajes (color amarillo) - 2Nos
Módulo controlador de motor L298N
MPU6050
Un par de ruedas
Batería de iones de litio de 7,4 V
Cables de conexión
Cuerpo impreso en 3D

Puede mezclar y elegir cualquiera de los componentes anteriores según la disponibilidad para hacer su propio kit de robot autoequilibrado, solo asegúrese de que los componentes cumplan con los siguientes criterios.

Controlador: El controlador que he usado aquí es Arduino UNO, porque es simplemente fácil de usar. También puede usar un Arduino Nano o Arduino mini, pero le recomendaría que se quede con UNO ya que podemos programarlo directamente sin ningún hardware externo.

Motores: La mejor elección de motor que puedes utilizar para un robot autoequilibrante, sin duda será el motor paso a paso. Pero para simplificar las cosas, he usado un motor de engranajes de CC. Sí, no es obligatorio tener un stepper; el bot también funciona bien con estos motores de engranajes de CC baratos de color amarillo comúnmente disponibles.

Controlador de motor: si ha seleccionado motores de engranajes de CC como el mío, puede usar el módulo de controlador L298N como yo, o incluso un L293D debería funcionar bien. Obtenga más información sobre cómo controlar el motor de CC con L293D y Arduino.

Ruedas: No subestimes a estos tipos; Me costó mucho entender que el problema estaba en mis ruedas. Por lo tanto, asegúrese de que sus ruedas tengan un buen agarre sobre el piso que está utilizando. Mire de cerca, su agarre nunca debe permitir que sus ruedas patinen en el piso.

Acelerómetro y giroscopio: la mejor opción de acelerómetro y giroscopio para su bot será el MPU6050. Así que no intente construir uno con un acelerómetro normal como ADXL345 o algo así, simplemente no funcionará. Sabrá por qué al final de este artículo. También puede consultar nuestro artículo dedicado al uso de MPU6050 con Arduino.

Batería: Necesitamos una batería que sea lo más liviana posible y el voltaje de funcionamiento debe ser superior a 5V para que podamos alimentar nuestro Arduino directamente sin un módulo boost. Por tanto, la elección ideal será una batería de polímero de litio de 7,4 V. Aquí, como tenía una batería de iones de litio de 7,4 V disponible, la he usado. Pero recuerde que un Li-po es más ventajoso que un Li-ion.

Chasis: otro lugar donde no debe comprometerse es con el chasis de sus bots. Puedes usar cartón, madera, plástico, cualquier cosa con la que seas bueno. Pero, solo asegúrese de que el chasis sea resistente y no se mueva cuando el robot está tratando de equilibrarse. He diseñado por propio chasis en Solidworks infiriendo de los otros bots y lo he impreso en 3D. Si tiene una impresora, también puede imprimir el diseño, los archivos de diseño se adjuntarán en el siguiente encabezado.

Impresión 3D y montaje de nuestro robot autoequilibrante

Si ha decidido imprimir en 3D el mismo chasis que estoy usando para construir mi bot, entonces los archivos STL se pueden descargar de thingiverse. También he agregado los archivos de diseño junto con él para que también pueda modificarlo según las preferencias de su personal.

Las piezas no tienen estructuras que sobresalgan, por lo que puede imprimirlas fácilmente sin ningún soporte y un relleno del 25% funcionará bien. Los diseños son bastante sencillos y cualquier impresora básica debería poder manejarlos con facilidad. Usé el software Cura para cortar el modelo e imprimí usando mi Tevo Tarantula, la configuración se muestra a continuación.

Tendría que imprimir la parte del cuerpo y las cuatro partes de montaje del motor. El montaje es bastante sencillo; use tuercas y pernos de 3 mm para asegurar el motor y las placas en su lugar. Después de ensamblarlo, debería verse como se muestra en la imagen de abajo.

El diseño real se planificó con el módulo de unidad L298N en el bastidor inferior, el Arduino y la batería encima, como se muestra arriba. Si está siguiendo el mismo orden, puede atornillar directamente la placa a través de los orificios provistos y usar una etiqueta de alambre para la batería Li-po. Esta disposición también debería funcionar, a excepción de las ruedas súper planas que tuve que cambiar más tarde.

En mi bot cambié la posición de la batería y la placa Arduino UNO para facilitar la programación y también tuve que introducir una placa perf para completar las conexiones. Entonces mi bot no se ve como lo planeé en la etapa inicial. Después de completar las pruebas de programación de cableado y todo, mi robot de dos ruedas finalmente se ve así

Diagrama de circuito

Hacer las conexiones para este robot de equilibrio automático basado en Arduino es bastante simple. Este es un robot autoequilibrado que usa Arduino y MPU6050, por lo que debemos conectar el MPU6050 con Arduino y conectar los motores a través del módulo del controlador del motor. Toda la configuración funciona con la batería de iones de litio de 7,4 V. El diagrama de circuito para el mismo se muestra a continuación.

El módulo de controlador de motor Arduino y L298N se alimenta directamente a través del pin Vin y el terminal de 12V respectivamente. El regulador integrado en la placa Arduino convertirá la entrada de 7,4 V a 5 V y el ATmega IC y el MPU6050 serán alimentados por él. Los motores de CC pueden funcionar con un voltaje de 5 V a 12 V. Pero conectaremos el cable positivo de 7,4 V de la batería al terminal de entrada de 12 V del módulo del controlador del motor. Esto hará que los motores funcionen con 7,4 V. La siguiente tabla enumerará cómo el módulo de controlador de motor MPU6050 y L298N está conectado con Arduino.

Pin de componente	Pin de Arduino
MPU6050
Vcc	+ 5V
Suelo	Gnd
SCL	A5
SDA	A4
EN T	D2
L298N
EN 1	D6
EN 2	D9
EN 3	D10
IN4	D11

El MPU6050 se comunica con Arduino a través de la interfaz I2C, por lo que usamos los pines SPI A4 y A5 de Arduino. Los motores de CC están conectados a los pines PWM D6, D9 D10 y D11 respectivamente. Necesitamos conectarlos a los pines PWM porque controlaremos la velocidad del motor de CC al variar el ciclo de trabajo de las señales PWM. Si no está familiarizado con estos dos componentes, se recomienda leer el tutorial sobre la interfaz MPU6050 y el controlador de motor L298N.

Código de robot autoequilibrado

Ahora tenemos que programar nuestra placa Arduino UNO para equilibrar el robot. Aquí es donde ocurre toda la magia; el concepto detrás de esto es simple. Tenemos que comprobar si el bot está inclinado hacia adelante o hacia atrás usando el MPU6050 y luego si está inclinado hacia adelante tenemos que rotar las ruedas hacia adelante y si está inclinado hacia atrás tenemos que rotar las ruedas en la dirección contraria.

Al mismo tiempo también tenemos que controlar la velocidad a la que giran las ruedas, si el bot está ligeramente desorientado desde la posición central las ruedas giran lentamente y la velocidad aumenta a medida que se aleja más de la posición central. Para lograr esta lógica utilizamos el algoritmo PID, que tiene la posición central como punto de ajuste y el nivel de desorientación como salida.

Para conocer la posición actual del bot usamos el MPU6050, que es un acelerómetro de 6 ejes y un sensor de giroscopio combinados. Para obtener un valor confiable de posición del sensor, necesitamos usar el valor del acelerómetro y el giroscopio, porque los valores del acelerómetro tienen problemas de ruido y los valores del giroscopio tienden a variar con el tiempo. Así que tenemos que combinar ambos y obtener el valor de cabeceo y balanceo de guiñada de nuestro robot, del cual utilizaremos solo el valor de guiñada.

Suena un poco la cabeza dando vueltas, ¿verdad? Pero no se preocupe, gracias a la comunidad Arduino tenemos bibliotecas fácilmente disponibles que pueden realizar el cálculo de PID y también obtener el valor de guiñada del MPU6050. La biblioteca está desarrollada por br3ttb y jrowberg respectivamente. Antes de continuar, descargue sus bibliotecas desde el siguiente enlace y agréguelas a su directorio de bibliotecas de Arduino.

github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h

github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Ahora que tenemos las bibliotecas agregadas a nuestro IDE de Arduino. Comencemos a programar para nuestro robot autoequilibrante. Como siempre, el código completo para el robot equilibrador MPU6050 se proporciona al final de esta página, aquí solo estoy explicando los fragmentos más importantes del código. Como se dijo anteriormente, el código se basa en el código de ejemplo MPU6050, solo vamos a optimizar el código para nuestro propósito y agregar el PID y la técnica de control para nuestro robot de autoequilibrio.

Primero incluimos las bibliotecas necesarias para que este programa funcione. Incluyen la biblioteca I2C incorporada, la biblioteca PID y la biblioteca MPU6050 que acabamos de descargar.

#include "I2Cdev.h" #include // De #include "MPU6050_6Axis_MotionApps20.h" //https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Luego declaramos las variables que se requieren para obtener los datos del sensor MPU6050. Leemos tanto el vector de gravedad como los valores de cuaternión y luego calculamos el valor de cabeceo y balanceo de guiñada del bot. La matriz flotante ypr contendrá el resultado final.

// control MPU / estado vars bool dmpReady = false; // establecer verdadero si DMP init fue exitoso uint8_t mpuIntStatus; // contiene el byte de estado de interrupción actual de MPU uint8_t devStatus; // devuelve el estado después de cada operación del dispositivo (0 = éxito ,! 0 = error) uint16_t packetSize; // tamaño esperado del paquete DMP (el valor predeterminado es 42 bytes) uint16_t FIFoCount; // recuento de todos los bytes actualmente en FIFO uint8_t FIFOBuffer; // Búfer de almacenamiento FIFO // orientación / movimiento vars Quaternion q; // contenedor de cuaterniones VectorFloat gravity; // vector de gravedad float ypr; // contenedor de guiñada / cabeceo / balanceo y vector de gravedad

Luego viene el segmento muy importante del código, y aquí es donde pasará mucho tiempo ajustando el conjunto correcto de valores. Si su robot está construido con un muy buen centro de gravedad y los componentes están dispuestos simétricamente (lo que en la mayoría de los casos no lo está), entonces el valor de su punto de ajuste será 180. De lo contrario, conecte su bot al monitor serial Arduino e inclínelo hasta encuentra una buena posición de equilibrio, lea el valor que se muestra en el monitor de serie y este es su valor de punto de ajuste. El valor de Kp, Kd y Ki debe ajustarse de acuerdo con su bot. No hay dos bots idénticos que tengan los mismos valores de Kp, Kd y Ki, por lo que no hay forma de escapar de ellos. Vea el video al final de esta página para tener una idea de cómo ajustar estos valores.

/ ********* Ajuste estos 4 valores para su BOT ********* / punto de ajuste doble = 176; // establece el valor cuando el bot está perpendicular al suelo usando un monitor serial. // Lea la documentación del proyecto en circuitdigest.com para aprender cómo configurar estos valores double Kp = 21; // Establecer este primer doble Kd = 0.8; // Establecer este segundo doble Ki = 140; // Finalmente configure esto / ****** Configuración de fin de valores ********* /

En la siguiente línea inicializamos el algoritmo PID pasando las variables de entrada input, output, set point, Kp, Ki y Kd. De estos, ya hemos establecido los valores de punto de ajuste Kp, Ki y Kd en el fragmento de código anterior. El valor de entrada será el valor actual de guiñada que se lee desde el sensor MPU6050 y el valor de salida será el valor calculado por el algoritmo PID. Entonces, básicamente, el algoritmo PID nos dará un valor de salida que debe usarse para corregir el valor de entrada para que esté cerca del punto de ajuste.

PID pid (& entrada, & salida, & setpoint, Kp, Ki, Kd, DIRECT);

Dentro de la función de configuración vacía inicializamos el MPU6050 configurando el DMP (Procesador de movimiento digital). Esto nos ayudará a combinar los datos del acelerómetro con los datos del giroscopio y proporcionará un valor confiable de Yaw, Pitch and Roll. No profundizaremos mucho en esto ya que irá mucho más allá del tema. De todos modos, un segmento de código que debe buscar en la función de configuración son los valores de compensación del giro. Cada sensor MPU6050 tiene sus propios valores de compensaciones. Puede usar este boceto de Arduino para calcular el valor de compensación de su sensor y actualizar las siguientes líneas en consecuencia en su programa.

// proporcione aquí sus propias compensaciones giroscópicas, escaladas para sensibilidad mínima mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

También tenemos que inicializar los pines PWM digitales que estamos usando para conectar nuestros motores. En nuestro caso es D6, D9, D10 y D11. Así que inicializamos estos pines como pines de salida, los hacemos BAJOS por defecto.

// Inicializar los pines de salida del motor pinMode (6, OUTPUT); pinMode (9, SALIDA); pinMode (10, SALIDA); pinMode (11, SALIDA); // Por defecto apague ambos motores analogWrite (6, LOW); analogWrite (9, BAJO); analogWrite (10, BAJO); analogWrite (11, BAJO);

Dentro de la función de bucle principal comprobamos si los datos del MPU6050 están listos para ser leídos . Si es así, lo usamos para calcular el valor PID y luego mostramos el valor de entrada y salida de PID en el monitor en serie solo para verificar cómo responde el PID. Luego, basándonos en el valor de la salida, decidimos si el bot debe avanzar, retroceder o quedarse quieto.

Dado que asumimos que el MPU6050 devolverá 180 cuando el bot esté en posición vertical. Obtendremos valores de corrección positivos cuando el bot esté cayendo hacia adelante y obtendremos valores negativos si el bot está cayendo hacia atrás. Por lo tanto, verificamos esta condición y llamamos a las funciones apropiadas para mover el bot hacia adelante o hacia atrás.

while (! mpuInterrupt && FIFoCount <packetSize) { // sin datos de mpu - realizando cálculos PID y salida a motores pid.Compute (); // Imprime el valor de Entrada y Salida en el monitor serial para comprobar cómo está funcionando. Serial.print (entrada); Serial.print ("=>"); Serial.println (salida); if (input> 150 && input <200) {// Si el Bot está cayendo if (output> 0) // Cayendo hacia el frente Forward (); // Gire las ruedas hacia adelante else if (salida <0) // Cayendo hacia atrás Reverse (); // Gira las ruedas hacia atrás } else // Si el Bot no cae Stop (); // Mantenga las ruedas quietas }

La variable de salida PID también decide qué tan rápido se debe girar el motor. Si el bot está a punto de caer, hacemos una pequeña corrección girando la rueda lentamente. Si estas pequeñas correcciones no funcionan y aún así el bot se está cayendo, aumentamos la velocidad del motor. El valor de la rapidez con que giran las ruedas lo decidirá el algoritmo PI. Tenga en cuenta que para la función Reverse hemos multiplicado el valor de salida por -1 para que podamos convertir el valor negativo en positivo.

void Forward () // Código para rotar la rueda hacia adelante { analogWrite (6, salida); analogWrite (9,0); analogWrite (10, salida); analogWrite (11,0); Serial.print ("F"); // Información de depuración } void Reverse () // Código para rotar la rueda hacia atrás { analogWrite (6,0); analogWrite (9, salida * -1); analogWrite (10,0); analogWrite (11, salida * -1); Serial.print ("R"); } void Stop () // Código para detener ambas ruedas { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }

Funcionamiento del robot autoequilibrante Arduino

Una vez que esté listo con el hardware, puede cargar el código en su placa Arduino. Asegúrese de que las conexiones sean correctas, ya que estamos usando una batería de iones de litio. Se necesita extrema precaución. Por lo tanto, verifique dos veces si hay cortocircuitos y asegúrese de que los terminales no entren en contacto incluso si su bot experimenta algunos pequeños impactos. Encienda su módulo y abra su monitor serial, si su Arduino pudo comunicarse con el MPU6050 exitosamente y si todo está funcionando como se esperaba, debería ver la siguiente pantalla.

Aquí vemos los valores de entrada y salida del algoritmo PID en el formato entrada => salida . Si el bot está perfectamente equilibrado, el valor de salida será 0. El valor de entrada es el valor actual del sensor MPU6050. El alfabeto "F" representa que el bot se mueve hacia adelante y "R" representa que el bot en reversa.

Durante las etapas iniciales de PID, recomiendo dejar su cable Arduino conectado al bot para que pueda monitorear fácilmente los valores de entrada y salida y también será fácil de corregir y cargar su programa para los valores de Kp, Ki y Kd. El siguiente video muestra el funcionamiento completo del bot y también muestra cómo corregir sus valores PID.

Espero que esto le ayude a construir su propio robot autoequilibrado si tiene algún problema para que funcione, luego deje sus preguntas en la sección de comentarios a continuación o use los foros para preguntas más técnicas. Si quieres más diversión, también puedes usar la misma lógica para construir un robot de equilibrio de bolas.