_

_

domingo, 18 de septiembre de 2016

Humanoide - vex IQ

Un de las cosas que siempre quise hacer desde pequeño, es un robot humano como los que salen en las películas que son capaces de hacer muchas cosas como si se tratara de una persona.

Tras varios intentos fallidos debido a que los componentes que trae vex IQ no son los mas adecuados para este tipo de proyectos, he conseguido una aproximación que mas o menos puede darse por valida.

El humanoide creado tiene las propiedades de poder andar (para adelante y para atrás) y girar (para la derecha y para la izquierda) así como corregir su rumbo ante posibles desviaciones, también esta dotado de inteligencia que ante un obstáculo es capaz de encontrar su salida (ir para la izquierda, para la derecha o retroceder).

La mayor complicación con la que nos hemos encontrado es la de dotar de movimiento al humanoide, es decir, que ande ya que el peso del mismo lo hacia muy inestable. Para ello hemos simulado el movimiento de la cadera con dos motores uno que hace una pequeña elevación de la pierna y otro que hace una pequeña rotación para conseguir el paso. 





Componentes:
  • Distintas piezas de construcción
  • 5 motores
  • 1 sensor de distancia
  • 1 gyro
  • 1 touch led

Podemos decir que la dificultad con la que nos hemos encontrado para la programación del humanoide ha sido media, por eso, la hemos realizado con RobotC que es un entorno de desarrollo mas avanzado.

Sin mas aquí os pongo un vídeo que muestra las capacidades de este simpático humanoide hecho íntegramente con vex IQ y programado con RobotC.




Y para los mas curiosos, os paso el código hecho con RobotC para vex IQ. 





Espero que os haya gustado o por lo menos haber despertado un poco de vuestra curiosidad.

viernes, 27 de mayo de 2016

Brazos articulados I

Unos de los campos más interesantes en el tema de la robótica, es el que se encarga de estudiar los brazos articulados, estos tienen infinidad de aplicaciones en la vida real como por ejemplo en cadenas de montaje, para medicina y un sinfín de usos.




Hay un montón de tipos distintos de brazos articulados, pero nosotros vamos a basarnos en un modelo sencillo llamado S.C.A.R.A. que solo permite movilidad en el eje X e Y.

Para su mejor comprensión es importante conocer una serie de términos que relatamos a continuación:
  •    Nº grados de libertad, es el nº de segmentos articulados de los que consta un brazo robot, en nuestro caso vamos a usar un modelo sencillo de 2 grados de libertad.
  •    Cinemática directa, nos dice una coordenada (x,y) dado el valor en grados de los ángulos de los segmentos articulados de un brazo robot.
  •    Cinemática inversa, nos dice el valor en grados de los ángulos de los segmentos articulados de un brazo robot dado una coordenada (x,y).

Los conceptos anteriores son muy importantes ya que son la base del movimiento del brazo articulado, normalmente partimos de un sistema de coordenadas y a partir de la cinemática inversa calculamos el valor de los ángulos que deberemos de proporcionar a los motores del robot para que se posicionen en el punto que deseamos.

Imaginemos por ejemplo que queremos mover un objeto de la posición (x,y) a la posición (x1,y1), para ello calcularemos los ángulos de la posición (x,y), el robot se moverá a esa posición y cogerá el objeto que se encuentre en ella, luego calcularemos los ángulos de la posición (x1,y1), el robot nuevamente se moverá a esa nueva posición y soltara el objeto que tiene.

Para que veáis el funcionamiento he desarrollado un simulador para un brazo robótico de dos grados de libertad, en el podemos escoger una imagen, esa imagen se va a trasformar en puntos, esos puntos se van a trasformar en ángulos y posteriormente se moverá el simulador del robot a esos ángulos para ver cómo es capaz de dibujar esa imagen.



Como podemos observar, el vídeo refleja dos situaciones, la primera es la situación ideal donde los cálculos son exactos ya que usamos todos los decimales generados, en este caso el dibujo generado es perfecto. En la segunda situación hacemos un redondeo de los cálculos para quitar los decimales ya que los motores no trabajan con decimales y como resultados vemos que el dibujo se distorsiona un poco, podemos distinguir la figura geométrica que se está dibujando pero claramente vemos que no es perfecta.

En el siguiente articulo vamos a construir un brazo robot con vex IQ que sea capaz de dibujar estas figuras geométricas de forma autónoma, es decir, vamos a crear un brazo robot pintor que es capaz de pintar en una hoja de papel las figuras que le pasemos previamente.


También recogeremos en una traza los movimientos del brazo robot para llevarlos al programa del ordenador y que los pinte para que podamos comparar lo que le hemos mandado pintar y lo que realmente ha pintado y de esa forma ver la desviación que se ha producido.


jueves, 17 de marzo de 2016

El escorpión - vex IQ

Uno de los proyectos más difíciles a los que me he enfrentado por ahora, es este escorpión, la dificultad viene dada por que el kit de vex IQ que tengo, no tiene suficientes piezas para hacerlo como me hubiese gustado y he tenido que improvisar para salir al paso en cada problema encontrado, pero bueno, el resultado es bastante aparente como veréis a continuación.




Hay que destacar que el sistema de movimiento se basa en dos motores que hay debajo del escorpión y que se mueven haciendo girar tres ruedas dentadas que cada una hace mover una pata, y el desfase de la posición de cada pata hace posible el movimiento.

Componentes:
  • Distintas piezas de construcción
  • 4 motores
  • 1 sensor de distancia
  • 1 gyro
  • 1 touch led

En primer lugar decir que este escorpión con un aspecto que da un poco de miedo tiene las siguientes características:
  • Se pone en marcha y se para al pulsar el touch led.
  • Anda de forma autónoma, salvando los obstáculos que pueda encontrar a su paso, esto lo hace basándose en el sensor de distancia y girando 90º a la izquierda usando el gyro cada vez que detecta un obstáculo. 
  • En caso de encontrar un objeto de color rojo suena una sirena, activa su potente aguijón para atacarlo y después retrocede un poco hacia atrás. 
  • En caso de encontrarse un objecto verde, lo coje con sus pinzas y da por finalizada su misión con un sonido, avanzado para adelante un poco y mostrando un mensaje de 'Conseguido' en el display.


Como novedad en este desarrollo, es la utilización de RobotC vex IQ para la programación del mismo en vez de ModKit, no es que no se podría llevar a cavo usando ModKit, sino que ya quiero empezar a usar algo mas avanzado para los desarrollos futuros.



Sin mas aquí os pongo un vídeo que muestra las virtudes que ya hemos mencionado de este simpático a la vez que aterrador robot hecho íntegramente con vex IQ.




Como no podia faltar, os paso el código hecho con RobotC para vex IQ.


#pragma config(Sensor, port3,  colorSensor,    sensorVexIQ_ColorHue)
#pragma config(Sensor, port4,  distanceSensor, sensorVexIQ_Distance)
#pragma config(Sensor, port5,  gyroSensor,     sensorVexIQ_Gyro)
#pragma config(Sensor, port7,  touchLED,       sensorVexIQ_LED)
#pragma config(Motor,  motor1,          leftMotor,     tmotorVexIQ, PIDControl, encoder)
#pragma config(Motor,  motor6,          rightMotor,    tmotorVexIQ, PIDControl, reversed, encoder)
#pragma config(Motor,  motor10,         colaMotor,   tmotorVexIQ, PIDControl, encoder)
#pragma config(Motor,  motor11,         pinzasMotor,     tmotorVexIQ, PIDControl, encoder)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//

bool working;
TSimpleColors colorName;
bool greenFound;

void colorDetection()
{
if (colorName == colorRed && getColorProximity(colorSensor) > 280)
{
stopMultipleMotors(leftMotor, rightMotor);

int count = 0;
while(count < 3)
{
playSound(soundCarAlarm2);

setMotorSpeed(colaMotor, -20);
sleep(1000);
setMotorSpeed(colaMotor, 20);
sleep(1000);

count++;
}
stopMotor(colaMotor);

setMotorSpeed(leftMotor, -50);  //Move left motor at 50% speed
setMotorSpeed(rightMotor, -50); //Move right motor at 50% speed

// Se mueve 3 sg
sleep(3000);
stopMultipleMotors(leftMotor, rightMotor);
}
else if (colorName == colorGreen && getColorProximity(colorSensor) > 300)
{
stopMultipleMotors(leftMotor, rightMotor);

playSound(soundTada);

greenFound = true;

eraseDisplay();
displayCenteredBigTextLine(1, "Conseguido!");

setMotorSpeed(pinzasMotor, -25);
sleep(1000);
stopMotor(pinzasMotor);

setMotorSpeed(leftMotor, 50);
setMotorSpeed(rightMotor, 50);
sleep(4000);
stopAllMotors();
}
}

void refreshDisplay()
{
displayTextLine(0, "Distance: %d mm", getDistanceValue(distanceSensor));
displayTextLine(1, "working: %d", working);
displayTextLine(2, "Degrees: %d", getGyroDegrees(gyroSensor));

if (getColorProximity(colorSensor) > 200)
{
if(getColorValue(colorSensor) < 30)
{
colorName = colorRed;
displayTextLine(3, "Color: Red Dist: %d", getColorProximity(colorSensor));
}
if(getColorValue(colorSensor) >= 30 && (getColorValue(colorSensor) <= 50))
{
colorName = colorNone;
displayTextLine(3, "Color:");
}
else if((getColorValue(colorSensor) > 50) && (getColorValue(colorSensor) <= 130))
{
colorName = colorGreen;
displayTextLine(3, "Color: Green Dist: %d", getColorProximity(colorSensor));
}
else if((getColorValue(colorSensor) > 131) && (getColorValue(colorSensor) <= 219))
{
colorName = colorBlue;
displayTextLine(3, "Color: Blue Dist: %d", getColorProximity(colorSensor));
}
else if(getColorValue(colorSensor) > 219)
{
colorName = colorRed;
displayTextLine(3, "Color: Red Dist: %d", getColorProximity(colorSensor));
}
}
else
{
colorName = colorNone;
displayTextLine(3, "Color:");
}
}

task main()
{
// Valores por defecto
greenFound = false;
working = false;

resetMotorEncoder(leftMotor);
resetMotorEncoder(rightMotor);
resetMotorEncoder(pinzasMotor);
setMotorBrakeMode(pinzasMotor, motorHold);
resetMotorEncoder(colaMotor);
setMotorBrakeMode(colaMotor, motorHold);

//Set the minimum detectable range to 100mm (10cm/0.1m)
setDistanceMinRange(distanceSensor, 100);

//Set the maximum detectable range to 5000mm (50cm/0.5m)
setDistanceMaxRange(distanceSensor, 500);

// Lo dejo en amarillo parpadeando
setTouchLEDColor(touchLED, colorYellow);
setTouchLEDBlinkTime(touchLED, 40, 10);

while(!greenFound)
{
refreshDisplay();

if(getTouchLEDValue(touchLED) != 0)
{
working = !working;

if (working)
{
// Fin del parpadeo
setTouchLEDBlinkTime(touchLED, 0, 0);
}
else
{
// Que parpadee en amarillo
setTouchLEDColor(touchLED, colorYellow);
setTouchLEDBlinkTime(touchLED, 40, 10);

// Paro los motores
stopMultipleMotors(leftMotor, rightMotor);
}
}

if (working)
{
if (getDistanceValue(distanceSensor) > 400)
{
setTouchLEDColor(touchLED, colorGreen);

setMotorSpeed(leftMotor, 80);  //Move left motor at 80% speed
setMotorSpeed(rightMotor, 80); //Move right motor at 80% speed

// Se mueve 10 msg
sleep(10);
}
else if (getDistanceValue(distanceSensor) > 300)
{
setTouchLEDColor(touchLED, colorOrange);

setMotorSpeed(leftMotor, 50);  //Move left motor at 50% speed
setMotorSpeed(rightMotor, 50); //Move right motor at 50% speed

// Se mueve 10 msg
sleep(10);
}
else
{
setTouchLEDColor(touchLED, colorRed);

//Reset the gyro sensor to remove any previous data
resetGyro(gyroSensor);

//Loop while the gyro sees a value less than 90 degrees.
long angle = getGyroDegrees(gyroSensor) + 90;
while(getGyroDegrees(gyroSensor) < angle)
{
refreshDisplay();

//Set the motors to turn to the left at 25% speed.
setMotorSpeed(leftMotor, -40);
setMotorSpeed(rightMotor, 40);

colorDetection();
}
}

colorDetection();
}
}

sleep(5000); // Antes de finalizar el programa
}

martes, 15 de marzo de 2016

Mecanismos básicos usados en robótica

Aquí unos principios básicos que son muy importantes tener en cuenta a la hora de hacer  cualquier robot y creo que desde mi punto de vista todo el mundo debería de conocer y aplicar en sus desarrollos.


PALANCA
Está formada por una barra rígida que puede girar alrededor de un punto llamado punto de apoyo. Se puede distinguir tres elementos:
  • La potencia o la fuerza que hago.
  • La resistencia o carga que tengo que vencer.
  • Punto de apoyo que es punto donde gira la palanca.

Las palancas pueden ser de tres tipos dependiendo de donde coloque los tres elementos de la palanca:

  • Primer género el punto de apoyo se encuentra entre la potencia y la resistencia, como las tijeras, balancín, etc.
  • Segundo género donde la resistencia se encuentra entre la potencia y el punto de apoyo, como la carretilla, cascanueces, etc.
  • Tercer género donde la resistencia está entre el punto de apoyo y la potencia, como las pinzas de depilar, caña de pescar, etc.



POLEA
Es una rueda que gira alrededor de un eje y que tiene un canal por donde pasa una cuerda. La polea nos permite elevar las cargas más cómodamente.





POLIPASTO
Es un conjunto de poleas que nos permiten levantar grandes pesos con poco esfuerzo y va a depender del número de poleas, así Peso / Nº de poleas.





POLEAS Y CORREA
Es un mecanismo que consta de dos poleas unidad por medio de una correa. Cuando giramos la polea por medio de una manivela, el movimiento se transmite a través de la correa, llegando a la otra polea con el mismo sentido, como una cinta transportadora, el movimiento del tambor de la lavadora, etc.
A veces el movimiento cambia de sentido cuando utilizamos una polea cruzada.





ENGRANAJES
Son dos ruedas que se encajan a través de los dientes que tienen alrededor. Estas ruedas con dientes giran en sentidos contrarios, es decir, si una va a derechas la otra va a izquierdas, como el mecanismo de los relojes, los brazos del compás, etc.




BIELA
Es una rueda en la que se coloca una barra rígida que no va sujeta en el centro de la rueda y que al girar la rueda la barra se mueve con un movimiento de vaivén, como la rueda de una locomotora de vapor, la máquina de coser, etc.




TORNILLO

Es un mecanismo que transforma un movimiento de giro en otro de avance, como el gato o sargento del taller de herramientas, el sacacorchos.


miércoles, 9 de marzo de 2016

¿Y cómo programo yo esto?

Una de las grandes preguntas a la hora de adquirir un kit de robótica es sin duda la forma en que posteriormente voy a programarlo.

Vamos a hacer un breve repaso a todas las posibilidades existentes al día de hoy para programar nuestros robots vex IQ, las que muestro aquí son las que tengo conocimiento, desconozco si hay alguna más.



Modkit:
Modkit es un entorno gráfico de programación desarrollado específicamente para VEX IQ. Sobre la base de la investigación del proyecto de Scratch en el MIT Media Lab, Modkit para VEX está construido alrededor de los bloques de traba a presión, que hacen que la programación sea verdaderamente accesible y divertido para todas las edades y niveles de habilidad.
Desde mi punto de vista es el mas sencillo ya que se basa en la programación por bloques de scratch.
Hay una versión online gratuita y una versión de escritorio de pago



Robotc:
ROBOTC permite a los usuarios programar sus robots VEX IQ utilizando una nueva interfaz de programación gráfica de arrastrar y soltar, o el lenguaje de programación C ROBOTC basada en estándares de la industria populares - todos en el mismo software!
Tiene dos modos de trabajo:
  • Gráfico de lenguaje natural permite a los principiantes utilizan los comandos simplificados tales como "Adelante", "Línea de pista", y "Repetir" loops.
  • Código C, permite programar robots usando los estándar de la industria

Más de 200 programas de muestra con una amplia documentación, lo que permite a los estudiantes para empezar a programar inmediatamente.
Desde mi punto de vista es el más completo
Tiene una versión de prueba de 15 días



Easyc:
Programación visual orientada a diagramas de flujo que da como resulta código C.
Tiene una versión de prueba de 15 días.



Robot Mesh Python:
Otra alternativa muy interesante
Tiene dos modos de trabajo:
  • Modo bloques (Blockly) parecido a Scrach
  • Modo código (Python)

Hay una versión online gratuita y una versión de escritorio de pago



Flowol:
Una alternativa curiosa a la hora de programar un robot que pretende evitar tener conocimientos de lenguajes de programación.
Programación visual orientada a diagramas de flujo
Disponible en inglés y en español
Tiene una versión de prueba de 30 días.



viernes, 4 de marzo de 2016

La catapulta movil - vex IQ

Os presento un nuevo robot muy sencillo y a la vez muy divertido, se trata de una catapulta móvil. El enfoque de este diseño lo vamos a ver con los siguientes casos:
  • En primer lugar una catapulta móvil que lanza objetos de forma manual y se mueve mediante el mando que tiene el kit de vex IQ
  • En segundo lugar una adaptación para que el lanzamiento de objetos sea controlado mediante el mando
  • En tercer lugar vamos a poner el robot en modo autopilotado y ver como hace las delicias de todos andando de un lado para otro de forma autónoma.
La construcción es muy sencilla ya que nos basamos en la base móvil del Clawbot a la que añadimos cual remolque la catapulta que no deja de ser un balancín ayudado por unas gomas y una cuerda atada a una rueda que gira y enrolla la misma.





Y sin mas os dejo con un vídeo para que podáis disfrutar de este sencillo y divertido robot.




domingo, 28 de febrero de 2016

Os presentó a Wall-E - vex IQ

Aquí en primicia una versión diferente de Wall-E hecha íntegramente con vex IQ, para empezar deciros que es un robot que anda de forma autónoma esquivando todos los obstáculos que encuentra a su paso, pasamos a ver como esta hecho y después explicaremos su programación. Como podeid observar, el robot no tiene un sistema de tracción basado en cadenas como tiene el original, pero es que no dispongo de tales piezas.



Componentes:
  • Distintas piezas de construcción
  • 5 motores
  • 1 sensor de distancia
  • 1 gyro
  • 1 touch led

Y ahora antes de empezar con la programación una demostración de su funcionamiento.



La programación de Wall-E es muy sencilla, la he realizado con la versión gratuita de Modkit y la vamos a explicar paso a paso desde el punto de vista de cada componente usado.

En primer lugar hablar de los componentes (motores y sensores) que forman la parte a programar del robot.



A continuaciòn las variables utilizadas:

  • Pausa, es la que nos indica si el robot esta en marcha o parado, este estado se cambia al tocar el touch led.
  • DerechaLibre, distancia hasta un obstáculo a la derecha del robot.
  • IzquierdaLibre, distancia hasta un obstáculo a la izquierda del robot.
  • Calculando, para el robot mientras busca por donde puede seguir.
  • Rotación, donde se almacena el giro que tiene que hacer para ir por el lado donde no hay obstáculos.



Ahora vamos a ver el código de las distintas partes del robot.


Brain, solo decir que el robot comienza en moda pausa y hasta que se pulse el touch led no se pone en marcha.


DriveTrain, la parte mas compleja donde se gestiona el movimiento del robot, el robot anda hacia adelante hasta que se encuentra un obstáculo y entonces mira hacia donde puede girar, una vez visto por donde puede ir, lo lleva a cabo.



Touch Led, aquí se gestiona el color de touch led, así como si el robot esta activo o esta en modo pausa, el led tiene tres posibles colores, rojo si hay un obstáculo cerca, verde si hay vía libre y naranja si hay un obstáculo lejos.


Distance, solo se ajusta la distancia máxima del sensor.


Gyro, lo calibramos e iniciamos su angulo y rotación para poder empezar a usarlo con precisión. Los demás componentes deberán de esperar 5 segundos antes de hacer nada ya que es el tiempo que se necesita en este proceso.


Cabeza (motor que gira el sensor de distancia), es el encargado de calcula por donde puede seguir el robot, básicamente gira a la derecha y a la izquierda para ver si hay algún obstáculo y se guarda la distancia al obstáculo mas cercano. 


BrazoIzq, se mueve para arriba y para abajo mientras este andando el robot.


BrazoDer, se mueve para arriba y para abajo mientras este andando el robot.




Como mejoras posibles, podríamos añadir al algoritmo de movimiento, una corrección al posible desvió de ruta, es decir, si el robot se va desviando poco a poco, podemos corregir su desviación. Algo así como:
  • Nos guardaríamos el angulo del gyro sobre el que estamos avanzando en una variable y lo actualizaríamos cada vez que cambiamos la dirección.
  • Cada vez que avanzamos miraríamos que:
    • Si el angulo del gyro es mayor que el angulo guardado + 2, corregiriamos a la derecha hasta el angulo guardado.
    • Si el angulo del gyro es menor que el angulo guardado - 2, corregiríamos a la izquierda hasta el angulo guardado.