2 Avanzado Manual - LEGO

INTRODUCCIN AL DISEO
DE MICROROBOTS MVILES
Trabajo realizado para la asignatura de Diseo de Microrrobots
Mviles de la Universidad de Alcal
por
Estela Daz Lpez
Julin Manzano DOnofrio
Ignacio Esperabe de Arteaga del Alamo
Jos Antonio Martn Esteban
Rubn Fernndez Carnicero
Javier Mateos Andaluz
David Gualda Gmez
Luis de Santiago Rodrigo
Noviembre 2006
ROBOTS LEGO MINDSTORMS
0. NDICE
0.
NDICE ............................................................................................................................... 1
1.
INTRODUCCIN ............................................................................................................. 6
1.1.
QU ES LEGO-MINDSTORMS?..................................................................................... 6
1.2.
POR QU USAR LEGO-MINDSTORMS? ........................................................................ 6
1.2.1.
VENTAJAS: ..................................................................................................................... 6
1.2.2.
DESVENTAJAS ................................................................................................................ 7
1.3.
BREVE HISTORIA DE LEGO:........................................................................................... 7
1.4.
QU VIENE CON LEGO? ............................................................................................... 8
2.
DESCRIPCIN GENERAL........................................................................................... 10
2.1.
EL RCX:......................................................................................................................... 10
2.1.1.
DESCRIPCIN ............................................................................................................... 10
2.1.2.
PUERTOS DE ENTRADA (1, 2,3)..................................................................................... 11
2.1.3.
PUERTOS DE SALIDA..................................................................................................... 12
2.1.4.
BOTONES DE CONTROL: ............................................................................................... 13
2.1.5.
PANTALLA LCD:.......................................................................................................... 13
2.1.6.
PUERTO DE COMUNICACIN INFRARROJA.................................................................... 13
2.1.7.
TRANSMISOR DE INFRARROJOS. ................................................................................... 13
2.1.8.
ALIMENTACIN:........................................................................................................... 14
2.2.
EL NXT: ......................................................................................................................... 15
2.3.
DIFERENCIAS HARDWARE ENTRE EL NXT Y RCX: .................................................... 20
2.4.
BIBLIOGRAFA PARA LA PARTE DE DESCRIPCIN: ...................................................... 21
3.
TRANSDUCTORES Y SENSORES:............................................................................. 23
3.1.
DEFINICIONES Y CONCEPTOS PREVIOS: ....................................................................... 23
3.1.1.
SENSOR: ....................................................................................................................... 23
3.1.2.
TRANSDUCTOR:............................................................................................................ 23
3.1.3.
SELECCIN DE LOS SENSORES: .................................................................................... 24
3.2.
3.2.1.
SENSORES DE LEGO:...................................................................................................... 24
SENSOR DE TEMPERATURA:......................................................................................... 24
Pgina 1
3.2.2.
SENSOR DE CONTACTO: ............................................................................................... 25
3.2.3.
SENSOR DE LUZ:........................................................................................................... 25
3.2.4.
SENSOR DE ROTACIN: ................................................................................................ 26
3.2.5.
SENSOR ULTRASNICO:................................................................................................ 26
3.2.6.
SENSOR DE SONIDO: ..................................................................................................... 27
3.2.7.
SENSOR DE COLOR HITECHNIC COMPATIBLE CON NXT :........................................... 28
3.2.8.
SENSORES DE PRESENCIA:............................................................................................ 29
3.3.
FABRICACIN DE SENSORES PARA LEGO: ................................................................... 30
3.3.1.
SENSOR DE LUZ: ........................................................................................................... 30
3.3.2.
GP2D12 SENSOR DE DISTANCIAS: ............................................................................... 30
3.3.3.
SENSOR DE COLOR: ...................................................................................................... 33
3.3.4.
CONSTRUCCIN DE UN SENSOR DE TEMPERATURA RCX COMPATIBLE:...................... 39
3.4.
FABRICACIN DE SENSORES PASIVOS: ......................................................................... 44
3.4.1.
SENSORES DE CONTACTO:............................................................................................ 44
3.4.2.
SENSORES DE LUZ: ....................................................................................................... 46
3.4.3.
SENSOR DE HUMEDAD:................................................................................................. 46
3.4.4.
SENSORES DE TEMPERATURA: ..................................................................................... 47
3.5.
FABRICACIN DE SENSORES ACTIVOS: ........................................................................ 48
3.5.1.
3.6.
4.
SENSORES DE LUZ REFLECTANTES:.............................................................................. 48

BIBLIOGRAFA PARTE DE SENSORES: ........................................................................... 52
MOTORES:...................................................................................................................... 53
4.1.
DESCRIPCIN GENERAL ................................................................................................ 53
4.1.1.
MOTORES PARA QUE? ................................................................................................ 53
4.1.2.
PRINCIPIO DE FUNCIONAMIENTO.................................................................................. 53
4.1.3.
MOTOR DE CORRIENTE CONTINUA .............................................................................. 53
4.2.
MOTORES LEGO: ........................................................................................................... 55
4.2.1.
PESO DE CADA MOTOR: ................................................................................................ 56
4.2.2.
CARACTERSTICAS EN VACO (SIN CARGA):................................................................. 57
4.2.3.
CARACTERSTICAS EN PARADO:................................................................................... 57
4.2.4.
CARACTERSTICAS EN CARGA:..................................................................................... 58
4.3.
BIBLIOGRAFA DE LA PARTE DE MOTORES:................................................................. 62
Pgina 2
5.
TRANSMISIN DE MOVIMIENTO Y ESFUERZO:................................................ 63
5.1.
6.
BIBLIOGRAFA PARTE TRANSMISIONES: ...................................................................... 68

PROGRAMACIN ......................................................................................................... 69
6.1.
INTRODUCCIN A LA PROGRAMACIN PARA LEGO. ................................................. 69
6.2.
RCX-CODE .................................................................................................................... 69
6.2.1.
INTRODUCCIN: ........................................................................................................... 69
6.2.2.
COMANDOS .................................................................................................................. 73
6.2.3.
BLOQUES DE CONTROL DE FLUJO ................................................................................. 75
6.3.
INTRODUCCIN A ROBOLAB ...................................................................................... 78
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.
BIBLIOGRAFA ROBOLAB ............................................................................................. 86
6.4.
LABVIEW ..................................................................................................................... 86
6.4.1.
QU ES LABVIEW?.................................................................................................... 86
6.4.2.
PROGRAMACIN GRFICA CON LABVIEW ................................................................... 87
6.4.3.
ENTORNO LABVIEW ................................................................................................... 88
6.4.4.
FLUJO DE DATOS .......................................................................................................... 89
6.4.5.
MANEJO DE PUERTOS CON LABVIEW ........................................................................ 90
6.4.6.
PUERTO SERIE .............................................................................................................. 92
6.4.7.
BIBLIOGRAFA LABVIEW.............................................................................................. 95
6.5.
6.5.1.
LENGUAJE NQC ............................................................................................................ 95

INTRODUCCIN A NQC:............................................................................................... 95
INTRODUCCION A RCX COMMAND CENTER ............................................................ 96

6.5.2.
ESTRUCTURA DE UN PROGRAMA.................................................................................. 99
6.5.3.
CONSTANTES Y VARIABLES ....................................................................................... 100
6.5.4.
INSTRUCCIONES ......................................................................................................... 101
6.5.5.
SENTENCIAS DE CONTROL .......................................................................................... 102
6.5.6.
FUNCIONES Y SUBRUTINAS ........................................................................................ 103
6.5.7.
TAREAS ...................................................................................................................... 105
Pgina 3
6.5.8.
SENSORES ................................................................................................................... 105
6.5.9.
SALIDAS ..................................................................................................................... 108
6.5.10.
SONIDOS ................................................................................................................... 110
6.5.11.
BIBLIOGRAFA NQC................................................................................................. 111
6.6.
SPIRIT.OCX Y VISUAL BASIC: ..................................................................................... 111
6.6.1.
INTRODUCCIN A SPIRIT.OCX .................................................................................... 111
6.6.2.
PROGRAMACIN EN VISUALBASIC ............................................................................ 111
6.6.3.
FUNCIONES PARA EL MANEJO DE LAS SALIDAS.......................................................... 121
6.6.4.
FUNCIONES PARA EL MANEJO DE LAS ENTRADAS. ..................................................... 122
6.6.5.
OTRAS FUNCIONES ..................................................................................................... 123
6.6.6.
SENTENCIAS DE CONTROL .......................................................................................... 123
6.6.7.
BIBLIOGRAFA SPIRIT.OCX Y VISUALBASIC: ............................................................. 124
6.7.
BRICKOS...................................................................................................................... 125
6.7.1.
CONFIGURANDO E INSTALANDO BRICKOS................................................................ 125
6.7.2.
PROGRAMACIN EN BRICKOS ................................................................................... 126
6.7.3.
BIBLIOGRAFA BRICKOS ............................................................................................ 130
6.8.
INTERACTIVE C ........................................................................................................... 131
6.8.1.
6.9.
BIBLIOGRAFA INTERACTIVE C:................................................................................. 131

LEGOS .......................................................................................................................... 132
6.9.1.
INTRODUCCIN ..................................................................................................... 132
6.9.2.
ASPECTOS GENERALES DE LEGOS............................................................................. 132
6.9.3.
ARQUITECTURA DE SOFTWARE USANDO LEGOS....................................................... 132
6.9.4.
EJEMPLOS DE PROGRAMAS......................................................................................... 133
6.9.5.
CMO SE PROGRAMA DESDE GNU/LINUX? ............................................................. 135
6.9.6.
HERRAMIENTAS RELACIONADAS CON LEGOS ........................................................... 136
6.10.
EMULEGOS................................................................................................................ 136
6.11.
WEBLEGOS ................................................................................................................ 138
6.12.
PROGRAMACIN EN JAVA PARA LOS LEGO-MINDSTORMS (LEJOS) ..................... 138
6.12.1.
INTRODUCCIN ........................................................................................................ 138
6.12.2.
CMO USO LEJOS BAJO LINUX? ............................................................................ 138
6.12.3.
CREAR Y EJECUTAR MI PRIMER PROGRAMA LEJOS ................................................. 140
6.12.4.
MOTORES ................................................................................................................. 143
6.12.5.
SENSORES ................................................................................................................. 144
6.12.6.
LCD ......................................................................................................................... 147
6.12.7.
BOTONES .................................................................................................................. 148
6.12.8.
BIBLIOGRAFA LEGOS ............................................................................................. 151
Pgina 4
7.
LEGO MINDSTORMS EN LA ENSEANZA .......................................................... 153
7.1.
TRABAJO CON LEGO MINDSTORMS EN LA ENSEANZA............................................ 153
7.1.1.
MTODO DE TRABAJO ................................................................................................ 153
7.1.2.
OBJETIVOS: A CONSEGUIR .......................................................................................... 155
7.1.3.
UN CASO PRCTICO: VISITA AL GRUPO COMPLUBOT. ............................................... 155
7.1.4.
ALGUNAS ESTADSTICAS INTERESANTES ................................................................... 157
7.2.
LEGO MINDSTORMS: VERSIN EDUCATIVA VS COMERCIAL .................................... 158
7.3.
ENTORNOS DE PROGRAMACIN POR FRANJAS DE EDADES: EVOLUCIN ................ 158
7.4.
LABVIEW VS ROBOLAB EN EL ENTORNO EDUCATIVO .............................................. 160
7.5.
BIBLIOGRAFA EDUCACIN. ....................................................................................... 161
8.
COMPETICIONES LEGO .......................................................................................... 163
8.1.
FIRST LEGO LEAGUE................................................................................................... 163
8.2.
ROBOCAMPEONES ....................................................................................................... 165
9.
ROBOTS LEGO ............................................................................................................ 166
9.1.
UN EJEMPLO MECNICO. ............................................................................................ 166
9.2.
UN EJEMPLO DE PROGRAMACIN: ............................................................................. 170
10.
PRECIOS ORIENTATIVOS...................................................................................... 172
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. Por qu usar LEGO-Mindstorms?

En este apartado indicaremos las principales ventajas y desventajas de utilizar Lego.
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.
1.3. Breve historia de LEGO:

LEGO, cuyo nombre viene de las palabras en dans "leg godt" ("jugar bien"), y de Mindstorms
(tormentas de ideas).
Todo empez en el MIT, dnde se empezaron las investigaciones sobre microcontroladores,
que fuesen fcilmente programables, y se conectasen a sensores y actuadores. All surgieron
los primero ladrillos programables. Fueron especialmente diseados para nios, jvenes y
estudiantes, para que pudiesen hacer sus primeros pinitos en el mundo de la robtica.
Pgina 7
Inspirados en el ladrillo del MIT(aunque completamente creado por LEGO, la compaa

juguetera lanz en 1998 al mercado el kit Robotics Invention System 1.0,un sistema basado
un microcomputador denominado RCX. En Espaa deberamos esperar hasta 1999, con la
versin 1.5 para poder comprarlo. En el 2006 Lego ha lanzado el nuevo modelo, el NXT.
As, las piezas de LEGO, tanta veces usadas para armar y desarmar, se convirtieron en una
autntica plataforma de desarrollo y estudio, implantndose en colegios y universidades.
1.4. Qu viene con LEGO?

En las dos plataformas de LEGO vienen las siguientes piezas:
Sistema de Invencin de Robtica 2.0
En l se incluye el RCX Microcomputer con su correspondiente CD-ROM de Software, la
Contructopedia (dnde podrs encontrar mltiples diseos), con tres desafos guiados y
seis desafos pro. Adems incluye el transmisor infrarrojo, y 718 piezas, entre las que se
incluyen dos motores, dos sensores tctiles y un sensor luminoso
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
En las siguientes fotografas se muestra como es internamente el modulo RCX. El primero es

una vista superior y la segunda inferior.
2.1.2. Puertos de entrada (1, 2,3)
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.
2.1.3. Puertos de salida
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
2.1.4. Botones de control:
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.
2.1.5. Pantalla LCD:

Es una pantalla de cristal liquido, donde se visualiza es estado del robot.
2.1.6. Puerto de comunicacin infrarroja.
A travs de el puede comunicarse con el PC o con otros RCX.
2.1.7. Transmisor de infrarrojos.
Pgina 13
Sirve para establecer un vnculo inalmbrico entre el PC y el RCX. Con el transmisor de

infrarrojos se puedes descargar programas al ladrillo controlador y para ejecutarlos. Para que
se establezca una comunicacin el RCX y el transmisor infrarrojos deben verse el uno al
otro con una separacin de entre 10m y 15 m aunque en condiciones de iluminacin optimas
pueden separarse hasta 30 m.
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
En el Modo arranque no puedes descargar programas en tu robot porque el RCX necesita el

firmware. El firmware es un software especial que permite la comunicacin entre tu equipo y
el RCX. Se necesita descargar desde el PC.
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.
El pin 1, ANA es un pin analgico conectado a un convertidor analgico/digital del procesador

AVR y tambin a un generador de corriente para alimentar al sistema sensorial.
Los pines 5 y 6, DIGIAI0 y DIGIAI1, son pines digitales de entrada/salida usados para la
comunicacin digital con el ARM-7 mediante un bus I2C a una velocidad de 9600 baudios.
El puerto 4 puede funcionar como un puerto de alta velocidad. Un RS485 esta implementado
en el interior el puerto. Esto permite una comunicacin bidireccional de alta velocidad.
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
A continuacin se muestra un dibujo donde se representan los componentes del controlador y

su interconexin con otros componentes:
Pgina 19
2.3. Diferencias hardware entre el NXT y RCX:

RCX
NXT
N puertos salida
N puertos de entrada
NO
SI
Compatibilidad con IR
SI
NO
Compatible con Bluetooth
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
Texto, imgenes, nmeros
N de programas cargados
Infinitos
Programacin sobre el brick
NO
SI
Usa nuevos y viejos sensores
NO
SI
Unin con el ordenador por
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
Diferencias generales entre RCX y NXT:
2.4. Bibliografa para la parte de descripcin:

http://mindstorms.lego.com/ : sobre el NXT, hay PDF con toda la descripcin hardware (lego
Xtreme).http://www.etse.urv.es/~aoller/robmob_eaiei/LEGO%20MindStorms%20RIS.htm:
sobre
el
RCX
http://complubot.educa.madrid.org/inicio.php?seccion=principal pagina de los nios de alcala
Pgina 21
Archivos en PDF de la universidad politecnica de Catalua sobre Robotic invention system

(http://bibliotecnica.upc.es/bustia/arxius/40427.pdf ), de la universidad de las Palmas de Gran
Canaria sobre una practica sobre sistemas roboticos moviles (http://serdis.dis.ulpgc.es/~iisrm/MatDocen/notas_practicas/Prac_1-2/Practica1y2.pdf ).
Otras paginas visitadas:
http://nxtbot.com/blog/?p=133 -> costruccion con lego rcx de juego de bolas

http://www.micromundos.com/solutions/mwexroboticspage2.html foto lego_mosca
http://www.donosgune.net/2000/ documento educacin robots
http://legolab.daimi.au.dk/ robots lego para investigacin
http://www.crynwr.com/lego-robotics/ sobre RCX
http://gonzo.teoriza.com/2005/08/03/robotica-con-lego-mindstorms/
http://graphics.stanford.edu/~kekoa/rcx/
http://www.lego.com/eng/education/mindstorms/home.asp?pagename=rcx
http://robotics.benedettelli.com/
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
transductores digitales suelen ofrecer la ventaja de ser ms compatibles con las

computadoras digitales que los sensores analgicos en la automatizacin y en el control de
procesos.
Pgina 23
3.1.3. Seleccin de los Sensores:

La seleccin se basa en la decisin sobre cual es el sensor ms adecuado. Esto depende del
material del objeto el cual debe detectarse.
Si el objeto es metlico, se requiere un sensor inductivo. Si el objeto es de plstico, papel, o si
es lquido (basado en aceite o agua), granu1ado o en polvo, se requiere un sensor capacitivo.
Si el objeto puede llevar un imn, es apropiado un sensor magntico.
Sensores activos y pasivos:

Los sensores pasivos, no necesitan alimentacin para funcionar. Los sensores activos, por
otra parte, son los que necesitan su propia alimentacin. Una manera fcil de distinguir los
sensores activos de los pasivos es contar el nmero de pines que tienen. Lo sensores activos
tienen un tercer pin extra para obtener la alimentacin, mientras que los sensores pasivos
slo tiene dos.
Conector para sensores pasivos. Conector para sensores activos.
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:
3.2.1. Sensor de Temperatura:

El sensor de temperatura permite leer el valor aproximado de la temperatura, mediante la
interaccin de un termistor en uno de los extremos, generando un campo magntico que
permite la deteccin aproximada de la temperatura del bloque que lo contiene. El bloque
original de Lego posee un termistor de 12 k a 25 C con un coeficiente de correccin
aproximado de un -3,7%/C
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).
3.2.2. Sensor de Contacto:

El sensor de contacto permite detectar si el bloque que lo posee ha colisionado o no con
algn objeto que se encuentre en su trayectoria inmediata. Al tocar una superficie, una
pequea cabeza externa se contrae, permitiendo que una pieza dentro del bloque cierre un
circuito elctrico comience a circular energa, provocando una variacin de energa de 0 a 5
V.
En este caso, si la presin supera una medida estndar de 450, mostrado en la pantalla de
LCD, se considera que el sensor est presionado, sino est sin presin. Este Sensor se
puede utilizar para determinar cuando un Robot toca algo con el fin de que tome la decisin
de regresar o cambiar de direccin. (ref. W779911).
3.2.3. Sensor de Luz:

El sensor de luz permite tomar una muestra de luz mediante un bloque modificado que un
extremo trae un conductor elctrico y por el otro una cmara oscura que capta las luces. Esta
cmara es capaz de captar luces entre los rangos de 0,6 a 760 lux. Este valor lo considera
como un porcentaje, el cual es procesado por el bloque lgico, obteniendo un porcentaje
aproximado de luminosidad.
El bloque RCX calcula con la frmula Luz = 146 RAW / 7 para determinar el porcentaje
obtenido por la lectura de la luz, tomando una muestra cada 2,9 ms, siendo ledo en 100 us. ,
el valor que se lee a partir del sensor.
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).
3.2.4. Sensor de Rotacin:

El sensor de rotacin permite conocer la posicin del robot en cualquier instante. Para
conocer la posicin del robot, el sensor produce una variacin de energa entre cuatro
estados, los cuales son detectados cada 2,9 ms. y procesados por el bloque RCX durante 100
us, en los cuales pasa entre cuatro estados de energa:
2,0volts
->
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).
3.2.5. Sensor ultrasnico:

El sensor Ultrasnico slo se incluye en el empaque de Lego Mindstorms NXT, y su principal
funcin detectar las distancias y el movimiento de un objeto que se interponga en el camino
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.
3.2.6. Sensor de sonido:

El sensor incluido en el nuevo LEGO MindStorms NXT permitir programar robots que
respondan ante un nuevo estmulo como lo es el sonido. Las caractersticas del sensor
permitirn programarlo para que realice una tarea cuando una persona le da una orden o que
haga otra cuando varias personas le den la misma orden de modo simultneo.
El sensor de sonido tambin puede reconocer patrones de sonido. Por ejemplo, puede
programarse el robot para desarrolle un comportamiento en concreto mientras que con dos
palmadas haga algo totalmente diferente. El sensor tambin es capaz de discriminar tonos.
Pgina 27
3.2.7. Sensor de Color HiTechnic Compatible con NXT :

El sensor de color compatible con NXT est diseado para detectar con precisin el color de
un objeto, el sensor de color es perfecto para construir un organizador de ladrillos o cualquier
otro diseo que requiera deteccin de color.
El sensor de color funciona iluminando la superficie del objetivo con tres fuentes de luz
coloreadas (Diodos emisores de luz o led): uno rojo, otro verde y el tercero azul. La diferencia
entre la luz ambiente y el aumento debido a las fuentes de luz del sensor es utilizada para
medir la luz de cada color absorbida por la superficie del objeto. Los tres valores de color se
procesaran para corregir la dispersin en el espectro de emisin de cada uno de los led.
El NXT recibe tres valores: el nivel de ROJO, el nivel de VERDE y el nivel de AZUL.
El valor correspondiente a cada color est comprendido entre 0 y 255. por ejemplo, si el valor
devuelto es Rojo =255, Verde =255 y Azul =255 el color ledo es el Blanco.
La siguiente tabla muestra las lecturas que devolvern algunos colores:
Color
Rojo Verde Azul
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
calibracin finaliza, los led destellarn y el modo de funcionamiento pasar automticamente

a 0, modo normal de medida. El proceso calibracin dura alrededor de segundo. El valor
de calibracin se almacena en memoria no-voltil y ser recuperado cada vez que se aplica
tensin al sensor.
Si el modo de control se establece en 2, el sensor operar en modo calibracin de nivel de
negro y esperar ser situado en espacio vaco sin objetos en un cono de 90 en una distancia
de al menos 0.5m. La funcin calibracin nivel de negro mide la seal de cada color y crea un
desplazamiento (offset) para anular el nivel de luz ambiente en futuras mediciones. Cuando la
funcin calibracin finaliza, los led destellar y el modo de funcionamiento pasar
automticamente a 0, modo normal de medida. El proceso calibracin dura alrededor de 1
segundo. Esta funcin puede ser utilizada para contrarrestar seales devueltas por partes de
la estructura circundante. El valor de calibracin se almacena en memoria no-voltil y ser
recuperado cada vez que se aplica tensin al sensor.
3.2.8. Sensores de presencia:

Estn hechos con un Opto-Switch que contiene una fuente IR y un fototransistor separados
por una ranura de 0.15 pulgadas. Cuando se inserta un objeto en la ranura, la luz no alcanza
al fototransistor, que se pone en corte. Cuando el objeto se retira, el fototransistor conduce de
nuevo.
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.
Fabricacin de sensores para Lego:
3.3.1. Sensor de luz:

Introduccin: Probablemente tendrs en el aula uno o ms sensores de luz Lego, pero si
necesitas alguno ms lo puedes hacer de un modo muy sencillo. Adems te saldr mucho
ms econmico que el comercial. En cuanto al material, el nico elemento electrnico que
necesitas es un LDR. Lo puedes comprar en cualquier comercio de electrnica, en la figura
puedes ver el LDR y las dos piezas de Lego necesarias (el LDR de la figura tiene la referencia
MKY 76C348).
Circuito: El circuito es muy sencillo, y del mismo modo que sucede con el resto de
resistencias no es necesario tener en cuenta la polaridad.
Montaje: Hay diferentes modos para montar este sensor. El ms simple es cortar un cable de
los utilizados para conectar motores y sensores, y soldar directamente el LDR a l. Otro es el
que se puede ver en la figura. El LDR tiene sus terminales soldadas a los conectores de la
pieza blanca inferior. De este modo, podremos conectar el sensor por medio de un cable
estndar Lego.
Programa: El sensor que hemos montado a pesar de ser un sensor de luz es un sensor
pasivo, es decir, no requiere alimentacin. En consecuencia, en lugar de configurarlo como
sensor de luz lo haremos como sensor de contacto en modo RAW (tambin es posible
configurarlo en modo porcentual, pero siempre la precisin ser mayor en modo RAW).
Notas: Existe otro componente electrnico de semejante comportamiento al LDR, cuya
resistencia vara con el cambio de temperatura. Con l es posible hacer un sensor de
temperatura.
3.3.2. GP2D12 Sensor de distancias:

Lo que se intenta conseguir con este sensor es aadir potencia al conjunto de Lego, ya que
aunque tiene un buen con junto de sensores, nos faltara uno para medir distancias y que
fuera barato. Lo que conseguimos adaptando este pequeo sensor.
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
escasa para bloquear Q1. Q1 y Q3 entonces entran en conduccin y se acciona GP2D12.

Q2, montado como seguidor del emisor, protege la salida GP2D12 que ofrece unos valores
correspondientes a la medida tomada validos para RCX.
Cdigo de la muestra para leer el sensor:
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
SetSensor (SENSOR_1, SENSOR_LIGHT);

Lista De Componentes:
D1 evita que se destruya el sensor en caso de la conexin inversa. No utilizar el rectificador
usado en el sensor de Lego que permite a los sensores trabajar cuando est conectado al
revs (el nmero de diodos necesarios salta a partir del 3 al 8). Utilizamos el diodo 1N5819 de
1 amperio Shottky para D1, que es barato y fcilmente disponible. Con un pequeo voltaje a
la entrada, en este caso menos de 0.1V para la corriente que lo atraviesa, ste permite cargar
C1 con el voltaje ms alto posible.
C1 almacena la energa que ser utilizada durante fase de medida. Debe proporcionar +5V
en el extremo de esta etapa. Los valores tpicos asumidos para el GP2D12 (I=35mA,
conversin time=50ms) y un +7.5V inicial a travs de C1, su valor son C = I * despegue/dV =
35 * 50/(7.5-5) = el F 700. Margen pequeo con el F 1000
Para U1 utilizamos un Telcom TC55RP5000 aunque tambin podemos utilizar otros
reguladores como STMicroelectronics L4931-50. Los reguladores estndares tales como el
78L05 no nos sirven porque requieren ms de +7V en la entrada para conseguir tomar un
dato valido a la salida.
Para Q1 podemos utilizar un transistor de Zetex de alto rendimiento, como el ZTX718 que
ofrece un rpido aumento de intensidad.
El C2 estabiliza U1 y permite absorber los picos de corriente. Lo mejor seria una versin
barata del ESR.
Construccin del mdulo de interfaz del sensor
El mdulo de interfaz.
Vista superior
Pgina 32
Vista superior, con la identificacin de los
Viste inferior. Un circuito impreso de una

capa es fcil de dibujar.
componentes
Todo introducido dentro de las piezas
Para el montaje se usan 3 ladrillos huecos

4x2
Terminar el mdulo.
Listo para ser usado
Distancia contra la lectura del sensor
Curva linealizada: 1000/(distance-2) contra

la lectura del sensor + lnea lo ms mejor
posible cabida
3.3.3. Sensor de color:

Construccin: Las piezas necesitadas para construir el circuito estn muy comunes y
disponibles de la mayora de los surtidores electrnicos. Los lectores al corriente de mi libro
extremo de Mindstorms deben reconocer el mtodo de la construccin ilustrado en los
cuadros 3 y 4. Primero construyes y pruebas el circuito en un tablero para cortar el pan
Pgina 33
electrnico y en seguida transfieres las piezas al tablero de PC relacionado del prototipo.

Aunque el mtodo trabaja bien, los resultados adentro no son muy compactos y hay una
ocasin de los errores del cableado. Por esta razn, he preparado un tipo pequeo tablero
del por-agujero de PC para hacer el edificio y la cubierta el circuito ms fcil.
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.
Alternativamente, el tablero de PC es bastante pequeo para que el proyecto sea contenido

en una caja de la batera de #5391 Lego 9V. Esto es un recinto prctico con un conectador
construido a la derecha en la tapa. Es ms fcil conectar los sensores con un pedazo corto
de alambre del cuatro-conductor al usar esta caja. Los alambres cortos soldaron a los postes
donde la batera 9V habra unido pares el circuito al conectador de Lego en la tapa de la caja.
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.
La sensibilidad espectral de la fotoclula es otro factor importante en la determinacin de la

exactitud de la medida de color. No todas las fotoclulas de los CDes son semejantes en este
respeto. El mejor tipo para la discriminacin de color se llama Type 5. Tiene sensibilidad
mxima aproximadamente 560nm en la parte verde del espectro. La mayora de los otros
tipos de la fotoclula tienden para ser sensibles demasiado rojo o an infrarrojo. He
experimentado con las fotoclulas de varias fuentes y encontr el Mouser #338-54C348 tengo
la mejor respuesta espectral tan bien como la geometra deseable para montar mencionada
previamente.
Pgina 35
Descripcin del programa: Enumerar 1 es no absolutamente un programa de C que controla

el multiplexor y convierte las intensidades rojas, verdes y azules en un valor de la tonalidad.
Da vuelta al RCX en un colormetro simple continuamente exhibiendo la tonalidad en su LCD.
Usar el sensor para construir un compaginador robtico del ladrillo de Lego sera un uso ms
til del sensor.
Programa de la demostracin del sensor del color de //

// de Michael Gasperi
Sensor del COLOR SENSOR_1 //color del #define en el puerto 1 del sensor
Espera del #define SHORT_WAIT 2 //short para que valor se estabilice
tonalidad interna;
//hue como global
caera de la tarea ()
{
r interno, g, b, mximo, minuto, d, rd, gd, bd, h;
//declare el resto de
las variables
SetUserDisplay (tonalidad, 0);
exhibicin de //set para demostrar
valor de la tonalidad
SetSensor (COLOR, SENSOR_LIGHT);
//power en el sensor hacindote el tipo
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);
//wait para que lectura se estabilice

sonido de //alarm
}
SetSensor (COLOR, SENSOR_TOUCH); energa de //toggle de cambiar al canal 1
r = COLOR*100;
//read el rojo y la escala por 100
Pgina 36

g = COLOR*100;
//read el verde y la escala por 100

b = COLOR*100;
//read la escala de color azul por 100

si (r>g) {mximo = r;}{mximo = g;} //find el color con intensidad mxima
si (b>max) {max=b;}
si (r<g) {minuto = r;}{minuto = g;} //find el color con intensidad mnima
si (b<min) {min=b;}
d = ((mximo-minuto) /60);
//diff del mximo y los minutos
tambin escalan
rd = (mximo - r) /d;
intensidad del color de //normalize
gd = (mximo - g) /d;
bd = (mximo - b) /d;
si (b==max) {h = 240 + gd - rd;}
tonalidad de //compute basada en color
mximo
si (g==max) {h = 120 + rd - bd;}
si (r==max) {h = bd - gd;}
si (h<0) {h = h + 360;}
la tonalidad de //if es negativa
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
3.3.4. Construccin de un sensor de temperatura RCX compatible:
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).
Si el margen de error es aproximado a 1C lo consideraremos como bueno (el RCX mide

temperaturas de -20C a 70C solamente).
Comparativa del RCX y temperatura real
Construccion del sensor:
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
Insertar la punta de prueba en el tubo.
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.
La entrada Mux de RCX y sensor del color:

Un multiplexor funciona conectando los sensores mltiples con una sola entrada una a la vez.
La mayora de las computadoras emplean un multiplexor en su hardware a digital de la
conversin anloga al espacio y al dinero de ahorro. De hecho, el RCX tiene un multiplexor,
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
Los diodos D1 a travs de D4 y del condensador C2 forman la fuente de alimentacin. El

arreglo de onda completa del puente permite que el accesorio del conectador de energa al
RCX est en cualquier orientacin. Te cercioras de observar la polaridad del C2. Los
circuitos integrados U1 y U2 del Cmos tienen sus conexiones de la fuente de alimentacin
demostradas en tablas al lado de VCC y de la tierra. VCC debe medir por lo menos 6V
durante la operacin normal con las buenas bateras.
El circuito integrado U2 es un contador digital que ordena a partir la cero a tres y entonces
reajustes. Los diodos D7 y D8 junto con el resistor R3 y el condensador C1 crean el reloj para
U2. El voltaje en la entrada de reloj permanece alto durante la lectura accionada normal del
modo del sensor por el RCX, pero el punto bajo de las gotas durante el tiempo mucho ms
largo en que la entrada del sensor cambia a la voz pasiva. Cuando el sensor entr palancas
de nuevo a modo accionado el circuito crea el borde de levantamiento necesitado para
registrar U2.
El circuito integrado U1 contiene los interruptores anlogos usados para conectar un sensor
con el RCX a la vez. U1A proporciona la regeneracin al RCX para la sincronizacin. Si no,
no podras decir qu sensor fue conectado. El interruptor anlogo U1A se cierra cuando U2
cuenta cero y ste conecta el RCX a travs del diodo D5 o D6 y R1 con la tierra. La lectura
creada en el RCX bajo esta condicin es siempre 100. Los tres sensores conectan con R2,
que es clasific de modo que su lectura mxima alcance nunca absolutamente 100.
El cuadro 2 demuestra una gama de entradas y la lectura que resulta en el RCX. Los
sensores resistentes o los voltajes se pueden aplicar a las entradas. Las lecturas son al revs
de lo que puede ser que esperes. Voltio cero da lugar a una lectura cerca de 95 mientras que
sobre 4.3V es 0. La resistencia cero da lugar a una lectura cerca de 95 mientras que la
resistencia muy alta lee 0.
Pgina 43
3.4. Fabricacin de sensores pasivos:

Como curiosidad mostramos como se pueden fabricar otro tipo de sensores de forma barata y
a la vez sencilla.
Aqu te enseamos como fabricar tres sensores pasivos: de contacto, de luz, y de
temperatura. Todos los sensores pasivos necesitan slo dos pines (sensor y tierra, como se
muestra arriba).
3.4.1. Sensores de contacto:

Los sensores de contacto son algunos de los ms simples, pero son sin embargo los ms
tiles. La idea general es muy simple: si tenemos dos objetos conductores que deben tocarse
entre ellos para activarse (por ejemplo al ser pulsado o pisado) o viceversa. A continuacin
les presentamos algunos ejemplos de sensores de contacto.
Papel y papel de aluminio:
Es probablemente la manera ms fcil de fabricar un sensor de contacto. Pegamos el papel
de aluminio a una hoja de papel doblada de tal manera que al apretarla se establecer el
contacto entre las lminas. Despus conectamos un conductor a cada hoja. Podemos, por
supuesto, sustituir la lmina de aluminio por otros elementos conductores (por ejemplo clips o
clavos).
Palitos de madera y papel de aluminio:

Los palitos de madera son excelentes para fabricar estructuras simples. Son ms slidos que
el papel, por lo cual, al usarlos con una lmina de aluminio podemos fabricar sensores de
contacto mucho ms rgidos. La foto siguiente muestra un ejemplo.
Pgina 44
Sensores de contacto superpuestos:

Para fabricar este tipo de sensor se necesita dos contactos conductores superpuestos a un
material no conductor. Las protecciones de diapositivas son muy tiles porque son flexibles.
Podemos pegar en ellas la lmina de aluminio y usar dos de ellas para hacer una especie de
bocadillo con un pedazo de cartulina. Debemos hacer agujeros en la cartulina para permitir
que las lminas entren en contacto al tocarlas.
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
3.4.2. Sensores de luz:

El sensor de luz ms comn es conocido como LDR (Light Dependant Resistor) (Resistencia
dependiente de la luz). Tambin se le conoce como "Clula fotoelctrica" Un LDR es
bsicamente una resistencia, que cambia su resistencia cuando cambia la intensidad de la
luz. Se ven a menudo en los sistemas automticos de iluminacin.
Como los LDRs son simplemente resistencias, se pueden conectar sencillamente los dos
pines del sensor.
3.4.3. Sensor de humedad:

Puede conectar sencillamente dos cables o clips a los pines para medir la humedad en el
suelo. Cuando el suelo se humedece conduce ms electricidad. As, las lecturas del sensor
que obtendremos se modificarn con los cambios de la humedad del suelo. Esta misma idea
puede ser usada para fabricar un sensor detector de agua. Cuando los dos cables tocan el
agua, las lecturas del sensor cambian.
Se puede mejorar el sensor de humedad conectando los dos cables a un pedazo de yeso,
argamasa o cualquier otro material que absorba el agua. La idea es siempre la misma, pero
mejorando la pureza del medio conductor. El comportamiento del sensor no cambiar
demasiado de un lugar a otro. El yeso es el material usado para cubrir el interior de los
edificios (cielos rasos, muros, etc. Se usa tambin para hacer una escayola a un paciente.
Pgina 46
3.4.4. Sensores de temperatura:

Para fabricar un sensor de temperatura necesitar un termistor. Algunos termistores son
simplemente resistencias, que cambian su resistencia cuando cambia la temperatura. Otros
termistores son sensores activos que necesitan una alimentacin extra para funcionar.
Pgina 47
3.5.
Fabricacin de sensores activos:
A continuacin les presentamos algunos ejemplos de sensores activos tiles.
3.5.1. Sensores de luz reflectantes:

Este tipo de sensor es til cuando deseamos detectar la presencia de objetos sin tocarlos. Por
ejemplo, desea detectar cuando alguien camina a travs de una puerta o cuando alguien est
demasiado cerca.
El uso de LEDs y sensores de luz:

Una idea simple para este sensor es emitir luz sobre un LDR (sensor de luz). Si alguien pasa,
bloquea la luz y el LDR lo detecta. Si la fuente luminosa es un foco, estamos simplemente
detectando sombras. Si usamos un puntero lser como fuente luminosa, su deteccin tendr
ms alcance y sus lecturas sern muy precisas.
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
A continuacin mostramos un esquema de cmo fabricar este sensor. La resistencia se

coloca para limitar la corriente que pasa a travs del LED. Cuanto ms pequeo es el valor de
la resistencia ms brillante ser el LED.
Uso de luz infrarroja (IR):

Puede conseguirse una mejor versin del sensor reflectante anterior usando luz infrarroja (IR),
ya que hay muchas menos interferencias. La IR es un tipo de luz que los seres humanos no
podemos ver. Es conveniente cuando no se desea que la gente vea nuestro sensor (por ej. en
los sistemas de seguridad).
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
Sensores reflectantes comerciales:

Tambin puede comprar los sensores reflectantes IR. Generalmente vienen en un tamao
compacto y las lecturas de los sensores son ms fiables.
ste es un ejemplo de como preparar un sensor reflectante IR comercial (como el QRD1114ND).
Sensor de efecto Hall (campo magntico):

Podemos usar este sensor para detectar la presencia de imanes. Las aplicaciones son
similares al sensor reflectante IR pero no dependen de la luz, lo que a menudo significa que
son ms fiables. Sin embargo, necesita tener un imn, mientras que la luz se encuentra en
todas partes.
ste es un ejemplo de cmo montar un sensor de efecto Hall (de digikey.com, nmero de
pieza DN6848-ND)
Pgina 50
Clculo de las lecturas del sensor:

Para aqullos que se interesen por los detalles tcnicos ms a fondo, hay una resistencia de
referencia de 33K en cada puerto de sensor, que es usada para determinar las lecturas que
obtenemos. La figura de abajo muestra cmo se coloca la resistencia de referencia. El
microcontrolador mide la cada de tensin a travs del sensor, la cual puede calcularse
mediante la siguiente ecuacin.
V = 5 x ( Rs / (33K + Rs))
Donde Rs = Resistencia del sensor
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
3.6. Bibliografa parte de sensores:

http://mindstorms.lego.com/
www.tik.ee.ethz.ch/tik/education/lectures/PPS/mindstorms/sa_nxt/index.php?page=home
www.labview.ch/doc/FAQ/FAQ.LEGO.M/LEGO%20MINDSTORMS_NXT?set_language=en&c
l=en
www.lego.com/eng/education/mindstorms/home.asp?pagename=input
www.radioshack.com
www.allelectronics.com
www.digikey.com
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.
4.1.2. Principio de funcionamiento

Los motores elctricos, en general, basan su funcionamiento en las fuerzas ejercidas por un
campo electromagntico y creadas al hacer circular una corriente elctrica a travs de una o
varias bobinas. Si dicha bobina, generalmente circular y denominada estator, se mantiene en
una posicin mecnica fija y en su interior, bajo la influencia del campo electromagntico, se
coloca otra bobina, llamada rotor, recorrida por una corriente y capaz de girar sobre su eje,
esta ltima tender a buscas la posicin de equilibrio magntico, es decir, orientar sus polos
NORTE-SUR hacia los polos SUR-NORTE del estator, respectivamente. Cuando el rotor
alcanza esta posicin de equilibrio, el estator cambia la orientacin de sus polos, aquel tratar
de buscar la nueva posicin de equilibrio; manteniendo dicha situacin de manera continuada,
se conseguir un movimiento giratorio y continuo del rotor y a la vez la transformacin de una
energa elctrica en otra mecnica en forma de movimiento circular.
4.1.3. Motor de Corriente Continua

Tipos y funcionamiento.
Servomotores.
Motor que funciona con corriente elctrica contina. El campo magntico se crea en el
inducido (rotor) y en el inductor (estator). Necesitan un colector en el rotor y escobillas para su
alimentacin elctrica. Este tipo de motor fue el primero que se utiliz en la traccin de los
vehculos elctricos por la simplicidad de los sistemas de control de revoluciones. Tiene un
elevado mantenimiento por el desgaste de las escobillas y de los colectores por el alto
consumo de corriente que tienen. En los motores de alta potencia, su tamao llega a ser muy
voluminoso.
En lugar de un armazn con un ncleo de hierro y muchos bobinados, hay una nica espira
conductora cuadrada girando alrededor de un eje, el cual no se dibuja.
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
4.2. Motores Lego:

Motor Elctrico Technic 9V
Lego 74569: El motor de 9v ms antiguo de Technic
(1990). Sin engranajes internos, esto le confiere alta
velocidad de rotacin y un momento de rotacin bajo, por
esto requiere para la mayor parte de usos una reduccin
de engranajes externa.
Micromotor Elctrico Technic
Lego 70823: Aparecido en 1993, es pequeo, de poco
peso y baja velocidad, ofrecen el momento de rotacin
bajo - pero respetable para su tamao. Debe ser usado
generalmente con la polea, la cima y la base, pero otras
transmisiones de movimiento tambin son posibles.
Mini-Motor Elctrico Technic 9v

Lego: 71427. Desde 1997, este motor sustituye al 2838.
Engranado abajo y bastante eficiente, supone la mejor
opcin para la mayor parte de usos.
Mini-Motor Elctrico Technic 9v

Lego 43362: En 2002, Lego substituy el motor 71427
por un nuevo tipo, el 43362. Por fuera casi idntico, su
estructura interna es muy diferente. El funcionamiento es
igual de bueno pero con un peso mucho inferior.
Motor Elctrico para Buggy RC
Peeron 5292: Presentado en 2002, este motor apareci
con el Coche de Carreras de RC. Resulta muy poderoso,
pero consume mucha energa. No recomendado para el
empleo con un RCX que no puede entregar la corriente
que necesita esta bestia. El agujero de eje interno es
aumentado por un factor 23/17. Slo la salida exterior es
probada debajo.
Pgina 55
Motor Elctrico Technic 9V con engranajes

Peeron 47154: Aparecido en 2003, este motor viene con
un orificio en el eje de friccin, permitiendo escoger la
longitud de eje sin la necesidad de un extensor. Permite
un montaje plano inferior fcil.
Motor NXT
Este motor es especfico del NXT, se pone a la venta en
2006. Incluye un codificador de rotacin, volviendo al
NXT la posicin del eje con gran resolucin. A causa del
conector especial de este motor (el tipo de enchufe no
estndar telefnico), requieren de un adaptador de cable
para funcionar con fuentes de 9V. No recomendado para
el empleo con un RCX que no puede entregar la alta
corriente que este motor puede consumir. Velocidad de
rotacin lenta, reduciendo al mnimo la necesidad de tren
de engranaje externo.
4.2.1. Peso de cada motor:
2838
2986
71427
43362
5292
47154
NXT
48g
10g
42g
28g
55g
40g
80g
El 43362 que resulta equivalente al 71427, es un 30 % ms ligero. Esto es generalmente una

ventaja, excepto cuando el motor es usado como un contrapeso, o para equilibrar la
estructura.
Pgina 56
4.2.2. Caractersticas en vaco (sin carga):

Condiciones de prueba: el motor es impulsado por una fuente de energa variable, regulada.
Un ampermetro mide la corriente que fluye por el motor, un voltmetro supervisa la tensin a
travs. La velocidad de rotacin es medida por un RCX equipado con un sensor ligero(de luz),
mirando un cilindro mitad-blanco/mitad negro.
Vcc: 9 V
2838
Velocidad
de rotacin
Corriente
sin carga
4100
r.p.m.
35 mA
2986
71427
35 r.p.m.
360 r.p.m. 340 r.p.m.
6 mA
3.5 mA
43362
9 mA
5292
1300
r.p.m.
160 mA
47154
NXT
460 r.p.m. 170 r.p.m.
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.
4.2.3. Caractersticas en parado:

El consumo de corriente parado es medido con el eje de motor para a mano. El momento de
rotacin en parado es medido para el peso mximo que puede ser levantado por la mquina.
La medida del momento de rotacin es MUY IMPRECISA.
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.
4.2.4. Caractersticas en carga:

Utilizando ampermetro y voltmetro para medir las condiciones del sistema en carga, vemos
que el poder mecnico entregado por el motor es evaluado a partir del tiempo que tarda en
levantar un peso una determinada altura (5 vueltas de cilindro - las dos primeras vueltas no
son contadas para eliminar la aceleracin inicial). El momento de rotacin aplicado es
obtenido a partir del radio del cilindro y del peso.
El cilindro se encuentra colocado directamente sobre el eje del motor, excepto en el motor
2838 al cual se le coloca una reduccin de engranaje de 1/5, que resulta muy necesaria para
la mayor parte de usos. El momento de rotacin mostrado por el motor corrige la reduccin de
engranaje. El motor 5292 es muy rpido, por lo que tambin tuvo que ser medido con una
reduccin de engranaje de 1/3.
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 %
La velocidad del motor 43362 es aproximadamente un 12 % menor que la velocidad del

71427.
Motor NXT: Vista interna:
Pgina 61
4.3. Bibliografa de la parte de motores:

www.philohome.com/motors/motorcomp.htm
www.monografias.com
mindstorms.lego.com/eng/products/ris/index.asp
Pgina 62
5. Transmisin de movimiento y esfuerzo:

Transmisiones entre ejes paralelos: La transmisin de movimiento y esfuerzos entre ejes
paralelos se hace utilizando engranajes rectos, poleas o cadenas. LEGO ofrece los tres
sistemas aunque la cadena no se encuentra en los kits destinados a montar robots. LEGO
comercializa los dos elementos de la figura: el primero es una cadena sin ms, mientras que
la segunda permite disear orugas que sustituyan las ruedas de un vehculo (o arrastrar otro
conjunto de piezas). Este segundo elemento permite tambin disear una cinta
transportadora.
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:
Nmero de dientes de la corona
16
24
40
Relacin de transmisin
0.125
0.0625
0.042
0.025
Transformacin del movimiento: El mecanismo pin cremallera se utiliza para transformar

un movimiento de rotacin en un movimiento rectilneo. El mdulo de la cremallera que LEGO
comercializa tiene un mdulo de 3.175 mm, s que, si utilizamos como pin una rueda
dentada de 8 dientes conseguiremos un desplazamiento por vuelta de 25.4 mm (1").
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.
El mecanismo tronillo/tuerca: Es de uso habitual cuando se necesita un movimiento

rectilneo en mquina-herramientas (aunque hoy en da est siendo sustituido por el husillo a
bolas). LEGO no ofrece elementos para montar este mecanismo, pero se puede conseguir
algo similar utilizando tornillos sinfn y un engranaje recto.
El tornillo sinfn ser el conductor, mientras que el engranaje recto se encontrar bloqueado.
De este modo pueden conseguirse desplazamientos rectilneos con gran precisin. El paso
del tornillo es de 3.175 mm, as que por cada vuelta del eje el desplazamiento horizontal ser
de 3.157 mm.
El mecanismo biela/manivela: Se utiliza para transformar el movimiento rectilneo en

circular, o viceversa. Al contrario de los dos mecanismos anteriores, en este caso el
movimiento rectilneo es de vaivn.
Un ejemplo de la transformacin de movimiento rectilneo en circular se encuentra en el motor
de un automvil (pistn - biela - cigeal) o en las viejas locomotoras a vapor. En el caso
contrario se encuentran los compresores de aire alternativos.
Pgina 65
Mecanismo leva / seguidor: Una leva convierte un movimiento de rotacin en un movimiento

alternativo. En un motor de explosin las levas abren y cierran las vlvulas de los cilindros.
La forma de las levas es variable dependiendo de la utilidad a la que se destinan. El elemento
LEGO de la figura puede utilizarse como leva.
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
5.1. Bibliografa parte transmisiones:

www.euskalnet.net/kolaskoaga/mekanika/trasmisi_c.htm
www.legoengineering.com/
llk.media.mit.edu/projects/cricket/about/index.shtml
www.ni.com/company/robolab.htm
lcs.www.media.mit.edu/groups/el/projects/programmable-brick/
www.eduteka.org/RoboticaSondas.php
www.Mindtorms.lego
LEGO Education - MINDSTORMS Home
robotikas.blogspot.com/2006/08/precios-de-lego-educacin_25.html
www.etse.urv.es/~aoller/robmob_eaiei/LEGO%20MindStorms%20RIS.htm
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.
Desafortunadamente, tiene limitaciones que no lo hacen aconsejable para aplicaciones

avanzadas, por lo que su aplicacin se limita a un nivel bsico. Una de las limitaciones es la
imposibilidad de utilizar variables (slo utiliza varios contadores).
La ltima versin comercializada es la 2.0 comercializada en Espaa y otros pases, ofrece un
entorno de programacin que obtiene mayor provecho de las capacidades del RCX. No es
software libre.
Pgina 69
Arquitectura de Software utilizando RCX-CODE
Partes del RCX-CODE

Como este entorno de programacin esta orientado a nios, y es muy sencillito de manejar,
explicaremos las partes que lo componen mediante imgenes.
El almacenamiento de programas se hara de la siguiente forma:
Pgina 70
La pantalla de configuracin es la siguiente:
A continuacin se muestran los bloques bsicos; pueden ser de secuencia, de paralelismo,

comandos, condiciones sensoriales, control de flujo, grupos de bloques...
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.
El panel de control tiene este aspecto:
Pgina 72
Accionndolo podremos realizar las funciones que se describen.
6.2.2. Comandos
Movimiento de motores. Este es el bloque que permite controlar el movimiento de los
motores.
Sonidos:
Pgina 73
Varios tipos de bloques

Contadores:
Temporizadores:
Pgina 74
Condiciones sensoriales
Ahora mostraremos lo bloques para controlar las condiciones sensoriales.
6.2.3. Bloques de control de flujo
Pgina 75
Bloques de rutinas propias
Pgina 76
Pros y contras del cdigo RCX
z
z
z
z
z
Usa el firmware de LEGO

No hay variables
Es interpretado
Visual, muy bueno para empezar
Demasiado farragoso y limitado para hacer cosas complejas
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
6.3. Introduccin a ROBOLAB

El lenguaje de programacin ROBOLAB es el ms fcil e intuitivo de los diversos
lenguajes existentes para la programacin del ncleo de lego. Presenta un entorno grfico
que es semejante a diagramas de flujo. Es un lenguaje desarrollado por LAB VIEW, el cul
nos ofrece opciones avanzadas como la realizacin de clculos. Es el mejor entorno de
programacin para empezar a disear aplicaciones con lego ya que es muy educativo e
intuitivo por la posibilidad de desarrollar las aplicaciones a travs de bloques.
Una vez instalado el programa al ejecutarlos nos aparecer la siguiente pantalla:
Si pinchamos en ADMINISTRADOR podemos configurar el puerto de salida a travs del cual

nos comunicaremos con el ncleo de lego RCX.
Para empezar a programar pinchamos en PROGRAMADOR, y posteriormente elegiremos el
modo de programacin que explicaremos a continuacin.
6.3.1. MODOS DE PROGRAMACION
Para familiarizarse con el entorno y la programacin en ROBOLAB, el programa nos

proporciona 3 modos con dificultad ascendente. Estos modos son:
Pgina 78
6.3.2. Modo PILOT

Es el nivel bsico. A travs de plantillas introduce la lgica de la programacin. Estas
plantillas estn protegidas por lo que no pueden ser alteradas y por tanto no nos ofrece
libertad a la hora de programar. Este modo nos es til para familiarizarnos con el entorno
ROBOLAB y los smbolos utilizados en el diagrama. Este modo consta de cuatro niveles de
dificultad que se componen de ejemplos de menor a mayor complicacin.
Pilot nivel 1:
En este primer nivel nos muestran un programa muy sencillo. Cada smbolo nos
indica una funcin:
Comienzo del programa.
Movimiento del motor A en el sentido que indica la flecha.
Espera de cuatro segundos.
Fin del programa.
Para cargar el programa al robot de lego correctamente enchufado en el puerto de

comunicaciones correspondiente, pincharemos en el botn de la flecha
Pilot nivel 2:
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:
Lmpara. Se enciende y su potencia se determina por un nmero del 1 al 5. Est

conectada en la salida C.
Sensor de contacto. Este smbolo nos indica que cuando es presionado este sensor,
el programa avanza al siguiente paso.
Pilot Nivel 3:
Pgina 80
En este nivel nos encontramos la posibilidad de la recursividad, esto se consigue

mediante este botn
Nos aparecen nuevos smbolos:
Pone en off una determinada salida.
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.
6.3.3. Modo INVENTOR

Este modo se refiere a la segunda fase del aprendizaje. Se desarrollarn aplicaciones
con libertad de enlazarlos como se quiera, adems de la inclusin de nuevas funciones que
nos permitirn realizar bucles o realizar programas multitarea, es decir que se ejecuten en
paralelo los flujos. Este modo tambin consta de cuatro niveles de dificultad.
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:
Cambiar de direccin. Esta funcin nos permite cambiar de direccin a un motor

determinado que le asignemos. Ejemplo:
Cambia de direccin el motor C.
Saltar y aterrizar. Mediante estos smbolos realizaremos un bucle infinito de

las funciones que contengan entre ellos. Es igual que la recursividad en el modo pilot.
Ejemplo:
Tiempo al azar. Mediante esta funcin el siguiente paso no se ejecutar hasta que
transcurra un determinado tiempo aleatorio. Ejemplo:
Tiempo al azar entre 0 y 3 segundos.

Inventor nivel 3:
Este nivel da un salto importante en la posibilidad de programacin con este lenguaje.
En este se incluye la posibilidad de realizar programas multitarea, sentencias condicionales,
recursividad y msica.
Pgina 83
A continuacin explicaremos las diversas nuevas posibilidades en este nivel:

Comando multitareas. Al introducirlo en nuestro programa nos ofrece dos flujos de
ejecucin, los cuales se ejecutarn aparentemente en paralelo. Veamos un ejemplo:
Como se puede observar en el siguiente ejemplo aparecen dos flujos de ejecucin.

En el primero (situado en la parte superior) juegan con los motores cambiando de direccin de
modo recursivo. En el segundo reproduce notas musicales.
Este grupo de funciones representa una sentencia condicional que ser

ejecutada mientras cumpla la condicin. Ejemplo:
En este ejemplo, si el sensor de contacto esta presionado ejecutar la cadena inferior;

mientras que si no est presionado ejectur la cadena superior.
Recursividad limitada. Las funciones que se siten entre estos smbolos se
ejecutarn un nmero predeterminado de veces. Ejemplo:
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:
En este ejemplo primero ponemos el contenedor a 0
. Posteriormente entramos en un
bucle infinito en el que vamos incrementando el contenedor
. 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.
6.3.4. Modo INVESTIGATOR

El modo investigador es una versin adaptada del LABVIEW. Convierte el RCX en
una herramienta de trabajo para la adquisicin de datos. Este modo nos permite elaborar un
procesado de los datos recogidos para la elaboracin de un informe. Para mayor informacin
consultar guas de programacin para el uso de este modo de programacin ya que para la
realizacin de aplicaciones de lego es suficiente con saber manejar el modo inventor ya que
se pueden realizar programas con bastante grado de dificultad.
Pgina 85
6.3.5. Bibliografa Robolab

http://www.donosgune.net/2000/gazteler/prg_leng/robolab.htm
http://www.ceeo.tufts.edu/robolabatceeo/Resources/articles/robolab.pdf
http://www.matnatverdensklasse.dk/uv-mat/robolab/robolab.pdf
http://cache.lego.com/downloads/education/led_quick_start_guide_ES.pdf
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.
LabVIEW enfocado a LEGO MINDSTORMS

Robolab esta basado en una versin sencilla de LabVIEW pero solo es valida para
el NTX y no es tan potente como LabVIEW. Si queremos sacarle el mximo
partido al NTX o incluso al RCX tenemos que hacernos con una versin
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.
6.4.2. Programacin grfica con Labview

Cuando usted disea programas con Labview est trabajando siempre bajo algo denominado
VI, es decir, un instrumento virtual, se pueden crear VI a partir de especificaciones
funcionales que usted disee. Este VI puede utilizarse en cualquier otra aplicacin como una
subfuncin dentro de un programa general. Los VI's se caracterizan por: ser un cuadrado con
su respectivo smbolo relacionado con su funcionalidad, tener una interfaz con el usuario,
tener entradas con su color de identificacin de dato, tener una o varias salidas y por su
puesto ser reutilizables.
Disee la interfaz de usuario a partir de su cdigo.
En el ambiente de trabajo de Labview existen dos paneles, el panel frontal y el panel de
programacin diagrama de bloques; en el panel frontal se disea la interfaz con el usuario y
en el panel de programacin se relacionan los elementos utilizados en la interfaz mediante
operaciones que determinan en s como funciona el programa o el sistema, exactamente es
la parte donde se realizan las especificaciones funcionales.
En el panel de programacin usted puede disear de manera grfica y como si fuera un

diagrama de bloques el funcionamiento de su sistema. La programacin grfica se basa en la
realizacin de operaciones mediante la asignacin de iconos que representen los datos
numricos e iconos que representan los procedimientos que deben realizar los (VI's), con
estos iconos y mediante una conexin simple como lo es una lnea recta se enlazan para
determinar una operacin y/o una funcin. Al disear el programa de forma grfica, se hace
visible una programacin orientada al flujo de datos, donde se tiene una interpretacin de los
datos tambin de forma grfica, por ejemplo un dato booleano se caracteriza por ser una
conexin verde, cada tipo de dato se identifica con un color diferente dentro de Labview;
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.
6.4.3. Entorno LabVIEW

La programacin G (grfica) de Labview consta de un panel frontal y un panel de cdigo
como se menciono antes. En el panel frontal es donde se disea la interface de usuario y se
ubican los controles e indicadores. En el panel de cdigo se encuentran las funciones. Cada
control que se utiliza en la interfaz tiene una representacin en el panel de cdigo,
igualmente los indicadores necesarios para entregar la informacin procesada al usuario
tienen un icono que los identifica en el panel de cdigo o de programacin. Los controles
pueden ser booleanos, numricos, strings, un arreglo matricial de estos o una combinacin
de los anteriores; y los indicadores pueden ser como para el caso de controles pero
pudindolos visualizar como tablas, grficos en 2D o 3D, browser, entre otros.
Las funciones pueden ser VIs prediseados y que pueden ser reutilizados en cualquier
aplicacin, estos bloques funcionales constan de entradas y salidas, igual que en un lenguaje
de programacin estndar las funciones procesan las entradas y entregan una o varias
salidas, estos VI pueden tambin estar conformados de otros subVIs y as sucesivamente, de
esta forma se pueden representar como un rbol genealgico donde un VI se relaciona o
depende de varios SubVIs. Labview tiene VIs de adquisicin de datos e imgenes, de
comunicaciones, de procesamiento digital de seales, de funciones matemticas simples,
hasta funciones que utilizan otros programas como Matlab o HiQ para resolver problemas,
otras mas complejas como "nodos de formula" que se utilizan para la resolucin de
ecuaciones editando directamente estas como en lenguajes de programacin tradicionales y
definiendo las entradas y las salidas. Labview tambin se puede utilizar para graficar en tres
dimensiones, en coordenadas polares y cartesianas, tiene disponibles herramientas para
Pgina 88
anlisis de circuitos RF como la Carta de Smith, tiene aplicaciones en manejo de audio y se

puede comunicar con la tarjeta de sonido del computador para trabajar conjuntamente. Entre
sus muchas funciones especiales se encuentran las de procesamiento de imgenes, como
capturar una imagen a travs de una tarjeta de adquisicin como la PCI-1408
(monocromtica), analizarla y entregar respuestas que difcilmente otros sistemas realizaran.
6.4.4. Flujo de Datos

Otra caracterstica se encuentra en el flujo de datos, que muestra la ejecucin secuencial del
programa, es decir, una tarea no se inicia hasta no tener en todos sus variables de entrada
informacin o que las tareas predecesoras hayan terminado de ejecutarse. Debido al lenguaje
grfico el compilador con que cuenta Labview es ms verstil ya que sobre el mismo cdigo
de programacin se puede ver fcilmente el flujo de datos, as como su contenido.
Pgina 89
Cmo utilizar la ayuda?

Para visualizar el cuadro de ayuda, simplemente se hace HelpShow Context Help o
presionando <Ctrl-h>; en este cuadro se mostrar la informacin del objeto sobre el cual nos
paremos con el puntero del mouse. Tambin se puede notar que en el cuadro de ayuda se
observa un Link azul, el cual nos lleva al Labview help, donde encontramos una informacin
mas completa del elemento; (haciendo clic derecho del mouse, tambin se puede observar el
Labview help).
6.4.5. Manejo de puertos con LABVIEW

Objetivo: Realizar una adquisicin de datos mediante la tarjeta de adquisicin de datos de
National Instruments PCI 1200.
1. Seleccione en la paleta de funciones la opcin "analog Input" y desplace el vi de "AI MULT
PT". Este vi le permite captura muestras del puerto de la tarjeta de forma continua
2. Inicialice las entradas del vi de la siguiente forma
Pgina 90
La figura anterior muestra un detalle importante en la configuracin de la salida del vI, se

puede seleccionar el type de salida como un arreglo o una forma de onda "waveform". Escoja
inicialmente el tipo "Scaled Array"
La configuracin de este VI es de la siguiente forma: Device: 1, significa que para un numero
determinado de tarjetas de adquisicin y cualquier otra tarjeta de National Instruments, la
herramienta Measurement and Automatization Explorer MAX identifica todos los dispositivos
y le asigna a cada uno un numero, para saber que numero tiene la tarjeta se puede revisar
en la herramienta MAX y en "Devices and Interfaces". Con esta misma herramienta se deben
configurar la forma de funcionamiento de la tarjeta en cuanto a cuales son los niveles de
voltaje a manejar y si los niveles de voltaje son bipolares o unipolares.
Tambin dependiendo de la tarjeta esta puede tener un determinado numero de canales

anlogos de entrada, dependiendo de nuestra conexin fsica a la tarjeta se puede escoger
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.
6.4.6. Puerto Serie

Objetivo: Manejo de puerto serie. Se plantea el problema de controlar a un Fuente
programable mediante comandos por el puerto serial.
1.
Inicializar
el
puerto
serial.
Numero
de
Puerto
cero
correspondiente al COM1 Otros nmeros de puerto para windows

son:
0:
1:
2:
3:
4:
COM1
COM2
COM3
COM4
COM5
5:
6:
7:
8:
COM6
COM7
COM8
COM9
10:
11:
12:
13:
LPT
LPT
LPT
LPT
El VI serial port es el encargado de inicializar el puerto y las dems caractersticas

correspondientes a cada puerto
2. Envo del comando VOLT020 para programar la fuente a un voltaje de 2Voltios. Mediante
el VI de Serial Port Writer, se enva un string seguido de un carrier return. El string tiene un
formato necesario para que el comando se especifique de la forma adecuada. La
herramienta de formato de string se encuentran en la paleta de funciones.
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.
Ejemplo de Adquisicin de datos por el puerto paralelo.

Lo que se desea es escribir y leer datos por el puerto paralelo del PC. Las funciones
indicadas para esta aplicacin son IN PORT y OUT PORT (ubicadas en advanced/port i/o),
que entran y sacan un byte o una palabra a una direccin especfica de memoria. Por lo cual
debemos saber cual es la direccin del puerto paralelo del PC, cuyo dato se encuentra en la
informacin del sistema en el panel de control; por lo general es 0378-037B hex (888-891
dec). Tambin es necesario configurar en el setup del PC el puerto paralelo en modo EPP, el
cual, segn sus especificaciones se encuentra que la direccin de datos i/o es 888 dec y la
de control es 890 dec, de 8 bits cada una.
La palabra de control se configura con el bit # 1 para leer (1) o escribir (0), tiene adems 5
bits libres para cualquier aplicacin que se necesite como por ejemplo multiplexacin.
Control 7 6 5 4 3 2 1 0
1 1 x x x x i/o x
En el panel frontal se tiene un control (valor 1) en donde colocamos un nmero cualquiera
entre 0-256 dec (debido a que slo se tienen 8 bits), y al correr el programa en el indicador
(valor 2) se observar el mismo puesto que primero lo escribimos y luego se lee.
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.
6.4.7. Bibliografa Labview

http://www.ni.com/labview/
http://www.ni.com/academic/mindstorms/
http://www.lawebdelprogramador.com/cursos/
GABRIUNAS V. Apuntes de Electrnica. Universidad Distrital Francisco Jos de Caldas.
1999
RONCANCIO H., VELASCO. H. Una Introduccin a Labview. Semana de Ingenio y Diseo.
Universidad Distrital "Francisco Jos de Caldas". 2000.
6.5. Lenguaje NQC

6.5.1. Introduccin a NQC:
NQC es un entorno de programacin con lenguaje C adaptado para poder programar el
ncleo del robot de lego. Existen adems otros entornos de programacin en C como por
ejemplo Interactive c o BrickOS siendo este ltimo un lenguaje operativo que nos permite
programar en C y C++. Con el fin de iniciarse en el lenguaje C adaptado para LEGO, el ms
adecuado es NQC
ya que es un entorno de programacin que nos permite realizar
aplicaciones de diversos niveles, adems de la ventaja de que NQC utiliza el firmware de

LEGO.
Pgina 95
Para poder desarrollar aplicaciones en NQC es necesario disponer de la herramienta

RCX Command Center. Esta utilidad nos ayudara a escribir el programa, enviarlos al robot y
arrancar o detener el mismo.
INTRODUCCION A RCX COMMAND CENTER

Como se ha explicado anteriormente, para poder programar el robot de lego en los
diversos lenguajes de programacin que soporta, tenemos disponible la utilidad RCX
COMMAND CENTER, a travs de la cual podemos programar nuestro robot en diversos
lenguajes de programacin basados en C como pueden ser NQC y BRICOS, adems de
otros lenguajes como por ejemplo visual basic o java ya que en este software viene
incorporada la librera spirit.ocx, a travs de la cual nos permite programar en los lenguajes ya
descritos anteriormente.
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:
Una vez que entramos al programa, el entorno en el que vamos a programar

corresponde a la siguiente figura:
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
Ya tenemos lista nuestra ventana para empezar a escribir el cdigo que

introduciremos al RCX.
6.5.2. Estructura de un programa.

Para realizar la escritura de nuestro programa, tendremos que montar un robot que
nos permita realizar las rdenes que programemos. El robot a montar debe ser sencillo con el
fin de comenzar con aplicaciones simples. A continuacin se exponen diversos montajes
sencillos para utilizar los programas que vamos a desarrollar:
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
task main() //tarea principal

{
//inicializacin de variables
//rdenes
}
Para la inclusin de comentarios basta con poner delante // y escribir la aclaracin. El
comentario se escribir en color verde con el fin de poder distinguir cada funcin del
programa.
6.5.3. Constantes y variables

Como se aprecia en el esquema, lo primero que debemos hacer es declarar las
constantes y variables que creamos necesarias con el fin de desarrollar nuestro programa u
optimizarlo. Para declarar constantes utilizaremos la palabra reservada #define seguido del
nombre de la constante en maysculas y se inicializa a continuacin con un valor:
#define CONSTANTE 100
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;
Una vez definida dicha variable, la inicializamos a un valor dentro de la tarea:
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
Posterior a la declaracin y la inicializacin de variables se proceder a escribir las

diversas rdenes para el manejo del robot, las cuales las explicaremos en captulos
posteriores. Estas rdenes se marcan en un color azulado para poder distinguirlas. Para una
buena optimizacin del cdigo podemos incluir las diversas instrucciones dentro de diversas
sentencias como por ejemplo bucles if, while, for, etc que explicaremos a continuacin. Un
ejemplo de cdigo para el manejo de un robot puede ser el siguiente:
#define TIEMPO_GIRO 85
int tiempo_de_avance;
//declaracion variable global
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);
}
6.5.5. Sentencias de control

Como NQC est basado en el lenguaje C, las estructuras de control son las mismas
que para C y por tanto muy conocidas. Explicaremos brevemente el funcionamiento de las
ms importantes:
Sentencia if
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

....//instrucciones
....
}
Esta sentencia ejecuta las instrucciones contenidas en ella el nmero correspondiente de

veces como indique la expresin.
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;
}
La sentencia switch evala el valor que se introduzca entre parntesis y dependiendo de

dicho valor ejecuta una o varias instrucciones.
6.5.6. Funciones y subrutinas
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
}
En la parte de argumentos declararemos las variables de tipo entero que necesitaremos

recibir para realizar las operaciones correspondientes a dicha funcin.
Un ejemplo de llamada a una funcin puede ser el siguiente:
void gira(int tiempo_de_giro) //declaracion de la funcin
{
OnRev(OUT_C);
//instrucciones que explicaremos mas adelante
Wait(tiempo_de_giro);
OnFwd(OUT_A+OUT_C);
}
task main()
//tarea principal
{
OnFwd(OUT_A+OUT_C);
//instrucciones
Wait(100);
gira(200);
//llamada a la funcion con paso de parametro
Off(OUT_A+OUT_C);
}
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
La sintaxis para declarar una subrutina es parecida a la de una funcin:
sub nombre_subrutina() //declaracion de la subrutina

{
...
//instrucciones que explicaremos mas adelante ...
...
}
Pgina 104
Veamos a continuacin un ejemplo para el manejo de subrutinas:
sub gira() //declaracion de la subrutina

{
OnRev(OUT_C);
//instrucciones que explicaremos mas adelante
Wait(tiempo_de_giro);
OnFwd(OUT_A+OUT_C);
}
task main()
//tarea principal
{
OnFwd(OUT_A+OUT_C);
//instrucciones
Wait(100);
gira();
//llamada a la subrutina
Off(OUT_A+OUT_C);
}
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
SENSOR_1, SENSOR_2 y SENSOR_3. Estos nombres se pueden usar en cualquier funcin

que requiera el nombre de sensor como argumento, pudiendo adems leer el contenido del
sensor en cualquier momento:
x=SENSOR_1; //lee el sensor y lo almacena en x
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
SetSensor (sensor, configuracin)

Establece el tipo y modo de un sensor dado en una configuracin especificada,
que debe ser una constante especial conteniendo el tipo y el modo de la informacin.
SetSensor (SENSOR_1, SENSOR_TOUCH);
SetSensorType (sensor, tipo)
Establece un tipo de sensor, que debe ser una de las de las constantes de tipo de
sensor predefinidos.
SetSensorType(SENSOR_1, SENSOR_TYPE_TOUCH);
SetSensorMode (sensor, modo)
Establece un modo de sensor, que debe ser una de las de las constantes de modo
de sensor predefinidos. Se puede aadir, si se desea un argumento
de umbral para conversin booleana.
SetSensorMode(SENSOR_1, SENSOR_MODE_RAW); // modo puro
SetSensorMode(SENSOR_1, SENSOR_MODE_RAW+10); // umbral 10
ClearSensor(sensor)
Borra el valor de un sensor slo afecta a los sensores que se configuran para
medir una cantidad acumulativa tal como la rotacin o un recuento de pulso.
ClearSensor(SENSOR_1);
SensorValue(n)
Devuelve la lectura procesada del sensor para el sensor n, donde n es 0, 1 2.
Este es el mismo valor que devuelven los nombres de sensor (ej. SENSOR_1).
x = SensorValue(0); // lee el sensor 1
SensorType(n)
Devuelve el tipo configurado del sensor n, que debe ser 0, 1 2. Slo tiene tipos
configurables de sensor RCX, otros soportes devuelven el tipo el tipo pre-configurado
de sensor.
x = SensorType(0);
SensorMode(n)
Devuelve el modo de sensor en uso para el sensor n, que debe ser 0, 1 2.
x = SensorMode(0);
Pgina 107
A continuacin exponemos un ejemplo de cdigo para la utilizacin de sensores:

task main()
{
SetSensor(SENSOR_1,SENSOR_TOUCH);
OnFwd(OUT_A+OUT_C);
until (SENSOR_1 == 1) ;
Off(OUT_A+OUT_C) ;
}
A travs de la orden SetSensor configuramos la ubicacin del sensor y el tipo. Las

rdenes siguientes se explicaran en el manejo de las salidas.
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:
A continuacin exponemos diversas rdenes y su significado:

SetOutput(salidas, modo)
Establece la salida en el modo especificado. Salida es uno o ms de los valores
OUT_A, OUT_B, y OUT_C. Modo tiene que ser OUT_ON, OUT_OFF, o OUT_FLOAT.
SetOutput(OUT_A + OUT_B, OUT_ON); // Establece A y B encendidos
SetDirection(salidas, direccin)
Establece la salida en la direccin especificada. Salida es uno o ms de los
valores OUT_A, OUT_B, y OUT_C. Direccin tiene que ser OUT_FWD, OUT_REV, o
OUT_TOGGLE.
SetDirection(OUT_A, OUT_REV); // Hace girar A hacia atrs
SetPower(salidas , potencia)
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
Off(OUT_A); // Apaga la salida A
Float(salidas)
Establece las salidas especificadas como float. Salida es uno o ms de los
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
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
Para generar dichos sonidos utilizamos la orden PlaySound(numero)

Ejemplo:
task main()
{
PlaySound(1);
}
DISPLAY LCD
El RCX tiene 7 modos de display siguiendo la siguiente tabla:
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
6.6. Spirit.ocx y Visual Basic:

6.6.1. Introduccin a Spirit.ocx
El control spirit.ocx se copia automticamente al ordenador cuando instalamos el
software principal de lego. Por medio de este control podemos programar en diversos
entornos de programacin como por ejemplo visual java, visual c, visual basic
Como alternativa a diversos lenguajes como NQC o bricOS nos centraremos en el
entorno de programacin visual basic, ya que nos ofrece una gran cantidad de ventajas por su
sencillez de programacin y sus prestaciones. En los posteriores captulos explicaremos el
funcionamiento bsico a seguir para poder realizar aplicaciones sencillas mediante este
lenguaje.
6.6.2. Programacin en VisualBasic
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.
Posteriormente nos aparecer la siguiente pantalla:
Pgina 112
En la parte izquierda de la figura tenemos la barra de herramientas , desde la cul

podemos insertar los objetos que creamos necesarios para el desarrollo de la aplicacin, ya
sean botones, cuadros de texto, timers, etc. En la parte de la derecha nos aparecen las
propiedades del objeto activo en cada caso.
Barra de herramientas:
Con el fin de particularizar, seguidamente explicaremos como manejar el entorno

visual basic orientado para la realizacin de aplicaciones para lego. Para una informacin
generalizada de la utilizacin de este entorno de programacin con el fin de realizar
aplicaciones generales consultar manuales especializados de visual basic.
Para el desarrollo de aplicaciones de lego tenemos que agregar el componente ya

comentado anteriormente spirit.ocx, por lo que pincharemos con el botn derecho del ratn en
la barra de herramientas apareciendo posteriormente esta pantalla:
Seguidamente pinchamos con el ratn en la opcin componentes. Seguidamente nos

aparecer la pantalla que exponemos a continuacin.
Pgina 113
Marcamos el control LEGO PBrickControl, OLE Control module y hacemos click en

aceptar.
Cuando volvemos a la pantalla principal, nos fijamos que en la barra de herramientas se ha
agregado un nuevo componente, el cual corresponde al control de lego.
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:
Se puede apreciar el icono de lego en la ventana de desarrollo de nuestra aplicacin.

En la parte inferior derecha de la pantalla observamos las propiedades del componente:
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
Posteriormente se incluir en el formulario:
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.
Propiedades del botn command1:
Pgina 117
Descripcin de las propiedades ms significativas que vamos a utilizar:

(Name): nombre a travs del cual nos referiremos al botn en la hoja de cdigo.
Caption: nombre que se asignar al aspecto externo del botn.
Font: Tipo de letra que se le asignara al nombre del botn.
Para el desarrollo de algunos ejemplos pondremos en la propiedad (Name) inicio y
llamaremos al botn inicio en la propiedad caption. Lo dems lo dejamos como esta por
defecto.
A continuacin agregamos otro botn y le ponemos por nombre parada tanto en la
propiedad (name) como en caption.
El formulario nos quedar de la siguiente forma:
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.
Entraremos en el cdigo del botn haciendo doble click sobre el mismo:
Pgina 118
Automticamente nos aparecer el cdigo que apreciamos en la pantalla, y una

funcin ejecuta el cdigo que introduzcamos al hacer click con el ratn sobre el botn. Dentro
del cdigo escribiremos lo siguiente:
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
Ya hemos finalizado la elaboracin de nuestro primer programa. Para

ejecutarlo simplemente hay que clickear el smbolo play de la barra situada en la parte
superior de la pantalla:
Aparecer seguidamente esta pantalla:
Si tenemos bien conectado el robot al puerto de comunicaciones, al hacer click en el

botn inicio, el robot se desplazar hacia delante durante dos segundos y despus se
parar. Al pulsar el botn parada, se detendr la comunicacin con el robot por el puerto
serie y saldremos del programa.
En el siguiente captulo explicaremos la funcin de cada una de las funciones que puede
realizar el objeto de lego spirit1 para manejar tanto las salidas (motores) , como las entradas
(sensores).
6.6.3. Funciones para el manejo de las salidas
Spirit1.SetFwd <LISTA DE MOTORES>:

Con el parmetro SetFwd seguido de los motores: MOTOR_A, MOTOR_B MOTOR_C
establecemos el sentido de giro del motor hacia delante.
Spirit1.SetRwd <LISTA DE MOTORES>:
Con esta funcin configuramos los motores para que giren hacia atrs.
Pgina 121
Spirit1.AlterDir <LISTA DE MOTORES>:

La instruccin AlterDir provoca un cambio de direccin en el motor o motores que pasemos
como argumento.
Spirit1.On <LISTA DE MOTORES>
Activamos los motores que pasemos como argumento.
Spirit1.Off <LISTA DE MOTORES>
Desactivamos los motores que pasemos como argumento.
Spirit1.SetPower <LISTA MOTORES>, <VARIABLE>, <VALOR>
Esta funcin establece la potencia de los motores que pasemos como argumento. La
potencia puede tomar un valor de 0 a 7, siendo 7 el valor de la mxima potencia. Esto no
tiene efecto apreciable en la velocidad, pero si en la fuerza.
6.6.4. Funciones para el manejo de las entradas.

Spirit1.SetSensorType <SENSOR>, <TIPO>
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:
Spirit1.SetSensorMode <NUMERO>, <MODO>, <SLOPE>

A travs de esta orden configuramos el modo a travs del cual recibimos los datos de un
sensor determinado. El argumento NUMERO corresponde al nmero de sensor. El modo
puede tomar los siguientes valores:
Pgina 122
El argumento SLOPE slo se usa si hemos elegido el modo booleano, para cualquier otro
modo marcaremos 0 en el argumento SLOPE.
Variable = Spirit1.Poll (SENVAL, <SENSOR>)

Devuelve a la variable el valor que proporciona el sensor. Para crear una variable en
el entorno visual basic seguiremos la siguiente orden:
6.6.5. Otras funciones

Spirit1.wait <NUMSEGUNDOS>, <VARIABLE>
Esta funcin espera un nmero de segundos determinados, asocindolos a una
variable.
6.6.6. Sentencias de control

Las sentencias de control nos son de gran utilidad para la optimizacin y posibilidades de
nuestras aplicaciones. Las ms importantes son:
Sentencia if:
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.
6.6.7. Bibliografa Spirit.ocx y VisualBasic:
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.
6.7.2. Programacin en BrickOS

El mini sistema operativo BrickOS tiene las siguientes caractersticas:
Es un Sistema Operativo libre
Permite carga dinmica de programas
Permite gestin de memoria dinmica
Provee controladores para todos los subsistemas
Posee un tamao reducido de memoria y para almacenar programas
Permite la gestin de tareas con prioridad
Provee el uso de semforos POSIX

El funcionamiento BrickOS se basa en el kernel BrickOS es monoltico. La ROM llama a
kmain que inicializa el kernel, y arrancan las tareas:
iddle, mas baja prioridad para la CPU
packet_consumer para manejar el puerto IR
key_handler para el manejo de los botones.

Despus se carga el systime_handler, que es el encargado de revisar todos los
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:
fwd: hacia adelante
rev: hacia atrs
break: frenado de motor, impide que gire, posee gasto de batera
off: detiene el motor, lo libera, no tiene gasto de batera.
De la misma manera en la funcin motor_X_speed( Velocidad_del_Motor), X es el

puerto de salida que alimenta a algn motor, y su argumento es la velocidad. La velocidad
para BrickOS es un nmero entero que se sita entre MIN_SPEED y MAX_SPEED o 0 y
255.
Ejemplo para el uso de dos motores lego conectados a los puertos A y C:
void manejo_de_motor() {
int velocidad;
velocidad=0;
while (velocidad<MAX_SPEED) {
motor_a_speed(velocidad);
motor_c_speed(velocidad);
lcd_int (velocidad);
lcd_refresh();
motor_a_dir (fwd);
motor_c_dir (fwd);
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
Funciones Input, lectura de sensores: Los sensores son el conjunto de dispositivos y

herramientas que permiten al robot interactuar con el medio a travs de la recepcin de
lecturas del medio. Existe una gran variedad de sensores propietarios de Lego y otras
fbricas (compatibles con el RCX), los ms utilizados son los sensores de: tacto, luz, rotacin.
Otros ms especficos son los sensores de calor, sonido, ultrasonido, lser, de movimientos,
etc. A continuacin se remitir al uso de los sensores mas conocidos. El RCX posee 3 puertos
de lectura 1, 2, 3 y estos reciben las lecturas de los sensores lo que son transformados por un
conversor A/D de 8 canales para obtener valores. Estos valores pueden ser ledos en modo
Bruto o modo Procesado. Para acceder en modo Bruto se hace a travs de las variables
SENSOR_1, SENSOR_2 Y SENSOR_3, depediendo cual puerto de lectura se este utilizando.
La lectura en bruto tiene un rango hexadecimal de 0-0xffff, donde 0xffff corresponde 65535.
Los valores en modo Procesado, corresponden a valores transformados desde los valores
brutos. Estos dependen del sensor que se utilic, por ejemplo: para el sensor de choque es
TOUCH_2, para el sensor de luz es LIGHT_2.
El Sensor de Choque, sus valores procesados se accedan a travs de la macro
TOUCH_X, donde X puede ser cualquiera de los puertos de lectura 1, 2, 3. Esta macro
retorna un valor booleano, 0 o 1, BrickOS solo decide si el valor bruto esta por sobre o por
debajo de un umbral. Ejemplo de uso:
if (TOUCH_1) {
dlcd_show (LCD_ARMS); }
El Sensor de Luz, es un dispositivo capaz de emitir y recibir luz. Sus valores procesados
se acceden por medio de la macro LIGHT_X, donde X pueden ser cualquiera de los puertos
de lectura. Los valores brutos son escalados a un rango de enteros ms pequeos para luego
normalizarlos a porcentajes. Este sensor adems, posee dos modo de trabajo: modo pasivo
(para detectar luz) y modo activo (emite y recibe luz). En modo activo los valores brutos van
desde 50 a 300, se debe inicializar con la funcin ds_active(&SENSOR_X). En modo pasivo,
los
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
Ds_active(&SENSOR_X), sensor de rotacin en modo activo
ds_rotationon(&SENSOR_X), inicializando sensor 2 como rotacional
Ds_rotation_set(&SENSOR_X, valor_inicio), para que las lecturas comiencen desde

valor_inicio
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);
}
}
6.7.3. Bibliografa BrickOs

http://brickos.sourceforge.net/
http://pantuflo.escet.urjc.es/faqs/faq-de-robotica
http://bulunga.dat.escet.urjc.es/~acmlux/documentacion/x258.html
http://www.euskalnet.net/kolaskoaga/programz/bricko_c.htm
Pgina 130
6.8. Interactive C
El entorno de programacin C interactivo ha sido desarrollado para el proyecto MIT LEGO

Robot Design. Es un compilador multitarea basado en el lenguaje C que incluye una lnea de
comandos de usuario que permite compilar y evaluar expresiones de modo interactivo.
Originalmente fue creado para ser utilizado por estudiantes, su campo de aplicacin se
extendido a la investigacin y desarrollo de prototipos.
Se puede utilizar tanto con el RCX de LEGO como con el Handy Board del MIT (hay algunas
diferencias en las funciones a utilizar en uno u otro).
Hay versiones para trabajar sobre Linux, MacOS y Windows. La versin 4 de este programa
es de libre uso.
Para su explicacin nos remitimos al The Interactive C Manual for the Handy Borrad
6.8.1. Bibliografa Interactive C:

http://www.donosgune.net/2000/gazteler/prg_leng/IC_g.htm
http://www.euskalnet.net/kolaskoaga/programz/ic_c.htm
http://www.newtonlabs.com/ic/ic_toc.html
http://www.botball.org/educational-resources/ic.php
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.
6.9.2. Aspectos generales de LegOS

Entre las caractersticas ms importantes de la versin legOS 0.2 se pueden destacar:
Sistema operativo libre (Markus L. Noga).
La carga dinmica de programas y mdulos (desde la versin 0.2.x).
El protocolo de comunicacin basado en el transmisor infrarrojo.
La posibilidad de realizar programas multitarea.
La gestin de memoria dinmica (acceso a toda la memoria).
La existencia de drivers para todos los subsistemas del ladrillo.
El uso de la velocidad nativa del micro-procesador, esto es 16 MHz.
El acceso a los 32K de memoria RAM.
Gestin de tareas (con prioridad).
Semforos POSIX.
Permitir el uso completo del lenguaje de programacin elegido, como por ejemplo C.
Lo cual implica que se pueden usar punteros, estructuras de datos, etc.
6.9.3. Arquitectura de software usando LegOS
Pgina 132
6.9.4. Ejemplos de programas

LegOS es solo el sistema operativo, lo que quiere decir que se necesita el soporte de un
compilador capaz de generar cdigo para el H8 a partir del lenguaje de programacin que
deseemos y para el que existan las libreras adecuadas de LegOS. Para ilustrar el aspecto de
dichas libreras se incluye a continuacin un par de ejemplos de programas realizados en C:
Ejemplo 1.
#include
#include
#include
#include
<conio.h>
<unistd.h>
<dsensor.h>
<dmotor.h>
/*Declaro una funcin que se ejecutar al detectar la colisin*/

wakeup_t colision(wakeup_t dato);
int main(int argc, char *argv[]) {
int dir=0;
while(1) {
/* arranco
- Fijo velocidad*/
motor_a_speed(MAX_SPEED);
motor_c_speed(MAX_SPEED);
/* - Avanzo*/
motor_a_dir(fwd);
motor_c_dir(fwd);
/* Espero */
wait_event(&colision,0);
/* Me apunto en que lado fue la colisin*/
if(SENSOR_1<0xf000)
dir=0;
else
dir=1;
/* reculo */
motor_a_dir(rev);
motor_c_dir(rev);
/* - el ratito que reculo*/
msleep(500);
/* Una vez reculado, ahora giro un peln*/
if(dir==1) {
motor_c_dir(fwd);
} else {
motor_a_dir(fwd);
}
/* - ratito para girar */
msleep(500);
}
}
wakeup_t colision(wakeup_t dato) {
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>
wakeup_t colision(wakeup_t dato) {

lcd_refresh();
return TOUCH_1 || TOUCH_2;
}
int main(int argc, char *argv[]) {

while(1) {
motor_c_dir(fwd);
motor_a_dir(fwd);
wait_event(&colision,0);
if(SENSOR_1<0xf000)
dir = 0;
else
dir = 1;
motor_a_dir(rev);
motor_c_dir(rev);
Pgina 134
msleep(500);
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.
6.9.5. Cmo se programa desde GNU/Linux?

Se genera una versin cruzada de gcc para el H8 (binutils)
Se compila el propio LegOS
Se edita el programa (Emacs p.e.) y se compila con el gcc cruzado
Se descargan los programas con las herramientas de LegOS:
firmd3: descarga el firmware de legOS
dll: descarga un programa
Existen paquetes Debian y RedHat de todo
Tambin existen distribuciones para MS-Windows
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.
6.9.6. Herramientas relacionadas con legOS

Se eligi legOS como base para la programacin del RCX, lo que obliga a utilizar otras
herramientas, algunas evidentes como el entorno de compilacin cruzado. En este caso se ha
utilizado el entorno de la FSF basado en las binutils y el compilador gcc. Tambin se han
utilizado otras herramientas como los simuladores. Algunas de estas herramientas las
describimos a continuacin:
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
El aspecto externo de una aplicacin para legOS ejecutando en EmuLegOS es el de la

Figura. EmuLegOS permite al usuario configurar los sensores e interaccionar con ellos
mientras el programa est en ejecucin, por ejemplo simulando eventos externos. El interfaz
tambin muestra el estado de los hasta tres motores que se pueden ``pinchar virtualmente''
en los puertos A, B y C del RCX.
EmuLegOS tambin permite que se emule el mundo real, proporcionando un lugar donde
insertar cdigo que imite algunas de las caractersticas fsicas del robot. Por ejemplo, se
puede incorporar un sensor de rotacin que gire mientras un determinado motor virtual est
en marcha, o hacer que un sensor de colisin se active pasada una cantidad de tiempo desde
que se arranc el motor.
La mayor utilidad de los simuladores es la posibilidad de depurar. En ambos casos

(EmulegOS y LegoSim), se pueden utilizar todas las herramientas disponibles en el entorno
de desarrollo, ya que el programa para legOS se ejecuta dentro del simulador, y ste dentro
de la plataforma.
Otra categora de herramientas relacionadas con legOS son las que se pueden catalogar
como herramientas de terceras partes. As por ejemplo, existen compiladores para legOS
accesibles va Web, como el que se analiza en la siguiente seccin.
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.
6.12. Programacin en Java para los Lego-Mindstorms (LeJos)

6.12.1.
Introduccin
LeJOS es un sistema operativo basado en la TinyVM desarrollado por Jos Solorzano.

Actualmente leJOS est mantenido por Paul Andrews Jrgen Stuber. El lenguaje de
programacin que utiliza es Java. Puedes descargarlo directamente desde su pgina oficial
http://lejos.sourceforge.net/
El sistema operativo incluye threads, arrays multidimensionales, recursividad, operaciones en
coma flotante, funciones trigonomtricas, etc. Adems est disponible tanto para sistemas
Win32 como sistemas UNIX.
Con este API se puede desarrollar programas para el RCX bajo Java. Hay que instalar el JDK
(Java Development Kit) p.ej. de Sun y ya se puede utilizar las clases ofrecidos por lejOS.
Herramientas adicionales muy prcticas para programar bajo Java son el RCXDownload y el
RCXDirectMode.
6.12.2.
Cmo uso leJOS bajo Linux?
Antes de empezar debers establecer la variable local $LEJOS_HOME mediante export

LEJOS_HOME=/ruta/donde/este/lejos as como export RCXTTY=COM1 si tienes la torre de
infrarrojos conectada al puerto de serie o export RCXTTY=usb en caso de conexin USB.
El paquete leJOS est compuesto de varias utilidades:
firmdl: para descarga el sistema operativo al RCX del robot. Recuerda que es el primer paso
que debes hacer antes de ponerte a programar ya que por defecto el fabricante lo suministra
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
El estado 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 nivel de voltaje de la batera
Si la descarga no funciona, asegrate de que:
El RCX est encendido.
El puerto de infrarrojos del RCX (el panel oscuro frontal) est situado apuntando hacia la torre
USB.
La variable de entorno RCXTTY est correctamente configurada .
La torre debera parpadear una vez en color verde al ejecutar lejosfirmdl.
Pgina 139
6.12.3.
Crear y ejecutar mi primer programa leJOS
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
Enhorabuena! Has ejecutado tu primer programa leJOS en el RCX.

Mi segundo programa con leJOS
En esta seccin echaremos un vistazo ms detallado a otra aplicacin de ejemplo de leJOS
para discutir ciertos conceptos fundamentales. En este ejemplo se asume que el RCX tiene
conectado un motor en el puerto A, como en la figura:
Escribe
el
siguiente
programa
Java
(lgicamente,
en
un
fichero
llamado
SimpleSample.java):
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
Importa las clases esenciales para ejecutar los programas leJOS.
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.
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
A continuacin se detalla ms detenidamente las funciones asociadas a los diferentes

componentes de los robots Lego
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:
Los tres puertos se implementan como atributos estticos de la clase Motor:

Motor.A
Motor.B
Motor.C
As, una llamada tpica para arrancar el motor A (hacia adelante) sera:
Motor.A.forward();
O para ir hacia atrs:
Motor.A.backward();
Controlar los motores es muy simple:
public static void forward()
public static void backward()
public static void reverseDirection()
public static void flt()
public static void stop()
para mover el motor hacia adelante o hacia atrs, cambiar la direccin, hacerlo "flotar" (es
decir, dejarlo libre) o pararlo.
public static void setPower(int aPower)
ajusta la potencia del motor, de 0 a 7 (esto no afecta mucho a la velocidad, a no ser que el
motor tenga carga).
Y tambin existen los mtodos siguientes para obtener informacin de estado:
public static boolean isForward()
Pgina 143
public static boolean isBackward()

public static boolean isFloating()
public static boolean isMoving()
public static boolean isStopped()
y public static char getID(), que devuelve 'A', 'B' or 'C'.
Fjate en que la direccin de giro real del motor (en sentido de las agujas del reloj, o al revs)
depende de cmo est conectado al puerto: como se trata de motores de corriente continua,
cambiar la polaridad significa cambiar el sentido de giro.
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
aSensorId,int aRequestType), donde aSensorId es el identificador del sensor (0,1,2)

y aRequestType es el tipo de datos a leer (0 = valor numrico, 1 = valor configurado, 2 =
valor booleano).
Sin embargo, en la mayora de los casos, lo que interesa es recibir una notificacin de cuando
un motor ea activado (de contacto, por ejemplo), o bien mida un cierto valor (en el caso, por
ejemplo, de sensores de luz). Para este propsito se emplean los manejadores de eventos:
Para escuchar un evento, la clase tiene que implementar el mtodo public
void
stateChanged(Sensor aSource, int aOldValue, int aNewValue) de la interfaz

josx.platform.rcx.SensorListener, donde los dos parmetros indican el valor antes y
despus del cambio en la medida:
public class MySensorListener implements SensorListener {
public void stateChanged(Sensor aSource, int aOldValue, int aNewValue) {
// responder al cambio de valor en el sensor
} // stateChanged()
} // class MySensorListener
Con esto, es posible aadir esta clase como un escuchador del sensor en cuestin:
Sensor.S1.addSensorListener(mySensorListener);
As, cada vez que el sensor detecte un cambio en la medida, se ejecutar el mtodo
stateChanged() de la clase MySensorListener.
Esto es extremadamente til para sensores de contacto, por ejemplo.
Un sensor muy til: ProximitySensor (proximidad)
Desde las primeras versiones de la plataforma leJOS, se vio que un sensor de proximidad
sera muy til: as, el robot no tendra que chocar contra los objetos para detectar su
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
La pantalla de la parte superior del RCX es la nica manera de mostrar mensajes

directamente al usuario, y es capaz de mostrar hasta 5 nmeros o letras.
La clase esttica LCD ofrece varios mtodos de acceso a la pantalla:
public static void clear()

public static void clearSegment(int aCode)
public static void refresh()
para borrar o refrescar los segmentos de la pantalla, y
public static void setNumber(int aCode,int aValue,int aPoint)
public static void setSegment(int aCode)
public static void showNumber(int aValue)
public static void showProgramNumber(int aValue)
para mostrar valores.
Los
cdigos
de
segmento
son
constantes
definidas
en
la
interfaz
Segment
(Segment.BATTERY,Segment.WALKING, Segment.STANDING, etc.).. Recuerda que hay

que llamar refresh() tras poner un valor.
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
El RCX tiene 4 botones:
View: para mostrar los valores de los sensores

Prgm: para seleccionar el programa cargado
Run: para ejecutar programas
On/Off: para encender/apagar el RCX
Excepto el botn On/Off, los dems son accesibles con la API de leJOS. Como con el resto
de clases relacionadas con el hardware, los botones se implementan como mtodos estticos
de la clase Button:
Button.RUN
Button.PRGM
Button.VIEW
Otra posibilidad es acceder mediante el array Button[], que contiene VIEW, PRGM y RUN,
en este orden.
Detectar cuando un botn es pulsado (y liberado)
The main (and eventually the single) interaction the developer of leJOS programs is interested
in when referring to buttons is the event, when a user presses the button and - maybe even
more important - when he releases it.
Pgina 148
La
forma
ms
sencilla
de
detectar
cundo
se
pulsa
un
botn
es
llamar
waitForPressAndRelease(), con lo que el programa espera a que el usuario pulse y

suelte el botn:
try {
} catch(InterruptedException e) {
// quizs hacer algo aqu
}
Fjate que hay que capturar o declarar la excepcin InteruptedException.
Otra manera es emplear un evento para recibir una notificacin de cundo un usuario pulsa o
suelta un botn mientras que el programa est en ejecucin. La clase manejadora tiene que
implementar los dos mtodos:
public void buttonPressed(Button b)
public void buttonReleased(Button b)
de la interfaz josx.platform.rcx.ButtonListener.
public class MyButtonListener implements ButtonListener {
public void buttonPressed(Button b) {
// se ejecuta al pulsar el botn
} // buttonPressed()
public void buttonReleased(Button b) {
// se ejecuta al liberar el botn
} // buttonReleased()
} // class MyButtonListener
Para usar la clase en tu programa:
Button.RUN.addButtonListener(myButtonListener);
As, cada vez que se apriete o suelte el botn RUN, se ejecutarn los mtodos
correspondientes de la clase MyButtonListener.
Sonido
El RCX contiene un pequeo altavoz que puede generar sonidos simples, que se accede
mediante
la
clase
esttica
Sound
Sound.beep();
Pgina 149
con
la
tpica
llamada:
Existen varios mtodos para producir sonidos:

public static void beep(): pita una vez.
public static void twoBeeps(): pita dos veces.
public static void beepSequence(): escala de pitidos.
public static void buzz(): zumbido.
public static void playTone(int aFrequency,int aDuration): ejecuta un sonido de la
frecuencia (en Hz) y duracin (en centsimas de segundo) dadas, donde la duracin
mxima es 256 (=2,56 segundos). Las frecuencias bajo 31 Hz y sobre 25.000 Hz no
son audibles por la mayora de los seres humanos (pero puedes llamar a un perro
con el RCX!!).
public static void systemSound(boolean isQueued,int aCode): produce un sonido
preconfigurado del sistema (ver API).
Las llamadas anteriores (excepto systemSound()) terminan inmediatamente, as que el
programa contina mientras se est ejecutando el sonido en cuestin.
OJO: Los sonidos se pueden usar como depuracin de los programas, para controlar el punto
de ejecucin, por ejemplo.
Timer (temporizador)
La clase Timer se utiliza para ejecutar tareas que dependan del tiempo, est contenida en el
paquete josx.util y funciona de forma similar a la clase javax.swing.Timer:
Un TimerListener notifica de forma repetida a Timer a intervalos prefijados.
La API para gestionarlo es as de sencilla:
public int getDelay() obtiene el intervalo (en milisegundos)
public void setDelay(int aDelay) ajusta el intervalo
public void start() arranca el temporizador
public void stop() lo detiene
El TimerListener se le pasa al constructor
public Timer(int aDelay, TimerListener aListener)
y llama a su mtodo
public void timedOut()
cada vez que transcurre el intervalo.
Un ejemplo ilustrativo del uso de la clase Timer:
Pgina 150
import josx.util.*;
public class TimerSample implements TimerListener {
// crear y arrancar el temporizador, con intervalo 1 segundo
Timer timer = new Timer(1000,new TimerSample());
timer.start();
// ejecuta hasta pulsar el botn RUN
// detener el temporizador
timer.stop();
} // main()
public void timedOut() {

// slo pitar
Sound.beep();
} // timedOut()
} // class TimerSample
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,
- 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.
- Paul Andrews Jrgen Stuber, Jos Solrzano, LejOs, W22 agosto del 2006, 7 de noviembre
de 2006, http://lejos.sourceforge.net.
- 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.
Pgina 152
7. Lego Mindstorms en la enseanza

En muchos pases, el uso de elementos como la robtica en la enseanza esta muy
extendido, siendo Espaa una rara excepcin entre los pases ms desarrollados.
Una herramienta muy til a tal efecto es Lego Mindstorms, que desde su primera versin,
RCX, se ha consolidado como un medio efectivo para cubrir reas de la enseanza tales
como ciencia, tecnologa, ingeniera o matemticas; todo ello sin olvidar su evidente uso en el
mundo extra-acadmico como mero entretenimiento.
Actualmente con la nueva versin NXT, ayuda a alumnos desde 5 a 8 aos a descubrir que la
ciencia tambin pude ser entretenida; desarrollando progresivamente sus habilidades
construyendo y programando simpticos robots y motivndolos a investigar por s mismos
poniendo en prctica lo aprendido en desarrollos anteriores. Para ello se ha dotado a Lego
Mindstorms de entornos de programacin grficos muy intuitivos y de gran cantidad de
modelos con ayuda paso a paso.
Sin embargo Lego Mindstorms tambin tiene salida fuera del entorno escolar (primaria y
secundaria) donde se emplean con diversos fines empleando entornos de programacin ms
sofisticados que potencian las capacidades de los robots.
No obstante en este caso nos centraremos en la vertiente educativa de los robots de Lego.
7.1. Trabajo con Lego Mindstorms en la enseanza

7.1.1. Mtodo de trabajo
En el campo de la enseanza Lego Mindstorms ha sido concebido como una herramienta con
la que investigar y ser curioso, por tanto el profesor durante el trabajo con los nios debe
crear un ambiente en el que se promueva el dise y la prueba; se debe alentar a los
alumnos a aprender de los errores que se vayan cometiendo y estimularles a volver sobre sus
pasos para replantear el problema desde algn punto de vista alternativo. Se deber por
tanto:
Comprometer a los estudiantes con un problema relacionado con sus intereses y que se
abordar tecnolgicamente.
Numerosas experiencias con nios de primaria y secundaria demuestran que el hecho de
situar a los alumnos en un contexto que les sea familiar y que les motive constituye el primer
paso hacia el xito.
Por ejemplo alumnos de Irlanda fueron motivados plantendoseles situaciones de cuentos
populares del lugar, a continuacin se les invitaba a reproducir el mismo mediante robots que
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
correctamente en ambas pruebas. La complejidad de compaginar todos los requerimientos

hizo que gran parte del alumnado dejara de lado la prueba de seguimiento de la lnea,
haciendo un robot mediocre en este sentido; y se dedicara a la prueba de sumo con un mayor
carcter competitivo.
Habr que cerciorarse que se entiende correctamente el problema. Qu problema tratamos
de resolver? Sin embargo no se deber desvelar al alumno todo aquello que deber
descubrirse con su trabajo, tan slo se les deber guiar.
Para ello el profesor habr de hacer preguntas que ayuden a los grupos a progresar y a que
exploren distintos caminos.
Del mismo modo el profesor deber hacer notar de forma expresa que el diseo est abierto,
y por tanto hay mltiples soluciones "correctas" al problema, si bien habrn de ponerse de
manifiesto desde un principio las limitaciones que debemos tener en cuenta y no crear falsas
expectativas.
Crear grupos compatibles y asignarles roles para que un aprendizaje cooperativo.
En cuanto al gnero de los grupos, cabe descacar algunos aspectos importantes referidos a
la enseanza a nios de poca edad:
Los chicos tienen generalmente ms experiencia construyendo cosas con Lego que las chicas
y a diferencia de estas, tienden a ponerse a construir antes de pensar qu es lo que
realmente estn haciendo; ellas por su parte tienden a elegir cuidadosamente las piezas a
usar y se muestran ms dispuestas a compartir sus ideas.
Un buen mtodo para vencer estas diferencias se ha visto que es la elaboracin de un plano
previo, aunque no termine siguindose, habr servido para promover la organizacin dentro
del grupo.
Otra forma de trabajo que se ha empleado ha sido la de hacer inicialmente grupo de slo
chicas y de slo chicos. Se ha visto que esto da confianza a las chicas para que empiecen a
trabajar con Lego. Una vez que se conozca el estilo de trabajo de cada uno, los grupos
podrn hacerse mixtos.
En cuanto al trabajo cooperativo, como mtodo de aprendizaje informal, podemos afirmar que
es algo fundamental, no slo en el trabajo con robots o en la enseanza; sino en el desarrollo
como persona de cara a un futuro, puesto que fomenta las capacidades de trabajo en equipo,
Pgina 154
el liderazgo y la toma de decisiones. En este sentido, de nuevo la utilizacin de robots de

Lego se ha mostrado como una herramienta muy adecuada para fomentar estos valores.
Por ltimo, y no menos importante habr que hacer explcita, las matemticas, la ciencia, u
otras ideas implcitas en el juego.
7.1.2. Objetivos: a conseguir

Motivar al alumno a enfrentarse a un problema que le interese y le motive a resolverlo como
algo personal; todo ello mediante la construccin de un robot.
Fomentar la imaginacin as como habilidades como el diseo y la construccin.
Introducir al alumno a la programacin, ya sea en entornos grficos o de ms alto nivel.
Hacer que el alumno ponga de manifiesto sus conocimientos en un sistema real, observe su
comportamiento y busque alternativas para solucionar posibles eventualidades.
Hacer que los alumnos se conviertan en sus propios maestros a travs de la prueba y el
error.
Fomentar la cooperacin entre alumnos.
Y con todo ello a los alumnos que la ciencia es entretenida.
Durante todo el proceso el profesor se convertir en cmplice del proceso de aprendizaje de
los alumnos y muy probablemente las relaciones entre estudiantes y profesores cambien
dando vida al trabajo en el aula.
7.1.3. Un caso prctico: Visita al grupo Complubot.

El pasado 14 de Noviembre nos visitaron unos chicos del colegio Miguel Hernndez y nos
hablaron, de su experiencia con Lego Mindstorms. Al da siguiente nos acercamos nosotros
los a fin de ver su trabajo ms de cerca.
A continuacin resumimos el encuentro:
Segn llegamos pudimos ver cmo un padre intentaba apuntar a su hijo en la actividad,
desafortunadamente, la demanda de las clases y la escasez de medios haca imposible
que este nuevo alumno se pudiese integrar. Primera leccin aprendida, en Espaa
estamos a aos luz de otros mucho pases y lamentablemente si alguien quiere trabajar
con en estos temas (robtica etc), muy probablemente deba hacerlo en casa ante la falta
de organismos que fomenten sta actividad. De hecho como coment el grupo en su
visita a la universidad de Alcal su centro es el nico de toda Espaa que imparte una
asignatura de este tipo, aun con carcter extraescolar.
Por esto mismo, ser los primeros, han tenido que empezar desde muy abajo.
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
Imagen obtenida de http://complubot.educa.madrid.org

Actualmente estn en la transicin de los mdulos RCX a NXT y el mayor problema para
los alumnos es el cambio de filosofa en la construccin de robots con NXT: mientras en
RCX todas las piezas eran bloques que encajaban perfectamente entre si, en NXT todo
funciona a base de elementos entrecruzados a modo de travesaos. Tardarn todava
algn tiempo en acostumbrarse sobre todo teniendo en cuenta la forma de trabajo que
siguen: antes de nada se acostumbran a las piezas de los kits para saber todos sus
posibles usos, a continuacin las organizan perfectamente en cajas segn sus
funcionalidades.
- A quienes va dirigida la actividad extraescolar? Actualmente hay dos grupos con nios
de nios de 6, 1 y 2 de la ESO por un lado; y un poco ms mayores por otro; para el
prximo ao se pretende abrir un nuevo grupo para nios an ms pequeos.
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.
7.1.4. Algunas estadsticas interesantes

En cuanto al uso de Lego en la escuela para evaluar su eficacia como herramienta con la que
fomentar el trabajo en grupo[1]:
-
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.
Ms del 77 % de los estudiantes est de acuerdo en que el trabajo con robots de

Lego les ayuda a pensar de forma crtica y a cooperar con sus compaeros para el
logro de los objetivos
En un entorno universitario de carcter tcnico en que se usaba Lego para introducir al

alumnado a la programacin y a los sistemas empotrados se concluy[2]:
-
El 66% de los estudiantes tas sus habilidades de programacin como dbil o

moderada antes del curso. El 81% opinaba lo mismo en el uso de sistemas
empotrados. En un semestre dos terceras partes de los estudiantes tas sus
[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
habilidades de programa como fuerte o muy fuerte.

-
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.
Finalmente, el 60 % de los estudiantes dijo que recomendaran LEGO MINDSTORMS

el laboratorio de Robot en el futuro. Y un 32 % dijo que tambin lo recomendaran
para el empleo continuado durante el curso.
7.2. Lego Mindstorms: versin educativa vs comercial

Hay varias diferencias entre la versin comercial y la educativa.
En Espaa la primera diferencia puede ser la siguiente: mientras que la versin educativa
estar disponible en breve en castellano, la versin comercial no saldr a la venta al no estar
prevista su traduccin al Cataln, Gallego y Vasco.
En el software, la principal diferencia es el tutorial de programacin. El tutorial aparece
dividido en dos partes: en la primera slo se utilizan los bloques de programacin presentes
en la paleta bsica (similar a la del NXT comercial) y est compuesta de 20 propuestas de
programacin; la segunda utiliza la paleta de bloques completa en 19 propuestas. En algunas
de ellas no hace falta montar ninguna pieza ya que se trabaja nicamente con el NXT. En
todas ellas hay una simulacin, una gua de montaje y otra de programacin.
Otra diferencia significativa es la posibilidad de gestionar la transferencia de programas a
varios NXT de modo simultaneo, por medio de la herramienta Download to multiple NXT.
Por otro lado, algo que parece que en un corto plazo de tiempo se resolver es la
imposibilidad de utilizar con la versin comercial los sensores y motores del RCX, mientras
que con la educativa ya se puede hacer.
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
De hecho, la nueva filosofa de Lego es la de crear entornos de programacin adaptados a

cada franja de edad a diferencia de lo que haba ocurrido hasta ahora con Robolab. Se
pretende por tanto cubrir todo el itinerario del aprendizaje: desde su inicio, hasta el ltimo
paso en que se haga uso de LabVIEW.
En las siguientes figuras se puede observar la evolucin prevista del software de Lego.
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.
LabView vs Robolab en el entorno educativo
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.
A la hora de comenzar el aprendizaje en el aula, el software NXT no ofrece la posibilidad de

mantener ocultas algunas de las funcionalidades del programa como lo haca Robolab. Pero
ello no supone un gran problema, ya que lo que tenemos entre manos es un software
adaptado a niveles de primaria y secundaria obligatoria, en el que no vamos a encontrar una
serie de herramientas avanzadas como en Robolab. Hay tres paletas de bloques de
programacin: la primera es la bsica y comprende los bloques a utilizar en el inicio del
aprendizaje; la segunda es la completa, y presenta todos los bloques disponibles; en la
tercera tendremos los bloques creados por el usuario.
Este software nos permite saber en todo momento cul es la posicin de los motores y las
lecturas de los sensores mientras tengamos conectado el robot al ordenador ya sea por
Bluetooth o por USB. Ello es una gran ayuda en la programacin ya que permite hacer
pruebas previas.
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.
7.5. Bibliografa educacin.

Using Legos and RoboLab (LabVIEW) with elementary school children.
Eric Wang and Ryan Wang
Design, story-telling, and robots in Irish primary education.
Fred G. Martin Deirdre Butler Wanda M. Gleason
Teaching (with) robots in secondary schools some new and not-so-new pedagogical problems
Vassilios Dagdilelis, Maya Sartatzemi & Katerina Kagani
Mindstorms not just a kids toy.
Pgina 161
Paul Wallich; IEEE SPECTRUM September 2001

Educational robotics in a systems design masters program.
Uwe Gerecke, Patrick Hohmann, Bernardo Wagner
Peer learning with Lego Mindstorms.
Ciarn Mc Goldrick, Meriel Huggard
Principles and experiences in using legos to teach behavioral robotics.
Aaron Gage and Robin R. Murphy
The qualitative impact of using LEGO MINDSTORMS robots to teach computer engineering.
Andrew B. Williams
http://www.lego.com/education/
NXT-G Educacin; 21 Noviembre, 2006
http://www.euskalnet.net/kolaskoaga/programz/nxt/nxt_g_edu.htm
Aula Robtica del APA del C.P. Miguel Hernndez, 24 de septiembre 2006
http://complubot.educa.madrid.org/inicio.php?seccion=principal
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.
8.1. First Lego League
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.
ste ao tambin se va a celebrar una prueba clasificatoria en Espaa, el da 17 de diciembre

de 2006 en CosmoCaixa en Barcelona.
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.
Prueba de Ftbol 2+2

El propsito de esta prueba es realizar un pequeo partido de ftbol entre dos equipos
formados por dos robots mviles cada uno, mediante el uso de un campo y pelota de juego
especiales que permitan la orientacin de los robots y la localizacin de la pelota en todo
momento.
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.
9.1. Un ejemplo mecnico.

Este ejemplo est tomado de la direccin:
http://www.telepresence.strath.ac.uk/jen/lego/demag_crane.htm
(Realizado por Jennifer Clark)
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
reductora con una relacin 36:1(es

decir, 36 vuelta del motor se convierten
en una). As se consiguen movimientos
lentos pero potentes, necesario para
controlar con precisin y firmeza la
direccin de la gra. El eje de la
direccin
transmite
el
movimiento
circular a la goma, que es la que

mueve a las ruedas directrices.
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.
Detalles de los tres ejes, y del eje delantero.
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.
Chasis final con todos los componentes:
Pgina 169
9.2. Un ejemplo de programacin:

Quin no se ha propuesto alguna vez resolver el cubo de Rubik? Pues mediante un robot
construido con LEGO, podremos resolver en unos seis minutos de tiempo.
Este diseo ha sido diseado por J.P.Brown (http://jpbrown.i8.com/cubesolver.html),
construido e implementado con piezas LEGO. n este ejemplo podremos comprobar la
potencia del procesador de LEGO, y cmo se pueden construir diseos complejos, recibiendo
gran cantidad de datos, y enviando rdenes.
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.
Pasos del proceso:

-Una vez posicionado el cubo, el RCX deber conocer el estado inicial del cubo. Para ello,
mandar rdenes a las tres pinzas para que vayan girando al cubo, de forma que sus seis
caras puedan ser escaneadas por la cmara.
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
10. PRECIOS ORIENTATIVOS

A continuacin mostramos un listado con precios de algunos de los componentes ms
significativos de Lego Mindstorms, obtenidos de las siguientes webs:
http://electricbricks.com/
http://www.juguetronica.com
Mindstorms NXT Robotics Invetion 299.00
Robotics Invetion 2.0 195.00

Slo en brick RCX 99.95
1111 tecnopiezas 90.00
Motor con reductora 26.00
Pgina 172
Sensor de temperatura 39.00
Sensor de rotacin 26.00
Panel solar lego 54
Sensor de Luz 16
Sensor de sonido NXT 26.00
Sensor de contacto NXT 17.00
Sensor de luz NXT 17.00
Sensor de distancia NXT 34.00
Pgina 173

2 Avanzado Manual - LEGO

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

2 Avanzado Manual - LEGO

Загружено:

Авторское право:

Доступные форматы

INTRODUCCIN AL DISEO

Julin Manzano DOnofrio

Ignacio Esperabe de Arteaga del Alamo

Jos Antonio Martn Esteban

Rubn Fernndez Carnicero

Javier Mateos Andaluz

David Gualda Gmez

Luis de Santiago Rodrigo

ROBOTS LEGO MINDSTORMS

POR QU USAR LEGO-MINDSTORMS? ........................................................................ 6

BREVE HISTORIA DE LEGO:........................................................................................... 7

QU VIENE CON LEGO? ............................................................................................... 8

PUERTOS DE ENTRADA (1, 2,3)..................................................................................... 11

BOTONES DE CONTROL: ............................................................................................... 13

PUERTO DE COMUNICACIN INFRARROJA.................................................................... 13

TRANSMISOR DE INFRARROJOS. ................................................................................... 13

DIFERENCIAS HARDWARE ENTRE EL NXT Y RCX: .................................................... 20

BIBLIOGRAFA PARA LA PARTE DE DESCRIPCIN: ...................................................... 21

DEFINICIONES Y CONCEPTOS PREVIOS: ....................................................................... 23

SELECCIN DE LOS SENSORES: .................................................................................... 24

ROBOTS LEGO MINDSTORMS

SENSOR DE CONTACTO: ............................................................................................... 25

SENSOR DE ROTACIN: ................................................................................................ 26

SENSOR DE SONIDO: ..................................................................................................... 27

SENSOR DE COLOR HITECHNIC COMPATIBLE CON NXT :........................................... 28

FABRICACIN DE SENSORES PARA LEGO: ................................................................... 30

SENSOR DE LUZ: ........................................................................................................... 30

GP2D12 SENSOR DE DISTANCIAS: ............................................................................... 30

SENSOR DE COLOR: ...................................................................................................... 33

CONSTRUCCIN DE UN SENSOR DE TEMPERATURA RCX COMPATIBLE:...................... 39

FABRICACIN DE SENSORES PASIVOS: ......................................................................... 44

SENSORES DE LUZ: ....................................................................................................... 46

SENSORES DE TEMPERATURA: ..................................................................................... 47

FABRICACIN DE SENSORES ACTIVOS: ........................................................................ 48

SENSORES DE LUZ REFLECTANTES:.............................................................................. 48

DESCRIPCIN GENERAL ................................................................................................ 53

MOTORES PARA QUE? ................................................................................................ 53

MOTOR DE CORRIENTE CONTINUA .............................................................................. 53

MOTORES LEGO: ........................................................................................................... 55

PESO DE CADA MOTOR: ................................................................................................ 56

CARACTERSTICAS EN VACO (SIN CARGA):................................................................. 57

BIBLIOGRAFA DE LA PARTE DE MOTORES:................................................................. 62

ROBOTS LEGO MINDSTORMS

TRANSMISIN DE MOVIMIENTO Y ESFUERZO:................................................ 63

BIBLIOGRAFA PARTE TRANSMISIONES: ...................................................................... 68

INTRODUCCIN A LA PROGRAMACIN PARA LEGO. ................................................. 69

BLOQUES DE CONTROL DE FLUJO ................................................................................. 75

INTRODUCCIN A ROBOLAB ...................................................................................... 78

BIBLIOGRAFA ROBOLAB ............................................................................................. 86

PROGRAMACIN GRFICA CON LABVIEW ................................................................... 87

ENTORNO LABVIEW ................................................................................................... 88

FLUJO DE DATOS .......................................................................................................... 89

MANEJO DE PUERTOS CON LABVIEW ........................................................................ 90

PUERTO SERIE .............................................................................................................. 92

LENGUAJE NQC ............................................................................................................ 95

INTRODUCCION A RCX COMMAND CENTER ............................................................ 96

CONSTANTES Y VARIABLES ....................................................................................... 100

INSTRUCCIONES ......................................................................................................... 101

SENTENCIAS DE CONTROL .......................................................................................... 102

FUNCIONES Y SUBRUTINAS ........................................................................................ 103

TAREAS ...................................................................................................................... 105

ROBOTS LEGO MINDSTORMS

SENSORES ................................................................................................................... 105