Mi Lego(C) Mindstorms.

Robot SigueLíneas (IV): Resultados

2011-09-28T22:24:00.009+02:00

Y aquí os dejo un vídeo de este robot moviéndose a lo largo de la línea del panel que venía con el Lego(C) Mindstorms.

Va bastante lento. El que se mueva más rápido iba a necesitar de más labores de programación y tampoco estaba por la labor. Con hacer un seguidor de líneas utilizando dos sensores ya me daba por satisfecho.

En el vídeo se puede ver como comienza a girar el robot. Cuando uno de los sensores se acerca a la línea negra. Cuando la línea está entre los dos sensores el robot sigue recto.

El cable conectado al arduino,se utiliza para darle energía y para enviar la información al Matlab, que la lee a través del puerto serie. Matlab envía las órdenes utilizando el bluetooth, que milagrosamente ahora funciona.

Me gustaría como mejora, ponerle un portapilas al arduino para no tener cables. Enviar la información a través de un emisor rf a otro arduino, este sí, conectado por usb a un Matlab y que este envíe las órdenes por bluetooth al bloque.

Robot SigueLíneas (III): Matlab

2011-09-28T22:14:00.009+02:00

Aquí adjunto el código para mover todo con matlab.

umbral = 150;
potenciaAdelante = 5;
potenciaGiro = 3 * potenciaAdelante;

COM_CloseNXT all
hNXT = COM_OpenNXT('bluetooth.ini');
COM_SetDefaultNXT(hNXT);

placa = serial( 'COM4' , 'BaudRate', 9600 );
fopen( placa );

try
    i = 1;
    
    mi = NXTMotor('A');
    md = NXTMotor('B');
    
    
    while (i < 10000)
        loQueRecibo = fscanf( placa );
        loQueRecibo = sscanf(loQueRecibo,'%d');
        
        a = size(loQueRecibo);
        
        if(a(1) == 2)
            
            loQueRecibo;
            
            valorIzquierda = loQueRecibo(1);
            valorDerecha = loQueRecibo(2);
            
            if( (valorIzquierda < umbral) && (valorDerecha > umbral) )
                display('Me muevo hacia la izquierda.');
                mi.Stop('off');
                mi.SendToNXT();
                
                md.Power = potenciaGiro;
                md.SendToNXT();
            elseif( (valorDerecha < umbral) && (valorIzquierda > umbral) )
                display('Me muevo hacia la derecha.');
                
                md.Stop('off');
                md.SendToNXT();
                
                mi.Power = potenciaGiro;
                mi.SendToNXT();
            elseif( (valorDerecha > umbral) && (valorIzquierda > umbral) )
                display('Me muevo hacia adelante como los de alicante.');
                
                mi.Power = potenciaAdelante;
                mi.SendToNXT();
                
                md.Power = potenciaAdelante;
                md.SendToNXT();
            else
                md.Stop('off');
                mi.Stop('off');
                
                loQueRecibo
                
                %pause;
            end
            
            i = i + 1;
        end % compruebo que he recibido dos
    end
    
catch err
    loQueRecibo
    display('LEÑO GORDO')
    
    err
    
    try
        mi.Stop('off');
        md.Stop('off');
    catch err1
    end
    
    fclose( placa );
    COM_CloseNXT(hNXT);
end % try-catch

mi.Stop('off');
md.Stop('off');

fclose( placa );
COM_CloseNXT(hNXT);

He utilizado la la última versión estable de laRWHT toolbox. Ahora está orientada a objetos y utiliza una aplicación en nxc para un, según ellos, mejor control de los motores.

Robot SigueLíneas (II): Parte Arduino leyendo un sensor óptico QRD1114

2011-09-28T21:50:00.011+02:00

El montaje es bastante sencillo. Habría que repetirlo dos veces, para tener un sensor a cada lado de la línea.

En las entradas analógicas 0 y 5 del arduino recogemos la información del sensor.

El código del arduino es el siguiente

int pinIzquierdo = 0;
int pinDerecho = 5;

void setup(){
  Serial.begin(9600);

  pinMode( pinIzquierdo , INPUT );
  pinMode( pinDerecho , INPUT );
}//setup

void loop(){  
  delay(500);
  
  Serial.print( analogRead ( pinIzquierdo )  );
  Serial.print( " " );
  Serial.print( analogRead ( pinDerecho )  );
  Serial.println();  
  Serial.flush();  
}//loop

Y aquí está la salida que se muestra por el monitor serie.

A la izquierda de cuando detecta blanco por ambos lados. En el centro cuando detecta blanco a un lado y negro al otro. Y a la izquierda viceversa.

Robot Sigue Líneas (I): Introducción

2011-09-28T21:25:00.010+02:00

Hoy voy exponer un pequeño proyecto que es bastante típico dentro del mundo de la construcción de robots: un seguidor de líneas.

Cierto es que ya había construido un robot de características similares en un par de ocasiones. Pero en ambos casos sólo tenía un sensor para leer la línea. Ahora, voy a tener dos. Además de que no puse ningún vídeo.

No me he comprado ningún sensor de lego nuevo. Vamos a hacerlo con estos dos pequeños sensores (QRD1114), un arduino y un lego.

Estos sensores tienen aquí una hoja de especificaciones muy bien explicada para gente experta. Como soy un poco más mundano, lo voy a explicar para zotes como yo. Es un sensor análogico que mide la cantidad de luz reflejada por una superficie. De este modo, una superficie negra no refleja la misma luz que una blanca, permitiendo diferenciar el color de la superficie.

Lo que pretendo construir es un vehículo que tenga incrustado el arduino conectado a los dos sensores. Este arduino enviará la lectura de los sensores a Matlab a través de un cable usb. Matlab la interpretará y moverá los motores del vehículo acorde a través de la conexión bluetooth.

Lo ideal sería prescindir del cable usb y enviar la información a Matlab a través de un emisor rf, como ya hice con anterioridad. Pero es que de momento, tampoco sé alimentar al arduino con otra cosa que no sea un cable usb.

Comunicación i2c con Arduino

2011-04-09T10:51:00.012+02:00

El i2c es un bus serie para la transmisión de datos. Aquí seguro que lo explican mucho mejor que yo. Pero como pequeño resumen, el bus i2c tiene dos líneas importantes SDA para datos y SCL para la señal del reloj.

Las placas Arduino tienen soporte para este protocolo en los pines analógicos 4 y 5 y se proporciona una librería, Wire, para trabajar.

Así que lo que voy a explicar a continuación es un pequeño ejemplo de como dos placas Arduino se pueden comunicar a través de i2c.

El escenario será el habitual. Un Arduino hará de maestro y enviará al Arduino esclavo si se ha pulsado un botón para que ilumine un led y otro.

Aquí va el código para el maestro

#include 

int pinBotonRojo = 2;
int pinBotonVerde = 3;

int rojo = 1;
int verde = 2;
int azul = 3;
int nada = 4;

void setup(){
  Wire.begin();
  Serial.begin(9600);

  pinMode( pinBotonRojo , INPUT );
  pinMode( pinBotonVerde , INPUT );
}//setup

void loop(){

  Wire.beginTransmission(4);

  int valorBotonRojo = digitalRead ( pinBotonRojo );
  int valorBotonVerde = digitalRead ( pinBotonVerde );

  if ( (valorBotonRojo == HIGH) && (valorBotonVerde == HIGH) ){
    Wire.send(nada);
    Serial.println("Envío -> nada");
  }else if ( (valorBotonRojo == HIGH) && (valorBotonVerde == LOW) ){
    Wire.send(rojo);
    Serial.println("Envío -> rojo");
  }else if ( (valorBotonRojo == LOW) && (valorBotonVerde == HIGH) ){
    Wire.send(verde);
    Serial.println("Envío -> verde");
  }else if ( (valorBotonRojo == LOW) && (valorBotonVerde == LOW) ){
    Wire.send(azul);
    Serial.println("Envío -> azul");
  }

  Wire.endTransmission();

  delay(500);
}//loop

Y aquí va el código para el esclavo

#include 

int pinLedRojo = 2;
int pinLedVerde = 3;

int rojo = 1;
int verde = 2;
int azul = 3;
int nada = 4;

void setup() {
  Wire.begin(4);
  Wire.onReceive(receiveEvent);
  Serial.begin(9600);
  pinMode( pinLedRojo , OUTPUT );
  pinMode( pinLedVerde , OUTPUT );  
}

void loop(){}

void receiveEvent(int howMany) {
  int recibo = Wire.receive();
  Serial.print("Recibo : ");
  Serial.println(recibo);
  Serial.print("howMany : ");
  Serial.println(howMany);

  if( recibo == nada ){
    digitalWrite( pinLedRojo , HIGH );
    digitalWrite( pinLedVerde , HIGH );    
  }else if ( recibo == rojo ){  
    digitalWrite( pinLedRojo , HIGH );
    digitalWrite( pinLedVerde , LOW );        
  }else if ( recibo == verde ){  
    digitalWrite( pinLedRojo , LOW );
    digitalWrite( pinLedVerde , HIGH );        
  }else if ( recibo == azul ){  
    digitalWrite( pinLedRojo , LOW );
    digitalWrite( pinLedVerde , LOW );        
  }
}//receiveEvent

Aquí hay una foto del montaje final.

Y aquí un pequeño video para los incrédulos.

Como se puede ver es bastante sencillo utilizar el i2c del Arduino. Por lo menos para comunicar dos Arduinos.

El paso siguiente será conectar un Lego(c) NXT con un Arduino usando i2c. De este modo podré usar un Arduino como sensor para el NXT.

Emisor Receptor RF con Arduino (III): Conclusiones

2011-03-24T20:08:00.001+01:00

Los tutoriales que encontré por internet trataban el tema a tan bajo nivel que se me hacía imposible seguirlos. Esta librería te abstrae completamente de todo y sólo te tienes que preocupar practicamente de la función enviar mensaje y recibir mensaje. Te lo dan todo hecho. Aunque esto, para gente que le guste trastear más, pueda ser un inconveniente. Yo, sólo puedo decir cosas buenas de VirtualDrive para Arduino.

He probado el alcance, y a unos tres metros, que es lo máximo que me dan los cables usb, funciona igual de bien. No estoy usando antenas de ningún tipo. Debería buscar como alimentar al Arduino con una base de pilas. De este modo no estaría limitado al cable conectado al ordenador.

Lo siguiente que voy a intentar hacer en esta línea, es conectar el Arduino emisor al ordenador que leerá órdenes de un joystick, y un Arduino receptor al Lego(C) Mindstorms y tratar de manejarlo remotamente, al más puro estilo coche teledirigido.

Emisor Receptor RF con Arduino (II): Primer intento

2011-03-24T19:45:00.008+01:00

He estado buscando por internet tutoriales sobre el tema y de todo lo que he encontrado, lo que más esperanzas me ha generado, ha sido VirtualWire para Arduino.

Como dicen los creadores, y yo traduzco, "VirtualWire es una librería para Arduino que permite enviar mensajes cortos, sin direccionamiento, retransmisión o confirmación, como un UDP inalámbrico, utilizando ASK"

VirtualWire is an Arduino library that provides features to send short messages, without
addressing, retransmit or acknowledgment, a bit like UDP over wireless, using ASK
(amplitude shift keying).

El enlace anterior apunta a un documento donde está explicada perfectamente toda la librería. Lo cierto es que la API que proporcionan es bastante limpia y parece sencilla. Así que manos a la obra.

Lo primero que vamos a programar es la parte emisora y el código que he escrito es el siguiente. Es realmente sencillo. Lee cada medio segundo el estado de los botones y lo envía.

#include 

int pinRojo = 2;
int pinVerde = 3;
// me he dado cuenta de que no hace falta
// configurarlo para salida o entrada
int pinTx = 4;

void setup(){
  pinMode(pinRojo,INPUT);
  pinMode(pinVerde,INPUT);

  vw_set_tx_pin(pinTx);
  vw_setup(2000);

  Serial.begin(9600);
}//setup

void loop(){
  delay(500);

  int estadoRojo = digitalRead(pinRojo);
  int estadoVerde = digitalRead(pinVerde);

  char *mensaje = "VACIO";

  if ( (estadoRojo ==  HIGH ) && (estadoVerde == HIGH) ){
    mensaje = "A"; // rojo + verde = azul
  }else if ( (estadoRojo == LOW) && (estadoVerde == LOW) ){
    mensaje = "N"; // nada
  }else if ( (estadoRojo == HIGH) && (estadoVerde == LOW) ){
    mensaje = "R"; // rojo
  }else if ( (estadoRojo == LOW) && (estadoVerde == HIGH) ){
    mensaje = "V";      //verde
  }
  
  Serial.print("Enviado -> ");
  Serial.println( mensaje );

  vw_send( (uint8_t *) mensaje , strlen(mensaje) );   
}//loop

Y aquí se puede ver el circuito que he montado para el emisor. Está hecho con Fritzing. Como no tenía un componente para el emisor, he dejado el cableado suelto y he añadido las patillas.

Y ahora, vamos a por la parte receptora. También sencilla, cada vez que recibe un mensaje, lo compara y enciende el LED correspondiente.

#include 

int pinRojo = 2;
int pinVerde = 3;
int pinRx = 4;

void setup(){
  pinMode(pinRojo,OUTPUT);
  pinMode(pinVerde,OUTPUT);

  Serial.begin(9600);

  vw_set_rx_pin(pinRx);
  vw_setup(2000);
  vw_rx_start();
}//setup

void loop(){
  // esto es un poco engañoso porque sólo voy
  // a recibir cosas de tamaño 0
  uint8_t mensaje[VW_MAX_MESSAGE_LEN];
  uint8_t longitud = VW_MAX_MESSAGE_LEN;

  if (vw_get_message( mensaje , &longitud ) ){    
    Serial.print("Recibido -> ");
    Serial.println( mensaje[0] ); 
    
    if( mensaje[0] == 'A' ){
       digitalWrite( pinRojo , HIGH );
       digitalWrite( pinVerde , HIGH );       
    }else if( mensaje[0] == 'R' ){
       digitalWrite( pinRojo , HIGH );
       digitalWrite( pinVerde , LOW );             
    }else if( mensaje[0] == 'V' ){
       digitalWrite( pinRojo , LOW );
       digitalWrite( pinVerde , HIGH );             
    }else if( mensaje[0] == 'N' ){
       digitalWrite( pinRojo , LOW );
       digitalWrite( pinVerde , LOW );             
    }// if de caso de mensaje
  }//if de he recibido un mensaje 
}//loop

Y aquí se puede ver el circuito que he montado para el receptor. Está hecho con Fritzing. Como no tenía un componente para el receptor, he dejado el cableado suelto y he añadido las patillas.

Y me ha funcionado todo, más o menos a la primera, y no me lo creo todavía. He conseguido exactamente lo que pretendía en un principio. Aquí os dejo un video de esta maravilla funcionando.

Emisor Receptor RF con Arduino (I): Introducción

2011-03-24T19:35:00.003+01:00

Durante un arrebato consumista estas navidades, hice un pedido a una tienda de electrónica de un montón de cachirulos. Una de las cosas que pedí, fueron un par de módulos emisor y receptor de radiofrecuencia.

Y como el pedido me vino muy bien, rápido y no tengo ninguna queja, os he enlazado los productos a la tienda.

Lo que pretendo conseguir es conectar un Arduino a un emisor, y otro Arduino al receptor, y tratar que se comuniquen entre si utilizando la magia de las ondas.

Aprovecho para contar, que en mi arrebato consumista navideño, cayó un Arduino Uno. Para que juege con el Arduino Duemilanove que ya tenía, que estaba muy sólo ultimamente.

¿Cómo voy a probar que mis dos Arduinos se llevan bien, y hablan entre si? El Arduino emisor leerá los valores de dos botones, y el Arduino receptor encenderá un par de leds según el botón pulsado.

Vehículos dirigidos (III): Resultados

2011-02-21T18:40:00.000+01:00

Una vez que tenemos los valores de los sensores del mando en matlab lo único que queda es programación.

Aquí mi mayor problema ha sido que no he sido capaz de encontrar una explicación lógica a los valores que leía del mando, por lo que mi calibrado y mi código es un tanto artesanal.

Yo esperaba que dejando el mando en reposo, y moviendo sólo un eje, sólo obtendría valores distintos para ese valor. Nada más lejos de la realidad. Los valores que recibía del mando variaban todos.

Así que como ya he comentado el convertir los valores que leía en movimientos se ha hecho de manera artesanal.

Aquí os dejo dos vídeos, en el primero se maneja el vehículo con el joystick y en el segundo con el acelerómetro.

Vehículos dirigidos (II): Conectando nunchuck + wiichuck + arduino + matlab

2011-02-01T21:00:00.000+01:00

El objetivo es enviar los valores de los sensores del mando nunchuck al arduino.

Lo que aparentemente parecía muy fácil ya que hay cienes y cienes de tutoriales y librerías, no resultó tan fácil. Aquí os resumiré los pasos que he ido siguiendo y como conseguí que todo funcionara.

En primer lugar nos descargamos de aquí la librería nunchuck_funcs.h. Esta librería nos ofrece una interfaz muy sencilla para obtener los valores del mando.

// returns zbutton state: 1=pressed, 0=notpressed
static int nunchuck_zbutton()

// returns zbutton state: 1=pressed, 0=notpressed
static int nunchuck_cbutton()

// returns value of x-axis joystick
static int nunchuck_joyx()

// returns value of y-axis joystick
static int nunchuck_joyy()

// returns value of x-axis accelerometer
static int nunchuck_accelx()

// returns value of y-axis accelerometer
static int nunchuck_accely()

// returns value of z-axis accelerometer
static int nunchuck_accelz()

Quizás otro día explique como está construida esta librería por dentro e incluso que haga yo una, pero de momento me supera por todos lados.

Con esta interfaz tan sencilla, sólo nos queda escribir un pequeño código para arduino que recupere los valores.

#include 
#include "nunchuck_funcs.h"

int loop_cnt=0;

int accx,accy,accz,zbut,cbut,jx,jy;

void setup(){
  pinMode(10, OUTPUT); // LEYENDO INFORMACIÓN DEL MANDO
  pinMode(11, OUTPUT); // ENVIANDO AL PUERTO SERIE
  pinMode(12, OUTPUT); // ESPERANDO
  
  digitalWrite(10,LOW);
  digitalWrite(11,LOW);
  digitalWrite(12,LOW);
  
  Serial.begin(9600);
  nunchuck_setpowerpins();
  nunchuck_init();
}

/*
se queda iluminado durante x tiempo y sólo está a bajo nivel
cuando está recibiendo información
*/

void loop(){
  digitalWrite(10,HIGH);  

  nunchuck_get_data();

  accx  = nunchuck_accelx();
  accy  = nunchuck_accely();
  accz  = nunchuck_accelz();

  zbut = nunchuck_zbutton();
  cbut = nunchuck_cbutton(); 
  
  jx = nunchuck_joyx();
  jy = nunchuck_joyy();

  digitalWrite(10,LOW);  

  digitalWrite(11,HIGH);  
  Serial.print( accx );
  Serial.print(" ");
  Serial.print( accy );
  Serial.print(" ");
  Serial.print( accz );
  Serial.print(" ");
  Serial.print( zbut );
  Serial.print(" ");
  Serial.print( cbut );
  Serial.print(" ");
  Serial.print( jx );  
  Serial.print(" ");
  Serial.println( jy );  
  Serial.flush();
  digitalWrite(11,LOW);  

  digitalWrite(12,HIGH);
  delay(250);  
  digitalWrite(12,LOW);

}//loop

El utilizar los pines con los leds, sólo tiene la función de depurar la aplicación. Como se puede ver lo único que se hace es leer los valores y escribirles separados al puerto serie. Para probarlo, podemos arrancar el monitor serie del entorno Arduino.

Se ve como si movemos el mando, pues los valores se van cambiando y así se recogen, separados por espacios.

Si queremos leer con matlab el valor de un puerto serie, hay que utilizar el siguiente código. Que nos deja los valores en un array llamado loQueRecibo. Habrá mejores y peores maneras, pero mis conocimientos de matlab, no dan para más

Cosas importantes, el nombre del puerto USB al que está conectado el arduino y la velocidad de conexión.

placa = serial( 'COM16' , 'BaudRate', 9600 );
fopen( placa );
loQueRecibo = fscanf( placa );
loQueRecibo = sscanf(loQueRecibo,'%d');

De este modo tenemos en el array loQueRecibo, los valores que se recogen del nunchuck y que se pueden ver en el pantallazo del monitor serie.

Vehículos dirigidos (I): Introducción

2011-02-01T20:51:00.000+01:00

Hace mucho, mucho tiempo en una galaxia muy, muy ... ¡no!, espera, no era así. Pues eso, que hace mucho tiempo que no escribo nada en mi blog. Esto no quiere decir que haya estado sin hacer nada. He trasteado y mucho, pero no he obtenido los resultados que yo esperaba.

Para empezar jugué mucho con mi off-roader, le monté y desmonté e hice cajas y cajas de cambios, pero eso es otra historia. Y luego también hice muchas cosas con el arduino, y me compré un montón e componentes, pero eso es otra historia. La historia que os contaré hoy, trata sobre un nunchuck, un wiichuck, un arduino y un lego. Que si bien eran cada uno hijos de su padre y de su madre, hablaban usando un usb, bluetooth y un matlab.

Hay infinidad de videos en youtube que muestran coches manejados con mandos de la wii, o aparatos más extraños. En esta serie de entradas os voy a contar mis experiencias construyendo alguno de estos vehículos.

Espero que a alguien le sirva de ayuda. Empecemos.

Lego 8297 Off Roader (I): Contenido

2010-06-19T13:15:00.009+02:00

Pues de tanto mirar y mirar videos de youtube, al final pasa lo que pasa, que se te ponen los dientes largos, se te calienta la cabeza, y te compras cosas.

Mi último juguetito es, ni más ni menos, que el Lego 8297: Off Roader.

Aquí os dejo unas fotos de la caja, y del contenido.

He de decir que he estado alucinando sólo con la caja. Así que no sé qué pasará cuando la abra.

Semáforo con Arduino

2010-05-10T20:46:00.003+02:00

Hoy os voy a contar un muy, pero que muy simple proyecto que he realizado con Arduino.

Ya he utilizado resistencias, la placa de prototipado, algún cable y, aprovechando que tengo un emisor rojo, otro amarillo y otro verde ... pues he hecho un pequeño semáforo.

Aquí os dejo un vídeo, digno de varios Óscar, donde se ve el semáforo en funcionamiento.

El código fuente del programa, está también aquí, como se puede ver es muy sencillo y creo que tampoco necesita mucha explicación.


int pinRojo =  4;
int pinAmarillo = 3;
int pinVerde = 2;

void setup(){                
  pinMode(pinRojo, OUTPUT);     
  pinMode(pinAmarillo, OUTPUT);     
  pinMode(pinVerde, OUTPUT);     
}


void loop(){
  digitalWrite(pinRojo, HIGH);
  delay(1000);
  digitalWrite(pinRojo, LOW);
  delay(1000);

  digitalWrite(pinAmarillo, HIGH);
  delay(1000);
  digitalWrite(pinAmarillo, LOW);
  delay(1000);

  digitalWrite(pinVerde, HIGH);
  delay(1000);
  digitalWrite(pinVerde, LOW);
  delay(1000);
}

Para el próximo día, un semáforo con interruptores.

Hola Mundo u Hola LED

2010-05-03T15:45:00.006+02:00

Hoy voy a dar mi primer paso con Arduino. Al parecer para iniciarse en este mundo, tenemos un Hola mundo!, pero a lo Arduino, y con un diodo emisor de luz. Voy a seguir los pasos de este tutorial, que iré comentado con las cosas que me encuentre.

A mano todo lo importante

Lo primero que necesitamos es obviamente un Arduino, yo tengo un Duemilanove, así que a partir de ahora, mis referencias a Arduino, son en realidad a Arduino Duemilanove.

También hace falta un cable USB, de conector A a B. El que viene con nuestro Lego(c) MindStorms, sirve perfectamente. Esto es para conectar el Arduino con el ordenador.

Y por último hace falta el entorno de desarrollo de Arduino, que se puede descargar desde aquí. Sigo pendiente de volver a instalar mi distribución GNU/Linux favorita, Gentoo, así que voy a comentar todo sobre un Microsoft Windows XP SP3. Es un fichero zip, que descomprimimos donde queramos y hay que ejecugtar arduino.exe. Es una aplicación java, así que hay que darle tiempo. Ahora podemos ver una pantalla que tengo la impresión que se me va a hacer muy familiar dentro de poco.

Conectado Arduino a un ordenador por primera vez

Conectamos el Arduino con el cable USB y a Windows le da un jamacuco intentando reconocer el hardware, pero no hay problema. Le damos a buscar los controladores por nuestra cuenta y seleccionamos el directorio drivers del zip que hemos descomprimido en el paso anterior.

Ahora muy importante, que a mi no me funcionó nada la primera vez por esto, es configurar el puerto donde está escuchando el Arduino y que tipo es la placa.

Para ello nos vamos al menú TOOLS -> BOARD y seleccionamos la que tengamos.

Y ahora en el menú TOOLS -> SERIAL PORT. Ahora viene la gran pregunta ... ¿en qué puerto tengo conectado el Arduino?, truquele fácil, enchufamos el Arduino y vemos la lista de puertos disponibles, desenchufamos el Arduino y vemos cuál ha desaparecido ... ese será nuestro puerto.

Darle al play

Ahora viene la parte más fácil. En el menú seleccionamos FILE -> OPEN y buscamos en examples/digital/blink el fichero blink.pde. Vemos que un código se ha cargado en la pantalla principal del editor.

Ahora, con el Arduino conectado pinchamos en el botón de upload, que es como el de play y si todo ha ido bien ... veremos a nuestro Arduino haciendo lo siguiente.

Si algo ha fallado, nos toca buscar en este enlace.

Por hoy ya he tenido suficiente. Al próximo día más y mejor. Hay muchos tutoriales y vídeos por internet donde se pueden encontrar ideas interesantes. De momento no tengo nada definido de cual será mi siguiente paso

Arduino: entre mis manos

2010-05-03T15:36:00.007+02:00

Hoy por fin he podido recoger mi Arduino Duemilanove. Una vez más el servicio de FunGizmos ha sido muy bueno, correcto embalaje y protección de todo lo pedido y en un tiempo más que razonable.

Aquí os dejo algunas fotos de mi nuevo juguetito y de cómo ha venido. Una vez más, un diez para FunGizmos

Podeis ver que a parte he pedido también algunas resistencias, unos interruptores y unos diodos emisores.

Tampoco tiene mucho sentido contar cosas de un Arduino en un blog sobre Lego(c) MindStorms, pero como el objetivo es que en un futuro, todo esté dentro del mismo saco ... Además así tiene más actividad el blog.

¡ El arduino ! ¡Qué viene!. Tenía que hacer la gracia, lo siento. En breve mi primera aventura y espero que no desventuras.

WiiChuck

2010-04-05T15:24:00.005+02:00

Navegando por internet, que es una fuente inagotable de ideas trastear con nuestro Lego(R), me he encontrado con los siguientes enlaces, que vienen a tratar todos más o menos de lo mismo.

Resumen: se puede conectar el Nunchuck de Nintendo a NXT para controlarlo con el joystick y también servir de sensor de aceleración.

* Enlace al vídeo anterior en youtube
* http://forums.nxtasy.org/index.php?showtopic=3075
* http://www.hispalug.com/foro/index.php?topic=9882.0

En el segundo y tercer enlace, que la verdad, pongo como obligada lectura, se explica como conectar el nunchuk al nxt. Un foro en inglés, y otro en castellano. De todo un poco.

Aquí me pongo como objetivos:

* Aprender a utilizar el i2c (algo bastante general)
* Hacer con un Nunchuck un sensor para nuestro Lego (ejemplo concreto de lo mencionado anteriormente)

Ni corto ni perezoso he pedido un WiiChuck Adapter por internet. No tengo acciones de ninguna tienda ni me llevo beneficios, pero como la experiencia con Fungizmos ha sido muy buena, os la voy a comentar.

El WiiChick Adapter es, hablando un poco en plata, una pequeña placa que permite conectar un NunChuck a un cabezal de cuatro. Y luego ya se puede conectar este cabezal a cualquier invento electrónico que se nos venga a la cabeza, como por ejemplo, un Arduino

La pieza que pedí fue la siguiente. Se pudo pagar con PayPal, tuve tan sólo un dolar de gastos de envío y llegó en tres días, desde Estados Unidos a España. Experiencia 100% recomendable y asequible para bolsillos en crisis, 3,75 euros en total.

Aquí os dejo unas fotos de cómo vino embalado y del adaptador en cuestión.

Como se puede ver, no se han gastado mucho en embalaje, pero es que el producto, tampoco lo requería. Ha sido enviado por correo ordinario.

El adaptador es bastante pequeño, parece muy poca cosa, aunque espero que dé mucho juego a la hora de la verdad

Y poco más puedo contar de este nuevo juguetito de momento. Dentro de poco espero poder trastear un poco más con él y escribir la crónica de algún experimento interesante. Además en este afán consumista que me rodea ultimamente, he pedido hoy un Arduino y unos componentes básicos (leds, resistencias, y botones) para trastear un poco más con este tema.

En breve ... mis aventuras y desventuras con el Lego(R) y el Arduino.

Máquinas de Turing (II): Leyendo una cinta

2010-03-19T18:46:00.008+01:00

Voy a empezar a construir un robot que sea capaz de leer una cinta.

La cinta, serán tiras de papel de distinta longitud, puestas en línea recta por el suelo.

Y el robot encargado de leerlas, será este. Es un poco cutrecillo, porque está hecho a lo deprisa y corriendo, pero cumple su función con creces.

No voy a añadir un LDD en este momento, pero si un par de fotos para que veaís como se ha construido.

Y ahora vamos a ponerlo en marcha. Aquí tenéis el video, el cable que cuelga es el del usb, porque hoy no funcionaba la conexión bluetooth, yo creo que es porque llueve.

He registrado con matlab los valores que lee el sensor de luz y este es el resultado

Se pueden ver claramente que hay cuatro tramos de color blanco detectado, uno mediano, dos pequeños consecutivos y por último uno largo final. Que se corresponden con las tiras que había en el suelo.

Y con esto y un bizcocho, he hecho una primera aproximación a leer una cinta de una máquina de turing, no sé si el modelo final será así, pero para empezar me vale.

Máquinas de Turing (I): Primera toma de contacto

2010-03-19T18:36:00.003+01:00

Navegando por internet me encontré con algo que resultó muy interesante: máquinas de turing construidas con legos.

Este es el primer blog de máquinas de turing hechas con el nxt que encontré. El video, aparte de divertido, es bastante espectacular.

Utilizan el sensor de contacto para leer los valores de la cinta, montada sobre unos railes de lego. Y para escribir utilizan un motor que hace girar los cuadrados de lego.

La segunda referencia sobre legos y máquinas de turing la encuentro en el capítulo 3 del libro Lego Mindstorms Masterpieces.

En la previsualización del libro, en el índice, se puede ver una foto del resultado. No la pongo porque vete tú a saber que pasaría ... igual es ilegal y todo.

Aquí la cinta es una serie de "interruptores" fabricados con vigas de tres y un dispositivo motor que las gira de un lado al otro, posición borrar y escribir. Es un resultado un poco menos vistoso que el anterior.

Em ambos casos la cinta está limitada, podría ser interesante construir una máquina que tuviera cinta ilimitada.

Una vez que he visto todo esto y se me han puesto los dientes largos ... voy a ver como construyo mi propia máquina de turing.

Para empezar me hace falta un poco más de teoría sobre las máquinas de turing, para ver exactamente qué puedo construir.

Creo recordar así del tirón que había casos en los que no hacía falta escribir, sólo leer. En este caso por ejemplo con el sensor de luz podría leer líneas dibujadas en el suelo de algún color para distinguir

#ROJA# #VERDE## #VERDE# #ROJA# #VERDE#

Luego en matlab ver una gráfica del tipo ___---____----___ e interpretarla como 0 ó 1.

Mientras refresco todos mis conocimientos de máquinas de turing, voy a intentar construir un primer prototipo de este modelo.

Bueno, ya hemos empezado otra aventurita con el lego :D

laberintos (IX): resultado

2010-02-27T00:09:00.003+01:00

Mucha letra ... pero lo que más interesa es ver un video de todo esto que os he contado en funcionamiento.

Qué los disfruteis

Laberintos (VIII): Conclusiones y líneas de trabajo futuras

2010-02-27T00:08:00.000+01:00

Ya habéis visto que el que no tiene un lego que escapa de laberintos es porque no quiere. Voy a intentar resumir aquí las conclusiones que he obtenido de este experimento.

- El lego sigue sin parecerme una herramienta de precisión. Obviamente es un juguete.

Esto lo he visto muy patente a la hora de realizar los giros, que prácticamente nunca eran de 90 grados justos. A veces te giraba más y a veces menos. A veces avanzaba hasta la mitad del cuadrado y otras veces hasta el final

Esos pequeños fallos se iban acumulando y no se obtenían resultados buenos. El robot se iba de la habitación, se quedaba dando vueltas sobre sí mismo.

- Roborealm es la repanocha !!! le veo muchas posibilidades y todas muy interesantes. Creo que no va ser el último proyecto en que lo utilice.

- He utilizado un montón de herramientas y he visto como colaboran todas en paz y armonía para obtener el resultado final. Cámara web -> Roborealm -> Telnet -> Java -> Matlab -> Lego.

Que buen integrador soy :D.

Como futuros trabajos quiero proponerme que sea el propio lego el que sin ayuda de ningún sistema externo salga del laberinto. Ya tengo algo en mente, pero utilizando NXC, así que dentro de poco ... mis aventuras y desventuras con NXC.

Espero que os haya gustado esta entrada. Ale, todos a hacer el Prison Break

laberintos (VI) : algoritmo de búsqueda A*

2010-02-27T00:06:00.003+01:00

Esto si que es superior a mis fuerzas explicarlo ... así que aquí tenéis un enlace a la wikipedia, que seguro que lo explica mucho mejor que yo.

Lo que intento obtener del algoritmo, son las posiciones por las que tiene que pasar el robot para salir del laberinto. Y con qué acción se ha llegado a ellas.

Asi tenemos una lista de movimientos por ejemplo

AV, avanza
GT, gira 180 grados
GD, gira 90 grados a la derecha
GI, gira 90 grados a la izquierda

Para salir del laberinto hay que pasar por las siguientes posiciones

00,10,20,30,31,32,33,34,24,14,04,03,02,21

que son los siguientes movimientos del robot

GT,AV,AV,AV,GD,AV,AV,AV,AV,AV,GD,AV,AV,AV,GD,AV,AV,GD,AV

Estas son las instrucciones que le enviamos a Matlab. Las escribimos en un fichero de texto plano en un directorio en el que Matlab está escuchando constantemente en busca de instrucciones para enviar al robot.

Laberintos (V): ROBOREALM

2010-02-27T00:05:00.000+01:00

Roborealm es, hablando muy por encima, una aplicación de visión artificial y procesamiento de imagenes. Roborealm podría llenar por sí sólo blogs y blogs, así que lo que voy a contar aquí, no hace más que arañar la superficie de la cantidad de cosas que se pueden hacer con él.

En este ejemplo vamos a proporcionar sentido de la vista a nuestro robot. Y hablando más técnicamente, vamos a transformar una imagen de un laberinto, en información que pueda entender el robot. En este caso, una matriz de dos dimensiones, que indique si hay pared o hay camino libre para moverse.

Como se puede ver, lo que voy a intentar conseguir en que posiciones de la matriz habrá pared o no. Que podría ser perfectamente una matriz de booleanos.

Empecemos a trabajar con RoboRealm. Recordar que tenéis que jugar con ello para obtener buenos resultados y que yo disto mucho de ser un experto en su uso. seguro que se os ocurren muchas y mejores maneras de hacer lo mismo que yo.

Información en bruto

El punto de partida en RoboRealm es un dispositivo capturador de imagenes, como puede ser una cámara web, o una imagen, como es el caso que nos ocupa.

Sobre estas imágenes se aplican una serie de filtros de manera consecutiva que van filtrando, extrayendo, modificando ... de modo que podamos extraer información útil de la misma.

Lo primero que vamos a realizar sobre la imagen es aplicar el filtro Affine. Este filtro modifica los límites de la imagen para cuadrarla. Y fingir que estamos mirando el laberinto desde arriba. De este modo queda mucho mejor delimitado el laberinto.

De todo lo que aparece en la foto, sólo nos interesa los papeles verdes. Vamos a filtrar utilizando el RGB Filter.

Ahora ya sólo tenemos en la imagen información interesante. Vamos a centrarnos en obtener tres cosas: dónde está la meta, dónde está la salida y dónde están las paredes.

Obtener la meta
Como se puede ver en la imagen inicial, la meta está representada con un triángulo. Luego deberemos buscar en la imagen objetos con forma de triángulo. Yo lo he resuelto de la siguiente manera.

Utilizando el Blob Filter, podemos buscar formar en la imagen. En este caso queremos sólo buscar formas que tengan un área triangular y pulsamos CREATE BLOBS VARIABLE. Esta variable almacena el centro de gravedad de todos los objetos devueltos por el filtro. De este modo tenemos el punto donde está la salida dentro de la imágen.

Y ahora con el lenguaje de script que tiene roborealm, introducimos la variable BLOBS en la variable TRIANGULO.

Tras esta serie de pasos, tenemos en la variable TRIANGULO de RoboRealm la posición de la salida.

Obtener la salida

El procedimiento es similar. Volvemos a la posición de partida, con el marcador de inicio. Aplicamos un nuevo Blob Filter, pero esta vez buscamos objetos que tengan forma circular. Marcamos "CREATE BLOBS ARRAY VARIABLE"

De forma similar a antes introducimos la variable BLOBS en una nueva variable CIRCULO. Tenemos que hacer esto, porque si no, la llegada, habría sobrescrito el valor de la llegada.

Tras esta serie de pasos, tenemos en la variable CIRCULO de RoboRealm la posición de la meta.

Obtener las paredes

Las paredes se obtienen de manera similar. La única salvedad es que ahora tendremos no sólo un punto, sino un array de los mismos. Esto es importante de cara a recuperar los valores desde aplicaciones fuera de roborealm.

Aquí podemos ver los pesos que tienen las figuras, el triángulo y el círculo han desaparecido porque hemos ajustado un valor muy alto. De este modo podemos ajustar los objetos "más cuadrados", "más redondos" ... Este filtro es muy interesante y creo que es el que más juego puede ofrecer.

Tras esta serie de pasos, tenemos en la variable PAREDES de RoboRealm la posición de las paredes.

Comunicación con otros sistemas

Ahora voy a mostraros otra característica bastante interesante de RoboRealm, que es la comunicación con otros sistemas a partir de su API. Vamos a facilitar toda la información que ha extraído RoboRealm a la imagen, a un pequeño programa escrito en java. Este programa será el encargado de encontrar una salida al laberinto. Pero eso será en otra entrada.

De este modo estoy separando el procesado de la imagen, con el procesado de la información extraida de la imagen. Así, detrás de RoboRealm, podemos tener cualquier otro sistema de resolución de problemas, más apropiado al caso que nos concierna.

El uso de la API es bastante sencillo. Roborealm disponibiliza un servidor de telnet al que podemos atacar, por ejemplo, solicitando variables con

 
<request>
  <get_variables>VAR_1_NAME, VAR_2_NAME, etc.</get_variables>
</request>

y aquí podemos ver como Roborealm nos ha devuelto los puntos donde estaban las paredes.

Y con esto he dado una pequeña introducción a RoboRealm. Espero que haya quedado relativamente claro, y animaros una vez más a trastear por vuestra cuenta, porque con la visión artificial se amplían bastante los límites de los proyectos que podemos emprender con nuestro robot.

laberintos (IV): ¿Qué vamos a utilizar?

2010-02-27T00:04:00.001+01:00

Todo esto está muy bien: tenemos un lego, un laberinto en el suelo ... pero nos falta algo. ¿Cómo vamos a hacer a lego inteligente para encontrar la salida? ¿Cómo va a ver el lego el laberinto? ... hay muchas preguntas, así que vamos a contestarlas por partes.

¿Cómo va el lego a interpretar el laberinto?
Vamos a utilizar Roborealm. Es un software de visión artificial. De este modo, podemos hacer que el lego "vea" a través de roborealm (mediante una foto del laberinto o una cámara web enfocada al laberinto), dónde está metido.

Una vez que ya sabe dónde está metido ¿Cómo va a saber salir?
Para esto vamos a usar inteligencia artificial. Vamos a aplicar algoritmos de búsqueda de soluciones sobre lo que ve Roborealm y dar una solución al problema.

Chuck Norris una vez tuvo un Lego Mindstorms. La televisión hizo documental sobre él, le llamó The Terminator.

Uff, muchas cosas ¿Cómo lo vamos a unir todo?
Es un poco lio la verdad, pero lo voy a intentar explicar lo mejor que pueda.

Roborealm va a reconocer la información del laberinto.

Esa información va a ser procesada por un algoritmo de búsqueda de soluciones implementado en java. De este algoritmo se obtienen una serie de movimientos que son los que tiene que hacer el robot para salir del laberinto.

Mediante matlab vamos a enviar esa serie de movimientos al robot para que salga del laberinto.

Es importante resaltar que no es el bloque el que sabe salir del laberinto, si no que se limita a escuchar los movimientos que le llegan.

Hay una entrada para cada una de estas partes, así que allí intentaré explicarlo un poco mejor

Vamos al lío !!!

Laberintos (II): el laberinto

2010-02-27T00:02:00.000+01:00

Vamos a hablar de las partes de las que va a constar este experimento: un lego saliendo de un laberinto. Creo que a estas alturas todos sabemos lo que es un lego, así que no queda otra que hablar del laberinto.

Recortando trozos de papel cuadrados he dibujado en el suelo de mi habitación un laberinto cuadrado 5x5 como puede ver en la siguiente imagen. Los bordes no están limitados por otros cuadrados, si no por las dimensiones.

El robot se puede mover por el suelo que no está ocupado por cuadrados verdes.

La salida estará representada por un triángulo y el punto de llegada con un círculo.

Y aquí diferentes laberintos.

Si mi habitación fuera más grande ... pues podría hacer un laberinto enorme.

Lo que pretendo es que el robot situado en la entrada, vaya hacía la salida.

Con esto creo que ya está explicado el dominio del problema.

Laberintos (I)

2010-02-27T00:00:00.000+01:00

Hola a todos,

Hace bastante bastante tiempo que no publico nada. No es que haya estado sin tocar estos temas, pero nada de lo que he intentado me ha salido bien.

Aunque hoy escribo porque tengo un nuevo tema, y he obtenido un bonito resultado. A lo largo de las siguientes entradas podréis ver como mi lego escapa de un laberinto dibujado en el suelo.

Un saludo y espero que la espera haya merecido la pena.

Vehiculo que aparca sólo (SPC, Self Parking Car)

2009-06-27T21:37:00.007+02:00

Uno de los robotos hechos con el nxt más recurrentes que podemos encontrar por youtube (fuente inagotable de inspiración), son los llamados SPC.

He modificado un poco el siguiente diseño de nxtPrograms, y he obtenido lo siguiente, un pequeño coche con dirección.

Lo importante de este diseño es la dirección, que nos permitirá girar para aparcar el coche. Además de ya por fin ver cumplido mi sueño de construir un vehículo con dirección)

Y el sensor de ultrasonidos, que nos permitirá encontrar huecos en la carretera o sobre una mesa con libros, donde podamos aparcar el lego.

El resultado que he obtenido es el siguiente.

El resultado es medianamente aceptable. He tenido que recordarme a mi mismo que tengo que hacer prácticas de aparcar con el coche de nuevo, y comprarme coche ya de una vez también.

El sensor de ultrasonidos, tan sólo se usa para encontrar un hueco para aparcar, los demás giros que hace el lego, están metidos a capón en el código del programa. Ha sido un caso de programación por prueba y error. Como veis no entra mucho en el hueco, se queda más bien fuera, sospecho que es probelma de que la dirección no gira tanto como debería.

Esto es un modelo muy sencillo, pero ya que estamos, voy a ver si lo mejoro un poco. He visto en youtube dos videos realmente interesantes.

Este lego me ha gustado mucho porque creo que se asemeja mucho a lo que hace un conductor real cuando aparca, una vez que el coche está medio metido, avanza hacia delanta y atrás mirando hasta que el coche esté bien encajado.

No parece muy complicado añadir esta modificación al lego que tenemos entre manos, aunque eso será otro día.

Este video se lleva la palma, especialmente los últimos segundos, cuando se vé quien hace realmente toda la chicha. El autor no da ninguna información sobre el proceso o que usa para hacer ese gráfico tan bonito que da la ruta que debe tomar el robot. Sólo que está hecho con .net.

Parece un caso para matlab y alguna de sus toolbox. Investigaré un poco y veré que puedo encontrar.

Me he puesto dos objetivos de tarea, a ver si cumplo alguno.

Rotar 360 grados sobre si mismo

2009-03-09T12:04:00.009+01:00

Hoy voy a dar una solución a un problema que creo que todos los que jugamos con nuestro lego nos hemos encontrado alguna vez. Hacer una rotación completa en el sitio.

Es una situación bastante común

Un robot que analice el entorno para detectar algo. Como el ball hunter de nxtprograms, o mi fallido intento de hacer un mapa del entorno.
Un robot que vea algo que no le guste y de media vuelta. Como por ejemplo la demo del nxt.

Para hacer que el tribot gire sobre si mismo, lo que todos hemos hecho alguna vez ha sido poner que los motores giren 360º cada uno, pero en sentido contrario. Pero ... ¡¡¡ se queda corto, no gira más !!! ... ¿Nos suena esto verdad? algo no cuadra.

Un poco de geometría, nos dará no sólo la solución sino que nos ayudará a comprender el problema. Lo principal es recordar que el perímetro de una circunferencia es pi * diámetro ó pi * 2 * diámetro.

Pongamos de ejemplo la vuelta de una rueda de bicicleta (el reflectante empiece en el punto más bajo y vuelva a estarlo). La distancia que ha recorrido la bicicleta es pi*diámetro. También, la rueda de la bicicleta, ha girado 360 grados. Es decir, para girar 360º hace falta recorrer el perímetro completo.

Ahora mirad el siguiente dibujo. Es nuestro tribot visto desde arriba y dibujado por un pintor abstracto. Los rectángulos de los lados son las dos ruedas del tribot y la circunferencia sobre las que están, es lo que tienen que girar para hacer un giro completo. Para que el tribot gire completamente sobre sí mismo, cada rueda tiene que girar volviendo a su posición original.

Nuestro fallo, es que hacemos que cada rueda gire 360º, es decir, pi*diámetro, cuando en realidad lo que tienen que recorrer es pi*distancia entre las dos ruedas,que es el diámetro de la circuferencia grande.

Ahora unas fórmulas que nos harán la vida más fácil y también la correspondencia entre grados, radianes y coordenadas polares.

Las veces que tiene que girar la rueda para volver al origen, o para recorrer 360º pi*distancia entre ruedas / pi * diametro rueda = distancia entre ruedas / diametro rueda.

Si queremos que el giro no sea de 360º sino de un número de grados en concreto, pues una regla de tres. Dividimos entre 360º para sacar lo que recorre en un grado y multiplicamos por n, número de grados. (distancia entre ruedas * número de grados) / (diámetro ruedas * 360º)

Sobre radianes y grados. En este enlace de la wikipedia, os lo contarán mucho mejor que yo. Pero recordad que pi radianes son 180º.

derrotado otra vez

2009-01-30T20:40:00.004+01:00

Retomando mi última creación.

Estaba totalmente seguro de que el problema era que las paredes estaban muy lejos, por lo que situaba al nxt en un entorno mucho más reducido (un "corral" hecho con libros), obtendría mejores resultados. También incluí algunas mejoras en el programa, como por ejemplo la normalización de datos

Nada más lejos de la realidad.

Esto es lo que detectaba si el robot estaba totalmente encerrado dentro de un cuadrado hecho de libros. Hay puntos repartidos por todo el contorno. ¡¡¡ Pero no equidistantes del centro !!!

Y esto lo que detectaba si quitaba una pared del cuadrado. En la parte de abajo de la gráfica no hay ningún punto detectado.

Como veis con mucha mucha imaginación ... algo se puede sacar. Pero visto que rodeando al robot con libros tampoco obtengo buenos resultados, voy a desistir de este modelo y cambiar la construcción del robot.

Lo único que girará será el sensor de rotación y extremadamente lento.

No obstante, esto me ha servido para probar la facilidad con que en matlab puedo representar gráficas, eliminar ruido, calcular medias ...

A ver si tengo tiempo y pongo un pequeño video del robot dando vueltas ... no hace nada, casi me da verguenza enseñarlo.

primera aproximación a un robot que detecta su entorno

2009-01-18T18:50:00.012+01:00

En este nuevo proyecto, quiero abordar la construcción de un robot que "vea" el entorno en el que se encuentra, e intente alejarse lo más posible de su punto de partida. Para ello aprovecharé el modelo de robot que presenté en este mismo blog y sustituiré el sensor de intensidad de luz por el sensor de ultrasonidos. El modelo resultante lo podeis ver aquí mismo.

El funcionamiento que tengo en mente es el siguiente: que el robot gire 360º sobre sí mismo a la vez que recopila información sobre su entorno mediante el sensor. Esta información es la distancia a los objetos que existen a su alrededor.

Lo que pretendo es averiguar el punto que más alejado esté del origen y desplazar el robot hacía allí, y repetir el proceso otra vez. Teniendo en cuenta de que no vuelva por donde haya venido.

Este proyecto en nxtprograms hace algo muy similar a lo que yo quiero, por lo que bajaré el programa para el nxt-g y estudiaré las partes que me puedan venir bien.

Lo más interesante del programa es lo siguiente. Se puede ver que si se encuentra un objeto, a una distancia menor que un objeto que ya tuvieramos localizado, guardamos este nuevo objeto como el más cercano, a la vez que también guardamos la nueva posición.

Es interesante ver como la posición se guarda reseteando la cuenta de grados recorridos por el motor, de este modo al rotar el motor a su posición inicial tendremos el objeto más cercano delante.

También se puede ver como no hay ninguna medida estándar para que el robot gire 360º sobre si mismo. Haciendo pruebas he calculado que unos 600º de giro de una rueda equivalen a 360º del robot.

A continuación esbozo un pseudocódigo de lo que hace el robot mientras gira

variable distanciaMasLejana <- 0

variable gradosDistanciaMasLejana <- 0

mientras el robot gira

variable valorRecogido <- recojo medición del sensor de ultrasonidos

si valorRecogido > distanciaMasLejana // es decir, hay un punto más lejano al que puedo ir que el que tenía almacenado

distanciaMasLejana <- valorRecogido

reseteamos motor

fin si

fin mientras el robot gira

Una vez que haya finalizado el giro del robot, en la posición inicial de giro tendremos el camino más largo para andar.

Teniendo en cuenta todo lo anterior ... vamos a entrar en harina. Un poco de matlab por aquí y por allá, un par de maldiciones ... y más o menos ya lo tengo. Antes de todo unas consideraciones

Como he hecho en robots anteriores, tomar varias medidas y luego hacer la media, no funciona aquí. Se podría pensar que si el robot en vez de dar una vuelta, diera cinco se tendría mucha más precisión. Se obtiene todo lo contrario. Como los grados que se recorren no son exactamente múltiplos de 360º, y el sensor está moviéndose contínuamente mientrasa hace mediciones ... a más vueltas, lo que se obtiene el que es robot está rodeado de todos los obstáculos.

Es bastante complicado interpretar el dibujo resultante. El que se ve a continuación es el del robot situado en medio de un pasillo. Con paredes cerca a los lados y paredes al principio y al final del pasillo que no se ven. Se puede ver que con cada ejecución del programa, obtenemos un resultado bastante diferente.

Voy a filtrar en el resultado los valores muy altos, para ello no voy a mostrar en el resultado aquellos valores que estén muy por encima de la media. Se puede ver como ahora el resultado es un poco más intuitivo.

Aqui vemos el resultado con una botella. La verdad es que no se ve nada ... por lo que deduzco que sólo podrá detectar objetos pequeños.

Más que suficiente para una entrada en el blog. Voy a titularla primera aproximación a un robot que detecta su entorno. Es una primera aproximación por que intuyo que esto no va a funcionar realmente.

Es incapaz de localizar objetos pequeños en distancias medias.
Los gráficos resultantes son extremadamente dificiles de interpretar.
A parte que hay como dos tipos de gráficos: unos con los puntos bien delineados y otros con grupitos curvados. Ignoro a qué se debe eso todavía.
El robot no puede girar excesivamente lento, ya que necesita algo de potencia para mover todo su peso. Esa es la razón de los gráficos tan extraños.

La solución podría ser cambiar totalmente el diseño del robot. Montando el sensor sobre un servo, que gire extremadamente lento y consiga unos resultados más precisos con muchas más mediciones por giro. Pero eso ya será en otra ocasión.

También este robot podría tener otro ámbito de actuación, como por ejemplo un laberinto de paredes estrechas. Sería interesante probar su desarrollo en un campo de esas características.

En la próxima entrada acabaré el programa, probaré el robot en varios entornos y subiré algún video.

Un saludo a todos.

Clasificación First Lego League Madrid 2008

2008-12-14T19:19:00.006+01:00

Hoy he tenido la oportunidad de trabajar como voluntario en la ronda clasificatoria de la First Lego League 2008 española que ha tenido lugar en Madrid. Mi colaboración ha sido más bien escasa al ser mi primer año y se ha reducido a vigilar a los chavales en el PIT o área de entrenamiento, en la lengua del Cantar del Mio Cid.

En el área de entrenamiento los chavales disponen de una réplica del tapete de juego donde se hacen las eliminatorias oficiales, y les sirve para hacer los últimos retoques a los robots.

Los chavales parecen ser igual que los mayores, porque salvo un grupo al que no le he visto entrenar casi nada (los ganadores finales he de añadir), los demás han dado buena cuenta de su tiempo de práctica.

Esto me ha dado la oportunidad de ver un montón de robots interesantes. La verdad es que me han sorprendido varios de los robots, para estar hechos por chavales. Había mecanismos muy ingeniosos. Muchos de ellos programaban con labview dejando de lado al nxt-g.

A título personal diré que me hubiera gustado poder echar un ojo a los proyectos más en profundidad, puede que al próximo año si sigo de voluntario, intente hacer de juez de proyecto técnico. O tal vez se podría sugerir que los proyectos ganadores se alojen en una especie de repositorio al más puro estilo nxtLog (un modelo lxf y un documento con su documento técnico )

La final española será en el Cosmo Caixa de Barcelona el día uno de febrero de 2009.

Enhorabuena a los ganadores, y mucha suerte en la ronda final española.

Ya por último, otro pequeño evento de robótica usando lego. El viernes se celebró el V Certamen de Robótica Educativa, la complubot. Podeis ver el evento, que fué retransmitido en directo aquí. Unos combates de sumo, laberitnos, y seguidores de líneas, y se presentó lo que puede ser un nuevo sensor de movimiento: wedo

vehículo para muchos propósitos

2008-12-13T20:43:00.006+01:00

Hola a todos, hoy me gustaría presentaros un modelo de vehículo que pretendo usar para varios modelos como base.

Es un pequeño vehículo capaz de ir en cuatro direcciones a ras de suelo, pero con la peculiaridad que se deja poner en la parte adelantada cualquier sensor, apuntando al frente o al suelo. Esto nos permite hacer con él, dependiendo del sensor que coloquemos, robots con propósito totalmente diferente.

Con este diseño consigo que robot y sensor giren a la vez, haciendo posible recopilar datos de los 360 grados. Si sólo girara el sensor, quedando el resto del robot fijo. El cable que une sensor-bloque, se enrollaría sobre si mismo quitando maniobrabilidad al conjunto.

El procedimiento para colocar los sensores, va a la imaginación de cada uno, pero viendo el modelo, creo que lo tendreís bastante fácil.

Este modelo en concreto con el sensor de luz apuntando hacia el suelo, lo he utilizado para programar el típico robot que sigue la línea del tapete. Lo he programado en matlab, para variar y la verdad es que he tenido buenos resultados.

No he conseguido que sea tan rápido como mi anterior intento usando el nxt-g. Creo que al tema motores, sensores ... no le acabo de coger bien el truco con la toolbox. También cabe la posibilidad, de que todo sea debido a que he usado bluetooth, y tiene un retardo mayor que el usb, o el programa embebido. No he hecho ningún video porque no he aportado nada distinto al que ya tenía hecho.

Ahora quiero usar este modelo de coche con el sensor de ultrasonidos para hacer un robot que salga de laberintos o alguna cosa similar. Ese es mi próximo proyecto.

Aunque siguiendo con el tema de seguir líneas ... tengo otro proyecto en la trastienda. Mirad que video más espectacular.

He hablado con el autor y muy amablemente me cedió el lxf y el rbt asociado, así que creo que intentaré repetir su proyecto y programarlo con matlab. Ya os contaré. Muchas gracias cesky79. Youtube es sinduda una fuente inagotable de sabiduría

Voy a volver a casa por navidad, como el turrón, así que estaré un poco aislado de mi lego. Tendreís noticias mías a la vuelta de vacaciones.

¡ Felíz navidad a todos !

Adaptador Bluetooth

2008-11-28T09:31:00.008+01:00

Me ha dado por utilizar la rwth toolbox para programar el nxt, y como ya he comentado tiene dos modos de funcionamiento: con un cable usb conectado siempre al equipo donde corra matlab o mediante bluetooth. Como tener el cable usb quita mucha libertdad de movimiento, me he decidio a comprar un adaptador bluetooth.

La cosa parece bastante sencilla; vamos a la tienda, cogemos el más bonito, enchufamos y listo. Pero en la realidad esto es un poco distinto. Empecemos con un poquito de documentación.

Bluetooth es un especificación de comunicación en redes inalámbricas de área personal. Estas con redes muy pequeñas, y para un uso específico: pasar una canción entre móviles o conectar el gps en el coche. Al ser una especificación, los fabricantes lo implementan luego como quieren apareciendo sutiles diferencias entre las distintas implementaciones. Cuando los dispositivos se construyen para una máxima conectividad o son dispositivos de uso general: móviles, pdas, equipos con windows, gps ... no se aprecian problemas en el uso de las distintas implementaciones. Pero cuando el dispositivo a conectar es algo especial, en mi caso nxt sobre matlab, la cosa cambia, ya que el protocolo debe tener en cuenta más cosas. La conclusión es, que no todos los dispositivos bluetooth nos servirán para controlar remotamente el nxt.

Un buen punto de partida es la documentación oficial de lego al respecto. Allí podemos ver una matriz de compatibilidad con cabezas lego que no todos los pares dispositivos/adaptador son soportados. No están todos los modelos del mercado ni mucho menos.

Como punto de partida está bien, pero necesito algo más, experiencia real, así que habrá que investigar por los foros. Desde aquí recomiendo los foros de nxtasy, que tienen un montón de cosas interesantes, además de experiencias de otros usuarios de nxt.

Tras mucha búsqueda y mucho leer, en este hilo se resumen mucho el tema del adaptador. A modo de resumen diré que los modelos recomendados son aquellos adaptadores cuyos drivers bluetooth sean de Widdcom, o que usen la implementación de Microsoft Windows XP SP2.

Ahora viene cuando la matan, porque a parte de querer un adaptador compatible con el nxt, necesito uno compatible con la toolbox. Asi que, mirando su matriz de compatibilidad y algún comentario que deja Linus, uno de los programadores de la toolbox en los foros de nxtasy, lo que funciona con uno ... no tiene que poder funcionar con el otro.

Desesperado porque era practicamente imposible concicilar un dispositivo que apareciera en las dos listas, que usara controladores Widdcom y que se vendiera en tiendas ... al final me decidí por el conceptronic cbt200u2a, animado por comentarios en un hilo del foro.

Que funcionara con el nxt-g fue muy sencillo, enchufar y listo (bendito plug & play), independientemente de los controladores que instalara. Otra cosa fue la toolbox.

Con los controladores de Microsoft y Widdcom, me fue imposible hacerlo funcionar. Creo que es porque estos dos controladores crean dos puertos serie para la comunicación, uno de entrada y otro de salida, y la toolbox requiere uno bidireccional. En uno de estos intentos desesperados actualicé el firmware del bloque a la última versión, la 1.05. Fué rápido e indoloro. Seguramente haga una entrada para contar como fué.

Al final ya un poco asqueado probé a instalar los controladores toshiba que venían con el adaptador. Según los foros ... esto no iba a funcionar ni de coña, pero ver que sólo creaba un puerto COM ... la esperanza volvió. Hice una prueba rápida y fuí capaz de mover un motor a distancia.

Me gustaría probarlo sobre gnu/linux, pero ahora mismo no tengo ninguna distribución instalada. Me imagino que no haya ningún problema porque la pila bluetooth la proporciona el propio kernel y si alguien ha conseguido hacerlo funcionar en una distribución, funcionará en todas al compartir el núcleo. Pero es sólo una suposición.

Conclusión: lo de los bluetooth es una lotería, hay que recorrerse muchos foros y ver opiniones de usuarios con el mismo dispositivo que quieras adquirir, y recorrer muchas tiendas hasta encontrar en la que vendan tu modelo. Y luego para ver como funcionan exactamente con lo que dice la gente que no va a funcionar. Lo bueno, que son baratos, me costó once euros y un céntimo.

Como era muy tarde, no hice más pruebas, aunque espero este fin de semana probarlo bien, ya que tengo en mente volver a hacer un seguidor de líneas. Ya sé que tengo uno hecho, pero ahora le intentaré hacer desde cero y con matlab, y por bluetooh !!!

Lego Digital Designer (LDD)

2008-11-24T10:10:00.007+01:00

Lego Digital Desisgner es una herramienta de diseño gráfico para inmortalizar nuestras creaciones lego.

Existen muchas otros programas. Leyendo un poco las dos opciones más importantes que he encontrado por internet son LDraw y la que os presento hoy, LDD. Me he decantado por esta última porque he encontrado pequeñas dificultades a la hora de hacer funcionar LDraw. Espero que este pequeño problema mio, no os desanime a probarlo.

Tras modelar la pieza del separador de bolas, puedo decir que su instalación y uso es bastante sencillo.

Podemos descargar el instalador de la página de descargas. El programa está mantenido por el propio Lego y a día de hoy la versión es la 2.0. No he encontrado ningún histórico de instalaciones, aunque no descarto que exista. La aplicación se conecta a internet al arrancar para descargarse nuevos modelos de piezas.

Una vez abierto, recomiendo el visionado del get Started. El programa es muy sencillo y fácil de manejar. Se coge el ritmo bastante rápido.

He de decir que sin tener una máquina especialmente potente (Intel Pentium IV a 2Ghz y 1 GB de memoria), el programa va bastante fluido. Esto para mi es un punto muy a tener en cuenta. Yo he usado la versión que funciona sobre windows.

Una cosa que me ha llamado bastante la atención es que una vez hecha la pieza, el programa genera secuencias de instrucciones para la construcción de la misma, lo cual está bastante bien. Eso sí, las instrucciones que genera por lo menos para mi. no tienen mucho sentido.

Enumero a continuación, a modo de resumen los pros y los contras que más me han llamado la atención.

Ventajas

Es freeware, su uso no conlleva gasto alguno.
No consume muchos recursos.
Curva rápida de aprendizaje.
Genera automáticamente instrucciones de montaje.
Es un producto oficial de Lego, por lo que se nos da acceso a otros servicios de Lego, como puede ser la Lego Factory, o saber que siempre tendremos soporte para todas nuestras piezas.

Desventajas

No se puede ejecutar sobre plataformas Linux.
Lego Factory no da soporte para modelos que utilicen piezas technics. No es una desventaja del programa, pero es un efecto colateral.
La gente "experta" en el modelado considera que es un buen punto para empezar pero que no es muy potente.

Yo de momento voy a usarlo algún tiempo, luego ... ya veremos. Con este artículo sólo pretendo dar una pequeña introducción al mundo del modelado a través del LDD.

Separador de Bolas

2008-11-21T19:44:00.007+01:00

Hola,

Este blog seguramente no tiene ningún seguidor, pero aún así pediré perdón por llevar tanto tiempo sin escribir. Después de vacaciones, mudanzas y un sin fin de historias raras ... al fin he vuelto a cacharrear.

Quiero presentar en esta entrada varios temas que yo considero muy interesantes. mi tiempo de inactividad en el blog no ha sido un tiempo de inactividad con mindstorms.

Lo primero de todo ... http://www.mindstorms.rwth-aachen.de/ como podreis ver es una toolbox de matlab para programar el nxt. Hay muchas formas diferentes de programarlo, pero os voy a explicar las razones que me han llevado a elegir esta.

no es necesario cambiar el firmware del bloque, lo cual para los temerosos de los briqueos (jugador de psp y wii) como yo, es un riesgo eliminado.

control mediante bluetooth o usb. con esto podemos hacer que nuestro robot se vaya de paseo por el pasillo mientras lo controlamos a distancia. y el usb, pues para gente que todavía no tiene bluetooth, como soy yo

es matlab. así que tengo toda la potencia y versatibilidad de un lenguaje de programación de alto nivel (para mi es más fácil hacer un bucle for que un dibujito con el nxg) con la potencia de matlab. puedo tomar 200 mediciones del sensor de luz y luego hacer una media con una simple llamada a la función mean, o representar gráficamente un barrido circular del sensor de ultrasonidos para ver un mapa de la habitación a la altura del lego.

se aprenden bastantes cosas de como funciona el bloque por dentro, los mensajes que se mandan de control, funcionamiento intero del motor ...

como desventajas

no se pueden "bajar" programas al lego por bluetooth ni por el usb, los comandos se ejecutan desde la consola de matlab teniendo el bloque encendido. siempre se depende de un matlab corriendo.

el matlab necesrio es la versión 7.4, que es bastante pesada

dicho todo esto, os animo a que lo probeis, la verdad es que a mi me ha sorprendido bastante y ha pasado a ser mi forma estándar de programar con el bloque.

Ahora pasemos a harina. en este video podeis ver la vida que he creado.

si no os habeis arrancado los ojos debido a la pésima calidad del mismo os doy mi más sincera enhorabuena. mi webcam no da para más, estoy pensándome mucho el comprar una cámara digital para inmortalizar estos momentos lego y también, claro está, del resto de mi vida. ( Se aceptan donativos :D)

como podeis ver es un separador de piezas, en este caso bolas del sobrevive de mb, que tenía rondando por casa así que antes de donarlo a algún primo pequeño, pues a jugar con las bolas.

para reconocer las bolas he utilizado el sensor de luz. he realizado 500 mediciones de la intensidad, y luego calculado la media. (bucle y mean, fácil en matlab). para cada color se tenían unos valores más o menos diferenciados, así que eso he usado para separarles. la medición dependía de la intenesidad de luz de la habitación así que con la lámpara pues he intentado que fuera constante. como podeis ver en el juego hay bolas de cuatro colores, pero el sensor de luz no me daba valores muy separados para cada uno de ellos, así que me era imposible separarlos. con el negro y el azul, obtenía medias muy distantes, así que esa es la razón de que les haya usado.

una vez que se reconocía la bola, había que mover la pala hasta el recipiente.

para esto la verdad es que me he buscado bien las castañas, he construido una base, que soporta el motor y con la doble rueda he conseguido hacer una plataforma móvil. si veis los dibujos estará mejor explicado.

para la pala me he inspirado en algunos modelos de brick sorteres que he visto por internet.

el principal problema que he encontrado aquí es la inercia que se gastan los motores. me explico, tu le dices que se mueva 90 grados y cuando el motor lleva 90 grados movido, deja de suministrar energía pero el motor sigue girando por que conserva su momento angular.

esto tiene una solución y es la de regular la velocidad de moviemiento del motor. si el motor se pasa, el mismo se recupera marcha atrás. una vez concluido el moviemiento, el motor no se queda en el modo COAST (libertad de movimiento) sino que se queda en modo BRAKE. se le está suministrando energía para que no se mueva y es imposible de mover a dedo. hay que añadir que este modo requiere mucha energía.

a este pequeño inconveniente hay que añadir que he leido que usando la regulación de velocidad y pequeños movimientos del motor, se acaba perdiendo precisión del mismo. sigo investigando esto, porque no me ha quedado muy claro.

podeis ver como cuando vuelve a la posición inicial no queda en el mismo lugar. así que también hay que jugar un poco de por donde poner los recipientes.

creo que eso es todo. espero haberme explicado bien. y que me hayas entendido.

Aquí podeis descargar el modelo usando el LDD, lo he divido en tres ficheros para que se vea mejor. de momento no hay nada incluido de instrucciones, vistas y demás, que aunque veaís que no se puede incluir desde la propia aplicación, el formato si lo soporta.

base

pala

completo

y el código fuente en matlab. es una guarrada de código ... os aviso, así que por esta vez ... haced con él lo que os dé la gana, más adelante lo publicaré bajo alguna licencia.

código fuente

el proyecto que tengo ahora en mente es un robot que sea capaz de explorar su entorno y moverse lo más alejado de su punto de origen. para ello usaré las capacidades bluetooth, así que ahora mismo estoy mirando modelos de dispositivos bluetooth, habrá una entrada sobre ellos y características recomendables, no os preocupeis. es un tema un poco más peligudo de lo que parece.

un saludo y no hagais nada de lo que os podais arrepentir

Cumpliendo objetivos

2008-06-26T16:43:00.003+02:00

este pasado finde estuve programando el lego que seguía líneas el solito.

tras empaparme de los programas de nxtPrograms. me puse a programar yo solito pero esta vez que siguiera la línea por dentro y no por fuera. como en el colegio, que te ponían un problema y luego te mandaban otro para casa con los datos cambiados. o como en la universidad que te ponían un problema y ... no espera, en la universidad no.

lo hizo bastante bien, pero cuando llegaba al pico del start, se volvía un poco tonto y daba vueltas sin parar, como el objetivo de mi sesión no era hacer el programa perfecto sino, hacer yo algo por mi cuenta, me quedé por satisfecho.

al día siguiente intenté hacer que siguiera la línea más rápidamente, introduciendo algo de lógica borrosa a la hora de tomar las decisiones. que guay queda decir eso ... en realidad lo que hice fue meter más condiciones en el if.

lo que hacía era dado el nivel de negro/blanco que se estaba recibiendo, girar el motor en mayor o menor medida. como sigue a continuación

si el nivel de blanco está entre 75% y 100%: giro el motor a todo trapo
si el nivel de blanco está entre 50% y 75%: giro el motor un poco menos
si el nivel de blanco está entre 25% y 50%: giro el motor un poco menos
...
si el nivel de blanco es nulo, pues sigo recto.

por alguna extraña razón, sólo funcionaba si empezaba sobre la línea negra, y la verdad, se notaba un poco más de velocidad, pero tampoco para tirar cohetes. y cuando llegaba al pico del start ... fuera también, a dar vueltas !!!. estoy pensando en hacerme un circuito redondo sin picos.

ahora que he puesto esa tabla arriba se me ha ocurrido que en vez de usar un if ... podría hacer que la potencia del motor fuera directamente proporcional al nivel de blanco. sería encadenar la salida del sensor de luz a un operador aritmético, y este que fuera a la entrada del motor especificando el porcentaje de potencia. pero no sé si se podrá hacer esto último habrá que probarlo.

y con esto daría por terminado mi primer objetivo, el de hacer cosas por mi mismo con el programita de marras.

también he de decir que con el giga de ram mi equipo se mueve de maravilla. una buena compra de las mias :D

otra cosa ... en un blog que he encontrado por ahí, creo haberlo mencionado antes. , siguiendo un par de enlaces he encontrado este montaje que parece entretenido, para calcular coeficientes de rozamiento

me parece interesante hacerlo en los dos sentidos, es decir, que calcule lo que tardará en bajar, si le especificas el peso del objeto o que dado el tiempo y el peso, el sólo calcule la pendiente ... cosas de física, vamos como si fuera un científico intentando calcular el mejor momento para enviar un cohete a marte.

y además el mecanismo de hacer que la pendiente suba o baje, y calcular los grados. esto me servirá seguramente a trabajar con los servos y a mirar un poco más el toronomaki, que seguramente tendrá mecanismos de esas trazas.

bueno, eso es todo por hoy, así que como diría ed wood ¡a positivar!

compromisos

2008-06-18T18:12:00.002+02:00

bueno voy a dejar por escrito mis dos compromisos para hacer con el lego a corto plazo, para que así me entre cargo de conciencia si no les cumplo

hacer mi propia implementación del robot que sigue líneas. así ya por fin aprendo a usar bien el programa ese infernal, que espero que con el giga de ram que he metido a mi equipo ya pueda ir decente ...

hacer algo poco a poco, del brick sorter, o en la lengua del cantar del mio cid, un lego que separe piezas de colores. lo empezaré a hacer modular, poco a poco y sin juntar hasta que ya tenga color y forma. esa será mi primera obra de producción propia. es que he visto algunos modelos muy interesantes en youtube.

el que más me ha llamado la atención ha sido este

ya que usa una rueda para convertir moviemiento circular en una sola dimensión (menuda manera de explicarlo ...), vamos cosas del toronomaki, y me ha gustado

weno, este mismo finde me voy a poner con ellos !!! o ya empiezo poniendo excusas ... porque seguramente me toque viajar y no esté en mi casita dándole calor al lego (estaré con mi novia celebrando su matrícula de honor en termodinámica)

sin perdón del root

2008-06-17T15:58:00.003+02:00

bueno, tengo este blog un poco muerto, hace mucho que no escribo nada, pero no quiere decir que no haya trasteado nada con mi lego ... he trasteado y mucho.

me he dedicado a hacer cosas que he visto por diversas páginas. la más mejor para mi es nxtPrograms. Tienen un montón de artilugios diversos con instrucciones de montaje y los programas hechos.

aquí os dejo unos enlaces a las cosas que he estado haciendo

aquí podeis ver una variante del brazo robótico que se mueve por la voz, o mejor dicho por los gritos que le pegaba.

este es el que sigue líneas

y esta es la demo del nxt

también hay un video de una metralleta sacaba de nxt programs, pero es tán súmamente rápida, que no se vé absolutamente nada en el vídeo. os aconsejo que lo hagais. también estuve a punto de hacer un vídeo de un robot que buscaba bolas y miraba a ver de que color eran, pero el vago de mi compañero de piso no me dejó la cámara y no pude hacer vídeo. como veis los vídeos que hago son bastante cutres, debido a mi cutre web cam ... y dado mi arrebato último arrebato (por fin tengo play) consumista pasará mucho tiempo hasta que adquiera un modo de hacer mejores vídeos

ahora mismo me encuentro inmerso en el robot que sigue líneas (con un sólo sensor de luz :P, esto va por mi novia, que es la mejor de todas, pero ella lo hizo con dos sensores en la carrera). quiero hacer el programa por mi mismo o modificarlo de algún modo porque me he dado cuenta de que tengo que empezar a crear cosas por mi mismo, más que copiar cosas que veo por ahí sueltas.

de todos modos copiar también es una buena forma de aprender. también he intentado volver a hacer, de forma fallida, la dirección del coche ... os podeis imaginar el resultado.

en fin como veis, he hecho muchas cosas, tampoco para tirar cohetes, pero me comprometo a poner cosas interesantes de vez en cuando y a contar mis progresos ...

algunas direcciones interesantes a parte de la anterior son

http://robotikas.blogspot.com/ que es un blog con cosas muy interesantes con foro y todo en castellano

super libro para aprender estructuras muy interesantes. merece la pena echarle un ojo. yo me lo estudio todos los días en el curro. http://www.isogawastudio.co.jp/legostudio/toranomaki/jp/

el brazo del robot

2008-02-23T20:35:00.002+01:00

tras un par de semanas olvidado de la mano de dios me puse a trastear un poco más: hoy toca hacer el brazo robot.

en el montaje tardé igual unas tres horas, pero es que remolono mucho y voy lento, sólo tuve una pieza mal, era un poco más larga de lo normal, pero al final no pasó nada grave :D.

primera decepción: es imposible accionar bien el sensor de tacto, me hace lo que le da la gana :S, el servo tiene que hacer mucha presión para pulsarlo bien y se atasca todo ...

así que pensé en ponerle un sensor de voz, y gritarle para al brazo para que cambiara el orden de giro, bajara cogiera ... un poco de todo un poco.

creo que el programa me estaba vacilando porque hacía lo que le daba la gana, se saltaba bucles, a veces le gritabas y no te hacía ni caso ...

en fin hoy me lo he pasado bien con el lego, pero tampoco he sido capaz que hiciera todo lo que yo quería así en plan bien ...

mañana intentaré acoplar en lugar de sensor de tacto el de ultrasonidos, para encontrar la bola y dejarla en su sitio, no sé si saldrá pero por lo menos me entretengo.

a ver cuando cuelgo el video

la primera desilusión

2008-02-10T02:25:00.000+01:00

tras habermelo pasado pipa con mi lego que esperaba que le aplaudieran me puse ha hacer el que con unas pinzas cogía la bola ... ...

bueno pues primero el robot arrastraba la bola para adelante y nunca se pulsaba el sensor de movimiento ... bueno pues tras hacer fuerza con el dedo para que no se la llevara por delante, nunca conseguí darle los grados suficientes ni la potencia suficiente para que las pinzas lo agarraran ...

así que pensé, bueno pues voy a hacer un coche, que ya paso de estas cosas de principiantes ... bueno a hacer un coche así con mis engranajes de cremalleras.

arrrr muerte súbita. problemas por todos lados: no sé como van las piezas, ni las conozco, doy mil vueltas para enganchar dos cosas, las ruedas dentadas para cambio de eje no tienen una medida exacta; son de algo y medio ... al final conseguí cambiar el eje de rotación del servo pero con mucho cariño y trabajo y de un modo super sencillo. a ver si pongo el vídeo o la foto o algo con ello.

luego para enganchar el engranaje de cremallera ... ... bueno pues ahí literalmente morí. me he muerto señores ... mi lego mindstorms, ha podido conmigo, así que he decidido empezar a hacer modelos ya con planos ... snifff, pero volveré a por mi coche más tarde o más temprano !!!

empecemos en 30 minutos

2008-02-09T10:12:00.000+01:00

bueno ya he montado el cacharrómetro de los 30 minutos ...

al final han sido más de 30 pero es que no me cosco muy bien buscando las piezas ... lo de un taper para tenerlas bien y a la vista va a ser importante, de momento estoy con la tapa de unas tarrinas de dvds.

bueno no sé si ha alguno que lo haya comprado y lo ponga por primera vez le haya invadido la siguiente pregunta ... ¿esto que hace?

tengo un aparato con ruedas quieto ... y cuando le dé al play ?? destruirá mi habitación ?? al final le llevé al salón que es más bien grande y la sorpresa de he tirado todas tus paredes o me choco con todas las patas de tus muebles podría ser menor

tras ver que no hace nada destructivo le llevé a mi habitación y grabé este vídeo

espero que os guste !!!

después de esto le hice alguna modificación, y así de paso aprendí a usar el infernal programa ese que te viene con el cd.

se queda quieto al final esperando que des un aplauso, para dar una vuelta sobre sí mismo. de esto no tengo vídeo, pero os lo podeis imaginar :P.

a comprar

2008-02-09T08:00:00.000+01:00

tras un viaje infernal en el metro en que las dos líneas que tenia que coger se estropearon justo una parada antes del trasbordo y calle respectivamente, y tras andar cuesta arriba un cuarto de hora hasta la tienda ... ahí estaba, electricBricks.

el tío de la tienda es muy majo, me estuvo enseñando cosas y tal y videos de youtube (me los sé todos de mirarlos en el trabajo, pero no se lo digáis a mi jefe !!!). al final me llevé el básico y cuatro engranajes de cremallera porque tenía alguna cosa en mente.

la tienda es una pasada, yo no he visto tantos legos en mi vida, tenían todos de star wars ... pero tampoco era plan comprármelos todos. el x-wing de mis sueños costaba 150 €, y se me iba un poco del presupuesto de aquella tarde.

otro viaje infernal a casa y a abrir impacientemente la caja y luego al día a por las pilas. con esto de alimentación tengo que mirar algo, pero ya veré. también alguna cosa tipo taper, o bolsa de plástico para guardar todas las piezas clasificadas de algún modo que ya estudiaré.

perdón por las cutre fotos ... pero es que no tengo cámara digital y las tengo que hacer con la cutre-webcam, pero creo que se ven algo bien. las de aquí como podreis imaginar, son sacadas vilmente de internet.

Presentación

2008-02-08T08:00:00.000+01:00

hola,

este va a ser mi blog en el que publicaré todas mis experiencias con el lego mindstorms.

ahora mismo será un blog de principiante principiante, pero espero que se convierta en un buen blog.

siempre me quedé en la carrera con la espinita clavada de no hacer las de informática industrial y microcontroladores ... ( en fin es que las optativas de economía tenían mucho más éxito ), así que ahora me hayo dispuesto a sacarme esa espina por mis propios medios y con las pinzas del tribot !!!

sed bienvenidos todos, espero que os guste