_

_

lunes, 6 de marzo de 2017

Roomba - vex IQ

Cuando hablamos de kits de robótica, muchas veces pensamos en que lo que podemos hacer con ellos no tienen una utilidad real. Nunca mas lejos de la realidad y para demostrarlo hoy en este articulo voy a hablar de un robot que puede ser muy útil en el entorno domestico.

Esta versión de roomba con vex IQ es muy sencillita ya que se basa en la parte móvil del Clawbot, al que le hemos añadido un cajetín y un cepillo giratorio.

El gran reto aquí ha sido como hacer funcionar un cepillo giratorio en nuestro robot ya que este elemento no existe como accesorio, por lo que hemos tenido que tirar de imaginación, para ello en un chino hemos comprado un cepillo para limpiar el interior de botellas al cual hemos cortado el mango y lo hemos adaptado a nuestras necesidades.

La forma de moverse de la roomba es muy sencilla, va para delante hasta que encuentra un obstáculo, en ese momento gira avanza un poco y va para detrás, de esta forma hace un barrido completo de la zona. También esta preparada para corregir su rumbo ante posibles desviaciones.






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

Podemos decir que la dificultad con la que nos hemos encontrado para la programación de la roomba ha sido media, por eso, la hemos realizado con RobotC.

Sin mas aquí os pongo un vídeo que muestra como recoge todas las piezas azules que hemos dejado tiradas en el suelo.





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





Espero que os haya gustado y que construyáis mas cosas en que los robots os puedan hacer un poco mas fácil la vida.










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.