Coche robot controlado con guante flexo resistivo

Contenido:

• Materiales necesarios
• Introducción
• Sensores flexo resistivos: La clave de la interacción
• Circuito
• Programación de nuestro robot
• Simulación
• Usos en el mundo real
• Conclusión

Materiales necesarios:

• Arduino UNO
• 3 Sensores flexo resistivos
• 3 Resistencias 25K
• 2 Puente H L293D
• 4 Motorreductores

Introducción:

Hoy queremos compartir con ustedes un emocionante proyecto que hemos llevado a cabo utilizando la potencia de Arduino y la versatilidad de Tinkercad. En esta ocasión, hemos creado un coche robot controlado de manera innovadora: ¡con un guante flexo resistivo!

La robótica es un campo que continúa evolucionando rápidamente, y en nuestro afán por explorar nuevas formas de interactuar con las máquinas, nos hemos aventurado en el desarrollo de este fascinante proyecto. El objetivo principal era construir un coche robot que pudiera ser controlado de una manera más intuitiva y natural, y qué mejor manera de lograrlo que utilizando un guante flexo resistivo.

Con ayuda de Arduino, una plataforma de código abierto ampliamente utilizada para la creación de proyectos electrónicos, y Tinkercad, una herramienta de diseño en línea que nos permite simular y prototipar nuestros circuitos, hemos dado vida a este emocionante coche robot controlado por los movimientos de nuestra mano.

A lo largo de esta entrada de blog, te llevaremos paso a paso a través del proceso de construcción y programación de nuestro coche robot. Exploraremos los componentes necesarios, las conexiones eléctricas, el código que controla el sistema y, por supuesto, ¡los resultados y las posibilidades futuras de este innovador proyecto!

¡Así que ponte cómodo y prepárate para adentrarte en el fascinante mundo de la robótica y la interacción humano-máquina!

Sensores flexo resistivos: La clave de la interacción:

Uno de los elementos fundamentales en nuestro proyecto de coche robot controlado con un guante flexo resistivo son los sensores flexo resistivos. Estos sensores desempeñan un papel crucial al permitirnos capturar y traducir los movimientos de nuestra mano en comandos que el coche robot puede entender.

Los sensores flexo resistivos, también conocidos como sensores de flexión o sensores de fuerza, son dispositivos electrónicos que cambian su resistencia eléctrica en respuesta a la flexión o deformación mecánica. Cada sensor flexo resistivo está compuesto por una tira de material conductor con propiedades elásticas y resistivas. Cuando se aplica una fuerza o se produce una flexión en el sensor, la distancia entre las partículas conductoras se modifica, lo que a su vez altera la resistencia eléctrica del sensor. Este cambio en la resistencia se convierte en una señal eléctrica que podemos medir y utilizar para controlar el coche robot.

Para asegurarte de capturar con precisión los movimientos de la mano, debes colocar 3 sensores flexoresistivos en el guante, uno para el dedo indice, otro para el dedo medio y por ultimo uno para el dedo anular. De esta manera al doblar cada uno de los dedos tendrás diferentes combinaciones, combinaciones que nos permitirán manipular nuestro robot.

Circuito:

Utilizando los materiales descritos al inicio de esta entrada, debemos conectar cuidadosamente el siguiente circuito:

Una vez ensamblado y verificado nuestro circuito, solo resta realizar la programación necesaria para darle vida a nuestro proyecto.

Programación de nuestro robot:

Comencemos especificando la funcionalidad del mismo, en este caso como estamos utilizando 3 sensores flexo resistivos vamos a darle al robot 8 casos distintos de funcionamiento, esto tomando en cuenta un código binario de 3 bits(porque son 3 sensores). Como ya pudiste darte cuenta, no vamos a utilizar cada uno de los niveles de flexión de cada sensor, sino que vamos a definir un umbral a rebasar para que la respuesta de salida de cada sensor sea un 0 o un 1. Por aquí te dejo el código binario de 3 bits que representará cada caso posible para el robot, en esta ocasión tomaremos el 0 como el dedo sin flexionar y el 1 como el dedo flexionado. por lo tanto el caso 2 sucedería solo cuando el único dedo flexionado sea el dedo medio.

Una vez definida esta parte, ahora si podemos comenzar a programar nuestro robot, comencemos por la definición de las constantes que almacenarán la posición de los pines de salida que irán conectados a nuestros Puentes H.

//Motor 1
const int motor1A1  = 3;  // Pin 14 de L293
const int motor1A2  = 2;  // Pin 10 de L293
//Motor 2
const int motor2B3  = 6; // Pin  7 de L293
const int motor2B4  = 4;  // Pin  2 de L293


//Motor 3
const int motor3A1  = 7;  // Pin 14 de L293
const int motor3A2  = 8;  // Pin 10 de L293
//Motor 4
const int motor4B3  = 13; // Pin  7 de L293
const int motor4B4  = 12;  // Pin  2 de L293

const int motorPin1 = 5; // Pin del motor
const int motorPin2 = 9; // Pin del motor
const int motorPin3 = 10; // Pin del motor
const int motorPin4 = 11; // Pin del motor

Ahora debemos definir el ciclo de trabajo al cual estarán operando los motores, esto si gustas lo puedes ver como la velocidad a la cual van a estar girando los motores, que aunque claramente no es lo mismo, para este ejemplo el ciclo de trabajo repercute en la velocidad angular de los motores.

const int motorSpeed = 100;

Excelente, ya hemos superado la parte inicial, ahora toca el turno de definir el comportamiento que deberán adoptar los pines del microcontrolador, que como lo mencionábamos anteriormente, deberán de comportarse como salidas. Para esto utilizaremos pinMode(). Además vamos a inicializar nuestra comunicación serial para visualizar en el monitor la dirección que está tomando nuestro robot. Todo esto lo realizamos dentro del void setup().

void setup() {
  Serial.begin(9600);
  pinMode(motor1A1, OUTPUT);
  pinMode(motor1A2, OUTPUT);
  pinMode(motor2B3, OUTPUT);
  pinMode(motor2B4, OUTPUT);
  pinMode(motor3A1, OUTPUT);
  pinMode(motor3A2, OUTPUT);
  pinMode(motor4B3, OUTPUT);
  pinMode(motor4B4, OUTPUT);
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

La siguiente sección es la del void loop(), en la cual colocaremos todo lo que queremos que el microcontrolador realice y repita una y otra vez. Por lo tanto en esta sección colocaremos la lectura analógica de los sensores flexo resistivos.

void loop() {
  int sensor1 = analogRead(A0);
  int sensor2 = analogRead(A1);
  int sensor3 = analogRead(A2);

Y como mencionábamos también anteriormente, el comportamiento de nuestros dedos sobre los sensores lo interpretaríamos como un código binario de 3 bits que posteriormente convertiríamos a decimal para poder ejecutar cada uno de los casos definidos con anterioridad. Para esto realizaremos el siguiente bloque de código.

  int code = 0;
  bitWrite(code, 0, sensor1 < 300);
  bitWrite(code, 1, sensor2 < 300); 
  bitWrite(code, 2, sensor3 < 300);

Lo que está sucediendo es que bitWrite() nos permite escribir un bit en una variable numérica, en este caso estamos escribiendo en el bit 0, 1 y 2 de la variable numérica code, y el valor que estamos escribiendo está dado por la condicional de que la lectura de cada uno de los sensores sea menor a 300, es decir que si la lectura es menor a 300, entonces se considerará como un 1, continuemos.

Ahora es momento de pasar a la definición de los casos que obedecerán al valor decimal formado por la combinación de los sensores, dicha estructura de casos quedará de la siguiente manera, siempre respetando el funcionamiento de los puentes H.

switch (code) {
    case 0:
		motores(LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW);
      	Serial.println("detenido");
    	break;
    case 1:
        motores(HIGH, LOW, HIGH, LOW, HIGH, LOW, HIGH, LOW);
        Serial.println("adelante");
    	break;
    case 2:
        motores(LOW, HIGH, LOW, HIGH, LOW, HIGH, LOW, HIGH);
        Serial.println("atras");
        break;
    case 3:
        motores(HIGH, LOW, LOW, LOW, HIGH, LOW, LOW, LOW);
        Serial.println("derecha adelante");
        break;
    case 4:
        motores(LOW, LOW, HIGH, LOW, LOW, LOW, HIGH, LOW);
        Serial.println("izquierda adelante");
        break;
    case 5:
        motores(LOW, HIGH, LOW, LOW, LOW, HIGH, LOW, LOW);
        Serial.println("derecha atras");
        break;
    case 6:
        motores(LOW, LOW, LOW, HIGH, LOW, LOW, LOW, HIGH);
        Serial.println("izquierda atras");
        break;
    case 7:
        motores(HIGH, LOW, LOW, HIGH, HIGH, LOW, LOW, HIGH);
        Serial.println("giro 360");
        break;
    default:
    Serial.println("No vale ninguna de los valores anteriores");
  }
}

Ahora solo resta crear la función que recibe los datos que controlan el sentido de giro de los motores, quedándonos la función de la siguiente forma

void motores(bool m1A1, bool m1A2, bool m1B1, bool m1B2, bool m2A1, bool m2A2, bool m2B1, bool m2B2){
      analogWrite(motorPin1, motorSpeed);
      analogWrite(motorPin2, motorSpeed);
      analogWrite(motorPin3, motorSpeed);
      analogWrite(motorPin4, motorSpeed);    
      digitalWrite(motor1A1, m1A1);
      digitalWrite(motor1A2, m1A2); 
      digitalWrite(motor2B3, m1B1);
      digitalWrite(motor2B4, m1B2);
      digitalWrite(motor3A1, m2A1);
      digitalWrite(motor3A2, m2A2); 
      digitalWrite(motor4B3, m2B1);
      digitalWrite(motor4B4, m2B2);

}

Y listo, tenemos funcional nuestro coche robot controlado por un guante flexo resistivo, ahora te toca probar e implementar este proyecto de la forma que más te llame la atención.

Simulación:

Usos en el mundo real:

La robótica tele-operada ha jugado un papel vital dentro de diversas áreas, dentro de las cuales podemos destacar seguridad, manipulación de objetos peligrosos o radioactivos. Como ejemplo de ello podemos poner al robot Joker, un robot policial que era controlado a distancia, y que su principal funcionalidad era la desactivación de bombas. Este robot fue prestado por Alemania para ayudar a limpiar el material radioactivo de la central nuclear de Chernobyl. tarea que resultaba demasiado peligrosa para los humanos y que además terminó con la vida útil del robot.

Conclusión:

Si bien este desarrollo implemento en Arduino es algo sencillo y no seguro para actividades a gran escala, puede ser visto como el prototipo de un proyecto aun más grande, recordemos que la lógica de funcionamiento ya se tiene, solo es cuestión de mejorar el hardware y un poco de software para brindarle la estabilidad requerida para tareas mayores. Sin duda es impresionante la facilidad con la que en estos tiempos podemos obtener conocimiento valioso, y que además este conocimiento puede ser adaptado y mejorado para la realización de proyectos aun más grandes y con mayor utilidad. Me despido pero no sin antes recomendarte investigar sobre motorreductores, encoders y puentes H de mayor potencia.

Si este proyecto te gustó te recomiendo suscribirte a nuestro Newsletter para que estés enterado de todas la entradas siguientes.