sábado, 30 de marzo de 2013

Tutorial : Raspberry Pi con adaptador de Arduino


Bien hemos comprado una RaspBerry Pi, y después de algunas pruebas iniciales hemos sacado algunas cosas claras.

 1º Que una vez que coges el concepto de como hacerlo funcionar es sencillo (aunque mucho mas engorroso que cuando lo hacemos normalmente, seguramente acabe creando un script para que lo haga solo).
2º Dentro del startx, la potencia de la RaspBerry se viene abajo, así que no recomiendo entrar.

 A continuación defino la RaspBerry usada y como se ha compilado y usado.


  La Raspberry Pi que he comprado es la mas potente de las 2, con una tarjeta SD de 8 gigas de clase 6 (seguramente acabe comprando una clase 10, a ver si gano un poco de velocidad de lectura). 

El adaptado usado para poder trabajar con los componentes que tengo de Arduino es el modulo de conexion de Cooking-hacks . (40€)

Antes de nada vamos a configurar la RaspBerry para poder usarla.
1)  Hacer una copia de seguridad de nuestro boot:
     sudo cp /boot/cmdline.txt /boot/cmdline_backup.txt
2)  Editamos el archivo: (aquí podéis usar el vi o el nano)
     sudo nano/boot/cmdline.txt
3)  Y borramos las siguientes partes: (Si no hay un $, no os preocupeis)
      dwc_otg.lpm_enable=0
      console=tty1 $
4)  Reiniciamos la RaspBerry
     sudo reboot


Lo siguiente para compilar nuestro programa serán los siguientes:
1)   Hay que descargar las librerías que encontrareis en el siguiente link: Libreria 

2)   Compilar la librería descargada, vamos a la carpeta donde la hayamos descargado, la descomprimís y por consola ponemos:
       g++ -c arduPi.cpp -o arduPi.o

3)   A continuación compilamos nuestro programa:
       g++ -lrt -lpthread miPrograma.cpp arduPi.o -o nombreProgramaQueQueramos

4)   Lanzamos el programa:
      sudo ./nombreProgramaQueQueramos
     
Como veis es un poco cansino hacer eso, por eso en cuanto tenga el script os lo subiré para que no sean tan pesado esto.

El tutorial completo más detallado lo podéis encontrar aqui: Cooking-hacks 

Bueno eso es todo, iré probando todo e iré poniendo nuevos ejemplos. 
Disfrutadlo. 
raspberry pi Tutoriales

martes, 26 de marzo de 2013

Nueva serpiente robótica



Hay muchas escenas de desastre donde los grupos de rescate no se atreven a pisar, aunque hayan personas que necesiten ayuda. Un edificio colapsado es una trampa mortal, también para los servicios de rescate, cuyo más mínimo movimiento equivocado puede desencadenar una avalancha que los entierre junto a quienes vinieron a rescatar.
La Serpiente Robot que ha sido desarrollada por el Technion, Israel, es un robot en miniatura que se desliza en zonas de desastre de cualquier tipo. Es lo suficientemente ligera como para no causar daños y, equipadas con cámaras y sensores, puede trazar un camino para que los servicios de rescate puedan entrar sin dañar la estructura, así como determinar con exactitud dónde están los sobrevivientes.
El sistema puede ser utilizado en cualquier situación y proveer la información previa acerca de una situación que necesita preparativos especiales para que los equipos de rescate logren hacer su trabajo.
La serpiente robótica podría ser útil en la guerra urbana y subterránea, ya que permite la inspección y vigilancia de los sistemas de alcantarillado, túneles estrechos, o alcantarillas, inaccesibles por otros sistemas.
Otra ventaja de este tipo de robots es el hecho de que todo el robot actúa como brazo altamente flexible que tiene múltiples grados de libertad (DOF).
La serpiente es altamente maniobrable ya que puede maniobrar a través de terrenos difíciles, hacerlo sigilosamente dentro de edificios, y usar sus sensores para explorar sus interiores.
El robot es capaz de llevar sensores desechables que puedan ser separados y dejados en puntos estratégicos para controlar la actividad en el interior de edificios. Cuando la actividad dentro de edificios resulta sospechosa y es detectada, el robot sigiloso será capaz de identificar objetivos específicos mientras permanece virtualmente desapercibida, y podrá dejar tras de si cargas explosivas temporizadas.
Como sensores primarios, el robot está equipado con una cámara termográfica, cámaras en miniatura o de poca luz sensores de TV y, posiblemente, escáneres láser que funcionan como radar láser (LADAR).
Como cada uno de los enlaces está integrado con cámaras, todo el grupo es redundante, tiene vista múltiple de 360 grados de sus alrededores, con cartografía de zonas de interior y subterráneas por radar láser.
A diferencia de la serpiente anterior que tiene un DOF único por cada enlace, requiriendo 16 eslabones para formar la flexibilidad necesaria y capacidad de maniobra, cada uno de los enlaces de nuevo robot tiene dos articulaciones, proporcionando 2 DOF por enlace, por lo tanto, el número de enlaces por ‘robot serpiente puede reducirse a ocho.
Los motores integrados en el nuevo diseño tienen un momento significativamente más alto. Cada enlace está equipado con su propio sistema inercial, que informa sobre su posición relativa (a otros elementos), lo que permite el movimiento automático de maniobra y control para determinar la posición de todo el robot, y determinar el próximo movimiento para llevar al robot más cerca de su objetivo, a través de terreno difícil y a lo largo de la trayectoria de movimiento seleccionado para dicho movimiento.
Este prototipo que pesa 7 kilogramos utiliza elementos de aluminio para satisfacer el nivel de robustez requerida para la operación de campo. Sin embargo, para los modelos de producción investigadores del Technion esperan que el peso se reducirá a la mitad, por debajo de 4 kilogramos, tanto en las partes de aluminio con materiales compuestos duraderos.
Referencia: blog.periodistadigital.com


sábado, 23 de marzo de 2013

Tutorial: Sensor de proximidad por ultrasonidos LV-EZ3


El uso de los ultrasonidos de este tipo es sencillo, solo usaremos las siguientes salidas:
  1. GND (tierra)
  2. +5 ( 5v)
  3. AN ( analógica)


Código:
void setup()
{
    Serial.begin(9600);
}
void loop()
{   
   int analogValue1 = analogRead(0);
   Serial.print("ulstra sonido: ");
   Serial.println(analogValue1);
   delay(100);
}
 

Como ya vimos en el tutorial anterior de como usar la pantalla LCD de Nokia 5110, ahora vamos a ampliarlo y combinaremos la pantalla LCD con el sensor de proximidad por ultrasonidos LV-EZ3.

 void setup(void)
{
  LcdInitialise();
  LcdClear();
  drawBox();
}

void loop(void)
{
    int x = 0;
    int inches = 0;
    int cm=0;
    x = analogRead(0);
    inches = ((x*0.0049)/0.0098);
    cm= inches * 2.54;
  
    gotoXY(7,1);
    char buf[12];
    LcdString(itoa(cm, buf, 10));
 
   gotoXY(30,1);
   LcdString("cm");
    
   delay(200);
}


Sensores Tutoriales

Contacto

Para contactar con nosotros, envia tu email a:

udelunar@gmail.com.

Muchas gracias :)
Contacto

Tutorial: Arduino y pantalla LCD Nokia 5110

Hoy vamos a tener de tutorial como usar nuestra pantalla LCD de Nokia 5110 y mostrar el texto y los datos enviados desde nuestro Arduino Uno.



Primero necesitamos identificar los pines:
|-------------------------------------------------------------------|
|     1    |   2   |  3   |   4    |    5    |     6   |     7       |     8    |
|-------------------------------------------------------------------|
|  RST |  CE | DC | DIN | CLK | VCC | LIGHT | GND |
|-------------------------------------------------------------------|

Una vez identificados tenemos que conectarlos a las entradas digitales de acuerdo a como lo especifiquemos en nuestro código en mi caso tal y como lo he descrito arriba.

Usaremos desde el pin 1 hasta el 5, el pin 7 no lo usaremos  (light) y el VCC son 3,3v y el GND al cualquiera de nuestros GND.


Nota importante:
La instrucción  LcdString, solo admite char*, así que si necesitamos enviar un int, tendremos que convertirlo. ¿Cómo?, bien la forma que yo he usado ( y espero que haya otra mejor) es creando un buffer y con la instrucción atoa introducir el entero en el buffer y pintarlo.
int numero = 20;
char buf[12];
LcdString(itoa(numero , buf, 10));

El código para pintar en el lcd sera el siguiente (espero hacerlo bien y crear una librería, pero por ahora....):
// The pins to use on the arduino
#define PIN_SCE   2
#define PIN_RESET 1
#define PIN_DC    3
#define PIN_SDIN  4
#define PIN_SCLK  5

// COnfiguration for the LCD
#define LCD_C     LOW
#define LCD_D     HIGH
#define LCD_CMD   0

// Size of the LCD
#define LCD_X     84
#define LCD_Y     48

int scrollPosition = -10;

static const byte ASCII[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x00, 0x06, 0x09, 0x09, 0x06} // 7f →
};

void LcdCharacter(char character)
{
  LcdWrite(LCD_D, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D, 0x00);
}

void LcdClear(void)
{
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(LCD_D, 0x00);
  }
}

void LcdInitialise(void)
{
  pinMode(PIN_SCE,   OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC,    OUTPUT);
  pinMode(PIN_SDIN,  OUTPUT);
  pinMode(PIN_SCLK,  OUTPUT);

  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);

  LcdWrite(LCD_CMD, 0x21);  // LCD Extended Commands.
  LcdWrite(LCD_CMD, 0xBf);  // Set LCD Vop (Contrast). //B1
  LcdWrite(LCD_CMD, 0x04);  // Set Temp coefficent. //0x04
  LcdWrite(LCD_CMD, 0x14);  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_CMD, 0x0C);  // LCD in normal mode. 0x0d for inverse
  LcdWrite(LCD_C, 0x20);
  LcdWrite(LCD_C, 0x0C);
}

void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}

void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

/**
 * gotoXY routine to position cursor
 * x - range: 0 to 84
 * y - range: 0 to 5
 */
void gotoXY(int x, int y)
{
  LcdWrite( 0, 0x80 | x);  // Column.
  LcdWrite( 0, 0x40 | y);  // Row.
}

void drawBox(void)
{
  int j;
  for(j = 0; j < 84; j++) // top
  {
    gotoXY(j, 0);
    LcdWrite(1, 0x01);
  }    

  for(j = 0; j < 84; j++) //Bottom
  {
    gotoXY(j, 5);
    LcdWrite(1, 0x80);
  }    

  for(j = 0; j < 6; j++) // Right
  {
    gotoXY(83, j);
    LcdWrite(1, 0xff);
  }    

  for(j = 0; j < 6; j++) // Left
  {
    gotoXY(0, j);
    LcdWrite(1, 0xff);
  }
}

void Scroll(String message)
{
  for (int i = scrollPosition; i < scrollPosition + 11; i++)
  {
    if ((i >= message.length()) || (i < 0))
    {
      LcdCharacter(' ');
    }
    else   
    {
      LcdCharacter(message.charAt(i));
    }
  }
  scrollPosition++;
  if ((scrollPosition >= message.length()) && (scrollPosition > 0))
  {
    scrollPosition = -10;
  }
}

void setup(void)
{
  LcdInitialise();
  LcdClear();
  drawBox();

  gotoXY(7,1);
  LcdString("Nokia 5110");
  gotoXY(4,3);
  LcdString("HELLO WORLD");

}

void loop(void)
{
  gotoXY(4,4);
  Scroll("Scrolling Message from www.arduino.com.es");

  delay(200); 

}


Actuadores Tutoriales

viernes, 22 de marzo de 2013

Construye tu propio robot aspiradora




Hoy vamos a hablar, a modo de curiosidad, de una revista japonesa de robótica gracias a la cual podéis construir un robot aspirador de sobremesa.




Ya conocíamos la existencia de pequeños robots de sobremesa, pero éste, lo bueno que tiene es que te lo hace tú mism@.

La revista en cuestión se llama Otona no Kagaku (Ciencia para adultos) y está editada por la prestigiosa
firma Gakken, que se dedica a la divulgación científica, fabricación de productos educativos, publicación de libros de texto y enciclopedias.

Otona no kagaku lanza, con cada número de la revista, kits para fabricar juguetes/ingenios electrónicos. Te proporcionan los componentes y la información necesarios para para construir increíbles y divertidos proyectos de Ciencia. En el número 33, el kit que acompaña a la revista tiene todo lo necesario para montar una mini Roomba [sic].

Este robot aspirador está diseñado para usarlo en nuestra mesa de trabajo en la oficina o en la mesa del comedor en casa, para recoger migas, restos de goma de borrar, virutas del lápiz, etc. Y si no sois de los que piensan que el tamaño importa, este aspirador os va a gustar.




- El kit consta de 20 piezas pero NO incluye los tornillos, la cinta adhesiva y el tubo de grasa lubricante que se van a necesitar en el proyecto.

- Se tardan 60 minutos en construirlo. Es un poco ruidoso y su velocidad es aproximadamente 15 cm x segundo.

- Este robot aspirador funciona con 2 pilas de tipo AA y tiene un motor sencillo de corriente contínua. Son los únicos componentes electrónicos del robot.
Es ligero y compacto. Tiene un diámetro de 10,15 cm y una altura de 3,8 cm.




- El motor lleva acoplado un pequeño ventilador, que succiona la suciedad y la manda al depósito pasando previamente por un filtro.




- El interruptor tiene 2 posiciones: sólo ventilador y ventilador más engranajes.
- Carece de cepillo central y de cepillos laterales.

- Si se encuentra un obstáculo o llega al borde de la mesa, cambia de dirección y sigue haciendo su trabajo. Esto se debe gracias a unos sensores de choque y anticaídas, que consisten básicamente en un mecanismo de palanca que se acopla con un tornillo sin fin en el eje de dirección, lo que provoca un desplazamiento lateral del eje y se produce un cambio de engranajes que van acoplados a la rueda del robot, y esto hace que el robot aspirador deje de ir hacia adelante y gira 123 grados durante un segundo hasta que el tornillo sin fin se desconecta y el eje de dirección vuelve a su posición normal, haciendo que el robot aspirador siga un nuevo trazado, aleatoriamente. (¿Qué esperábais?. Recordemos que es un juguete, aunque aspira decentemente) con lo que pasará inevitablemente por zonas que ya ha limpiado.
Se puede ajustar la sensibilidad del sensor de colisión mediante el cambio de la posición de una pequeña palanca situada en el interior del robot.

- La boca de succión, lógicamente, es bastante pequeña. Mide 3,2 cm de largo y su abertura es sólo de 3,8 mm. Pero es suficente para recoger migas, hilos o polvo.

Referencia: robotsaldetalle

miércoles, 13 de marzo de 2013

SmartBot, para los iniciados en la robótica que quieran aprobechar su móvil




SmartBot es una base con ruedas a la que acoplamos nuestro smartphone (Android, iOS, Windows Phone) para convertirlo en un singular robot capaz de reconocer nuestra voz o de realizar tareas de videovigilancia, además de ser completamente programable.

La empresa que lo desarrolla, Overdrive Robotics, lo ha puesto a la venta por 160 euros, y cuando esté disponible en abril sus usuarios podrán disfrutar de una plataforma que llega con varias utilidades integradas que aprovechan sus sensores y componentes.


En esa base móvil encontramos un receptor GPS, un micrófono, un acelerómetro, y un chip NFC que es la tecnología utilizada normalmente para comunicarse con nuestro smartphone, aunque hay terminales sin esta conectividad que también son compatibles con SmartBot, como se puede comprobar en la página de especificaciones del producto.

Además de poder responder a órdenes de voz, a tomar fotos o a convertirse en un singular sistema de videovigilancia, este dispositivo cuenta con compatibilidad con Arduino y es programable gracias al SmartBot SDK, un conjunto de herramientas que permiten aprovechar lenguajes como Java, C# u Objective C para sacarle más partido a la plataforma.

A ello también contribuye el puerto de expansión que permite gestionar hasta cuatro salidas para controlar tanto los accesorios disponibles de forma oficial como los que puedan desarrollar usuarios y empresas independientes. Sus controladores de movimiento son muy precisos, y tanto los desplazamientos como las rotaciones pueden realizarse con total control.

Referencia: xataka.com

viernes, 8 de marzo de 2013

Nueva versión de un robot subacuático con forma de avión




Deslizarse bajo el agua tiene algunas similitudes con hacerlo por el aire. Un vehículo capaz de "planear" dentro del agua puede ahorrar mucha energía propulsiva. Esto es fundamental para los robots acuáticos autónomos que navegan solos durante largos periodos de tiempo, ya que no pueden depender de que el personal humano les recoja y reabastezca de energía en cualquier momento.

Un pez robótico de alta tecnología desarrollado en la Universidad Estatal de Michigan y en el que se han hecho mejoras recientemente, es ahora capaz de deslizarse a largas distancias, economizando energía con notable eficacia. Este robot ahora tiene la capacidad de planear a través del agua, prácticamente por tiempo indefinido, usando poca o ninguna energía mientras recoge valiosos datos.

Diseñado y construido por el equipo de Xiaobo Tan, profesor de ingeniería electrónica y de computación en la citada universidad, el pez robot está equipado con un conjunto de sensores que no sólo le permiten viajar de forma autónoma sino también medir la temperatura del agua, su calidad y otros parámetros importantes. El robot está diseñado mayormente para navegar en lagos y ríos, aunque sus innovaciones podrían ser útiles para robots comparables destinados a navegar por el mar.

Nadar requiere del constante aleteo de la cola, lo que significa que un robot que se desplace así bajo el agua agotará su batería en cuestión de horas, y necesitará recargarla muy a menudo, algo poco factible si se pretende que el robot realice misiones de larga duración sin apoyo humano in situ.


El robot subacuático. (Foto: G.L. Kohuth)

La desventaja de planear dentro del agua es que es más lento y tiene una menor maniobrabilidad.

A fin de contar con lo mejor de cada forma de desplazamiento, el equipo de Tan integró en el robot ambos modos de locomoción, el planeo y la natación. Tal integración también permite al robot adaptarse a diferentes entornos subacuáticos, desde los ríos poco profundos a los lagos profundos, desde los estanques tranquilos a los ríos con corrientes rápidas.

La habilidad del robot para planear se logra a través de una bomba recientemente instalada que empuja el agua hacia dentro y hacia fuera del pez robótico, dependiendo de si es necesario que el robot ascienda o descienda.

Los robots que planean bajo el agua son cada vez más habituales en las tareas subacuáticas. De hecho, uno de este tipo ya logró a fines de 2009 completar una travesía en la que cruzó de extremo a extremo el Océano Atlántico.

Una gran diferencia en el robot recientemente reformado es que, aparte de sus capacidades de natación y planeo, su tamaño y su peso son aproximadamente la décima parte de los de un planeador subacuático comercial tradicional.

Referencia: noticiasdelaciencia.com


 

Productos y tecnologias usadas en este blog:

  • No te pierdas ninguna entrada

    Subscribete aquí en nuestro newsletter y ¡no te pierdas nada!

    Copyright © LuneGate™ is a registered trademark.
    Designed by Templateism. Hosted on Blogger Platform.