_

_

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.