Consiste en una mano artificial controlada por un guante con sensores flexibles. La mano artificial reproduce los movimientos de la mano con el guante de control, de forma inalámbrica. La mano y el guante funcionan tanto con Arduino.
Materiales necesarios
- Arduino UNO y Genuino UNO
- Placa principal Arduino LilyPad
- XBee S1 (antena de rastreo)
- Escudo SparkFun XBee
- SparkFun Xbee Shield para Lilypad
- SparkFun LilyPad FTDI Basic Breakout – 5V
- Sensor Flex 2.2 «
- Resistencia de 47 kOhm
- Pila AAA
- Soporte de batería 3xAAA
- Batería de 9V (NiMh recargable)
- Escudo de robot
- Servomotor de 5V
Hacer el guante
Para hacer el guante de control, sugiero que primero elija la posición correcta de los diferentes componentes, luego conecte todo con la longitud de cable adecuada.
Para hacer una lectura analógica con Arduino LilyPad, debe hacer un divisor de voltaje, ya que los sensores flexibles no funcionan como potenciómetros (solo tienen 2 contactos).
Entonces, siguiendo el esquema, primero suelde la resistencia de 5 en la placa LilyPad, un lado a los 5 pines analógicos diferentes, el otro en común a la tierra. Luego suelde los sensores flexibles, un lado a los 5 pines analógicos diferentes y el otro en común al positivo.
Luego conecte el XBee Shield: dos cables para la alimentación, los otros dos para la señal. Suelde el pin Tx al Rx y viceversa.
Ahora necesita la batería y el guante está listo.
TENGA CUIDADO: no encienda el Arduino LilyPad a más de 5.5 V y no lo encienda a la inversa (incluso si a veces lo hice por error … ¡Y aún funciona!)
Hacer la mano robótica
Esta es la parte más complicada, porque tiene que elegir los materiales adecuados para hacer la mano, pero también puede ser fácil si tiene la posibilidad de imprimir en 3D la mano (hay muchos proyectos 3D diferentes en la web para imprimir partes de la mano )
Comencé a hacer los dedos con corcho, para encontrar la estructura adecuada para los movimientos, luego lo hice con una rama.
Entonces, haga tres cilindros de madera por dedo, dos de ellos con 1 cm sobre la longitud normal de su falange, necesarios para encajar una pieza en otra.
Luego, con una amoladora angular, haga las ranuras para que las piezas encajen entre sí (vea las imágenes, lo entenderá mejor).
Necesitarás un poco de papel de lija para hacer que las piezas se curven, para que puedan rotar.
Use un taladro para hacer los agujeros para la bisagra, luego debe hacer otros dos agujeros para el cable de pesca, verticalmente, uno hacia el interior de la mano y otro hacia afuera. Entonces, cuando los cables se colocan en la parte superior del dedo, cuando jalas el uno hacia adentro, el dedo se cerrará, y cuando jalas el dedo hacia afuera, el dedo se abrirá.
La palma era problemática, porque lo hice inicialmente con madera y las partes más delgadas siempre se rompían. Así que decidí hacerlo de acero y no tuve problemas.
Córtalo y haz algunas protuberancias similares a las hechas con los dedos para fijarlas a la palma (mira las imágenes como referencia). Luego use el taladro para hacer los otros agujeros para el cable de pesca, el pulgar será complicado porque no es vertical como los otros dedos.
Después de hacer la mano, debe hacer un soporte para los cinco servomotores y un soporte para las placas Arduino UNO. Asegúrese de elegir la posición correcta de los servos, para que no se toquen mientras giran.
La última parte consiste en conectar los dedos a los servomotores: fije los cables de pesca en la parte superior del dedo y haga que pasen por los agujeros; luego, cuando los cables estén en la parte inferior de la mano, gire el rotor (manualmente, sin alimentarlo) en su rotación máxima (180 °) para que quede en posición vertical, luego coloque el cable que cierra el dedo al nivel más bajo agujero del rotor, por ejemplo haciendo un nudo; gire nuevamente el rotor a 0 ° (nuevamente está vertical y el nudo hecho antes está en la parte superior) y luego coloque el otro cable (que abre el dedo) en el orificio más bajo del rotor. Siga la última imagen en este paso para comprender mejor.
Entonces, cuando el motor está a 0 ° (vertical), el dedo se abre y cuando el rotor está a 180 ° (vertical nuevamente), el dedo se cierra.
Circuito de la mano robótica
Para el circuito, puede optar por usar un escudo de servomotor para Arduino UNO con un escudo XBee, o hacer un escudo personalizado (lo haré lo antes posible) con el Módulo XBee y los pines para los servomotores, y alimente el Arduino UNO por su puerto jack.
El DIY XBee Shield que hice utiliza una resistencia de 12 KOhm y una resistencia de 22 KOhm, puedes ver el cableado en las imágenes.
Así que usé lo que ya había comprado antes, pero puedes usar todo lo que te permite controlar los servomotores y el XBee.
Los servomotores tienen 3 cables:
- amarillo: señal (conectar a un pin digital);
- rojo: potencia (+5 V);
- marrón: tierra (GND).
Así que ahora no cometerás errores 🙂
Utilicé el tipo más simple de servomotor, trabajando a 5 V, con un ángulo de rotación de 180 grados (ese es el ángulo perfecto, no necesitamos más).
Los puertos USB de una computadora no pueden proporcionar suficiente energía para controlar 5 servomotores, por lo que sugiero usar una fuente de alimentación de 12V para probar todo y luego usar la batería de 9V (se prefieren las alcalinas).
CÓDIGO
/
// Variables de los valores cuando la mano está completamente abierta
int OpenedIndex = 0 ; // Esto es necesario para una calibración continua
int OpenedMiddle = 0 ;
int OpenedAnnular = 0 ;
int OpenPinky = 0 ;
int ClosedThumb ; // Variables de los valores cuando la mano está completamente cerrada int ClosedIndex ; // No podemos establecerlo en cero ya que el valor mínimo alcanzó int ClosedMiddle ; // en la lectura analógica nunca llega a cero. Asignaremos el valor de
int ClosedAnnular ; // una primera lectura analógica, luego el programa en el ciclo
int ClosedPinky ; // automáticamente asignando valores más bajos
int thumb = 0 ; // Variables de los valores para enviar int index = 0 ; int medio = 0 ; int anular = 0 ; int pinky = 0 ; configuración nula () { Serie . comenzar ( 9600 );
// Activando la comunicación serial, XBee Series 1 están preprogramados a 9600 baudios / s
pinMode ( ResThumb , INPUT ); // Las variables del sensor se configuran como input pinMode ( ResIndex , INPUT ); pinMode ( ResMiddle , INPUT ); pinMode ( ResAnnular , INPUT ); pinMode ( ResPinky , INPUT ); ClosedThumb = analogRead ( ResThumb ); ClosedIndex = analogRead (
ResIndex );
ClosedMiddle = analogRead ( ResMiddle ); ClosedAnnular = analogRead ( ResAnnular ); ClosedPinky = analogRead ( ResPinky ); } void loop () { thumb = analogRead ( ResThumb ); índice = analogRead ( ResIndex ); medio = analogRead ( ResMiddle ); anular = analogRead (
Resanular );
pinky = analogRead ( ResPinky ); if ( pulgar > OpenedThumb ) // Lectura de calibración y configuración de los valores máximos. Esto necesita que abras completamente tu mano varias veces OpenedThumb = thumb ; if ( índice > índice abierto ) índice abierto = índice ; if ( medio > OpenedMiddle ) OpenedMiddle = medio ; if ( anular >
AbiertoAnular )
AbiertoAnular = anular ; if ( pinky > OpenedPinky ) OpenedPinky = pinky ; if ( thumb < ClosedThumb ) // Calibración de lectura y configuración de los valores mínimos. Esto necesita que cierre completamente su mano varias veces ClosedThumb = thumb ; if ( index < ClosedIndex ) ClosedIndex = index ; if ( medio < ClosedMiddle )
ClosedMiddle = middle ;
if ( anular < ClosedAnnular ) ClosedAnnular = anular ; if ( meñique < ClosedPinky ) ClosedPinky = meñique ; thumb = map ( thumb , ClosedThumb , OpenedThumb , 0 , 180 ); // La lectura analógica debe ser readaptada en valores entre 0 y 180 para ser utilizados por los servomotores. índice = mapa ( índice ,
ClosedIndex , OpennedIndex , 0 , 180 ); // Los valores mínimo y máximo de las calibraciones se utilizan para establecer correctamente las lecturas analógicas.
middle = map ( middle , ClosedMiddle , OpenedMiddle , 0 , 180 ); anular = mapa ( anular , anular cerrado , anular abierto , 0 , 180 ); pinky = map ( pinky , ClosedPinky ,
Abierto Rosa , 0 , 180 );
De serie . escribir ( "<" ); // Este carácter representa el comienzo del paquete de los cinco valores Serie . escribir ( pulgar ); // Los valores se envían a través del pin Tx (el pin digital 1) Serie . escribir ( índice ); De serie . escribir ( medio ); De serie . escribir ( anular ); De serie . escribir ( meñique );
retraso ( 30 );
}#include <Servo.h> // Library needed to use function for servomotors
Servo ServoThumb, ServoIndex, // Viene assegnato un nome a ciascun servomotore.
ServoMiddle, ServoAnnular, ServoPinky;
byte startPackage; // Variable that will contain the character of start package set in the GloveTX sketch, "<"
int AngThumb = 0; // Variables with the values for the servomotors (between 0 and 180)
int AngIndex = 0;
int AngMiddle = 0;
int AngAnnular = 0;
int AngPinky = 0;
void setup()
{
Serial.begin(9600); // Serial communication is activated at 9600 baud/s.
ServoThumb.attach(9); // The servomotors are asigned to the pins of the Arduino UNO board.
delay(300); // A delay of 300ms is set for a secure connection (this can be optional)
ServoIndex.attach(8);
delay(300);
ServoMiddle.attach(7);
delay(300);
ServoAnnular.attach(6);
delay(300);
ServoPinky.attach(5);
delay(300);
Serial.println("Ready to receive.");
}
void loop()
{
if(Serial.available()) { // Witing for data incoming from the other XBee module
startPackage = Serial.read(); // The first value will be "<", the other are assigned to the finger
AngThumb = Serial.read();
AngIndex = Serial.read();
AngMiddle = Serial.read();
AngAnnular = Serial.read();
AngPinky = Serial.read();
if(startPackage == '<'){ // Verifying that the first value is "<"
if(AngThumb!=255) // Sometimes the incoming value goes to 255, I couldn't discover yet the reason, so I simply excluded it when it happens. You can remove this line for every finger if you don't have this kind of problem
ServoThumb.write(AngThumb); // The servomotors rotates of the assigned degrees
if(AngIndex!=255)
ServoIndex.write(AngIndex);
if(AngMiddle!=255)
ServoMiddle.write(AngMiddle);
if(AngAnnular!=255)
ServoAnnular.write(AngAnnular);
if(AngPinky!=255)
ServoPinky.write(AngPinky);
}
}
delay(30); // a delay to make the servomotors working correctly (a lower value could make the system not working, higher value make it slower)
}
/
int ResThumb = A4; // Variables of the analog read form the flex sensors connected to the analog pins of Arduino LilyPad
int ResIndex = A3;
int ResMiddle = A2;
int ResAnnular = A1;
int ResPinky = A0;
int OpenedThumb =0; // Variables of the values when the hand is completely opened
int OpenedIndex =0; // This is needed for a continuous calibration
int OpenedMiddle =0;
int OpenedAnnular =0;
int OpenedPinky =0;
int ClosedThumb; // Variables of the values when the hand is completely closed
int ClosedIndex; // We can't set it to zero since that the minimum value reached
int ClosedMiddle; // in the analog read never reach zero. We'll assign the value of
int ClosedAnnular; // a first analog read, then the program in the loop will
int ClosedPinky; // automatically assing lower values
int thumb =0; // Variables of the values to send
int index =0;
int middle =0;
int annular =0;
int pinky =0;
void setup()
{
Serial.begin(9600); // Activating serial communication, XBee Series 1 are pre-programmed at 9600 baud/s
pinMode(ResThumb, INPUT); // The variables of the sensor are set as input
pinMode(ResIndex, INPUT);
pinMode(ResMiddle, INPUT);
pinMode(ResAnnular, INPUT);
pinMode(ResPinky, INPUT);
ClosedThumb = analogRead(ResThumb);
ClosedIndex = analogRead(ResIndex);
ClosedMiddle = analogRead(ResMiddle);
ClosedAnnular = analogRead(ResAnnular);
ClosedPinky = analogRead(ResPinky);
}
void loop()
{
thumb = analogRead(ResThumb);
index = analogRead(ResIndex);
middle = analogRead(ResMiddle);
annular = analogRead(ResAnnular);
pinky = analogRead(ResPinky);
if(thumb > OpenedThumb) // Calibration reading and setting the maximum values. This needs you to completely open your hand a few times
OpenedThumb = thumb;
if(index > OpenedIndex)
OpenedIndex = index;
if(middle > OpenedMiddle)
OpenedMiddle = middle;
if(annular > OpenedAnnular)
OpenedAnnular = annular;
if(pinky > OpenedPinky)
OpenedPinky = pinky;
if(thumb < ClosedThumb) // Calibration reading and setting the minimum values. This needs you to completely close your hand a few times
ClosedThumb = thumb;
if(index < ClosedIndex)
ClosedIndex = index;
if(middle < ClosedMiddle)
ClosedMiddle = middle;
if(annular < ClosedAnnular)
ClosedAnnular = annular;
if(pinky < ClosedPinky)
ClosedPinky = pinky;
thumb = map(thumb ,ClosedThumb ,OpenedThumb ,0,180); // The analog read has to be readapted in values between 0 and 180 to be used by the servomotors.
index = map(index ,ClosedIndex ,OpenedIndex ,0,180); // The minimum and maximum values from the calibrations are used to correctly set the analog reads.
middle = map(middle ,ClosedMiddle ,OpenedMiddle ,0,180);
annular = map(annular,ClosedAnnular,OpenedAnnular,0,180);
pinky = map(pinky ,ClosedPinky ,OpenedPinky ,0,180);
Serial.write("<"); // This character represent the beginning of the package of the five values
Serial.write(thumb); // The values are sent via the Tx pin (the digital pin 1)
Serial.write(index);
Serial.write(middle);
Serial.write(annular);
Serial.write(pinky);
delay(30);
}
/
int ResThumb = A4; // Variables of the analog read form the flex sensors connected to the analog pins of Arduino LilyPad
int ResIndex = A3;
int ResMiddle = A2;
int ResAnnular = A1;
int ResPinky = A0;
void setup()
{
Serial.begin(9600); // Activating serial communication, XBee Series 1 are pre-programmed at 9600 baud/s
pinMode(ResThumb, INPUT); // The variables of the sensor are set as input
pinMode(ResIndex, INPUT);
pinMode(ResMiddle, INPUT);
pinMode(ResAnnular, INPUT);
pinMode(ResPinky, INPUT);
}
void loop()
{
Serial.println("<"); //This symbol is needed to indicate the start of the "data package".
Serial.println(analogRead(ResThumb ));
Serial.println(analogRead(ResIndex ));
Serial.println(analogRead(ResMiddle ));
Serial.println(analogRead(ResAnnular));
Serial.println(analogRead(ResPinky ));
Serial.println("---------------");
delay(1000);
}
/
#include <Servo.h> // Library needed to use function for servomotors
Servo ServoThumb, ServoIndex, // Viene assegnato un nome a ciascun servomotore.
ServoMiddle, ServoAnnular, ServoPinky;
byte startPackage; // Variable that will contain the character of start package set in the GloveTX sketch, "<"
int AngThumb = 0; // Variables with the values for the servomotors (between 0 and 180)
int AngIndex = 0;
int AngMiddle = 0;
int AngAnnular = 0;
int AngPinky = 0;
void setup()
{
Serial.begin(9600); // Serial communication is activated at 9600 baud/s.
ServoThumb.attach(9); // The servomotors are asigned to the pins of the Arduino UNO board.
delay(300); // A delay of 300ms is set for a secure connection (this can be optional)
ServoIndex.attach(8);
delay(300);
ServoMiddle.attach(7);
delay(300);
ServoAnnular.attach(6);
delay(300);
ServoPinky.attach(5);
delay(300);
Serial.println("Ready to receive.");
}
void loop()
{
if(Serial.available()) { // Witing for data incoming from the other XBee module
Serial.println("The XBees are connected each other.");
startPackage = Serial.read(); // The first value will be "<", the other are assigned to the finger
AngThumb = Serial.read();
AngIndex = Serial.read();
AngMiddle = Serial.read();
AngAnnular = Serial.read();
AngPinky = Serial.read();
if(startPackage == '<'){ // Verifying that the first value is "<"
Serial.println("I'm receiving analog signals:"); // If you are seeing this in the Serial Monitor you have correctly received data
if(AngThumb!=255) // Sometimes the incoming value goes to 255, I couldn't discover yet the reason, so I simply excluded it when it happens. You can remove this line for every finger if you don't have this kind of problem
ServoThumb.write(AngThumb); // The servomotors rotates of the assigned degrees
if(AngIndex!=255)
ServoIndex.write(AngIndex);
if(AngMiddle!=255)
ServoMiddle.write(AngMiddle);
if(AngAnnular!=255)
ServoAnnular.write(AngAnnular);
if(AngPinky!=255)
ServoPinky.write(AngPinky);
Serial.print(AngThumb);
Serial.print(" | ");
Serial.print(AngIndex);
Serial.print(" | ");
Serial.print(AngMiddle);
Serial.print(" | ");
Serial.print(AngAnnular);
Serial.print(" | ");
Serial.println(AngPinky);
}
}
delay(100); // a delay to make the servomotors working correctly (a lower value could make the system not working, higher value make it slower)
}
-
Arduino ATmega 2560 R3¡Oferta!$20.50$19.00 -
Arduino Uno Wifi¡Oferta!$15.00$13.00 -
Arduino Mini USB Nano V3.0 CH340 Chip Board 5V 16M + Cable¡Oferta!$9.00$8.50
