DE MICROROBOTS MVILES
Trabajo realizado para la asignatura de Diseo de Microrrobots
Mviles de la Universidad de Alcal
por
Estela Daz Lpez
Noviembre 2006
0. NDICE
0.
NDICE ............................................................................................................................... 1
1.
INTRODUCCIN ............................................................................................................. 6
1.1.
QU ES LEGO-MINDSTORMS?..................................................................................... 6
1.2.
1.2.1.
VENTAJAS: ..................................................................................................................... 6
1.2.2.
DESVENTAJAS ................................................................................................................ 7
1.3.
1.4.
2.
DESCRIPCIN GENERAL........................................................................................... 10
2.1.
EL RCX:......................................................................................................................... 10
2.1.1.
DESCRIPCIN ............................................................................................................... 10
2.1.2.
2.1.3.
PUERTOS DE SALIDA..................................................................................................... 12
2.1.4.
2.1.5.
PANTALLA LCD:.......................................................................................................... 13
2.1.6.
2.1.7.
2.1.8.
ALIMENTACIN:........................................................................................................... 14
2.2.
EL NXT: ......................................................................................................................... 15
2.3.
2.4.
3.
TRANSDUCTORES Y SENSORES:............................................................................. 23
3.1.
3.1.1.
SENSOR: ....................................................................................................................... 23
3.1.2.
TRANSDUCTOR:............................................................................................................ 23
3.1.3.
3.2.
3.2.1.
SENSORES DE LEGO:...................................................................................................... 24
SENSOR DE TEMPERATURA:......................................................................................... 24
Pgina 1
3.2.2.
3.2.3.
SENSOR DE LUZ:........................................................................................................... 25
3.2.4.
3.2.5.
SENSOR ULTRASNICO:................................................................................................ 26
3.2.6.
3.2.7.
3.2.8.
SENSORES DE PRESENCIA:............................................................................................ 29
3.3.
3.3.1.
3.3.2.
3.3.3.
3.3.4.
3.4.
3.4.1.
SENSORES DE CONTACTO:............................................................................................ 44
3.4.2.
3.4.3.
SENSOR DE HUMEDAD:................................................................................................. 46
3.4.4.
3.5.
3.5.1.
3.6.
4.
MOTORES:...................................................................................................................... 53
4.1.
4.1.1.
4.1.2.
PRINCIPIO DE FUNCIONAMIENTO.................................................................................. 53
4.1.3.
4.2.
4.2.1.
4.2.2.
4.2.3.
CARACTERSTICAS EN PARADO:................................................................................... 57
4.2.4.
CARACTERSTICAS EN CARGA:..................................................................................... 58
4.3.
Pgina 2
5.
5.1.
6.
6.1.
6.2.
RCX-CODE .................................................................................................................... 69
6.2.1.
INTRODUCCIN: ........................................................................................................... 69
6.2.2.
COMANDOS .................................................................................................................. 73
6.2.3.
6.3.
6.3.1.
MODOS DE PROGRAMACION................................................................................ 78
6.3.2.
MODO PILOT............................................................................................................... 79
6.3.3.
MODO INVENTOR...................................................................................................... 81
6.3.4.
MODO INVESTIGATOR............................................................................................. 85
6.3.5.
6.4.
LABVIEW ..................................................................................................................... 86
6.4.1.
QU ES LABVIEW?.................................................................................................... 86
6.4.2.
6.4.3.
6.4.4.
6.4.5.
6.4.6.
6.4.7.
BIBLIOGRAFA LABVIEW.............................................................................................. 95
6.5.
6.5.1.
ESTRUCTURA DE UN PROGRAMA.................................................................................. 99
6.5.3.
6.5.4.
6.5.5.
6.5.6.
6.5.7.
Pgina 3
6.5.8.
6.5.9.
6.5.10.
6.5.11.
6.6.
6.6.1.
6.6.2.
6.6.3.
6.6.4.
6.6.5.
6.6.6.
6.6.7.
6.7.
BRICKOS...................................................................................................................... 125
6.7.1.
6.7.2.
6.7.3.
6.8.
6.8.1.
6.9.
6.9.1.
6.9.2.
6.9.3.
6.9.4.
6.9.5.
6.9.6.
6.10.
EMULEGOS................................................................................................................ 136
6.11.
6.12.
6.12.1.
6.12.2.
6.12.3.
6.12.4.
6.12.5.
6.12.6.
6.12.7.
6.12.8.
Pgina 4
7.
7.1.
7.1.1.
7.1.2.
7.1.3.
7.1.4.
7.2.
7.3.
7.4.
7.5.
8.
8.1.
8.2.
9.
9.1.
9.2.
10.
Pgina 5
1. INTRODUCCIN
1.1. Qu es LEGO-Mindstorms?
Imagina poder construir un robot completo, con sensores, motores, engranajes, reductoras,
estructuras, poder programarlo y configurarlo, y todo sin soldar, grapinar, taladrar, pegar o
taladrar tornillos. Pues eso es LEGO-Mindstorms, una forma fcil y sencilla de aprender
robtica y construir tu propio robot.
Lego Mindstorms es una plataforma para el diseo y desarrollo de robots, que sigue la
filosofa de la marca LEGO, armar y construir todo tipo de objetos simplemente uniendo
bloques interconectables. Pues eso es LEGO Mindstorms,
El bloque central es un microcontrolador, al que se le ha aadido un cscara de ladrillo con
forma de LEGO. La conexin de sensores y actuadores es muy sencilla, por simple presin
en cualquiera de las puertas y en cualquier posicin. Las piezas de Lego tienen mltiples
formas y tamaos, lo que nos permite construir diversas estructuras, usando los bloques
como ladrillos o vigas.Mediante un PC, se realiza la programacin del ladrillo, usando
diferentes programas y lenguajes.
1.2.1. Ventajas:
-Fcil de montar y desmontar, no es necesario usar soldadura, ni tornillo. Todo lo que se arma
se puede desarmar rpidamente. Adems, eso permite usar las piezas en mltiples diseos
distintos.
-Muy extendido por todo el mundo, lo que permite encontrar gran cantidad de informacin e
ideas por Internet, diseos, soluciones, participar en foros, competiciones.
-No es un pack cerrado, es decir, se puede comprar ms ampliaciones de lego, adquirir
piezas deterioradas o perdidas, o aadir piezas echas manualmente, como por ejemplo,
sensores o motores, e incluso circuitos neumticos.
-Mltiples posibilidades y lenguajes de programacin, desde el nivel ms bsico e intuitivo,
como el Robolab, uso de lenguajes conocidos como C o Java, utilizacin de Linux
Pgina 6
-Que sea escalable, es decir, que a partir de un material bsico haya opciones de ampliacin.
-Muy indicado para entornos educativos, desde colegios a universidades, pues se puede
aprender de forma fcil tanto mecnica como electrnica.
1.2.2. Desventajas
-La principal desventaja de LEGO es su estructura. Est formada por bloques de LEGO, que
se unen por simple presin. Cierto que se pueden aadir elementos de refuerzo y sujecin,
pero para diseos exigentes, no es recomendable. Golpes, cadas, pueden debilitar
rpidamente la estructura, llegando a desarmar el robot.
-No se pueden construir estructuras circulares, pues todas las piezas y ladridos de LEGO son
rectangulares.
-Colocacin de las bateras. Tanto en el NXT cmo en el RCX de LEGO, se alimentan
mediante seis pilas AA R6, que deben ser colocadas dentro del ladrillo. Esto obliga a disear
el robot con la necesidad de acceder directamente al bloque, para poder cambiar las pilas,
limitando la construccin del robot.
-Relacin masa-volumen. Las piezas LEGO no son tiles en diseos donde la relacin masavolumen se hace crtica. Por ejemplo, para construir un robot de SUMO, no sera eficiente,
pues la estructura LEGO es demasiado liviana, y se deberan aadir pesos para hacer el
robot ms robusto, o el caso contrario, para construir robot pequeos, ligeros, y resistentes,
las piezas LEGO son mucho peores que los materiales cmo la fibra de carbono.
-Precio. Obviamente, comprar un robot prefabricado, resulta ms caro que construirte tu
propio robot.
Pgina 7
Pgina 8
LEGO MINDSTORMS NXT incluye el NXT Intelligent Brick con procesador de 32-bit, 3 Servo
motores interactivos, un sensor de sonido, un sensor visual ultrasnico, un sensor de tacto
mejorado, y un preciso sensor de luz. El kit incorpora 519 piezas de LEGO TECHNIC.
Adems incorpora 4 puertos (input), 3 puertos (output), altavoces, las tecnologas USB 2.0 y
Bluetooth junto con un software de programacin compatible con PC y Mac.
Pgina 9
2. DESCRIPCIN GENERAL
La parte mas importante de este tipo de robots es el elemento de control, segn el modelo se
le conoce por RCX o NXT.
2.1. El RCX:
2.1.1. Descripcin
Es el cerebro de Robotics Invention System, que contiene el sistema de comandos para el
robot. Es una mini computadora integrada en un ladrillo Lego. Se puede programar con un PC
o utilizar uno de sus cinco programas que tiene integrados.
El ncleo del RCX es un microcontrolador Hitachi H8, exactamente el H8/3292. Tiene una
velocidad de funcionamiento de 16 MHz y esta alimentado con 5V.
Tiene una memoria interna ROM de 16 KB que contiene el driver que se ejecuta cuando se
alimenta por primera vez el RCX y los programas base para no perderlos en caso de que se
desconecte la alimentacin, una memoria interna de tipo RAM de 512 bytes y otra externa del
mismo tiempo de 32 KB para el firmware (sistema operativo que controla el boque), los
programas y configuraciones personales, pues con este tipo de memorias
si se va la
alimentacin durante mas de un minuto se perdern sus datos y habr que volver a cargarlos
desde el PC. Tiene dos temporizadores de 8 bits y uno de 16 bit, un conversor
analgico/digital de 8 bit y un altavoz integrado, capaz de emitir sonidos sencillos (Beep).
Pgina 10
Tiene tres puertos de entrada para los sensores. Dependiendo del tipo de sensores, activos o
pasivos, tiene una forma de funcionar distinta.
Si los sensores son pasivos, como son el de contacto o el de luz, que no necesitan
alimentacin utilizan el siguiente hardware.
Pgina 11
Si los sensores son activos, necesitan alimentacin, pero como solo tenemos dos hilos, y uno
es la masa, tenemos que conmutar el otro para poder leer el sensor.
El interruptor S se mantiene cerrando durante 3 ms. para alimentar el sensor y durante 0.1
ms. se abre para obtener el estado del sensor.
Tiene tres puertos de salida para los actuadotes (motores y lmparas). Cada puerto puede
estar en tres estados: on, off y floating. Cada salida tiene solo dos hilos por ello solo tienen
una direccin asociada, forward (hacia adelante) y reverse (hacia atrs) y utilizan una
modulacin por ancho de pulso (PWM). Los pulsos se envan cada 8 ms. y presentan hasta
ocho posibles anchos, desde 1ms. (nivel de potencia mas bajo) a 8ms. (nivel de potencia mas
alto, potencia continua).
Pgina 12
Son 4 los botones de control. El botn rojo (On-OFF) enciende y apaga el RCX. Los demos
solo funcionan cuando el ladrillo controlador esta encendido. El botn verde (RUN) inicia y
detiene el programa seleccionado. En este modo el personaje de la ventana de visualizacin
aparece andando. El botn gris (PRGM) permite cambiar entre los 5 programas integrados del
RCX. El nmero de programa seleccionado aparece a la izquierda del personaje en la
ventana de visualizacin. El botn negro (VIEW) slo est activo despus de descargar el
firmware y permite obtener informacin de los sensores y motores. Se pueden ver las lecturas
de sensor en los puertos de entrada 1,2 o 3 y la direccin del motor en los puertos de salida
A, B o C.
Pgina 13
2.1.8. Alimentacin:
La alimentacin del RCX se lleva a cabo mediante seis pilas de tipo AA/LR6. Se recomienda
utilizar alcalinas aunque tambin se pueden utilizar recargables pero su potencia ser menor.
Curiosidades:
Al tener esta forma de ladrillo Lego, permite la construccin muy rpida de robots con piezas
de tipo ladrillo Lego y de otros tipos.
La primera vez que se enciende el RCX o despus de cambiar las bateras tardando ms de 1
min., el RCX se encuentra en Modo de arranque. En la pantalla de visualizacin no aparece
el reloj.
Pgina 14
2.2. El NXT:
En la figura anterior se muestra el NXT brick, es el objeto donde reside todo el control del
robot. Para ello, esta compuesto por un microprocesador ARM-7 de 32 bits, el
AT91SAM7S256 de Atmel. Este microprocesador de arquitectura Risc incluye 256 KB de
memoria flash (no voltil), 64 kB de RAM (voltil) y una velocidad de funcionamiento de 48
MHz. (Ver hojas caractersticas para conocerlo con mayor profundidad).
Tiene cuatro botones en la parte superior para utilizar los programas que tengamos
instalados, configurarlos y ejecutarlos. Tambin podemos visualizar en la pantalla el estado
de los sensores o crear pequeos programas sin necesidad de utilizar el ordenador y
programas adicionales. El botn de color naranja tiene como funciones el encendido (ON), la
confirmacin de acciones (Enter) y el comenzar (Start). Las flechas de color gris son para
moverse por los mens y el rectngulo gris oscuro es para limpiar la pantalla (Clear) y volver
atrs (Go back).
Pgina 15
Mediante una pantalla grfica de LCD de 1000 x 64 pxel blancos y negros, con un rea de
visin de 26 x 40,6 mm manejamos el NXT de una manera muy sencilla. El LCD se controla
mediante un UltraChip 1601 que se conecta mediante un bus SPI de 2 MHz de velocidad, al
ARM7. Lo que se visualiza en el display esta almacenado en memoria como si fuera un array
bidimensional (X, Y) y se actualiza cada 17 ms.
Podemos emitir sonidos, pues tambin incluye un altavoz con un sistema de sonido de 8 bits
de resolucin, 8 Khz. de calidad de sonido y que soporta una frecuencia de muestreo entre 2
y 16 kHz. La seal de salida es una seal PWM controlada por el microprocesador ARM7. Se
filtra, pasa por un amplificador diferencial (SPY0030A de SunPlus) de ganancia mxima igual
a 20 y sale al exterior por un altavoz de impedancia caracterstica de 16 y un dimetro de
21 mm. A continuacin se muestra su esquemtico:
Para interactuar con el exterior, esta compuesto por 8 puertos de entrada/salida que se unen
mediante conectores muy similares a los de tipo telefnico. Tienen 6 hilos pero tienen la
ranura a la derecha en vez de en el medio como el del telfono. (Para convertir un cable
telefnico
al
uno
valido
para
el
NXT
http://philohome.com/nxtplug/nxtplug.htm)
Pgina 16
visitar
el
siguiente
enlace:
Los puertos de salida son el A, el B y el C y son para los motores. El siguiente esquemtico
muestra en detalle un puerto de salida.
MA0 y MA1 son seales de salida para controlar a los actuadotes. El pin 3 es masa y el pin 4
es Vcc que esta conectado internamente a todos los Vcc de todos los puertos tanto de
entrada como de salida. TACHOA0 y TACHOA1 son seales de entrada al microcontrolador
ARM-7.
Los puertos de entrada son el 1, el 2, el 3 y el 4 y son para los sensores. Como antes,
mostramos el esquemtico de un puerto de entrada.
Pgina 17
Tambin consta de un puerto USB de gran velocidad (12Mbits/s) que se encuentra al lado de
los puertos de salida, es el primero de la parte superior derecha.
La gestin de las entradas y salidas es llevada a cabo por un procesador AVR de 8 pines, el
ATmega48 de Atmel. Que tiene 4 kB de memoria Flash, 512 B de RAM y una velocidad de
funcionamiento de 8 MHz. Sus funciones mas importantes son el control de la alimentacin,
la creacin de las seales de salida PWM para los motores y la conversin A/D de las
seales de entrada de los sensores. Se conecta con el microprocesador ARM7 a travs de un
bus I2C. A causa de las limitaciones del ARM7, esto solo funciona como maestro en la
comunicacin por el I2C.
Para la gestin del Bluetooth tiene otro microcontrolador de la empresa CSR (Cambridge
Silicon Radio), llamado BlueCoreTM 4 y una memoria Flash externa de 8 Mbit, que contiene
todo el hardware necesario para una comunicacin inalmbrica.
Se conecta al ARM7 a travs de un modulo SPI (Interfaz serie sincrona) y un modulo UART
(Transmisor-Receptor Asncrono Universal).
Gracias a este sistema pueden conectarse hasta 4 NXT-brick a la vez, uno como maestro y
los otros tres como esclavos, pero solo puede comunicarse con uno en un mismo tiempo.
Como fuente de alimentacin podemos utilizar 6 pilas AA o una batera recargable de litio,
que se conecta en la parte inferior del modulo NXT.
Pgina 18
Pgina 19
NXT
N puertos salida
N puertos de entrada
NO
SI
Compatibilidad con IR
SI
NO
NO
SI
SI
SI
Velocidad de motor
100
100
Sonidos
6 beeps
Infinitos
Drive straight
NO
SI
On-board variables
64
100-100
Display control
Nmeros
N de programas cargados
Infinitos
NO
SI
NO
SI
NO
SI
NO
SI
Sistema
de
batera
recargable
Comunicacin
mltiple
de
bricks
cable rpido
Grficos en display en placa
A pesar de las diferencias que tienen, se pueden usar los motores y los sensores del RCX
para el nuevo NXT. Esta conexin se facilita gracias al siguiente cable de conexin.
Cuya funcin es unir el PIN1 y el PIN2 con los hilos del conector antiguo.
Pgina 20
sobre
el
RCX
http://complubot.educa.madrid.org/inicio.php?seccion=principal pagina de los nios de alcala
Pgina 21
Pgina 22
3. Transductores y Sensores:
3.1. Definiciones y conceptos previos:
3.1.1. Sensor:
Dispositivo sensible que utiliza un fenmeno fsico o qumico dependiente de la naturaleza y
el valor de la magnitud fsico qumica a medir, lo cual permite la transduccin del estmulo a
una seal utilizada directa o indirectamente como medida.
Como sabemos un sensor es un dispositivo capaz de detectar diferentes tipos de materiales,
con el objetivo de mandar una seal y permitir que contine un proceso.
3.1.2. Transductor:
Un transductor es un dispositivo que transforma un tipo de variable fsica (por ejemplo, fuerza,
presin, temperatura, velocidad, etc.) en otro.
Un sensor es un transductor que se utiliza para medir una variable fsica de inters. Algunos
de los sensores y transductores utilizados con ms frecuencia son los calibradores de tensin
(utilizados para medir la fuerza y la presin), los termopares (temperaturas), los velocmetros
(velocidad).
Cualquier sensor o transductor necesita estar calibrado para ser til como dispositivo de
medida. La calibracin es el procedimiento mediante el cual se establece la relacin entre la
variable medida y la seal de salida convertida.
Los transductores y los sensores pueden clasificarse en dos tipos bsicos, dependiendo de la
forma de la seal convertida.
Los dos tipos son:
Transductores analgicos: Proporcionan una seal analgica continua, por ejemplo voltaje o
corriente elctrica.
Esta seal puede ser tomada como el valor de la variable fsica que se
mide.
Transductores digitales: Producen una seal de salida digital, en la forma de un conjunto de
bits de estado en paralelo o formando una serie de pulsaciones que pueden ser contadas.
En una u otra forma, las seales digitales representan el valor de la variable medida.
Los
Pgina 23
Los sensores activos son ms complejos, pero abren una amplia gama de posibilidades de
deteccin. Entre los ejemplos de sensores activos se incluyen los sensores infrarrojos [que
detectan presencia y distancia], los sensores de efecto Hall [que detectan los campos
magnticos], los sensores de ruido, los sensores de vibracin, etc.
3.2.
Sensores de Lego:
Pgina 24
La frmula Temp = (785 RAW) / 8 puede determinar la temperatura detectada por el sensor.
Funciona en un rango de temperaturas entre 20 y +50 grados Celsius. El RCX puede leer y
mostrar las lecturas en grados Celsius o Fahrenheit (ref. W979889).
Pgina 25
Debido a que este sensor capta grados de luminosidad, no es capaz de distinguir colores,
slo captando la existencia del blanco (claridad), negro (oscuridad) y los tonos de grises que
corresponden a los distintos porcentajes de luz existentes en el medio. (ref. W779758).
->
4,5
volts
->
1,3
volts
->
3,3
volts
(en
sentido
horario)
3,3 volts -> 1,3 volts -> 4,5 volts -> 2,0 volts (en sentido antihorario)
Con estos estados se permite verificar cuantas variaciones de energa han sucedido desde la
lectura. Cada voltaje representa un giro aproximado de 22,6 del sensor, por lo tanto
existiendo cerca de 16 ciclos de voltaje para detectar un giro completo. El problema de esta
lectura es a bajas velocidades, debido a que genera unas minsculas variaciones de energa,
debido a que los valores intermedios no son considerados como movimiento vlido. Lee 16
posiciones de rotacin con un mximo de 500 revoluciones por minuto (RPM). El RCX puede
leer tanto ngulos de rotacin como dieciseisavas partes de un giro completo. (ref. W979891).
Pgina 26
del robot, mediante el principio de la deteccin ultrasnica. Este sensor es capaz de detectar
desde 0 a 255 cms, con una precisin relativa del +/- 3 cms.
Mediante el principio del eco, el sensor es capaz de recibir la informacin de los distintos
objetos que se encuentren en el campo de deteccin, teniendo un mejor reflejo del eco los
elementos planos que los curvos, como pelotas u otros elementos similares. Una advertencia
que se realiza es acerca de las conexiones mltiples de este sensor, ya que se puede detener
la ejecucin y/o lectura de los distintos elementos.
El sensor estar configurado por defecto para medir la distancia a un objeto, pero tambin
puede ser capaz de medir las distancias hasta un mximo de 8 objetos en un nico periodo
de medida.
Pgina 27
Negro
Blanco
255
255
255
Rojo
255
Verde
255
Azul
255
Amarillo
255
255
El sensor actualiza las lecturas a razn de 100 muestras por segundo. Las caractersticas del
modo de control del sensor de color permiten dos tipos de calibracin a efectuar por el
programa del NXT.
La calibracin por nivel de negro puede utilizarse para eliminar reflejos no deseados
provenientes de la estructura en la que el sensor est colocado.
La calibracin por balance de blancos puede utilizarse para adecuar la sensibilidad del sensor
para cada uno de los tres led cuando ilumina una superficie blanca a una distancia
determinada.
El modo de control por defecto es el 0, modo normal de medicin. Si el modo de control se
establece en 1, el sensor operar en modo calibracin de balance de blancos y esperar ser
dirigido a una superficie blanca difusa a una distancia de unos 15 mm. Cuando la funcin
Pgina 28
La ranura es suficientemente ancha para acomodar varias piezas Lego. En particular, una
rueda de 0.95 pulgadas con 6 huecos, de modo que bloquea el haz infrarrojo 6 veces por
revolucin. El sentido de la rotacin no se puede determinar monitorizando la seal del
fototransistor, pero esto es irrelevante si la rueda se halla conectada al motor, cuyo sentido de
giro es conocido.
Pgina 29
3.3.
Pgina 30
Estos dispositivos infrarrojos pequeos pueden medir distancia entre 10 y 80 centmetros con
buena precisin y bastante inmunes a las variaciones producidas por la reflectividad de los
obstculos y de la luz ambiente.
Para poder conectar el sensor con salida anloga GP2D12 usando un diseo lo ms simple
posible y utilizando solo la energa que viene de la entrada del sensor. Esto supone un
verdadero desafo debido a los 35mA del GP2D12 por debajo de 5V, mientras que la entrada
del sensor de RCX se encuentra limitada a 14mA!
El concepto principal para alcanzar esta meta seria: almacenar la energa en un condensador
mientras que el GP2D12 no se acciona, una vez cargado utilizaremos la carga para obtener
una medida. Por supuesto hay un pequeo problema con esta tcnica: el tiempo de la carga
es largo. El GP2D12 requiere 50ms por medida, mientras que el circuito necesita 300ms!
Con el siguiente circuito, podemos ver que durante 250ms, se configura el sensor mientras
que se acciona un pequeo sensor, entonces se carga C1 con D1 hasta alcanzar el valor
necesario para obtener una medicin. El regulador U1 de la entrada genera una tensin
regulada de +5V. Q1 es cortado por D2 (D2 mantiene la base a una tensin ms alta o igual
a su tensin del emisor), as que GP2D12 no se acciona.Q3 tambin esta en corte, por lo que
la corriente no atraviesa D3/R5/Q2. La nica corriente significativa es la de la carga C1 que
con R1 se hace menor de 2mA, y al final de esta fase C1 se carga completamente.
Fase de la medida: Durante los 50ms siguientes, el sensor se configura como sensor de
tacto (pasivo). Como la tensin de +5V con 10K (interior RCX), que existe a su entrada
resulta
Pgina 31
SetSensor
(SENSOR_1,
SENSOR_LIGHT);
Espera
(25);
SetSensor
(SENSOR_1,
SENSOR_TOUCH);
Espera
(5);
SetSensorMode
(SENSOR_1,
distancia
Carga
SENSOR_MODE_RAW);
=
de
SENSOR_1;
//Enable
C1
cuanto
antes
El mdulo de interfaz.
Vista superior
Pgina 32
componentes
Terminar el mdulo.
Pgina 33
El cuadro 5 demuestra el tablero de PC poblado con tres fotoclulas de los CDes para los
sensores. Las fotoclulas particulares usadas (Mouser #338-54C348) son bastante pequeas
caber en la poca rea ahuecada alrededor de los agujeros en vigas de la tcnica de Lego.
Los pedazos cortos de tubera aislada resbalaron sobre el plomo infundado de las fotoclulas
evitan el poner en cortocircuito durante la operacin. Las tres fotoclulas se deben alimentar
a travs de la viga antes de soldar al tablero de PC. Una caja del caramelo de Tictac
proporciona un recinto simple para el proyecto terminado segn las indicaciones del cuadro
6. La conexin al RCX es hecha cortando un alambre del motor de Lego #5111 9V por la
mitad.
Pgina 34
Sensor de color: La deteccin del color depende de medir la intensidad de la luz en diversas
longitudes de onda. Un espectrmetro hace esto partiendo la luz con un prisma o una rejilla
de difraccin en sus longitudes de onda componentes. Sin embargo, los espectrmetros son
complejos y demasiado difciles de construir. Otro acercamiento mide la intensidad de luz en
tres vendas del color primario: rojo, verde, y azul. Entonces calcula el color o la tonalidad de
la luz en software.
La tonalidad es un solo nmero que describe el color total de una luz. Se extiende a partir de
la 0 a 360, como los grados del ngulo alrededor de un crculo. En el caso de tonalidad: 0 es
rojo, 120 es verde, 240 es azules y 360 est detrs alrededor al rojo otra vez. Los colores
intermedios tienen tonalidades como 60 para el amarillo, 180 para cinico y 300 para la
magenta. El clculo de la tonalidad de valores rojos, verdes y azules es un algoritmo simple
descrito ms adelante.
Mi primer acercamiento era utilizar las lentes coloreadas del LED para los filtros. Puedes
verlos en el cuadro 3. Resultaron ser demasiado plidos y de color para las medidas
exactas. Entonces investigu con las placas transparentes de Lego. Son rojo disponible,
verde y azul en el kilt de accesorios transparente de Lego #5316. Tapan perfectamente en
los agujeros de las vigas de la tcnica para formar los filtros para los sensores de los CDes
demostrados en el cuadro 6.
Despus de la experimentacin substancial, encontr que las placas azules y verdes eran
demasiado plidas para el uso individualmente. Apilar dos placas verdes y tres azules cre
bastante densidad del filtro para la buena medida de color. El espectro real del color de los
filtros que resultan se puede considerar por la luz del sol que fotografa que brilla a travs de
ellos con una rejilla de difraccin segn las indicaciones del cuadro 8.
Pgina 35
caera de la tarea ()
{
r interno, g, b, mximo, minuto, d, rd, gd, bd, h;
//declare el resto de
las variables
SetUserDisplay (tonalidad, 0);
valor de la tonalidad
SetSensor (COLOR, SENSOR_LIGHT);
de la luz
mientras que //loop (verdadero) por siempre
{
mientras que (COLOR! de = el canal 0 del mux 100) //only leer 100
{
SetSensor (COLOR, SENSOR_TOUCH); //power del sensor haciendo tacto
SetSensor (COLOR, SENSOR_LIGHT); energa de //reapply de accionar la
palanca del canal
Espera (SHORT_WAIT);
PlaySound (SOUND_LOW_BEEP);
}
SetSensor (COLOR, SENSOR_TOUCH); energa de //toggle de cambiar al canal 1
SetSensor (COLOR, SENSOR_LIGHT);
Espera (SHORT_WAIT);
r = COLOR*100;
Pgina 36
tambin escalan
rd = (mximo - r) /d;
gd = (mximo - g) /d;
bd = (mximo - b) /d;
si (b==max) {h = 240 + gd - rd;}
mximo
si (g==max) {h = 120 + rd - bd;}
si (r==max) {h = bd - gd;}
si (h<0) {h = h + 360;}
agrega 360
tonalidad = h;
}
}
Despus de que sea variable la declaracin y la inicializacin all sea mientras que color no
igual un lazo a 100. Este lazo maneja la sincronizacin para cerciorarse de que el
multiplexor est en la cuenta derecha. Solamente cuando el contador en el multiplexor es
cero querer la lectura sea 100. El programa guarda el accionar la palanca de la energa y el
registrar del multiplexor hasta que lee 100.
Hay una llamada de PlaySound en el fondo del lazo que hace un sonido del zumbido. Esto
seala que est ocurriendo la sincronizacin. Despus la primera vez a travs, el programa
Pgina 37
no debe necesitar entrar este lazo otra vez. Si el RCX guarda el hacer del sonido del zumbido
para ms que algunos segundos, hay algo mal con el multiplexor.
El programa siguiente camina palanca la energa y ley los valores rojos, verdes y azules.
Porque el RCX tiene solamente matemticas del nmero entero, los valores necesitan ser
escalados para arriba por 100 para una aritmtica ms ltima. En nmero entero la
matemticas 1 se dividi por 4 resultados en 0 no 0.25 puesto que no hay particiones
fraccionarias. Escalando el denominador por ciento ante la divisin, el resultado se convierte
en 25. Una palanca adicional de la energa despus del azul de la lectura fija el multiplexor
para comenzar el proceso encima otra vez.
El clculo de la tonalidad requiere primero la determinacin de qu color tena el mximo y de
cul tena valor mnimo. Despus de ese, la diferencia entre el mximo y el mnimo se
calcula. Entonces el dividirse por la diferencia normaliza las intensidades del color.
Necesitaras ordinariamente ser referido sobre el acontecimiento inverosmil que la diferencia
igual cero, pero el RCX hace el resultado de la divisin por cero simplemente cero. Se
computa la tonalidad usando el color con el valor mximo. Si la tonalidad es negativa,
agregando 360 arreglos el resultado.
Resultados: Cuadro 9 demostraciones como de bien el sensor del color funciona. La carta
compara la tonalidad de casi 100 diversas fuentes de luz a la lectura de RCX. Los valores de
la transmisin fueron obtenidos brillando la luz fluorescente del amplio-espectro a travs de
los filtros transparentes fabricados por Rosco Laboratorio Ltd. y disponible de Edmund
cientfico como nmero de catlogo CR30394-17. Un ingeniero de Rosco me envi los
valores rojos, verdes y azules equivalentes de los filtros, que fueron utilizados para calcular la
tonalidad prevista. Los valores de la emisin fueron tomados sosteniendo el sensor contra
una ventana del color slido en la pantalla de un monitor de la computadora. Un programa
bsico visual simple permiti el control de los componentes rojos, verdes y azules del color
para el color de la ventana. Los valores reflejados donde medido reflejando la luz de las
muestras del color de un patrn de prueba en un profesional Photoguide de Kodak.
Parece la medida de la tonalidad es exacto dentro de ms o menos 60. Eso significa por
ejemplo, puede ser que no puedas discriminar entre verde y cinico, pero puedes decir
ciertamente verde del azul. El color y el tipo de fuente de luz tienen un efecto significativo en
la exactitud tambin. Si utilizas el sensor del color para clasificar ladrillos, necesitas calibrar la
lectura de la tonalidad para los ladrillos que deseas clasificar con una fuente de luz
controlada.
Pgina 38
Componentes bien escogidos. Esta clase de sensor se construye generalmente con una
variedad especial de resistor que su valor disminuya mientras que la temperatura sube (NTC,
resistor negativo del coeficiente de la temperatura). La resistencia del sensor de LEGO es
12K a 25C. Pero, Este valor no es fcilmente disponible, y el sensor se construye
probablemente usando una serie de 10K NTC montada con un resistor fijo 2K2.
Despus de agregar a ellos un resistor de la serie 2K2K, compare la temperatura exhibida
por RCX con la temperatura real (medida con un termmetro).
Pgina 39
Material necesario:
ladrillo 2x4
placa 2x4
cable elctrico del 1/2 LEGO
resistor de 10KOhm NTC, utilic a Murata ms pequeo uno
resistor 2.2KOhm
2 pedazos del tubo de cobre amarillo del dimetro de 4m m, un 1cm largo, un 4 cm largo
un pedazo de calor-contrae el tubo bastante grande para caber el tubo de cobre amarillo
el alambre elctrico fino, soldadura, multa calor-contrae el tubo para aislar los alambres
rpido-curar el pegamento de epoxy y el pegamento cyanoacrylic
Montaje:
Sujetar juntos ambos tubos de cobre amarillo con el tubo del encogimiento del calor, mientras
que dejar un 1 milmetro abre entre los pedazos. La extremidad de la punta de prueba ser
separada termal del resto del sensor. Los alambres de la soldadura y el resistor 2.2KOhm al
resistor de NTC, aslan las soldaduras con el tubo fino del encogimiento del calor.
Pgina 40
Sellar el tubo y fijar el NTC con una gota de rpido-curan el pegamento de epoxy.
Usar el cortador que mola mont en el taladro de la energa con el soporte, quita dos de tres
tubos internos del ladrillo 2x4. Perforar un agujero de 4 milmetros a travs del extremo del
ladrillo y del tubo interno restante. Hacer una muesca en parte posterior del ladrillo termina
con el archivo para permitir que el cable haga salir.
Insertar el tubo en agujero del ladrillo, despus cable elctrico de la soldadura LEGO. Pegar
el tubo de cobre amarillo al ladrillo con pegamento cyanoacrylic.
Cerrar el ladrillo con la placa 2x4.
Pgina 41
pero solamente tres entradas estn disponibles para el usuario. El RCX utiliza uno de los
otros canales internamente para leer su propio voltaje de la batera.
El diseo de un multiplexor para el RCX es difcil. Algunos esquemas obvios utilizan salidas
del motor con los relees para seleccionar los sensores mltiples. Sin embargo, porque el
RCX tiene solamente tres salidas, estos mtodos no se parecen muy aceptables. Algo es
necesario que pueda detectar que el programa de RCX desea cambiar a un diverso sensor
sin perder una de las salidas preciosas.
Para disear un multiplexor aceptable que necesitas entender cmo el RCX lee sus entradas
del sensor. El RCX tiene dos modos del sensor, pasivo y accionado. Los ejemplos de tipos
pasivos son sensores del tacto y de temperatura. Mientras que estn accionados los tipos
incluyen los sensores de la luz y de la rotacin.
En el modo pasivo, el RCX mide un voltaje en la entrada. Para hacer lectura los sensores o
los interruptores resistentes ms fciles, hay un resistor del ohmio 10K que intenta tirar de la
entrada hasta 5V. En modo accionado, el RCX se aplica sobre 8V a la entrada para 3ms y
despus lee la entrada apenas como un tipo pasivo durante un perodo corto 0.1ms.
Rpidamente accionando la palanca de una entrada del modo accionado a la voz pasiva y a
la parte posterior un circuito del multiplexor podra detectar que el programa de RCX dese
cambiar a otro sensor. La seleccin de si una entrada est en pasivo o el modo accionado se
puede cambiar en marcha dentro de lenguajes de programacin como no absolutamente C o
bsico visual. Desafortunadamente, la lengua de la escritura del P-ladrillo del cdigo de RCX
y de Lego no permite esta flexibilidad.
La limitacin del tipo de sensores multiplexados a la voz pasiva alcanza una gran
simplificacin en el diseo del multiplexor. Significa que solamente las seales del sensor
estn cambiadas y no la energa de funcionarlos. La deteccin ligera pasiva con las
fotoclulas del sulfuro de cadmio (CDes) trabaja sobre as como el sensor ligero de Lego de
todos modos.
Descripcin del circuito:
El cuadro 1 es el diagrama esquemtico del multiplexor del sensor. Permite que los tres
sensores resistentes S1, S2 y S3 compartan una sola entrada de RCX. Los buenos ejemplos
de sensores resistentes son fotoclulas, termistores, y potencimetros. Los interruptores
pueden tambin ser utilizados puesto que son apenas ejemplos extremos de sensores
resistentes.
Pgina 42
Pgina 43
Pgina 44
Interruptores comerciales:
Tambin se puede comprar interruptores en las tiendas de productos electrnicos y ponerlos.
Estos interruptores son de diferentes formas y tamaos. Los ms comunes son los
interruptores de palanca y los botones.
Pgina 45
Pgina 46
Pgina 47
3.5.
Existe otra idea para cumplir la misma tarea. Puede emitir luz hacia afuera y medir la cantidad
de luz que se refleja de vuelta. Cuando no hay nada que la bloquee, la luz reflejada ser muy
pequea. Sin embargo, si un objeto bloquea la luz, ella reflejar ms luz de vuelta. Esto es lo
que se llama un sensor de luz reflectante. El beneficio de este tipo de sensor es que est
situado totalmente fijo en un lugar y no se necesita ninguna alineacin cuando cambiamos la
direccin del sensor.
Se pueden fabricar sensores reflectantes simplemente con un LED y un LDR. Necesitamos un
LED brillante. Esto funciona bastante bien pero el alcance de la deteccin es limitado (menos
de 1 pulgada). Puede haber tambin muchas interferencias de fuentes luminosas externas.
Pgina 48
Observe en el diagrama, como usamos un fototransistor IR en lugar del LDR. En este caso,
los dos funcionan de la misma manera, pero el fototransistor IR es mucho ms sensible a la
luz IR que un LDR. A continuacin mostramos un esquema de cmo fabricar este sensor.
Pgina 49
Pgina 50
Sabemos que si la tensin cae de 5v obtenemos una lectura de 1023. Podemos usar la
misma ecuacin para determinar las lecturas del sensor directamente.
Lecturas del sensor = 1023 x (Rs / (33k + Rs))
Por ejemplo, si nuestro sensor tiene una resistencia de 10k Ohmios, nuestra lectura de sensor
ser:
1023 x (10000 / (33000 + 10000)) = 238
Pgina 51
Pgina 52
4. Motores:
4.1. Descripcin general
4.1.1. Motores Para que?
En numerosas ocasiones es necesario convertir la energa elctrica en energa mecnica,
esto se puede lograr, por ejemplo, usando los motores de corriente continua. Los usos ms
habituales pueden ser,
Traccin y direccin.
Orientacin de sistemas sensoriales.
Pgina 53
Las flechas rojas indican el sentido convencional de la corriente (de ms a menos). Las lneas
de campo magntico aparecen en rojo, dirigindose desde el polo norte (pintado en azul)
hacia el polo sur (pintado en verde). Las flechas de color negro representan la fuerza de
Lorentz que se ejerce sobre un conductor por el que circula una corriente elctrica situado en
el seno de un campo magntico.
Una vez explicado lo que es un motor y para que nos sirva, pasamos a mostrar los motores
que tiene Lego.
Pgina 54
Pgina 55
2838
2986
71427
43362
5292
47154
NXT
48g
10g
42g
28g
55g
40g
80g
Pgina 56
Vcc: 9 V
2838
Velocidad
de rotacin
Corriente
sin carga
4100
r.p.m.
35 mA
2986
71427
35 r.p.m.
6 mA
3.5 mA
43362
9 mA
5292
1300
r.p.m.
160 mA
47154
NXT
31 mA
60 mA
El motor 43362 tiene una corriente ms alta sin carga que el 71427, probablemente causado
por la gran friccin interna. El modelo 47154 tiene una corriente sin carga elevada, debido a
su reduccin de engranaje de 5 etapas. Para esto usa engranajes de diente grande en las
ltimas etapas, probablemente mucho ms robusto que el de 2 etapas, con engranajes
internos de diente delgado como 71427/43362. Los 5292 tambin exponen una corriente sin
carga muy alta, aqu otra vez causado por la friccin interna. Como es habitual para motores
de corriente continua, la velocidad de rotacin es proporcional ala tensin aplicado a ellos.
Vcc: 9 V
2838
Torque en 0.85
2986
71427
43362
1.6 N.cm
6 N.cm
5.5 N.cm
Pgina 57
5292
47154
NXT
12 N.cm
6 N.cm
50 N.cm
parado
Corriente
parado
N.cm
700 mA
80 mA
360 mA
340 mA
3.2 A
580 mA
2A
Se debe tener cuidado en no mantener los motores demasiado tiempo funcionando, pues
disipan demasiada potencia (6 vatios para 2838, 3 W para 71427) la cual provoca una rpida
subida de temperaturas. Atencin a los motores 71427 y 43362, equipados con un termisor,
deben ser protegidos de las altas temperaturas!! El motor NXT tambin esta protegido por un
termisor (Raychem RXE065 o Arroyos MF-R065). Esto significa que la corriente por el resulta
muy alta, entorno a los 2A la cual slo puede ser mantenida durante unos segundos.
Torque
o Velocidad
Poder
Poder
Mecnico
Elctrico
0.32 A
0.27 W
1.9 W
14 %
1000 rpm
0.32 A
0.46 W
2.3 W
20 %
0.45 N.cm
2000 rpm
0.32 A
0.9 W
3W
31 %
0.45 N.cm
3300 rpm
0.33 A
1.5 W
4W
39 %
momento
de
de rotacin
rotacin
6V
0.45 N.cm
580 rpm
7V
0.45 N.cm
9V
12 V
Corriente
Rendimiento
2838
Pgina 58
Torque
o Velocidad
momento
de
Corriente
de rotacin rotacin
Poder
Poder
Mecnico
Elctrico
Rendimiento
71427
4.5 V
2.25 N.cm
57 rpm
0.12 A
0.13 W
0.54 W
24 %
7V
2.25 N.cm
160 rpm
0.12 A
0.38 W
0.85 W
45 %
9V
2.25 N.cm
250 rpm
0.12 A
0.58 W
1.1 W
54 %
12 V
2.25 N.cm
375 rpm
0.12 A
0.88W
1.5 W
61 %
Poder
Poder
Mecnico
Elctrico
Torque
o Velocidad
momento
de
de rotacin
rotacin
4.5 V
2.25 N.cm
50 rpm
0.12 A
0.12 W
0.54 W
22 %
7V
2.25 N.cm
140 rpm
0.12 A
0.33 W
0.85 W
39 %
9V
2.25 N.cm
219 rpm
0.12 A
0.51 W
1.1 W
47 %
12 V
2.25 N.cm
333 rpm
0.12 A
0.77W
1.5 W
54 %
Poder
Poder
Mecnico
Elctrico
Corriente
Rendimiento
43362
Torque
o Velocidad
momento
de
de rotacin
rotacin
4.5 V
2.25 N.cm
90 rpm
0.19 A
0.21 W
0.85 W
24 %
7V
2.25 N.cm
210 rpm
0.19 A
0.49 W
1.33 W
37 %
9V
2.25 N.cm
315 rpm
0.19 A
0.74 W
1.7 W
43 %
Corriente
Rendimiento
47154
Pgina 59
12 V
2.25 N.cm
Torque
468 rpm
0.19 A
1.1 W
2.3 W
Poder
Poder
Mecnico
Elctrico
0.04 A
0.021 W
0.36 W
16 %
0.04 A
0.038W
0.48 W
28 %
Poder
Poder
Mecnico
Elctrico
o Velocidad
momento
de
de rotacin
rotacin
9V
1.28 N.cm
16 rpm
12 V
1.28 N.cm
Corriente
48 %
Rendimiento
2986
Torque
28 rpm
o Velocidad
Rendimiento
momento
de
de rotacin
rotacin
3V
2.48 N.cm
120 rpm
0.76 A
0.31 W
2.28 W
13 %
4.5 V
2.48 N.cm
340 rpm
0.77 A
0.88 W
3.46 W
25 %
7V
2.48 N.cm
670 rpm
0.78 A
1.74 W
5.46W
32 %
9V
2.48 N.cm
920 rpm
0.78 A
2.38 W
7.2 W
33 %
Poder
Poder
Mecnico
Elctrico
Corriente
5292
Torque
o Velocidad
momento
de
de rotacin
rotacin
4.5 V
16.7 N.cm
33 rpm
0.6 A
0.58 W
2.7 W
21.4 %
7V
16.7 N.cm
82 rpm
0.55 A
1.44 W
3.85 W
37.3 %
9V
16.7 N.cm
117 rpm
0.55 A
2.03 W
4.95 W
41 %
Corriente
Rendimiento
NXT
Pgina 60
12 V
16.7 N.cm
177 rpm
0.58 A
3.10 W
6.96 W
44.5 %
Pgina 61
Pgina 62
Transmisiones entre ejes que se cortan: Cuando hay que transmitir movimiento y
esfuerzos entre ejes que se cortan se utilizan los engranajes cnicos. LEGO ofrece
engranajes cnicos de 12 dientes. Adems, hay otro engranaje de 24 dientes (ver la figura)
que combinado con engranajes rectos permite transmitir movimiento entre ejes que se cortan.
Transmisiones entre ejes que se cruzan: Cuando dos ejes se cruzan se utiliza la
combinacin tornillo sinfn - corona (en nuestro caso la corona ser un engranaje recto). Por
medio de estas combinaciones se consiguen grandes relaciones de transmisin. En este
engranaje el tornillo sinfn siempre ser el conductor y la corona la conducida. El tornillo sinfn
Pgina 63
que suministra LEGO es de una entrada, por lo que las relaciones de transmisin sern las
siguientes:
16
24
40
Relacin de transmisin
0.125
0.0625
0.042
0.025
Engranajes que limitan el par: Este engranaje se utiliza para limitar el par. Con l se pueden
proteger ciertos mecanismos, por ejemplo, para que cuando lleguen a un lmite no sufran
daos.
Diferencial: Cuando un vehculo gira, las ruedas de un lado describen un recorrido de mayor
longitud que las del otro, as que si no se desea que se produzca un deslizamiento las
Pgina 64
velocidades de las ruedas no podrn ser iguales. Cuando se monta un robot mvil con las
ruedas de los dos lados movidas por un solo motor conviene utilizar un diferencial. Para ello
combinaremos el elemento de la figura con tres engranajes cnicos. El diferencial puede ser
til en otros casos, por ejemplo, cuando se controlan dos movimientos con un solo motor. Si
uno de los movimientos llega a un tope el otro podr continuar sin problemas.
Pgina 65
Ruedas dentadas. Engranajes: Las ruedas dentadas rectas que contiene LEGO MindStorms
tienen 8, 16, 24 y 40 dientes. Si las combinamos de dos en dos se pueden conseguir las
relaciones de transmisin que se recogen en la tabla: (Las imgenes de los elementos LEGO
de esta pgina estn cogidos de la pgina Technic con el permiso de su autor)
Los valores de la fila superior son el nmero de dientes de la rueda conductora, y los de la
columna izquierda los de la conducida.
8
16
24
40
16
0.5
1.5
2.5
24
0.33
0.67
1.67
40
0.2
0.4
0.6
Pgina 66
Poleas: La segunda opcin que se ofrece para transmitir movimiento y fuerza entre ejes
paralelos es utilizar poleas. Este sistema permite aumentar la distancia entre ejes. Adems, el
sentido de giro de los dos ejes ser el mismo. Sin embargo, la transmisin de movimiento y
esfuerzos por medio de engranajes ofrece mayor precisin y capacidad para transmitir
mayores esfuerzos.
Las tres poleas que contiene Lego MindStorms tienen los siguientes dimetros: 8.6, 21.9 y
34.2.
En la siguiente tabla se recogen las relaciones de transmisin tericas que se pueden
conseguir con estas poleas (en el caso en que no se produzca deslizamiento entre polea y
goma).
Pgina 67
Los valores de la fila superior son el dimetro de la rueda conductora, y los de la columna
izquierda, los de la conducida.
8.6
21.9
34.2
8.6
2.5
21.9
0.4
1.6
34.2
0.25
0.6
Pgina 68
6. Programacin
6.1. Introduccin a la programacin para LEGO.
Para programar el ncleo de Lego tenemos una amplia gama de lenguajes de programacin
de diversos niveles de dificultad y que nos ofrecen mltiples posibilidades y la opcin de
realizar aplicaciones complejas.
Para programar el ncleo sin tener grandes conocimientos de programacin se nos presentan
diversos lenguajes: RCX y Robolab, que son herramientas muy tiles y con grandes
posibilidades. Existen adems otros lenguajes como NQC e Interactive C que nos permiten
programar en el lenguaje C, muy conocido por la mayora de usuarios. Lego nos ofrece a
posibilidad de programar en Java o LabView siendo ste ltimo un referente en los ltimos
aos para programar RCX. Por ltimo existe la posibilidad de programar en lenguajes
orientados a objetos como Visual Basic, Visual C etc. Destacar adems la posibilidad de
programar directamente en C el ncleo a travs del sistema operativo del ncleo: LegOS y
BrickOS, siendo esto ltimo el ms utilizado en stos ltimos aos.
6.2. RCX-Code
6.2.1. Introduccin:
RCX-Code es el entorno de programacin grfico suministrado con LEGO MindStorms para
Windows. Est dirigido al mercado domstico. Es fcil de utilizar, y est basado en el lenguaje
educativo LOGO. Puedes editar un programa arrastrando bloques semejantes a los
tradicionales ladrillos LEGO. Una vez secuenciados de modo adecuado, y modificados sus
parmetros para adaptarlos a nuestros deseos, el programa puede ser transferido al RCX por
medio de la conexin de infrarrojos. A partir de ese momento, el robot podr funcionar de
modo autnomo sin depender del ordenador.
Pgina 69
Pgina 70
Pgina 71
Como podemos observar un bloque se ejecuta detrs de otro, puede haber bucles y varias
hebras que se puede ejecutar a la vez.
Pgina 72
6.2.2. Comandos
Movimiento de motores. Este es el bloque que permite controlar el movimiento de los
motores.
Sonidos:
Pgina 73
Temporizadores:
Pgina 74
Condiciones sensoriales
Pgina 75
Pgina 76
z
z
z
z
z
Bibligrafa
[1] Vicente Matelln Olivera, Jess M. Gonzlez Barahona, Pedro de las Heras Quirs, Jos
Centeno Gonzlez, Programacin de Lego MindStorms bajo GNU/Linux, 11 de noviembre
2000, 7 de noviembre 2006, http://es.tldp.org/Presentaciones/200002hispalinux/conf-16/16html/.
[2] Extrado de www.yuri.at, Robot de Lego, 9 de Noviembre de 2002, 7 de noviembre 2006,
http://www.yuri.at/go/robotica.
[3] Mario Ferrari, Marco Beri, EmuLegOs, 7 de noviembre 2006, 7 de noviembre 2006,
http://emulegos.sourceforge.net/.
[4]
Robotikarekin
jolase,
12
marzo
2001,
noviembre
de
2006,
http://www.euskalnet.net/kolaskoaga/lehenak/programa_c.htm.
[5] Alvin J. Alexander, DevDaily.com, Empezando con Lego MindStorms, 17 mayo 2003, 7 de
noviembre de 2006, http://www.devdaily.com/java/lejos/GettingStartedWithLejos/node1.shtml.
Pgina 77
[6] Paul Andrews Jrgen Stuber, Jos Solrzano, LejOs, W22 agosto del 2006, 7 de
noviembre de 2006, http://lejos.sourceforge.net.
[7] Alumnos de la URJC, Grupo de robtica de la URJC, 11 de octubre del 2006, 7 de
noviembre de 2006, http://veo.dat.escet.urjc.es/robotica/index.php/Portada
Universidad CarlosIII. Gua rpida de Lego Mindstorms y LeJos 19/9/2004.
http://robotit.it.uc3m.es/lego-guia.php
Pgina 78
En este primer nivel nos muestran un programa muy sencillo. Cada smbolo nos
indica una funcin:
Pgina 79
En este nivel se nos ofrece la posibilidad de controlar la potencia de cada elemento. Se puede
observar en la figura que la potencia tiene un rango de 1 a 5. Se han incluido nuevos
smbolos cuyas funciones son:
Sensor de contacto. Este smbolo nos indica que cuando es presionado este sensor,
el programa avanza al siguiente paso.
Pilot Nivel 3:
Pgina 80
Sensor de luz. Continua con la ejecucin del siguiente paso cuando detecta una zona
oscua.
Sensor de luz. Continua con la ejecucin del siguiente paso cuando no detecta una
zona oscura.
Pilot nivel 4:
Este nivel se diferencia del anterior en que puede programarse en mltiples pasos
haciendo ms extenso el programa.
Pgina 81
Inventor nivel 1:
En este nivel nos aparece un entorno de programacin diferente a los ya vistos anteriormente
en el modo pilot. A la derecha de la pantalla tenemos a nuestra disposicin las diversas
funciones que nos permite en este nivel, siendo el propio programador el que selecciona el
orden de ejecucin y realiza el diagrama. La mayora de las funciones ya nos son conocidas
por lo que explicaremos las nuevas. Cada programa siempre comienza con el smbolo del
semforo en verde y finaliza con el semforo en rojo. Una funcin que no hemos visto
anteriormente es la siguiente:
Nos proporciona un sonido.
Inventor nivel 2:
Pgina 82
En este nivel se nos ofrecen diversas funciones como cambio de direccin, saltar y
aterrizar y tiempo al azar:
Tiempo al azar. Mediante esta funcin el siguiente paso no se ejecutar hasta que
transcurra un determinado tiempo aleatorio. Ejemplo:
Pgina 83
Se repite 30 veces.
Pgina 84
Inventor nivel 4:
Este ltimo nivel presenta una diferencia relevante respecto al nivel anterior. Esta
diferencia es la posibilidad de utilizar contenedores. Un contenedor es un icono que almacena
un determinado valor y ordena al programa en qu momento se enva ese valor. Veamos
mediante un sencillo ejemplo el uso de los contenedores:
. Posteriormente entramos en un
. Seguidamente entramos en
una sentencia, en la cual si el contador es menor que 5 ejecutar la cadena inferior y por tanto
se repetir otra vez el bucle. Cuando el contador sea mayor que 5 entonces ejecutar la
cadena superior provocando un sonido que nos indica que ha salido del bucle y finaliza el
programa.
Pgina 85
6.4. LABVIEW
6.4.1. Qu es LabVIEW?
LabVIEW (Laboratory Virtual Instrument Engineering Workbench) es un lenguaje de
programacin grfico para el diseo de sistemas de adquisicin de datos, instrumentacin y
control. Labview permite disear interfaces de usuario mediante una consola interactivo
basado en software. Usted puede disear especificando su sistema funcional, su diagrama de
bloques o una notacin de diseo de ingeniera. Labview es a la vez compatible con
herramientas de desarrollo similares y puede trabajar con programas de otra rea de
aplicacin, como por ejemplo Matlab. Tiene la ventaja de que permite una fcil integracin con
hardware, especficamente con tarjetas de medicin, adquisicin y procesamiento de datos
(incluyendo adquisicin de imgenes).
Aplicaciones de LabVIEW
Labview tiene su mayor aplicacin en sistemas de medicin, como monitoreo de
procesos y aplicaciones de control, un ejemplo de esto pueden ser sistemas de
monitoreo en transportacin, Laboratorios para clases en universidades, procesos
de control industrial. Labview es muy utilizado en procesamiento digital de
seales (wavelets, FFT, Total Distorsin Harmonic TDH), procesamiento en
tiempo real de aplicaciones biomdicas, manipulacin de imgenes y audio,
automatizacin, diseo de filtros digitales, generacin de seales, entre otras, etc.
de
LabVIEW la versin bsica seta disponible por 1249.00 y la profesional por 4249.00
. Adems tendremos que comprar el toolkit de LabVIEW para LEGO MINDSTORMS por
unos 18 , National Instruments tambin pone a nuestra disposicin tarjetas de adquisicin
Pgina 86
de datos preparadas para actuar sobre los sensores y motores de lego con una mayor
cantidad de puertos que con el NTX o RCX. Teniendo en cuenta todo esto a continuacin se
explicar como utilizar LabVIEW genricamente, de tal forma que el lector pueda comprender
su uso y poder abordar la programacin con LEGO MINDSTORMS.
Pgina 87
tambin es necesario tener en cuenta que cuando se realiza una conexin a un VI esta
conexin se identifica por un tipo de dato especifico, que debe coincidir con el tipo de dato de
la entrada del VI (aunque esto no necesariamente es cierto ya que puede haber varios tipos
de datos conectados de VI a VI, adems de que un arreglo de datos ``cluster`` puede
albergar varios tipo de variables) permitiendo una concordancia en el flujo de datos; no
siempre el tipo de dato de la entrada del VI es el mismo que el de la salida, pero sin embargo
para la mayora de los casos si se cumple.
El flujo de datos va de izquierda a derecha en el panel de programacin y esta determinado
por las operaciones o funciones que procesan los datos. Es fcil observar en el panel de
programacin como se computan los datos en cada parte del programa cuando se realiza
una ejecucin del programa paso a paso. En Labview las variables se representan mediante
una figura tanto en el panel frontal como en el panel de programacin, de esta forma se
puede observar su respuesta en la interfaz del usuario y en el flujo de datos del cdigo del
programa. Otros objetos como grficas y accesos directos a pginas web cumplen estas
mismas condiciones.
Pgina 88
Pgina 89
Pgina 90
Pgina 91
el canal por donde se reciben los datos, para este ejemplo se ha tomado el canal de entrada
numero 0 de la PCI1200.
Numero de muestras 1000, Significa en cada ciclo de captura se va ha tomar N muestras par
representar la seal
Frecuencia de muestreo 1000. Importante. La frecuencia de muestreo escogida debe
cumplir con el criterio de Nyquist el cual dice que la frecuencia de muestreo debe ser por lo
menos el doble de la mxima componente de frecuencia de la seal ha capturar, es decir, si
la seal ha capturar es de 100Hz, la frecuencia de muestreo debe ser mayor que 200Hz.
Esto no significa que sea una frecuencia muy lejana de esta condicin, es mejor utilizar esta
frecuencia lmite para evitar procesamientos excesivos en el caso de implementar dentro de
la aplicacin filtros.
3. Por ultimo en el panel de control coloque un Waveform Graph, luego en el panel de
programacin realice la correspondiente conexin.
Inicializar
el
puerto
serial.
Numero
de
Puerto
cero
COM1
COM2
COM3
COM4
COM5
5:
6:
7:
8:
COM6
COM7
COM8
COM9
10:
11:
12:
13:
LPT
LPT
LPT
LPT
Pgina 92
Lea del puerto serial de la computadora la informacin de confirmacin que enva la fuente
El primer Vi corresponde a "Bytes at serial port" y es necesario para especificar al siguiente
VI, Serail port read.
Pgina 93
Para lograr esto, se utiliza la estructura Secuence, que como su nombre lo indica, corre un
nmero deseado de secuencias en forma cclica y ordenada, por lo que es ideal para nuestra
aplicacin. Primero configuramos el puerto para escribir, para lo que necesitamos escribir en
el control (890 dec) un 0 en el bit #1 (por ejemplo 0 dec).
Una vez configurado el puerto para escribir, se procede a escribir en la direccin de datos
(888 dec) el dato deseado por medio del control.
Pgina 94
Hasta el momento se han sacado datos, pero ahora podemos leer stos mismos
configurando primero el puerto para lectura, enviando a la direccin de control un 1 al bit #1
(por ejemplo 2 dec). Por ltimo con la ayuda de la funcin IN PORT leemos estos datos de la
direccin 888 dec y los visualizamos en el indicador.
Pgina 95
Una vez hemos instalado la herramienta RCX COMMAND CENTER, nos disponemos
a ejecutarla y nos aparecer la siguiente pantalla:
Por defecto vienen marcadas las casillas Automatic y RCX. Esto significa que el software
buscar en los diferentes puertos de comunicaciones la existencia del ncleo de
programacin RCX. Si por el contrario sabemos la ubicacin en la cual hemos conectado el
RCX entonces marcaremos el puerto de comunicacin correspondiente. En caso de no
detectar la conexin del ncleo nos aparecer por pantalla el siguiente mensaje:
Pgina 96
En la parte superior de la figura tenemos una barra en la que aparecen las siguientes
opciones:
Debajo de las mismas podemos observar diversos botones de acceso rpido, los cuales nos
permiten acceder a diversas opciones del programa sin necesidad de ir a la barra de
herramientas:
En la parte derecha de la figura principal del programa nos encontramos con una gua de los
comandos ms utilizados en NQC para la programacin del robot. La gua nos permite
conocer rpidamente el nombre de la funcin que necesitamos dependiendo que sea para el
manejo de sensores, las diversas salidas para el manejo de motores o para generar sonidos.
Pgina 97
Para empezar a escribir nuestro cdigo del programa que queremos realizar
pinchamos en el smbolo de la hoja en blanco en la parte superior de la pantalla o accedemos
al men file y despus marcamos new. Nos aparecer la siguiente figura:
Pgina 98
Una vez realizado un montaje sencillo del robot nos dispondremos a realizar un
programa en la herramienta RCX COMMAND CENTER. Para ello ejecutamos el programa y
abrimos una ventana nueva como ya se ha descrito en el capitulo anterior.
Pgina 99
Cada programa en NQC est compuesto por tareas. Todo programa ha de tener
como mnimo una tarea denominada main . la estructura bsica del programa es la siguiente:
//declaracin de constantes
//declaracin de variables
Definiremos por tanto las que creamos necesarias. Estas constantes pueden ser
usadas a lo largo del programa y son buenas ya que hacen que el programa sea ms legible y
ms fcil de cambiar los valores correspondientes a cada una de ellas. Como podemos
observar al definir una constante con la sintaxis adecuada, aparece con un color rojizo con el
fin de distinguir los distintos comandos.
Variables
Todas las variables en NQC son del mismo tipo, es decir enteros de 16 bits con signo.
Las variables las podemos diferenciar entre globales y locales. Las variables globales se
declaran en el mbito del programa, es decir fuera de las tareas. Estas variables pueden ser
utilizadas por cualquier tarea, subrutina o funcin.
Pgina 100
Las variables locales en cambio, se declaran dentro de la funcin, tarea, subrutina o funcin, y
slo se pueden utilizar dentro de las mismas.
Para definir variables en el espacio reservado para ello, se debe poner primero la
palabra reservada int seguida del nombre que elijamos para la misma y finalizando siempre
con ;:
int variable;
task main()
{
Variable = 5;
........
.......
......
}
6.5.4. Instrucciones
El cuerpo de un bloque de cdigo se compone de instrucciones. Todas las
instrucciones siempre terminan con ; La declaracin de variables, como se ha descrito en la
seccin anterior, es un tipo de instruccin. Una variable se declara como local (con
inicializacin opcional) cuando ha de ser utilizada dentro de un bloque de cdigo. Una vez
declarada se le asigna un valor con el operador =, adems de ste podemos utilizar otros
operadores que admitidos por NQC estos son:
= Asigna a una variable una expresin
+= Aade a una variable una expresin
-= Resta a una variable una expresin
*= Multiplica a una variable por una expresin
/= Divide una variable por una expresin
&= AND bit a bit de la expresin y la variable
|= OR bit a bit de la expresin y la variable
||= Asigna a una variable el valor absoluto de una expresin
+-= Asigna una variable el signo (-1, +1, 0) de una expresin
>>= Desplaza a al derecha la variable en una cantidad constante
<<= Desplaza a al izquierda la variable en una cantidad constante
Pgina 101
task main()
{
tiempo_de_avance = 20; //inicializacion variable
repeat(50)
//instrucciones
{
OnFwd(OUT_A+OUT_C);
Wait(tiempo_de_avance);
OnRev(OUT_C);
Wait(TIEMPO_GIRO);
tiempo_de_avance +=5;
}
Off(OUT_A+OUT_B);
}
if (condicion)
{
....//instrucciones
....
}
Else
{
...
}
Evala la condicin y si es verdadera entonces ejecutar las instrucciones posteriores. En
caso de no cumplirse ejecuta las instrucciones contenidas en la sentencia else si sta
existiera.
Sentencia repeat
repeat (expresion)
{
Pgina 102
Sentencia while
while (condicion)
{
.... //instrucciones
....
}
Esta sentencia ejecuta las instrucciones contenidas en ella tantas veces como se cumpla la
condicin.
Sentencia switch
switch (x)
{
case 1 : // se ejecuta cuando x es 1
break;
case 2 :
case 3 : // se ejecuta cuando x es 2 3
break;
default : // se ejecuta cuando x no es 1,2 ni 3
break;
}
Funciones:
A la hora de crear un programa para un robot de lego, puede ser til agrupar un
conjunto de instrucciones que utilizamos en una sola funcin, para posteriormente llamar a
Pgina 103
dicha funcin cuando la necesitemos y evitar as la repeticin de cdigo. Para declarar una
funcin recurriremos a la siguiente expresin:
void nombre(argumentos)
{
.......//instrucciones
}
Subrutinas:
Por otro lado tenemos la subrutinas, que a diferencia de las funciones permiten que
se comparta una nica copia del fragmento de cdigo ahorrando as espacio en la memoria
del RCX. Una desventaja de las subrutinas es que posee diversas limitaciones debido al
intrprete del cdigo de bytes LEGO. Las dos desventajas ms importantes de las subrutinas
son:
-A una subrutina no se le pueden pasar argumentos
-Una subrutina no puede llamar a otra
-El nmero mximo de subrutinas se limita a 8 en el RCX
Pgina 104
6.5.7. Tareas
Un programa en NQC nos permite declarar como mximo diez tareas. Siempre como
mnimo debe haber una tarea que es la principal: main. Las dems tareas se ejecutarn
cuando la funcin principal las llame utilizando la orden start. Una vez que se llama a otra
tarea, se ejecuta simultneamente con la primera. Una tarea en marcha puede detener a otra
tarea utilizando la orden stop. Al reiniciar la tarea que se ha parado, comienza siempre desde
el principio y no desde donde estaba cuando habamos parado dicha tarea.
task main()
{
.......
.......
start tarea1;
}
task tarea1 ()
{
//tarea principal
start tarea2;
//tarea1
.......
.......
}
task tarea2 ()
{
//tarea2
.......
.......
}
6.5.8. Sensores
Hay tres sensores, que se numeran internamente 0, 1 y 2, aunque externamente se numeran
como 1,2 y 3. Los nombres definidos para referirnos a un sensor determinado son:
Pgina 105
Los puertos de sensor en el RCX tienen capacidad de soportar una gran variedad de
sensores. Es funcin del programa decirle al RCX qu clase de sensor est conectado en
cada puerto. Se puede configurar el tipo de sensor por medio de SetSensorType. Si un puerto
de sensor se configura con el tipo incorrecto, el RCX puede no ser capaz de leerlo
correctamente.
El modo de sensor determina cmo se procesa el valor puro de un sensor. Algunos modos
slo tienen sentido para cierto tipo de sensores, por ejemplo SENSOR_MODE_ROTATION
slo es til con sensores de rotacin. El modo de sensor se puede establecer por medio de
SetSensorMode.
Para configurar a la vez el tipo de sensor y el modo existe la orden SetSensor (parmetros),
que es la que utilizaremos en los ejemplos para configurar los sensores.
Pgina 106
Pgina 107
6.5.9. Salidas
Todas las funciones que utilizan las salidas se las nombra como grupo. Cada valor
tiene que ser una constante OUT_A, OUT_B, OUT_C. tambin cabe la posibilidad de nombrar
dos salidas, por ejemplo (OUT_A+OUT_B) se refiere a las salidas A y B, sin necesidad de
repetir la orden.
Cada salida tiene tres atributos: modo, direccin y potencia. El modo se configura a
travs de la orden SetOutput (salida, modo). Modo admite las siguientes constantes:
Los dems atributos se pueden configurar con la orden SetDirection (salida, direccin).
Direccin puede adquirir los siguientes valores:
Pgina 108
Establece la potencia del motor especificado. Potencia puede ser una expresin,
cuyo resultado debe ser un valor entre 0 y 7. Las constantes OUT_LOW, OUT_HALF, o
OUT_FULL tambin pueden ser usadas.
SetPower(OUT_A, OUT_FULL); // A la mxima potencia
OutputStatus(n)
Devuelve el estado del motor n. Tener en cuenta que n debe ser 0, 1 o 2 no
OUT_A, OUT_B, o OUT_C.
x = OutputStatus(0); // Estado de OUT_A
On(salidas)
Establece las salidas especificadas como encendidas. Salida es uno o ms de los
valores OUT_A, OUT_B, y OUT_C.
On(OUT_A + OUT_C); // Enciende las salidas A y C
Off(salidas)
Establece las salidas especificadas como apagadas. Salida es uno o ms de los
valores OUT_A, OUT_B, y OUT_C.
Off(OUT_A); // Apaga la salida A
Float(salidas)
Establece las salidas especificadas como float. Salida es uno o ms de los
valores OUT_A, OUT_B, y OUT_C.
Float(OUT_A); // Detiene la salida A sin frenarla
Fwd(salidas)
Establece el sentido de giro de las salidas especificadas como avance. Salida es
uno o ms de los valores OUT_A, OUT_B, y OUT_C.
Fwd(OUT_A);
Rev(salidas)
Establece el sentido de giro de las salidas especificadas como retroceso. Salida
es uno o ms de los valores OUT_A, OUT_B, y OUT_C.
Rev(OUT_A);
Toggle(salidas)
Invierte el sentido de giro de las salidas especificadas. Salida es uno o ms de los
valores OUT_A, OUT_B, y OUT_C.
Toggle(OUT_A);
OnFwd(salidas)
Establece el sentido de giro de las salidas especificadas como avance y las pone
en marcha. Salida es uno o ms de los valores OUT_A, OUT_B, y OUT_C.
OnFwd(OUT_A);
OnRev(salidas)
Establece el sentido de giro de las salidas especificadas como retroceso y las
pone en marcha. Salida es uno o ms de los valores OUT_A, OUT_B, y OUT_C.
OnRev(OUT_A);
OnFor(salidas, tiempo)
Pone en marcha las salidas especificadas por un determinado tiempo y a
Pgina 109
continuacin las detiene. Salida es uno o ms de los valores OUT_A, OUT_B, y OUT_C.
Tiempo se mide en incrementos de 10ms (one second = 100) y puede ser una expresin.
OnFor(OUT_A, x);
Ejemplo:
task main()
{
OnFwd(OUT_A+OUT_C); //establece el sentido de giro y lo pone en marcha
Wait(100); //espera 1 segundo
Off(OUT_A+OUT_C); //desactiva las salidas
}
6.5.10.
Sonidos
El RCX posee un altavoz que nos permite generar diversos sonidos. Esto es til para
avisarnos de que algo sucede. Por defecto existen 6 sonidos diferentes en el RCX
numerados:
0
1
2
3
4
5
Click de tecla
Pitido
Barrido de frecuencia decreciente
Barrido de frecuencia creciente
Sonido de error
Barrido de rpido crecimiento
Pgina 110
6.5.11.
Bibliografa NQC
http://www.isaatc.ull.es/portal/doctorado/robotica/nqc_guia_sp.pdf
http://www.isaatc.ull.es/portal/doctorado/robotica/nqcovsp.pdf
http://www.donosgune.net/2000/gazteler/prg_leng/NQCgaz.htm
http://bricxcc.sourceforge.net/nqc/doc/NQC_Guide.pdf
INICIO
Para poder realizar las aplicaciones, debemos instalar la versin visual basic 5.0 o
superior. Visual basic es un entorno de programacin orientado a objetos que nos permite
realizar diversas aplicaciones grficas. Una vez instalado, nos dispondremos a ejecutarlo
mostrndonos la siguiente pantalla:
Pgina 111
En esta pantalla seleccionaremos el icono EXE estndar para poder realizar una aplicacin y
hacemos click en abrir.
Pgina 112
Pgina 113
Pgina 114
Seguidamente nos dispondremos a preparar una aplicacin para lego. Para ello hacemos
doble click en el icono correspondiente al nuevo componente que hemos agregado y nos
aparecer lo siguiente:
Pgina 115
Podemos observar diversas propiedades como (Name) que nos indica el nombre del
componente, siendo en este caso Spirit1, el cual es importante ya que nos referiremos a ese
componente mediante su nombre a la hora de realizar el cdigo del programa. Otra propiedad
a destacar es ComPortNo en la cul elegimos el puerto de comunicaciones donde
conectaremos el RCX. Por ltimo en la propiedad LinkType elegimos el modo de transmisin
de datos: 0 infrarrojos; 1 cable; 2 radio. Dejaremos la opcin que viene marcada por defecto.
Para realizar aplicaciones con el fin de controlar el robot de lego, insertaremos
diversos objetos en el formulario. Lo primero ser insertar dos botones haciendo doble click al
objeto command button de la barra de herramientas, el cul esta marcado con un crculo
rojo:
Pgina 116
Observamos que el nombre por defecto del botn es Command1 por lo que podemos
sealando el botn y situndonos en la ventana de propiedades para cambiar el nombre.
Pgina 117
Una vez que tenemos los objetos dispuestos en el formulario, nos dispondremos a
escribir el cdigo de cada objeto. Para ello podemos comenzar por el botn parada.
Pgina 118
A travs de spirit1 nos referimos al componente para manejar lego que hemos visto
anteriormente, seguido del . Y despus nos referimos a la propiedad CloseComm , la cul
se encarga de cerrar el puerto de comunicaciones.
A continuacin hacemos doble click en el formulario, para que nos aparezca el cdigo
correspondiente al iniciar nuestro programa:
Pgina 119
Nos mostrar el cdigo asociado al objeto del botn parada y un nuevo cdigo en la parte
superior, dentro del cual podemos escribir las instrucciones que queremos ejecutar al iniciar el
programa. A continuacin introduciremos lo siguiente:
Posteriormente hacemos doble click en el botn inicio para incluir el cdigo asociado
a ese botn cuando pinchemos sobre l. En el espacio correspondiente al cdigo del objeto
inicio escribiremos lo que queremos que realice el robot mediante rdenes secuenciales.
Veamos un ejemplo con el siguiente cdigo:
En el cdigo anterior se aprecia el manejo de las propiedades SetFwd, on, wait y off,
dentro del objeto Spirit1
Pgina 120
Pgina 121
Con esta funcin configuramos el nmero y el tipo de sensor que es. El valor SENSOR puede
adquirir los siguientes valores: SENSOR_1, SENSOR_2 SENSOR_3.
En el argumento TIPO se establece el tipo de sensor conforme a la siguiente tabla:
Pgina 122
El argumento SLOPE slo se usa si hemos elegido el modo booleano, para cualquier otro
modo marcaremos 0 en el argumento SLOPE.
Pgina 123
Sentencia while:
A continuacin modificaremos el cdigo del objeto inicio con el fin de utilizar tanto los
sensores como los motores. Para ello incluiremos el siguiente cdigo en el botn:
Con esta aplicacin el robot se mover hacia delante hasta que choque.
http://netwinder.osuosl.org/pub/misc/docs/mindstorms/pbrick.pdf
http://mindstorms.lego.com/sdk/default.asp
http://www.donosgune.net/2000/dokumen/VB_cast.zip
Pgina 124
6.7. BrickOS
6.7.1. Configurando e instalando BrickOS
Para utilizar BrickOS, se opto por trabajar bajo Windows y a si evitar problemas de
configuracin de los dispositivos USB. Lo primero es instalar la herramienta Cygwin, que es
un emulador de un ambiente Linux bajo Windows. Esta es un software freeware que puede
ser obtenido de su sitio oficial:
http://www.cygwin.com
Esta herramienta puede instalarse directamente de Internet o seleccionar los paquetes de
Linux necesarios, bajarlos y luego instalarlo desde un directorio local. Los mnimos paquetes
que debe contener para que brickOS funcione correctamente son: ash, autoconf, automake,
bash, binutils, cpio, cygwin, diff, file, fileutils, findutils, flex, gcc, grep, less, login, make, mingw,
patch, sed, shellutils, tar, textutils, time y w32api. Todos ellos deben ser instalados durante el
Setup de Cygwin. Luego deben ser bajados los siguientes paquetes Linux:
gcc-2.95.2.tar.gz
binutils-2.10.1.tar.gz
legos-buildgcc.zip (un script de configuracin)
Es conveniente dejarlos en un subdirectorio. Una vez terminada la instalacin, se debe
correr cygwin, se abrir una ventana bash shell. Luego se debe descomprimir legosbuildgcc.zip y correr el script. Este script instalara las herramientas gcc y binutils.
Luego debemos instalar BrickOS. El paquete debe ser descomprimido, lo cual creara un
directorio brickOS. Se debe entrar en este subdirectorio y escribir. /congure, esto buscara el
compilador Hitachi del lego. Luego se debe escribir make, con esto se configura toda la
herramienta, y se generan los binarios correspondientes. Si todo llega a buen termino, es
decir, sin errores, brickOS ya esta instalado. Por defecto BrickOS trabaja con el puerto serie,
en el caso se quiera trabajar con el puerto USB, deberemos realizar un par de pasos
adicionales. Primeramente debemos entrar al directorio til escribir make strip, luego
debemos sealar que la va de comunicacin debe ser por el puerto USB, y esto se hace
configurando la variable RCXTTY, y se hace de la escribiendo export RCXTTY=USB, por
defecto tiene el valor COM1. De esta manera la configuracin de BrickOS ha concluido, solo
resta transferir el firmware y transferir programas a los slot.
Cuando fue instalado brickOS, se generaron todos los binarios, y adems se compilo el
archivo firmware que se encuentra en el directorio /boot tiene el nombre de brickOS.srec, y
unos programas de ejemplos que se encuentran en el directorio /demo, los cuales han sido
compilados para brickOS.
Pgina 125
Lo que se debe hacer ahora es reemplazar el firmware estndar por el firmware BrickOS y
ello se lleva cabo escribiendo ./rmdl3../boot/brickOS.srec, comenzara de esta manera el
puerto infrarrojo a transmitir los datos y la pantalla ira mostrando su porcentaje de
transferencia hasta llegar al 100%, esto tomara unos 3 o 4 minutos.
En cuanto a los programas deben estar escrito en formato C/C++, en un archivo
mi_programa.c, y debe ser compilado con make mi archivo.lx, que es el nombre del binario
que se generara, ser transferido al RCX, y ser interpretado por el procesador Hitachi. Una
vez compilado se debe transferir el programa al RCX se utiliza el comando dll de la siguiente
forma ./util/dll -p2 /demo/mi_programa.lx, lo que significa que mi_programa.lx es transferido
al RCX y almacenado en el Slot2 de memoria.
dispositivos en cada interrupcin del timer cada 1 milisegundo, estos dispositivos son:
1. Motores
2. Sonido
3. Protocolo Comunicacin IR
4. Botones
5. Indicador de Batera
6. Actualizacin del LCD
7. Manejo de tareas (cada 20 milisegundos por defecto).
Pgina 126
Entre las funciones bsicas de BrickOS podemos destacar las de las de salida (output) y
las de lectura (input), que sern explicadas a continuacin.
Funciones de Output, Motores y LCD: Para trabajar con el robot lego es necesario
controlar ciertos dispositivos para poder accionar y llevar a cabo operaciones sobre el
medio externo en que se desenvuelve el robot. Estos dispositivos son los Motores y el LCD.
Los Motores, son parte esencial en la construccin de un robot movil. Son los
dispositivos que proveen de cinemtica al robot. El RCX posee 3 puertos de salida, los
puertos A, B, C, es decir, un robot construido con un RCX podr tener el control de hasta 3
motores. Para el manejo de los motores brickOS puede controlar la Direccin y la
Velocidad. Para ello provee las funciones motorXdir y motorXspeed.
En la funcin motor_X_dir(Direccion_del_Motor), X puede ser A, B o C, segn
corresponda al puerto a que esta conectado el motor que se desea controlar. El argumento
de esta funcin corresponde a la orientacin, esta puede ser:
Pgina 127
msleep(500);
velocidad +=20;
}
int main() {
cputs("brake");
lcd_refresh();
motor_a_speed(brake);
motor_c_speed(brake);
sleep(3);
manejo_de_motor();
cputs("off");
lcd_refesh();
motor_a_speed(off);
motor_c_speed(off);
sleep(3);
return 0;
}
El LCD es la pequea pantalla que posee el RCX la cual puede mostrar hasta 5 caracteres
y smbolos de conexin para cada uno de los puertos. BrickOS permite trabajar directamente
con el LCD, por esto dispone de variadas funciones para mostrar diversos tipos de datos, las
ms comunes son:
cputs(char *string), muestra un string de 5 letras directamente en pantalla.
lcdint(int X), para mostrar el valor entero X, valores entre -9999 y 9999.
lcdclear(), para limpiar pantalla.
cputw(unsigned int X), para mostrar valores hexadecimal entre el rango 0 y 65535.
dlcdshow() y dlcdhide(), funcin de bajo nivel para mostrar u ocultar los brazos de la
figura humana que aparece en el LCD al encenderlo.
lcdrefresh(), para obligar a dar un refresco a la pantalla.
Por otra parte tambin debe ser mencionada la LegoLamp, o lmpara de luz, la cual es
manejada de la misma manera que los motores, pero ahora la velocidad toma el sentido
como el valor de la intensidad de la luz que emite la legoLamp.
Pgina 128
valores
brutos
van
desde
220
280, se
debe
inicializar
con
la
funcin
ds_pasive(&SENSOR_X).
El Sensor Rotacional, es un dispositivo lego que detecta 1/16 de una rotacin
manteniendo un contador. Los sensores de rotacin pueden ser utilizados para la medicin de
ngulos, rotaciones, distancias, velocidades, etc. Posee modo pasivo y activo. El pasivo no
mide nada, no tiene utilidad. El modo activo, mantiene un acumulador relativo el cual cuenta
los ticks cada 22.5 grados de una revolucin. Para utilizar el sensor rotacional brickOS provee
las funciones:
Pgina 129
Ejemplo de uso:
int main(){
ds_active (&SENSOR_2); ds_rotation_on (&SENSOR_2); ds_rotation_set (&SENSOR_2 ,
0); msleep(100);
while(1) {
lcd_int (ROTATION_2); msleep(20);
}
}
Pgina 130
6.8. Interactive C
Pgina 131
6.9. LegOs
6.9.1. INTRODUCCIN
LegOS es un sistema operativo libre diseado para el LEGO Mindstorms, diseado e
implementado fundamentalmente por Markus Noga. Comparado con el sistema operativo
original de LEGO, ofrece muchas ventajas adems de mejores prestaciones y mayor
flexibilidad.
Pgina 132
Ejemplo 1.
#include
#include
#include
#include
<conio.h>
<unistd.h>
<dsensor.h>
<dmotor.h>
Pgina 133
lcd_refresh();
/* Los sensores estn conectados a los puertos 1 y 2 */
return SENSOR_1<0xf000 || SENSOR_2<0xf000;
}
Ejemplo 2.
#include <conio.h>
#include <unistd.h>
#include <dsensor.h>
#include <dmotor.h>
if(SENSOR_1<0xf000)
dir = 0;
else
dir = 1;
motor_a_dir(rev);
motor_c_dir(rev);
Pgina 134
msleep(500);
motor_a_speed(MAX_SPEED);
motor_c_speed(MAX_SPEED);
if(dir==1)
motor_c_dir(fwd); cputs("Izqda");
else
motor_a_dir(fwd); cputs("Drcha");
msleep(500); } }
La estructura del programa es equivalente al del NQC, pero en este caso slo se utiliza una
tarea que espera en un bucle infinito a que se produzca un evento, la pulsacin del sensor,
para realizar el giro. Se han aadido suficientes comentarios al cdigo como para que no
merezca la pena entrar en ms detalles de su descripcin.
El entorno de programacin bajo GNU/Linux incluye el compilador de C de GNU (gcc)
compilado como cruzado para el Hitachi H8, para lo que hace falta usar las binutils. La
distribucin para GNU/Linux de LegOS incluye varias herramientas que permiten descargar el
cdigo de forma dinmica, descargar el firmaware o sistema operativo, as como varios
ejemplos.
Adems, alrededor del sistema operativo LegOS se han desarrollado mltiples herramientas
auxiliares, como por ejemplo simuladores que hacen ms fcil la depuracin al permitir
ejecutar programas en la propia plataforma de desarrollo usando un depurador tradicional de
Pgina 135
GNU/Linux como por ejemplo gdb. Algunas de estas herramientas se analizan en la prxima
seccin.
LegoSim
LegoSim es un simulador para legOS cuya principal virtud, que le diferencia de Emulegos
(descrito en la siguiente seccin), es que el interfaz grfico de usuario (GUI) se puede separar
del simulador propiamente dicho. Esta separacin permite utilizar el GUI como unidad de
control no slo como simulador, permitiendo por ejemplo, conectarlo a otros RCX va infrarojos. Por supuesto, tambin permite ejecutar el GUI en una mquina distinta de la del
simulador.
El GUI es un applet de Java que se parece realmente al RCX. El simulador es slo una
biblioteca (librera). Ambos componentes se relacionan mediante un conjunto de scripts en
Perl. El simulador es una biblioteca que reemplaza la parte de legOS que se enlaza con
cualquier aplicacin en el proceso de compilacin, generando una aplicacin completa y
ejecutable en la mquina de desarrollo. En la simulacin, las tareas (tasks) de legOS se
traducen en threads POSIX. Las entradas y salidas, que resultan vitales, se simulan mediante
cadenas de texto sobre stdin y stdout siguiendo una sintaxis particular.
LegoSim se distribuye bajo licencia MPL, es decir, es software libre. Sus diseadores e
implementadores principales han sido Frank Mueller, Thomas Rblitz, y Oliver Bhn.
6.10. EmuLegOS
EmuLegOS es otro simulador de legOS. Su objetivo de diseo fue proporcionar un entorno
ms confortable para probar y depurar programas. EmuLegOS es, en esencia, un conjunto de
cdigo escrito en C++ que se puede compilar y enlazar junto con cualquier aplicacin para
legOS, generando como resultado de ese proceso una aplicacin que emula el
comportamiento de ese cdigo al que tuviese si estuviese ejecutndose en un RCX real. El
nivel de programacin o API (Application Program Interface) emula las rutinas de legOS. La
mayora de legOS est implementado en EmuLegOS, incluyendo por ejemplo el soporte de
tareas, o la comunicacin por infra-rojos.
Pgina 136
Pgina 137
6.11. WebLegos
Web-LegOS es un interfaz escrito en HTML para compilar programas escritos para el sistema
operativo legOS del LEGO Mindstorms RCX.
El uso de Web-LegOS es sencillo bastando con cortar y pegar un fichero fuente en una caja
de una pgina web, elegir el lenguaje de programacin y seleccionar la forma en que se
quiere recibir el fichero que se genera. A continuacin, con pulsar el botn de ``compilar'' se
produce el envo del fichero fuente y su compilacin cruzada remota a legOS. El fichero
obtenido est en formato S-record (un formato diseado para permitir la descarga de datos
desde un ordenador a otro diferente). Una vez que el fichero S-record se ha obtenido a
travs del compilador web es posible descargarlo en el RCX utilizando el canal de infra-rojos
habitual.
Introduccin
6.12.2.
Pgina 138
con su propio sistema operativo. (NOTA: si quitas las pilas durante un periodo de tiempo
largo, debers volver a cargarlo con firmdl)
lejosjc: es el compilador. Ejemplo: lejosjc sample.java
lejoslink: linkador para producir el fichero binario.
lejosdl: descarga el binario creado al RCX
Por tanto el modo de funcionamiento comn es:
firmdl #flasheamos el RCX con leJOS
lejosjc foo.java #compilo mi programa foo.java
lejoslink foo -o foo.bin #creo el binario
lejosdl foo.bin #descargo al RCX mi programa
Recuerda que puedes automatizar el progreso mediante un archivo Makefile. Revisa los
ejemplos que trae el paquete leJOS, copia cualquier Makefile y ajstalo a tus necesidades.
Instalar el firmware
OJO: Esto slo lo tendrs que hacer si el RCX no tena pilas o se han quitado durante ms de
1 minuto, con lo que el firmware se habr borrado.
Para poder ejecutar programas leJOS en el RCX, primero hay que reemplazar el sistema
operativo LEGO original con leJOS. Para ello:
Sita el sensor de infrarrojos del RCX frente a la torre USB
Enciende el RCX
Abre una consola del sistema
Ejecuta
lejosfirmdl
Pgina 139
6.12.3.
Este es el programa ms simple que puedes hacer con leJOS: el "Hola Mundo". Lo tienes
tambin en la seccin examples\hworld de la distribucin de leJOS:
import josx.platform.rcx.*;
/* Este programa, tras descargarlo, espera que pulses el botn RUN, tras lo
* cual muestra "hello" en la pantalla durante un tiempo, y luego
* muestra "world" (Por ltimo, una breve espera y vuelve al sistema operativo).
*/
public class HelloWorld {
public static void main (String[] aArg) throws Exception {
LCD.clear();
TextLCD.print ("hello");
Thread.sleep(2000);
TextLCD.print ("world");
Thread.sleep(2000);
}
}
Para ejecutar este programa en el RCX:
Abre una consola, crea un directorio donde almacenar tus programas, y crea un fichero
HelloWorld.java copiando el texto mostrado anteriormente
Complalo usando lejosc en vez de javac:
lejosc HelloWorld.java
Y transmtelo al RCX con el comando lejos
lejos HelloWorld
El progreso de la descarga se mostrar en la consola del sistema y en la pantalla del RCX; al
acabar, el RCX pitar dos veces y mostrar el icono con un hombre de pie
Pulsa el botn Run del RCX para ejecutar el programa
Si los comandos lejosc o lejos no se encuentran, asegrate de que la variable PATH est
correctamente configurada. Si las clases leJOS no se encuentran, revisa el valor de la
variable CLASSPATH.
Pgina 140
Escribe
el
siguiente
programa
Java
(lgicamente,
en
un
fichero
llamado
SimpleSample.java):
import josx.platform.rcx.*;
public class SimpleSample {
public static void main(String[] args) throws InterruptedException {
// message
TextLCD.print("DRIVE");
// drive forward
Motor.A.forward();
// just run until RUN button is pressed again
Button.RUN.waitForPressAndRelease();
} // main()
} // class SimpleSample
import josx.platform.rcx.*;
Importa las clases esenciales para ejecutar los programas leJOS.
public static void main(String[] args) throws InterruptedException {
Como con la mayora de los programa Java (menos los applets!), el punto de arranque es el
mtodo main(). In este caso, se declara la excepcin InterruptedException porque el
mtodo Button.RUN.waitForPressAndRelease() puede lanzarla. Al lanzar una
excepcin, el RCX detiene la ejecucin del programa y muestra un mensaje (bastante
crptico) en la pantalla.
Pgina 141
TextLCD.print("DRIVE");
Muestra la cadena DRIVE en la pantalla del RCX, que, como habrs visto, es muy limitada (...
esto hace difcil la depuracin de los programas en algunos casos...).
Fjate en dos cosas importantes:
leJOS tiene la clase habitual java.lang.String
se est empleando un mtodo esttico de la clase TextLCD. ste es un concepto muy
importante en leJOS: las clases relacionadas directamente con el hardware - motores,
sensores, botones y pantalla - son clases estticas. As no hay que construir objetos sino que
se pueden usar directamente.
Motor.A.forward();
Este cdigo pone en marcha el motor conectado al puerto A del RCX, hacia adelante
("forward"
en
ingls).
De nuevo, fjate en que se est empleando una instancia esttica de la clase Motor - para ser
ms preciso, un miembro esttico (llamado A) de la clase, que se refiere al "motor conectado
al puerto A". Como es lgico, los otros motores seran el B y el C.
Button.RUN.waitForPressAndRelease();
Para qu se usa esto? Es que no est funcionando todava el robot? La respuesta es: s y
no. Si esta lnea no estuviera:
El motor arrancara y el mtodo Motor.forward() terminara, con lo que el programa
seguira por la siguiente instruccin.
Como no habra ninguna, main() terminara, y devolvera el control al sistema operativo.
Como resultado, el motor se detendra.
Es decir, si no estuviera el mtodo Button.RUN.waitForPressAndRelease(), el
programa terminara rpidamente y el motor se detendra. Lo que hay que hacer es mantener
el programa en ejecucin durante ms tiempo. Esto se podra hacer de varias maneras, pero
una muy sencilla es dejarlo esperando a que se pulse un botn, en este caso, el botn RUN,
que es lo que hace el mtodo Button.RUN.waitForPressAndRelease().
Pgina 142
6.12.4.
Motores
La clase esttica Motor representa a los actuadores, es decir, los dispositivos conectados a
alguno de los tres puertos de salida de color negro, situados debajo de la pantalla del RCX:
Pgina 143
6.12.5.
Sensores
Los sensores son los sentidos del robot, que le permiten obtener un modelo perceptivo del
entorno y reaccionar a los eventos y situaciones segn est programado. Existen un montn
de sensores hardware disponibles para el RCX, todos los cuales se conectan a uno de los
tres puertos grises que hay sobre la pantalla del RCX:
De forma parecida a los motores, los tres puertos de los sensores se implementan como
atributos estticos de la clase Sensor:
Sensor.S1
Sensor.S2
Sensor.S3
As pues, una llamada tpica para leer el valor del sensor sera:
Sensor.S1.readValue();
Otra posibilidad sera acceder a los puertos mediante el array esttico Sensor[] que
contiene los tres sensores.
Configurar un sensor
Antes de leer datos de un sensor, primero hay que configurarlo, es decir, hay que indicar:
qu tipo de sensor hay conectado
cmo hay que leer los datos del sensor
Pgina 144
La
configuracin
se
hace
mediante
el
mtodo
public
static
void
setTypeAndMode(int aType, int aMode), donde type es uno de los cinco tipos de
sensor disponibles:
SensorConstants.SENSOR_TYPE_LIGHT: sensor de luz
SensorConstants.SENSOR_TYPE_ROT: sensor de rotacin
SensorConstants.SENSOR_TYPE_TEMP: sensor de temperatura
SensorConstants.SENSOR_TYPE_TOUCH: sensor de contacto
SensorConstants.SENSOR_TYPE_RAW: sensor no especfico
OJO: En el pack, slo hay disponibles los sensores de luz y de contacto.
El parmetro mode puede ser:
SensorConstants.SENSOR_MODE_ANGLE: medida de ngulos (slo sensores de
rotacin)
SensorConstants.SENSOR_MODE_BOOL:
pulsado/no
pulsado
(sensores
de
grados
centgrados
(sensores
de
grados
Fahrenheit
(sensores
de
contacto)
SensorConstants.SENSOR_MODE_DEGC:
temperatura)
SensorConstants.SENSOR_MODE_DEGF:
temperatura)
SensorConstants.SENSOR_MODE_EDGE: cuenta de rebotes (cuenta el nmero de
veces que cambia el estado de un sensor de contacto)
SensorConstants.SENSOR_MODE_PCT: medida relativa, en porcentaje (sensores de
luz)
SensorConstants.SENSOR_MODE_PULSE: cuenta de clicks (sensores de contacto)
SensorConstants.SENSOR_MODE_RAW: medida numrica (0 - 1023).
El modo edge tiene la peculiaridad de que mantiene los valores aunque se apague el RCX,
as que hay que recordar llamar a Sensor.setPreviousValue(0) para reiniciar la cuenta.
Al configurar el sensor, asegrate de utilizar una combinacin lgica del modo y tipo, o si no,
el valor no tendr sentido.
Activar un sensor
Algunos sensores, como los de luminosidad, necesitan corriente para funcionar. La llamada al
mtodo Sensor.activate() hace que el puerto en cuestin se "encienda", es decir, que
reciba corriente. La llamada opuesta para "apagar" el sensor es Sensor.passivate().
Pgina 145
Leer un sensor
La forma ms sencilla y directa de leer el valor de un sensor es usar uno de los mtodos
read...():
public static boolean readBooleanValue()
public static int readValue()
public static int readRawValue()
que devuelven el estado del sensor o el valor que estn midiendo, en el momento de llamar al
mtodo. Recuerda que este valor depende del tipo y modo de sensor que se haya
configurado, segn se vio anteriormente.
Existe otro mtodo de bajo nivel, public
static
int
readSensorValue(int
void
Pgina 146
existencia con un sensor de contacto, sino que podra evitarlos usando un sensor de luz para
percibirlos.
Para ello surgi el sensor ProximitySensor, que no es una subclase de la clase Sensor
sino que se construye con uno de ellos. En el constructor del sensor de proximidad se indica
un umbral, un valor entero que define la separacin con el objeto que hace que se active el
sensor: cuanto mayor es el valor, ms se acerca el robot al objeto.
El sensor se emplea llamando a waitTillNear(long aMilliseconds), que bloquea el
programa hasta que se detecta un objeto; el parmetro indica cunto se espera (en
milisegundos), o 0 para esperar indefinidamente (hasta detectar un objeto).
6.12.6.
LCD
cdigos
de
segmento
son
constantes
definidas
en
la
interfaz
Segment
Pgina 147
Existe una versin simplificada: la clase MinLCD, que contiene slo public static void
setNumber(int aCode,int aValue,int aPoint) y refresh(), que ocupa menos
memoria.
Otra clase disponible es TextLCD, que ofrece mtodos para escribir caracteres o cadenas de
hasta 5 letras:
public static void print(char[] aText)
public static void printChar(char aChar, int aPosition) )
public static void print(String aString)
6.12.7.
Botones
Pgina 148
La
forma
ms
sencilla
de
detectar
cundo
se
pulsa
un
botn
es
llamar
la
clase
esttica
Sound
Sound.beep();
Pgina 149
con
la
tpica
llamada:
Pgina 150
import josx.platform.rcx.*;
import josx.util.*;
public class TimerSample implements TimerListener {
public static void main(String[] args) throws InterruptedException {
// crear y arrancar el temporizador, con intervalo 1 segundo
Timer timer = new Timer(1000,new TimerSample());
timer.start();
// ejecuta hasta pulsar el botn RUN
Button.RUN.waitForPressAndRelease();
// detener el temporizador
timer.stop();
} // main()
6.12.8.
Bibliografa LegOS
-Vicente Matelln Olivera, Jess M. Gonzlez Barahona, Pedro de las Heras Quirs, Jos
Centeno Gonzlez, Programacin de Lego MindStorms bajo GNU/Linux, 11 de noviembre
2000, 7 de noviembre 2006, http://es.tldp.org/Presentaciones/200002hispalinux/conf-16/16html/.
-Extrado de www.yuri.at, Robot de Lego, 9 de Noviembre de 2002, 7 de noviembre 2006,
http://www.yuri.at/go/robotica.
-Mario Ferrari, Marco Beri, EmuLegOs, 7 de noviembre 2006, 7 de noviembre 2006,
http://emulegos.sourceforge.net/.
-Robotikarekin
jolase,
12
marzo
2001,
http://www.euskalnet.net/kolaskoaga/lehenak/programa_c.htm.
Pgina 151
noviembre
de
2006,
Pgina 152
Pgina 153
recreaban combates o personajes del mismo. Se pudo observar como rpidamente los nios
se involucraron con el problema.
En otras ocasiones, con alumnos ms mayores, se pudo comprobar lo contrario. Se hizo
construir a los alumnos un robot capaz de competir en dos pruebas simultneamente: sumo y
seguimiento de una lnea; se deba buscar un compromiso en las caractersticas del robot de
forma que, cumpliendo con las especificaciones dadas,
el robot se comportase
Pgina 154
Pgina 155
Al parecer todo comenz gracias a la aficin a estos temas del por entonces miembro del
APA Fernando Gallego. En un viaje al extranjero comprob lo integrado que estaba la
robtica en la enseanza de otros pases y desde entonces se propuso crear una
actividad extraescolar que fuese ms all del tpico curso de ofimtica que se imparte a
los
alumnos.
Con un presupuesto inicial que no dio ms que para comprar dos robots RCX, iniciaron
sus andaduras; y desde entonces gracias al esfuerzo de todos fueron ganando
competiciones, y empleando los premios en la compra de nuevo material de LEGO.
Actualmente, cuentan con un total de unos 20 kits que prueban en el aula en circuitos
construidos
por
ellos:
laberintos,
rampas,
obstculos
de
distinta
ndole
que
identificar/esquivar etc
Pgina 156
- Se limitan al uso de Lego? Lego les ofrece la posibilidad de montar y desmontar los
robots mil veces hasta que les quedan las cosas como ellos quieren (su forma de trabajar
es esa ms que ponerse a pensar antes de hacer las cosas), esa es la gran ventaja. Sin
embargo para los alumnos ms 'mayores' ya se les est quedando pequeo el mundo de
Lego puesto que, aunque hacen grandes diseos con Lego capaces de competir y ganar
a todo tipo de contrincantes de Lego; en otro tipo de competiciones los Lego no son
capaces de competir con los otros robots: No ofrece una relacin resistencia-peso
suficiente entre otros actores. Esto hace que se estn moviendo al uso de DSPs y
estructuras ms complejas de contrachapado para poder competir en certmenes
internacionales.
- Con qu material cuentan? Aparte de los robots y sus cajas de piezas, y los circuitos,
cuentan con ordenadores conectados en red y un servidor de documentos. Para la parte
de montajes, disponen de soldador, taladro y sierra de calar.
-
Qu tal las competiciones a las que han ido? En Espaa son el nico grupo que se
dedique al trabajo con robots, sin embargo en todo tipo de pases esto esta muy
avanzado. De sus experiencias nos cuentan que es muy divertido y gratificante el
contacto con otros grupos de desarrollo, especialmente con pases occidentales, otro tipo
de pases menos desarrollados como Irn etc al parecer hacen de su reconocimiento en
el campo de la robtica una forma de darse a conocer y por tanto imponen un secretismo
que les impide intercambiar conocimientos con ellos.
El 82 % de estudiantes opina que construir un robot con Lego cumple con la labor de
diseo y construccin que se espera del uso de esta herramienta.
[1] Peer Learning with Lego Mindstorms Ciarn Mc Goldrick, Meriel Huggard.
[2] The Qualitative Impact of Using LEGO MINDSTORMS Robots to Teach Computer Engineering Andrew B. Williams
Pgina 157
El 44% de los estudiantes que declar que el proyecto de laboratorio de Robot LEGO
era eficaz en la enseanza de ellos el programa de C. Otro el 44 % dijo que el
laboratorio de Robot LEGOabirmo que su eficacia era media.
El 76% de los estudiantes dijo que los Robots LEGO eran eficaces o muy eficaces en
la enseanza de sistemas integrados.
7.3.
Entornos
de
programacin
por
franjas
de
edades:
Evolucin
Tanto la versin comercial como la educativa han sido desarrolladas por Nacional Instruments
y las dos estn basadas en LabView. Sin embargo, este no es el nico software
comercializado por LEGO para el NXT ya que tambin est disponible la versin 2.9 de
Robolab. Esta versin de Robolab tiene como objeto facilitar la transicin del RCX al NXT y
dar soporte a los dos sistemas adems de ofrecer un nuevo firmware para el RCX.
No obstante en el plan de desarrollo de LEGO NXT Educacin se puede observar que el
horizonte de aprendizaje es el uso del NXT con LabVIEW.
Pgina 158
En 2010, LEGO Education ofrecer su lnea de productos que irn desde la escuela
elemental y primaria hasta el mundo real.
Pgina 159
7.4.
A continuacin hacemos una pequea comparativa entre los dos entornos ms usados para
la enseanza con Lego. Por una parte Robolab y por otra LabView como herramienta ms
actual y con mayor perspectiva de futuro.
Labview: Cambios respecto a Robolab
Bsicamente los cambios consisten en que han desaparecido los modos de programacin
Piloto e Investigador. Ahora slo se dispone de un modo de programacin que se
corresponde con el antiguo modo Programador .
El modo Piloto, era un modo dirigido al inicio en la programacin con nios y nias que se
inician en la programacin. Era un modo en el que se iban ofreciendo nuevas instrucciones
con cuentagotas y en el que no se podan cometer errores. Era muy limitado pero facilitaba
una introduccin a la programacin muy amigable.
Tambin ha desaparecido el modo Investigador . Este modo estaba dirigido principalmente a
la investigacin cientfica, registro sistemtico de datos, tratamiento de datos y su posterior
presentacin. Era muy til en el laboratorio de ciencias y para ello se comercializaban
diferentes tipos de sensores ( DCP Instruments ). Su desaparicin no es definitiva y quien
necesite seguir utilizndolo puede hacerlo con Robolab 2.9. En la web de LEGO Engineering
se puede ver que el plan de desarrollo de software para el NXT comprende ofrecerlo como un
software aparte, MindStorms Education Science.
Qu aporta de nuevo
De entrada la posibilidad de conectarse con el NXT por medio de Bluetooth, de modo
inalmbrico. Con el Bluetooth desaparecern muchos de los problemas que se generaban en
el aula cuando varios alumnos transferan sus programas al RCX. Es posible conectar de
modo simultneo ms de uno a un mismo ordenador. Tambin es posible conectarlo por
medio USB.
En Robolab el modo Programador ofreca una amplia coleccin de bloques de programacin
que haba que distribuir por el escritorio y unir por medio de cables para establecer las
secuencias y relaciones en el programa. En LEGO NXT Educacin se utilizan mucho menos
los cableados, ya que el nexo de unin entre los distintos bloques de programacin es una
viga LEGO que aparece y se alarga automticamente.
Pgina 160
Todo ello redunda en una mayor velocidad a la hora de programar, ya que con un nico
bloque podemos poner en movimiento un robot durante un tiempo determinado, cuando en
Robolab eran necesarios dos adems del cableado. Por otra parte tambin resulta ms fcil
desarrollar programas sin errores. En lo que sera la programacin bsica todos los
programas funcionan, hagan o no lo que desebamos.
Ahora bien, si lo que tenemos en mente es el modo Programador de Robolab hay ciertas
prdidas de funcionalidad, sobre todo para los usuarios avanzados. Quiz las ms evidentes
son el uso de la cmara y tratamiento de imagen, el piano para composiciones musicales y el
control remoto va Internet. Tampoco se pueden programar eventos ni establecer prioridades
entre tareas. Por otra parte el nuevo software no admite sensores genricos como lo haca
Robolab.
Pgina 161
Pgina 162
8. Competiciones LEGO
El diseo, la construccin y la programacin de los robots son una actividad perfecta para la
competicin. Se comportar el robot como esto debera? Cmo puede esto funcionar ms
con exactitud, rpidamente, y ms sofisticadamente? A los nios les gusta ste tipo de
desafos y sobretodo si les lleva a competir contra otros.
En 2005, ms de 100,000 nios y aproximadamente 8,000 equipos participaron en
acontecimientos competitivos de robtica por todo el mundo y LEGO MINDSTORMS a
menudo es el detonante de estos acontecimientos, donde compiten equipos escolares.
Las competiciones son organizadas por organizaciones no lucrativas y financiadas por los
patrocinadores que desean promover la participacin de nios en la ciencia y la tecnologa.
Uno de los precursores es la PRIMERA Liga LEGO, FLL, en 1998. Otras competiciones,
como la Olimpada de Robot Mundial, WRO, han atestiguado un aumento dramtico de la
participacin de forma que en 2005, tan slo un ao despus de su creacin, ya haba
inscritos ms de 3700 equipos.
Hoy en da existen centros de LEGO MINDSTORMS en pases como los EE.UU., Singapur,
Japn, Noruega, Suecia, Dinamarca, Irlanda, Alemania y el Reino Unido encargados de dirigir
jvenes en distintos temas del campo de la robtica.
www.firstlegoleague.com
La FIRST Lego League (conocida por su acrnimo FLL) es una competicin dirigida a
estudiantes entre 9 y 14 aos, organizada por la FIRST (r For Inspiration and Recognition of
Science and Technology, tambin organiza la competicin de robtica FRC). Cada ao se
centra en un tema relacionado con la ciencia, y cada equipo debe presentar diseos acorde a
el. Por ejemplo, en el ao 2006, el tema era la nanotecnologa, y deban de construir robots
relacionados con situaciones tan dispares como la informtica a la medicina. Debern pasar
diferentes clasificaciones, donde podrn entrar en contacto con los otros equipos, y compartir
conocimientos e ideas.
Pgina 163
Los equipos participantes en la FLL usan Lego Mindstorms kits para construirse pequeos
robots autnomos para construir su proyecto. La organizacin de la competicin tiene un
acuerdo con la compaa de LEGO.
Hay cuatro fases en la competicin. En la primera, los participantes deben pasar por un
jurado, demostrando su trabajo en equipo. En la segunda deben demostrar que el robot que
han construido est diseado adecuadamente a las restricciones impuestas. En la tercera
parte los estudiantes deben desarrollar un proyecto sobre un tema concreto, y deben
presentarlo a un jurado. Finalmente, los estudiantes deben usar los robots diseado para
competir en la cancha.
Los estudiantes tienen ocho semanas para trabajar en su robot. Una vez construido debern
presentarlo a las competiciones locales, de dnde se podrn clasificar a las regionales,
estatales y a la final mundial. El ao pasado, de los 80.000 estudiantes que se presentaron de
todo el mundo organizados en 7000 equipos llegaron a la final 82 equipos, que se celebr en
Atlanta.
Pgina 164
8.2. Robocampeones
www.robocampeones.com
Robocampeones es una competicin de robots organizada por el Grupo de Robtica de la
Universidad Rey Juan Carlos, dirigida a colegios e institutos cuyo fin es fomentar la aficin de
los alumnos por la ciencia y la tecnologa.
sta competicin se viene celebrando desde el 2003.
El objetivo fundamental de Robocampeones es fomentar entre los alumnos de secundaria el
inters por las carreras tcnicas como las ingenieras (Informtica, Telecomunicacin,
Industriales, etc.). Estas carreras normalmente se perciben como algo difcil y aburrido.
Robocampeones sin embargo, presenta la tecnologa como algo vistoso y divertido. Adems,
al plantearse en formato concurso, el aliciente de la competicin lo hace ms emocionante y
atractivo.
En la prueba slo se pueden usar exclusivamente robots construido con LEGO, aunque
excepcionalmente se permite el uso de algn sensor o adorno casero.
En la competicin celebrada ste ao, se celebraron dos pruebas:
Prueba El transportista
El propsito de esta prueba es construir un robot capaz de seguir una lnea de forma que
pueda coger y transportar dos latas de refresco de un extremo a otro de la lnea. Gana aquel
robot que lo haga en el menor tiempo posible.
Pgina 165
9. ROBOTS Lego
Una vez estudiados los robots LEGO, tanto su mecnica cmo su programacin, veremos
ejemplos prcticos de robots construidos con LEGO, dnde se puede ver toda su potencia.
Cul es el modelo real y cul es el modelo LEGO? Tal es la potencia de Mindstorms, que
cualquier diseo que uno se proponga es posible.
En ste ejemplo se ha construido con LEGO una fiel reproduccin de la gra modelo Demag
AC535.El modelo en Lego pesa 3,6kg. Slo nos centraremos en cmo se han construido los
elementos mecnicos ms importantes con LEGO.
La direccin:
Al
motor se
le
ha
aadido
una
transmite
el
movimiento
Pgina 166
La suspensin:
Para la suspensin, se ha utilizado un modelo pendular para el eje delantero, un sistema
independiente para el eje central, y se ha dejado fijo el eje trasero.
En un vehculo normal, el dispositivo encargado de absorber las vibraciones y los impactos es
el propio amortiguador, o las ballestas. En ste caso se trata de gomas extensibles, que
fijarn el eje, absorbiendo las irregularidades del terreno.
La configuracin del eje delantero permite hasta una inclinacin de 18 sin que el vehculo se
incline.
Apoyos
Se usan para estabilizar a la gra cuando levanta grandes cargas, pues se aumenta la
distancia entre los puntos de apoyo y el centro de masas, aliviando el peso sobre las ruedas,
y nivelando la gra
El movimiento del motor se transmite mediante engranajes a los cuatro apoyos.
Pgina 167
Ruedas motrices:
Para mover la gra, se utilizan dos motores de LEGO, a la salida de los dos motores se
conecta una reductora con una relacin 9:1 lo que permite una gran traccin a baja velocidad.
El movimiento se transmite a las dos ruedas trasera, para tener mayor agarre y poder circular
por los terrenos ms difciles.
Brazo gra
En ste caso se puede ver un ejemplo de cmo se pueden modificar los componentes de
LEGO, para adecuarlos a las necesidades del robot.
Piezas de LEGO a las que se las han aadido roscas para poder controlar el tornillo.
Pgina 168
Para construir el brazo de la gra, se ha utilizado un tornillo sinfn. El movimiento del motor
hace girar el tornillo, que con su movimiento hace que se eleve el brazo de la gra.
Pgina 169
Partes de la fotografa:
-Pinza azul: Se encargar de rotar el cubo, con giros 90, tanto a izquierda como a derecha.
Adems, deber sujetar firmemente la fila central del cubo para evitar giros. Para ello lleva
motores LEGO, uno para la pinza, y otro para la rotacin.
-Pinza amarilla y verde: Encargas del giro de las piezas del cubo.
-Cmara de vdeo: Cmara Logitech (muy similar a la que viene con LEGO).Conectada al PC
para el procesado de imgenes.
-Transmisor de infrarrojos: Enviar la informacin del PC al RCX.
-Bloque RCX, microcontrolador.
Pgina 170
-Se posiciona una cara delante de la cmara, la cmara la graba, y manda la informacin a un
PC. El ordenador se encarga de procesar la imagen y de detectar los colores, mediante el
siguiente programa (escrito por el diseador del robot)
Una vez que el programa ha detectado correctamente el color de cada ficha, enva la
informacin, guardad en una matriz, al RCX, va transmisor de infrarrojos.
-Una vez que el RCX ha obtenido la informacin, y sabe que color hay en cada cara, aplica el
algoritmo de Herbert Kociemba (que resuelve el cubo en menos de 40 rotaciones).
-Para conseguir el giro de una cara. La pinza azul atrapa fuertemente el cubo, y las pinzas
amarillas y verdes se encargan del giro de las caras.
Pgina 171
Pgina 172
Sensor de Luz 16
Pgina 173