Avanzado-Manual-LEGO.pdf

INTRODUCCIÓN AL DISEÑO DE MICROROBOTS MÓVILES Trabajo realizado para la asignatura de Diseño de Microrrobots Móviles de la Universidad de Alcalá por Estela Díaz López

Julián Manzano D’Onofrio

Ignacio Esperabe de Arteaga del Alamo

José Antonio Martín Esteban

Rubén Fernández Carnicero

Javier Mateos Andaluz

David Gualda Gómez

Luis de Santiago Rodrigo

Noviembre 2006

ROBOTS LEGO MINDSTORMS

0. ÍNDICE 0. ÍNDICE...............................................................................................................................1 1. INTRODUCCIÓN ...................................................................... ............................................................................................................. ....................................... 6 1.1. ¿QUÉ ES LEGO-MINDSTORMS?.....................................................................................6 1.2. ¿POR QUÉ USAR LEGO-MINDSTORMS? ....................................................................... ......................................................................... 6 1.2.1. VENTAJAS: .............................................................................. ..................................................................................................................... .......................................66 1.2.2. DESVENTAJAS ................................................................................................................7

1.3. BREVE HISTORIA DE LEGO:...........................................................................................7 1.4. ¿QUÉ VIENE CON LEGO? .................................................................... ............................................................................................... ........................... 8 2. DESCRIPCIÓN GENERAL...........................................................................................10 2.1. EL RCX:.........................................................................................................................10 2.1.1. DESCRIPCIÓN .......................................................................... ............................................................................................................... .....................................10 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 13 2.1.5. PANTALLA LCD:..........................................................................................................13 2.1.6. PUERTO DE COMUNICACIÓN INFRARROJA....................................................................13 2.1.7. TRANSMISOR DE INFRARROJOS....................................................................................13 2.1.8. ALIMENTACIÓN:...........................................................................................................14

2.2. EL NXT:.........................................................................................................................15 2.3. DIFERENCIAS HARDWARE ENTRE EL NXT Y RCX: .................................................... ....................................................20 20 2.4. BIBLIOGRAFÍA PARA LA PARTE DE DESCRIPCIÓN:......................................................21 3. TRANSDUCTORES Y SENSORES:.............................................................................23 3.1. DEFINICIONES Y CONCEPTOS PREVIOS:.......................................................................23 3.1.1. SENSOR : ....................................................................................................................... .......................................................................................................................23 23 3.1.2. TRANSDUCTOR :............................................................................................................23 :............................................................................................................23 3.1.3. SELECCIÓN DE LOS SENSORES: ........................................................................ .................................................................................... ............ 24

3.2. SENSORES DE LEGO:......................................................................................................24 3.2.1. SENSOR DE TEMPERATURA:.........................................................................................24 Página 1


0. ÍNDICE 0. ÍNDICE...............................................................................................................................1 1. INTRODUCCIÓN ...................................................................... ............................................................................................................. ....................................... 6 1.1. ¿QUÉ ES LEGO-MINDSTORMS?.....................................................................................6 1.2. ¿POR QUÉ USAR LEGO-MINDSTORMS? ....................................................................... ......................................................................... 6 1.2.1. VENTAJAS: .............................................................................. ..................................................................................................................... .......................................66 1.2.2. DESVENTAJAS ................................................................................................................7

1.3. BREVE HISTORIA DE LEGO:...........................................................................................7 1.4. ¿QUÉ VIENE CON LEGO? .................................................................... ............................................................................................... ........................... 8 2. DESCRIPCIÓN GENERAL...........................................................................................10 2.1. EL RCX:.........................................................................................................................10 2.1.1. DESCRIPCIÓN .......................................................................... ............................................................................................................... .....................................10 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 13 2.1.5. PANTALLA LCD:..........................................................................................................13 2.1.6. PUERTO DE COMUNICACIÓN INFRARROJA....................................................................13 2.1.7. TRANSMISOR DE INFRARROJOS....................................................................................13 2.1.8. ALIMENTACIÓN:...........................................................................................................14

2.2. EL NXT:.........................................................................................................................15 2.3. DIFERENCIAS HARDWARE ENTRE EL NXT Y RCX: .................................................... ....................................................20 20 2.4. BIBLIOGRAFÍA PARA LA PARTE DE DESCRIPCIÓN:......................................................21 3. TRANSDUCTORES Y SENSORES:.............................................................................23 3.1. DEFINICIONES Y CONCEPTOS PREVIOS:.......................................................................23 3.1.1. SENSOR : ....................................................................................................................... .......................................................................................................................23 23 3.1.2. TRANSDUCTOR :............................................................................................................23 :............................................................................................................23 3.1.3. SELECCIÓN DE LOS SENSORES: ........................................................................ .................................................................................... ............ 24

3.2. SENSORES DE LEGO:......................................................................................................24 3.2.1. SENSOR DE TEMPERATURA:.........................................................................................24 Página 1


3.2.2. SENSOR DE CONTACTO: ....................................................................... ............................................................................................... ........................ 25 3.2.3. SENSOR DE LUZ:...........................................................................................................25 OTACIÓN:................................................................................................26 3.2.4. SENSOR DE R OTACIÓN

3.2.5. SENSOR ULTRASÓNICO:................................................................................................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. FABRICACIÓN 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 33 3.3.4. CONSTRUCCIÓN DE UN SENSOR DE TEMPERATURA RCX COMPATIBLE:......................39

3.4. FABRICACIÓN DE SENSORES PASIVOS: .........................................................................44 3.4.1. SENSORES DE CONTACTO:............................................................................................44 3.4.2. SENSORES DE LUZ: .................................................................. ....................................................................................................... .....................................46 46 3.4.3. SENSOR DE HUMEDAD:.................................................................................................46 3.4.4. SENSORES DE TEMPERATURA: .....................................................................................47

3.5. FABRICACIÓN DE SENSORES ACTIVOS: ........................................................................48 3.5.1. SENSORES DE LUZ REFLECTANTES:..............................................................................48

3.6. BIBLIOGRAFÍA PARTE DE SENSORES:...........................................................................52 4. MOTORES:......................................................................................................................53 4.1. DESCRIPCIÓN 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 :................................................................................................56 4.2.2. CARACTERÍSTICAS EN VACÍO (SIN CARGA):.................................................................57 4.2.3. CARACTERÍSTICAS EN PARADO:...................................................................................57 4.2.4. CARACTERÍSTICAS EN CARGA:.....................................................................................58

4.3. BIBLIOGRAFÍA DE LA PARTE DE MOTORES:.................................................................62

Página 2


5. TRANSMISIÓN DE MOVIMIENTO Y ESFUERZO:................................................63 5.1. BIBLIOGRAFÍA PARTE TRANSMISIONES:......................................................................68 6. PROGRAMACIÓN.........................................................................................................69 6.1. INTRODUCCIÓN A LA PROGRAMACIÓN PARA LEGO. .................................................69 6.2. RCX-CODE ....................................................................................................................69 6.2.1. I NTRODUCCIÓN: ...........................................................................................................69 6.2.2. COMANDOS ..................................................................................................................73 6.2.3. BLOQUES DE CONTROL DE FLUJO .................................................................................75

6.3. INTRODUCCIÓN 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. BIBLIOGRAFÍA R OBOLAB .............................................................................................86

6.4. LABVIEW .....................................................................................................................86 6.4.1. ¿QUÉ ES LABVIEW?....................................................................................................86 6.4.2. PROGRAMACIÓN GRÁFICA CON LABVIEW ...................................................................87 6.4.3. E NTORNO 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. BIBLIOGRAFÍA LABVIEW..............................................................................................95

6.5. LENGUAJE NQC ............................................................................................................95 6.5.1. I NTRODUCCIÓN 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. I NSTRUCCIONES .........................................................................................................101 6.5.5. SENTENCIAS DE CONTROL..........................................................................................102 6.5.6. FUNCIONES Y SUBRUTINAS ........................................................................................103 6.5.7. TAREAS ......................................................................................................................105

Página 3


6.5.8. SENSORES...................................................................................................................105 6.5.9. SALIDAS .....................................................................................................................108 6.5.10. SONIDOS ...................................................................................................................110 6.5.11. BIBLIOGRAFÍA NQC.................................................................................................111

6.6. SPIRIT.OCX Y VISUAL BASIC: .....................................................................................111 6.6.1. I NTRODUCCIÓN A SPIRIT.OCX ....................................................................................111 6.6.2. PROGRAMACIÓN 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. BIBLIOGRAFÍA SPIRIT.OCX Y VISUALBASIC: .............................................................124

6.7. BRICKOS......................................................................................................................125 6.7.1. CONFIGURANDO E INSTALANDO BRICK OS................................................................125 6.7.2. PROGRAMACIÓN EN BRICK OS...................................................................................126 6.7.3. BIBLIOGRAFÍA BRICK OS ............................................................................................130

6.8. INTERACTIVE C ...........................................................................................................131 6.8.1. BIBLIOGRAFÍA I NTERACTIVE C:.................................................................................131

6.9. LEGOS ..........................................................................................................................132 6.9.1. INTRODUCCIÓN.....................................................................................................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. ¿CÓMO SE PROGRAMA DESDE GNU/LINUX? .............................................................135 6.9.6. HERRAMIENTAS RELACIONADAS CON LEGOS ...........................................................136

6.10. EMULEGOS................................................................................................................136 6.11. WEBLEGOS ................................................................................................................138 6.12. PROGRAMACIÓN EN JAVA PARA LOS LEGO-MINDSTORMS (LEJOS) .....................138 6.12.1. I NTRODUCCIÓN ........................................................................................................138 6.12.2. ¿CÓMO 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. BIBLIOGRAFÍA LEGOS .............................................................................................151

Página 4


7. LEGO MINDSTORMS EN LA ENSEÑANZA ..........................................................153 7.1. TRABAJO CON LEGO MINDSTORMS EN LA ENSEÑANZA............................................153 7.1.1. MÉTODO DE TRABAJO ................................................................................................153 7.1.2. OBJETIVOS: A CONSEGUIR ..........................................................................................155 7.1.3. U N CASO PRÁCTICO: VISITA AL GRUPO COMPLUBOT. ...............................................155 7.1.4. ALGUNAS ESTADÍSTICAS INTERESANTES ...................................................................157

7.2. LEGO MINDSTORMS: VERSIÓN EDUCATIVA VS COMERCIAL ....................................158 7.3. ENTORNOS DE PROGRAMACIÓN POR FRANJAS DE EDADES: EVOLUCIÓN ................158 7.4. LABVIEW VS ROBOLAB EN EL ENTORNO EDUCATIVO ..............................................160 7.5. BIBLIOGRAFÍA EDUCACIÓN. .......................................................................................161 8. COMPETICIONES LEGO ..........................................................................................163 8.1. FIRST LEGO LEAGUE...................................................................................................163 8.2. ROBOCAMPEONES .......................................................................................................165 9. ROBOTS LEGO ............................................................................................................166 9.1. UN EJEMPLO MECÁNICO. ............................................................................................166 9.2. UN EJEMPLO DE PROGRAMACIÓN:.............................................................................170 10. PRECIOS ORIENTATIVOS......................................................................................172

Página 5


1. INTRODUCCIÓN 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 fácil y sencilla de aprender robótica y construir tu propio robot. Lego Mindstorms es una plataforma para el diseño y desarrollo de robots, que sigue la filosofía 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 añadido un “cáscara” de ladrillo con forma de LEGO. La conexión de sensores y actuadores es muy sencilla, por simple presión en cualquiera de las puertas y en cualquier posición. Las piezas de Lego tienen múltiples formas y tamaños, lo que nos permite construir diversas estructuras, usando los bloques como “ladrillos” o “vigas”.Mediante un PC, se realiza la programación del ladrillo, usando diferentes programas y lenguajes.

1.2. ¿Por qué usar LEGO-Mind storms? En este apartado indicaremos las principales ventajas y desventajas de utilizar Lego.

1.2.1. Ventajas: -Fácil de montar y desmontar, no es necesario usar soldadura, ni tornillo. Todo lo que se arma se puede desarmar rápidamente. Además, eso permite usar las piezas en múltiples diseños distintos. -Muy extendido por todo el mundo, lo que permite encontrar gran cantidad de información e ideas por Internet, diseños, soluciones, participar en foros, competiciones. -No es un pack cerrado, es decir, se puede comprar más ampliaciones de lego, adquirir piezas deterioradas o perdidas, o añadir piezas echas manualmente, como por ejemplo, sensores o motores, e incluso circuitos neumáticos. -Múltiples posibilidades y lenguajes de programación, desde el nivel más básico e intuitivo, como el Robolab, uso de lenguajes conocidos como C o Java, utilización de Linux…

Página 6


-Que sea escalable, es decir, que a partir de un material básico haya opciones de ampliación. -Muy indicado para entornos educativos, desde colegios a universidades, pues se puede aprender de forma fácil tanto mecánica como electrónica.

1.2.2. Desventajas -La principal desventaja de LEGO es su estructura. Está formada por bloques de LEGO, que se unen por simple presión. Cierto que se pueden añadir elementos de refuerzo y sujeción, pero para diseños exigentes, no es recomendable. Golpes, caídas, pueden debilitar rápidamente la estructura, llegando a desarmar el robot. -No se pueden construir estructuras circulares, pues todas las piezas y ladridos de LEGO son rectangulares. -Colocación de las baterías. Tanto en el NXT cómo en el RCX de LEGO, se alimentan mediante seis pilas AA R6, que deben ser colocadas dentro del ladrillo. Esto obliga a diseñar el robot con la necesidad de acceder directamente al bloque, para poder cambiar las pilas, limitando la construcción del robot. -Relación masa-volumen. Las piezas LEGO no son útiles en diseños donde la relación masavolumen se hace crítica. Por ejemplo, para construir un robot de SUMO, no sería eficiente, pues la estructura LEGO es demasiado liviana, y se deberían añadir pesos para hacer el robot más robusto, o el caso contrario, para construir robot pequeños, ligeros, y resistentes, las piezas LEGO son mucho peores que los materiales cómo la fibra de carbono. -Precio. Obviamente, comprar un robot “prefabricado”, resulta más caro que construirte tu propio robot.

1.3. Breve historia de LEGO: LEGO, cuyo nombre viene de las palabras en danés "leg godt" ("jugar bien"), y de Mindstorms (tormentas de ideas). Todo empezó en el MIT, dónde se empezaron las investigaciones sobre microcontroladores, que fuesen fácilmente programables, y se conectasen a sensores y actuadores. Allí surgieron los primero ladrillos programables. Fueron especialmente diseñados para niños, jóvenes y estudiantes, para que pudiesen hacer sus primeros “pinitos” en el mundo de la robótica.

Página 7


Inspirados en el ladrillo del MIT(aunque completamente creado por LEGO, la compañía juguetera lanzó en 1998 al mercado el kit “Robotics Invention System 1.0”,un sistema basado un microcomputador denominado RCX. En España deberíamos esperar hasta 1999, con la versión 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 auténtica plataforma de desarrollo y estudio, implantándose en colegios y universidades.

1.4. ¿Qué viene con LEGO? En las dos plataformas de LEGO vienen las siguientes piezas: Sistema de Invención de Robótica 2.0 En él se incluye el RCX™ Microcomputer con su correspondiente CD-ROM de Software, la Contructopedia™ (dónde podrás encontrar múltiples diseños), con tres desafíos guiados y seis desafíos pro. Además incluye el transmisor infrarrojo, y 718 piezas, entre las que se incluyen dos motores, dos sensores táctiles y un sensor luminoso

Página 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 ultrasónico, un sensor de tacto mejorado, y un preciso sensor de luz. El kit incorpora 519 piezas de LEGO TECHNIC. Además incorpora 4 puertos (input), 3 puertos (output), altavoces, las tecnologías USB 2.0 y Bluetooth junto con un software de programación compatible con PC y Mac.

Página 9


2. DESCRIPCIÓN GENERAL La parte mas importante de este tipo de robots es el elemento de control, según el modelo se le conoce por RCX o NXT.

2.1. El RCX:

2.1.1. Descripción 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 núcleo 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 alimentación, 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 alimentación durante mas de un minuto se perderán sus datos y habrá que volver a cargarlos desde el PC. Tiene dos temporizadores de 8 bits y uno de 16 bit, un conversor analógico/digital de 8 bit y un altavoz integrado, capaz de emitir sonidos sencillos (Beep).

Página 10


En las siguientes fotografías 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 alimentación utilizan el siguiente hardware.

Página 11


Si los sensores son activos, necesitan alimentación, 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 lámparas). Cada puerto puede estar en tres estados: on, off y floating. Cada salida tiene solo dos hilos por ello solo tienen una dirección asociada, forward (hacia adelante) y reverse (hacia atrás) y utilizan una modulación por ancho de pulso (PWM). Los pulsos se envían 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).

Página 12


2.1.4. Boto nes de control:

Son 4 los botones de control. El botón rojo (On-OFF) enciende y apaga el RCX. Los demos solo funcionan cuando el ladrillo controlador esta encendido. El botón verde (RUN) inicia y detiene el programa seleccionado. En este modo el “personaje” de la ventana de visualización aparece andando. El botón gris (PRGM) permite cambiar entre los 5 programas integrados del RCX. El número de programa seleccionado aparece a la izquierda del “personaje” en la ventana de visualización. El botón negro (VIEW) sólo está activo después de descargar el firmware y permite obtener información de los sensores y motores. Se pueden ver las lecturas de sensor en los puertos de entrada 1,2 o 3 y la dirección 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 comunicación infrarroj a.

A través de el puede comunicarse con el PC o con otros RCX.

2.1.7. Transmisor de infrarrojos.

Página 13


Sirve para establecer un vínculo inalámbrico 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 comunicación el RCX y el transmisor infrarrojos deben “verse” el uno al otro con una separación de entre 10m y 15 m aunque en condiciones de iluminación optimas pueden separarse hasta 30 m.

2.1.8. Alimentación:

La alimentación del RCX se lleva a cabo mediante seis pilas de tipo AA/LR6. Se recomienda utilizar alcalinas aunque también se pueden utilizar recargables pero su potencia será menor.

Curiosidades: Al tener esta forma de ladrillo Lego, permite la construcción muy rápida de robots con piezas de tipo ladrillo Lego y de otros tipos.

La primera vez que se enciende el RCX o después de cambiar las baterías tardando más de 1 min., el RCX se encuentra en “Modo de arranque”. En la pantalla de visualización no aparece el reloj.

Página 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 comunicación 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 volátil), 64 kB de RAM (volátil) y una velocidad de funcionamiento de 48 MHz. (Ver hojas características para conocerlo con mayor profundidad).

Tiene cuatro botones en la parte superior para utilizar los programas que tengamos instalados, configurarlos y ejecutarlos. También podemos visualizar en la pantalla el estado de los sensores o crear pequeños programas sin necesidad de utilizar el ordenador y programas adicionales. El botón de color naranja tiene como funciones el encendido (ON), la confirmación de acciones (Enter) y el comenzar (Start). Las flechas de color gris son para moverse por los menús y el rectángulo gris oscuro es para limpiar la pantalla (Clear) y volver atrás (Go back).

Página 15


Mediante una pantalla gráfica de LCD de 1000 x 64 píxel blancos y negros, con un área de visión 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 también incluye un altavoz con un sistema de sonido de 8 bits de resolución, 8 Khz. de calidad de sonido y que soporta una frecuencia de muestreo entre 2 y 16 kHz. La señal de salida es una señal PWM controlada por el microprocesador ARM7. Se filtra, pasa por un amplificador diferencial (SPY0030A de SunPlus) de ganancia máxima igual a 20 y sale al exterior por un altavoz de impedancia característica de 16

Ω y

un diámetro de

21 mm. A continuación se muestra su esquemático:

Para interactuar con el exterior, esta compuesto por 8 puertos de entrada/salida que se unen mediante conectores muy similares a los de tipo telefónico. Tienen 6 hilos pero tienen la ranura a la derecha en vez de en el medio como el del teléfono. (Para convertir un cable telefónico

al

uno

valido

para

el

NXT

http://philohome.com/nxtplug/nxtplug.htm)

Página 16

visitar

el

siguiente

enlace:


Los puertos de salida son el A, el B y el C y son para los motores. El siguiente esquemático muestra en detalle un puerto de salida.

MA0 y MA1 son señales 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 señales 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 esquemático de un puerto de entrada.

El pin 1, ANA es un pin analógico conectado a un convertidor analógico/digital del procesador AVR y también 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 comunicación 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 comunicación bidireccional de alta velocidad.

Página 17


También 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 gestión 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 alimentación, la creación de las señales de salida PWM para los motores y la conversión A/D de las señales de entrada de los sensores. Se conecta con el microprocesador ARM7 a través de un bus I2C. A causa de las limitaciones del ARM7, esto solo funciona como maestro en la comunicación por el I2C.

Para la gestión 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 comunicación inalámbrica. Se conecta al ARM7 a través de un modulo SPI (Interfaz serie sincronía) y un modulo UART (Transmisor-Receptor Asíncrono 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 alimentación podemos utilizar 6 pilas AA o una batería recargable de litio, que se conecta en la parte inferior del modulo NXT.

Página 18


A continuación se muestra un dibujo donde se representan los componentes del controlador y su interconexión con otros componentes:

Página 19


2.3. Diferenci as hardware entre el NXT y RCX: RCX

NXT

Nº puertos salida

3

3

Nº puertos de entrada

3

4

Sistema

de

batería NO

SI

recargable 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

Números

Texto, imágenes, números

Nº de programas cargados

5

Infinitos

Programación sobre el brick

NO

SI

Usa nuevos y viejos sensores NO

SI

Unión con el ordenador por

NO

SI

NO

SI

Comunicación

múltiple

de

bricks

cable rápido Gráficos 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 conexión se facilita gracias al siguiente cable de conexión.

Cuya función es unir el PIN1 y el PIN2 con los hilos del conector antiguo.

Página 20


Diferencias generales entre RCX y NXT:

2.4. Bibl iogr afía para la parte de descrip ción : http://mindstorms.lego.com/ : sobre el NXT, hay PDF con toda la descripción hardware (lego X’treme).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 niños de alcala

Página 21


Archivos en PDF de la universidad politecnica de Cataluña 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 educación robots http://legolab.daimi.au.dk/ robots lego para investigación 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/

Página 22


3. Transductores y Sensores: 3.1. Defin icio nes y con ceptos previo s:

3.1.1. Sensor: Dispositivo sensible que utiliza un fenómeno físico o químico dependiente de la naturaleza y el valor de la magnitud físico química a medir, lo cual permite la transducción del estímulo a una señal 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 señal y permitir que continúe un proceso.

3.1.2. Transductor: Un transductor es un dispositivo que transforma un tipo de variable física (por ejemplo, fuerza, presión, temperatura, velocidad, etc.) en otro. Un sensor es un transductor que se utiliza para medir una variable física de interés. Algunos de los sensores y transductores utilizados con más frecuencia son los calibradores de tensión (utilizados para medir la fuerza y la presión), los termopares (temperaturas), los velocímetros (velocidad). Cualquier sensor o transductor necesita estar calibrado para ser útil como dispositivo de medida. La calibración es el procedimiento mediante el cual se establece la relación entre la variable medida y la señal de salida convertida. Los transductores y los sensores pueden clasificarse en dos tipos básicos, dependiendo de la forma de la señal convertida. Los dos tipos son: Transductores analógicos: Proporcionan una señal analógica continua, por ejemplo voltaje o corriente eléctrica. Esta señal puede ser tomada como el valor de la variable física que se mide. Transductores digitales: Producen una señal 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 señales digitales representan el valor de la variable medida.

Los

transductores digitales suelen ofrecer la ventaja de ser más compatibles con las computadoras digitales que los sensores analógicos en la automatización y en el control de procesos.

Página 23


3.1.3. Selección de los Sensores: La selección se basa en la decisión sobre cual es el sensor más adecuado. Esto depende del material del objeto el cual debe detectarse. Si el objeto es metálico, se requiere un sensor inductivo. Si el objeto es de plástico, papel, o si es líquido (basado en aceite o agua), granu1ado o en polvo, se requiere un sensor capacitivo. Si el objeto puede llevar un imán, es apropiado un sensor magnético.

Sensores activos y pasivos: Los sensores pasivos, no necesitan alimentación para funcionar. Los sensores activos, por otra parte, son los que necesitan su propia alimentación. Una manera fácil de distinguir los sensores activos de los pasivos es contar el número de pines que tienen. Lo sensores activos tienen un tercer pin extra para obtener la alimentación, mientras que los sensores pasivos sólo tiene dos.

Conector para sensores pasivos. Conector para sensores activos.

Los sensores activos son más complejos, pero abren una amplia gama de posibilidades de detección. 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 magnéticos], los sensores de ruido, los sensores de vibración, 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 interacción de un termistor en uno de los extremos, generando un campo magnético que permite la detección 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 corrección aproximado de un -3,7%/ºC

Página 24


La fórmula 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 algún objeto que se encuentre en su trayectoria inmediata. Al tocar una superficie, una pequeña cabeza externa se contrae, permitiendo que una pieza dentro del bloque cierre un circuito eléctrico comience a circular energía, provocando una variación de energía de 0 a 5 V. En este caso, si la presión supera una medida estándar de 450, mostrado en la pantalla de LCD, se considera que el sensor está presionado, sino está sin presión. Este Sensor se puede utilizar para determinar cuando un Robot toca algo con el fin de que tome la decisión de regresar o cambiar de dirección. (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 eléctrico y por el otro una cámara oscura que capta las luces. Esta cámara 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 lógico, obteniendo un porcentaje aproximado de luminosidad. El bloque RCX calcula con la fórmula Luz = 146 − RAW / 7 para determinar el porcentaje obtenido por la lectura de la luz, tomando una muestra cada 2,9 ms, siendo leído en 100 us. , el valor que se lee a partir del sensor.

Página 25


Debido a que este sensor capta grados de luminosidad, no es capaz de distinguir colores, sólo 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 Rotación: El sensor de rotación permite conocer la posición del robot en cualquier instante. Para conocer la posición del robot, el sensor produce una variación de energía 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 energía: 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 energía 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 minúsculas variaciones de energía, debido a que los valores intermedios no son considerados como movimiento válido. Lee 16 posiciones de rotación con un máximo de 500 revoluciones por minuto (RPM). El RCX puede leer tanto ángulos de rotación como dieciseisavas partes de un giro completo. (ref. W979891).

3.2.5. Sensor ultrasónico: El sensor Ultrasónico sólo se incluye en el empaque de Lego Mindstorms NXT, y su principal función detectar las distancias y el movimiento de un objeto que se interponga en el camino

Página 26


del robot, mediante el principio de la detección ultrasónica. Este sensor es capaz de detectar desde 0 a 255 cms, con una precisión relativa del +/- 3 cms.

Mediante el principio del eco, el sensor es capaz de recibir la información de los distintos objetos que se encuentren en el campo de detección, 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 múltiples de este sensor, ya que se puede detener la ejecución y/o lectura de los distintos elementos. El sensor estará configurado por defecto para medir la distancia a un objeto, pero también puede ser capaz de medir las distancias hasta un máximo 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 estímulo como lo es el sonido. Las características del sensor permitirán 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 simultáneo. El sensor de sonido también 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 también es capaz de discriminar tonos.

Página 27


3.2.7. Sensor de Color HiTechnic Compatible con NXT : El sensor de color compatible con NXT está diseñado para detectar con precisión el color de un objeto, el sensor de color es perfecto para construir un organizador de ladrillos o cualquier otro diseño que requiera detección 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 dispersión en el espectro de emisión 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 leído es el Blanco. La siguiente tabla muestra las lecturas que devolverán algunos colores: Color

Rojo Verde Azul

Negro

0

0

0

Blanco

255

255

255

Rojo

255

0

0

Verde

0

255

0

Azul

0

0

255

Amarillo

255

255

0

El sensor actualiza las lecturas a razón de 100 muestras por segundo. Las características del modo de control del sensor de color permiten dos tipos de calibración a efectuar por el programa del NXT. La calibración por nivel de negro puede utilizarse para eliminar reflejos no deseados provenientes de la estructura en la que el sensor está colocado. La calibración 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 medición. Si el modo de control se establece en 1, el sensor operará en modo calibración de balance de blancos y esperará ser dirigido a una superficie blanca difusa a una distancia de unos 15 mm. Cuando la función

Página 28


calibración finaliza, los led destellarán y el modo de funcionamiento pasará automáticamente a 0, modo normal de medida. El proceso calibración dura alrededor de ¼ segundo. El valor de calibración se almacena en memoria no-volátil y será recuperado cada vez que se aplica tensión al sensor. Si el modo de control se establece en 2, el sensor operará en modo calibración de nivel de negro y esperará ser situado en espacio vacío sin objetos en un cono de 90º en una distancia de al menos 0.5m. La función calibración nivel de negro mide la señal de cada color y crea un desplazamiento (offset) para anular el nivel de luz ambiente en futuras mediciones. Cuando la función calibración finaliza, los led destellará y el modo de funcionamiento pasará automáticamente a 0, modo normal de medida. El proceso calibración dura alrededor de 1 segundo. Esta función puede ser utilizada para contrarrestar señales devueltas por partes de la estructura circundante. El valor de calibración se almacena en memoria no-volátil y será recuperado cada vez que se aplica tensión al sensor.

3.2.8. Sensores de presencia: Están 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 revolución. El sentido de la rotación no se puede determinar monitorizando la señal del fototransistor, pero esto es irrelevante si la rueda se halla conectada al motor, cuyo sentido de giro es conocido.

Página 29


3.3.

Fabri cación de sensor es para Lego:

3.3.1. Sensor de luz: Introducción: Probablemente tendrás en el aula uno o más sensores de luz Lego, pero si necesitas alguno más lo puedes hacer de un modo muy sencillo. Además te saldrá mucho más económico que el comercial. En cuanto al material, el único elemento electrónico que necesitas es un LDR. Lo puedes comprar en cualquier comercio de electrónica, en la figura puedes ver el LDR y las dos piezas de Lego necesarias (el LDR de la figura tiene la r eferencia 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 más 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 estándar Lego. Programa: El sensor que hemos montado a pesar de ser un sensor de luz es un sensor pasivo, es decir, no requiere alimentación. En consecuencia, en lugar de configurarlo como sensor de luz lo haremos como sensor de contacto en modo RAW (también es posible configurarlo en modo porcentual, pero siempre la precisión será mayor en modo RAW). Notas: Existe otro componente electrónico de semejante comportamiento al LDR, cuya resistencia varía 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 añadir potencia al conjunto de Lego, ya que aunque tiene un buen con junto de sensores, nos faltaría uno para medir distancias y que fuera barato. Lo que conseguimos adaptando este pequeño sensor.

Página 30


Estos dispositivos infrarrojos pequeños pueden medir distancia entre 10 y 80 centímetros con buena precisión y bastante inmunes a las variaciones producidas por la reflectividad de los obstáculos y de la luz ambiente. Para poder conectar el sensor con salida análoga GP2D12 usando un diseño lo más simple posible y utilizando solo la energía que viene de la entrada del sensor. ¡Esto supone un verdadero desafío 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 energía en un condensador mientras que el GP2D12 no se acciona, una vez cargado utilizaremos la carga para obtener una medida. Por supuesto hay un pequeño problema con esta técnica: 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 pequeño sensor, entonces se carga C1 con D1 hasta alcanzar el valor necesario para obtener una medición. El regulador U1 de la entrada genera una tensión regulada de +5V. Q1 es cortado por D2 (D2 mantiene la base a una tensión más alta o igual a su tensión del emisor), así que GP2D12 no se acciona.Q3 también 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 tensión de +5V con 10KΩ (interior RCX), que existe a su entrada

resulta

escasa para bloquear Q1. Q1 y Q3 entonces entran en conducción 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. Código de la muestra para leer el sensor :

Página 31


Set Sensor

( SENSOR_ 1,

SENSOR_LI GHT) ;

Esper a

( 25) ;

Set Sensor

( SENSOR_ 1,

SENSOR_TOUCH) ;

Esper a

( 5) ;

Set Sens or Mode

( SENSOR_1,

di st anci a Car ga

SENSOR_MODE_ RAW) ;

= de

SENSOR_ 1;

/ / Enabl e

C1

cuant o

ant es

Set Sensor ( SENSOR_ 1, SENSOR_ LI GHT) ;

Lista De Componentes: D1 evita que se destruya el sensor en caso de la conexión inversa. No utilizar el rectificador usado en el sensor de Lego que permite a los sensores trabajar cuando está conectado al revés (el número de diodos necesarios salta a partir del 3 al 8). Utilizamos el diodo 1N5819 de 1 amperio Shottky para D1, que es barato y fácilmente disponible. Con un pequeño voltaje a la entrada, en este caso menos de 0.1V para la corriente que lo atraviesa, éste permite cargar C1 con el voltaje más alto posible. C1 almacena la energía que será utilizada durante fase de medida. Debe proporcionar +5V en el extremo de esta etapa. Los valores típicos asumidos para el GP2D12 (I=35mA, conversión time=50ms) y un +7.5V inicial a través de C1, su valor son C = I * despegue/dV = 35 * 50/(7.5-5) = el µF 700. Margen pequeño con el µF 1000… Para U1 utilizamos un Telcom TC55RP5000 aunque también podemos utilizar otros reguladores como STMicroelectronics L4931-50. Los reguladores estándares tales como el 78L05 no nos sirven porque requieren más 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 rápido aumento de intensidad. El C2 estabiliza U1 y permite absorber los picos de corriente. Lo mejor seria una versión barata del ESR. Construcción del módulo de interfaz del sensor

El módulo de interfaz. Vista superior

Página 32


Vista superior, con la identificación de los

Viste inferior. Un circuito impreso de una capa es fácil de dibujar.

componentes

Todo introducido dentro de las piezas

Para el montaje se usan 3 ladrillos huecos 4x2

Terminar el módulo.

Listo para ser usado

Distancia contra la lectura del sensor

Curva linealizada: 1000/(distance-2) contra la lectura del sensor + línea lo más mejor posible cabida

3.3.3. Sensor de color: Construcción: Las piezas necesitadas para construir el circuito están muy comunes y disponibles de la mayoría de los surtidores electrónicos. Los lectores al corriente de mi libro extremo de Mindstorms deben reconocer el método de la construcción ilustrado en los cuadros 3 y 4. Primero construyes y pruebas el circuito en un tablero para cortar el pan Página 33


electrónico y en seguida transfieres las piezas al tablero de PC relacionado del prototipo. Aunque el método trabaja bien, los resultados adentro no son muy compactos y hay una ocasión de los errores del cableado. Por esta razón, he preparado un tipo pequeño tablero del por-agujero de PC para hacer el edificio y la cubierta el circuito más fácil.

El cuadro 5 demuestra el tablero de PC poblado con tres fotocélulas de los CDes para los sensores. Las fotocélulas particulares usadas (Mouser #338-54C348) son bastante pequeñas caber en la poca área ahuecada alrededor de los agujeros en vigas de la técnica de Lego. Los pedazos cortos de tubería aislada resbalaron sobre el plomo infundado de las fotocélulas evitan el poner en cortocircuito durante la operación. Las tres fotocélulas se deben alimentar a través de la viga antes de soldar al tablero de PC. Una caja del caramelo de Tictac® proporciona un recinto simple para el proyecto terminado según las indicaciones del cuadro 6. La conexión al RCX es hecha cortando un alambre del motor de Lego #5111 9V por la mitad.

Alternativamente, el tablero de PC es bastante pequeño para que el proyecto sea contenido en una caja de la batería de #5391 Lego 9V. Esto es un recinto práctico con un conectador construido a la derecha en la tapa. Es más fácil 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 batería 9V habría unido pares el circuito al conectador de Lego en la tapa de la caja.

Página 34


Sensor de color : La detección del color depende de medir la intensidad de la luz en diversas longitudes de onda. Un espectrómetro hace esto partiendo la luz con un prisma o una rejilla de difracción en sus longitudes de onda componentes. Sin embargo, los espectrómetros son complejos y demasiado difíciles 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 número 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 círculo. En el caso de tonalidad: 0 es rojo, 120 es verde, 240 es azules y 360 está detrás alrededor al rojo otra vez. Los colores intermedios tienen tonalidades como 60 para el amarillo, 180 para ciánico y 300 para la magenta. El cálculo de la tonalidad de valores rojos, verdes y azules es un algoritmo simple descrito más adelante. Mi primer acercamiento era utilizar las lentes coloreadas del LED para los filtros. Puedes verlos en el cuadro 3. Resultaron ser demasiado pálidos 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 técnica para formar los filtros para los sensores de los CDes demostrados en el cuadro 6. Después de la experimentación substancial, encontré que las placas azules y verdes eran demasiado pálidas 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 fotografía que brilla a través de ellos con una rejilla de difracción según las indicaciones del cuadro 8.

La sensibilidad espectral de la fotocélula es otro factor importante en la determinación de la exactitud de la medida de color. No todas las fotocélulas de los CDes son semejantes en este respeto. El mejor tipo para la discriminación de color se llama Type 5. Tiene sensibilidad máxima aproximadamente 560nm en la parte verde del espectro. La mayoría de los otros tipos de la fotocélula tienden para ser sensibles demasiado rojo o aún infrarrojo. He experimentado con las fotocélulas de varias fuentes y encontré el Mouser #338-54C348 tengo la mejor respuesta espectral tan bien como la geometría deseable para montar mencionada previamente. Página 35


Descrip ción 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 colorímetro simple continuamente exhibiendo la tonalidad en su LCD. Usar el sensor para construir un compaginador robótico del ladrillo de Lego sería un uso más útil del sensor.

Programa de la demostración del sensor del color de // // de Michael Gasperi Sensor del COLOR SENSOR_1 //color del #def i Espera del #def i

ne en el puerto 1 del sensor

ne SHORT_WAI T 2 //short para que valor se estabilice

t onal i dad interna;

//hue como global

cañer í a de l a tarea ( ) { r interno , g, b, máxi mo, mi nut o, d, r d, gd, bd, h;

//declare el resto de

las variables

SetUserDi spl ay ( t onal i dad, 0) ;

exhibición de //set para demostrar

valor de la tonalidad

Set Sensor ( COLOR, SENSOR_LI GHT) ;

//power en el sensor haciéndote el tipo

de la luz mientras que //loop

( verdadero ) por siempre

{ ¡mientras que

( COLOR! de = el canal 0 del mux 100) //only leerá 100

{ Set Sensor ( COLOR, SENSOR_TOUCH) ; //power del sensor haciendo tacto Set Sensor ( COLOR, SENSOR_LI GHT) ;

energía

de

//reapply

de

accionar

la

palanca del canal

Esper a ( SHORT_WAI T) ; Pl aySound ( SOUND_LOW_BEEP) ;

//wait para que lectura se estabilice sonido de //alarm

} Set Sensor ( COLOR, SENSOR_TOUCH) ;

energía de //toggle de cambiar al canal 1

Set Sensor ( COLOR, SENSOR_LI GHT) ; Esper a ( SHORT_WAI T) ; r = COLOR*100; Set Sensor ( COLOR, SENSOR_TOUCH) ;

//read el rojo y la escala por 100 energía de //toggle de cambiar al canal 2

Página 36

ROBOTS LEGO MINDSTORMS Set Sensor ( COLOR, SENSOR_LI GHT) ; Esper a ( SHORT_WAI T) ; g = COLOR*100;

//read el verde y la escala por 100

Set Sensor ( COLOR, SENSOR_TOUCH) ;


Set Sensor ( COLOR, SENSOR_LI GHT) ; Esper a ( SHORT_WAI T) ; b = COLOR*100;

//read la escala de color azul por 100

Set Sensor ( COLOR, SENSOR_TOUCH) ;


Set Sensor ( COLOR, SENSOR_LI GHT) ; si ( r >g)

{máxi mo = r ; }{máxi mo = g; } //find el color con intensidad máxima

si ( b>max) si

{max=b; }

( r
si ( b
{mi n=b; }

d = ( ( máxi mo- mi nut o) / 60) ;

//diff del máximo y los minutos

también escalan

r d = ( máxi mo - r ) / d;

intensidad del color de //normalize

gd = ( máxi mo - g) / d; bd = ( máxi mo - b) / d; si

( b==max) {h = 240 + gd - r d; }

tonalidad de //compute basada en color

máximo si

( g==max) {h = 120 + r d - bd; }

si

( r ==max) {h = bd - gd; }

si

( h<0)

{h = h + 360; }

la

tonalidad

de

//if

es

negativa

agrega 360

t onal i dad = h; } }

Después de que sea variable la declaración y la inicialización allí sea “mientras que color no igual” un lazo a 100. Este lazo maneja la sincronización 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 energía 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 señala que está ocurriendo la sincronización. Después la primera vez a través, el programa

Página 37


no debe necesitar entrar este lazo otra vez. Si el RCX guarda el hacer del sonido del zumbido para más que algunos segundos, hay algo mal con el multiplexor. El programa siguiente camina palanca la energía y leyó los valores rojos, verdes y azules. Porque el RCX tiene solamente matemáticas del número entero, los valores necesitan ser escalados para arriba por 100 para una aritmética más última. En número entero la matemáticas 1 se dividió por 4 resultados en 0 no 0.25 puesto que no hay particiones fraccionarias. Escalando el denominador por ciento ante la división, el resultado se convierte en 25. Una palanca adicional de la energía después del azul de la lectura fija el multiplexor para comenzar el proceso encima otra vez. El cálculo de la tonalidad requiere primero la determinación de qué color tenía el máximo y de cuál tenía valor mínimo. Después de ese, la diferencia entre el máximo y el mínimo se calcula. Entonces el dividirse por la diferencia normaliza las intensidades del color. Necesitarías ordinariamente ser referido sobre el acontecimiento inverosímil que la diferencia igualó cero, pero el RCX hace el resultado de la división por cero simplemente cero. Se computa la tonalidad usando el color con el valor máximo. 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 transmisión fueron obtenidos brillando la luz fluorescente del amplio-espectro a través de los filtros transparentes fabricados por Rosco Laboratorio Ltd. y disponible de Edmund científico como número de catálogo 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 emisión fueron tomados sosteniendo el sensor contra una ventana del color sólido en la pantalla de un monitor de la computadora. Un programa básico 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 patrón de prueba en un profesional Photoguide de Kodak.

Parece la medida de la tonalidad es exacto dentro de más o menos 60. Eso significa por ejemplo, puede ser que no puedas discriminar entre verde y ciánico, pero puedes decir ciertamente verde del azul. El color y el tipo de fuente de luz tienen un efecto significativo en la exactitud también. 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.

Página 38


3.3.4. Construcción de un senso r 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 25°C. Pero, Este valor no es fácilmente disponible, y el sensor se construye probablemente usando una serie de 10K Ω NTC montada con un resistor fijo 2K2Ω. Después de agregar a ellos un resistor de la serie 2K2K Ω, compare la temperatura exhibida por RCX con la temperatura real (medida con un termómetro).

Si el margen de error es aproximado a 1°C lo consideraremos como bueno (el RCX mide temperaturas de -20°C a 70°C solamente).

Comparativa del RCX y temperatura real

Construccion del sensor:

Página 39


Material necesario: ladrillo 2x4 placa 2x4 cable eléctrico del 1/2 LEGO resistor de 10KOhm NTC, utilicé a Murata más pequeño uno resistor 2.2KOhm 2 pedazos del tubo de cobre amarillo del diámetro 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 eléctrico fino, soldadura, multa calor-contrae el tubo para aislar los alambres rápido-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 milímetro 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, aíslan las soldaduras con el tubo fino del encogimiento del calor.

Página 40


Insertar la punta de prueba en el tubo.

Sellar el tubo y fijar el NTC con una gota de rápido-curan el pegamento de epoxy.

Usar el cortador que molía montó en el taladro de la energía con el soporte, quita dos de tres tubos internos del ladrillo 2x4. Perforar un agujero de 4 milímetros a través 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, después cable eléctrico 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 múltiples con una sola entrada una a la vez. La mayoría de las computadoras emplean un multiplexor en su hardware a digital de la conversión análoga al espacio y al dinero de ahorro. De hecho, el RCX tiene un multiplexor,

Página 41


pero solamente tres entradas están disponibles para el usuario. El RCX utiliza uno de los otros canales internamente para leer su propio voltaje de la batería. El diseño de un multiplexor para el RCX es difícil. Algunos esquemas obvios utilizan salidas del motor con los relees para seleccionar los sensores múltiples. Sin embargo, porque el RCX tiene solamente tres salidas, estos métodos 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 diseñar un multiplexor aceptable que necesitas entender cómo 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 están accionados los tipos incluyen los sensores de la luz y de la rotación. En el modo pasivo, el RCX mide un voltaje en la entrada. Para hacer lectura los sensores o los interruptores resistentes más fáciles, 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 después lee la entrada apenas como un tipo pasivo durante un período corto 0.1ms. Rápidamente accionando la palanca de una entrada del modo accionado a la voz pasiva y a la parte posterior un circuito del multiplexor podría detectar que el programa de RCX deseó cambiar a otro sensor. La selección de si una entrada está en pasivo o el modo accionado se puede cambiar en marcha dentro de lenguajes de programación como no absolutamente C o básico visual. Desafortunadamente, la lengua de la escritura del P-ladrillo del código de RCX y de Lego no permite esta flexibilidad. La limitación del tipo de sensores multiplexados a la voz pasiva alcanza una gran simplificación en el diseño del multiplexor. Significa que solamente las señales del sensor están cambiadas y no la energía de funcionarlos. La detección ligera pasiva con las fotocélulas del sulfuro de cadmio (CDes) trabaja sobre así como el sensor ligero de Lego de todos modos. Descripción del circuito: El cuadro 1 es el diagrama esquemático 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 fotocélulas, termistores, y potenciómetros. Los interruptores pueden también ser utilizados puesto que son apenas ejemplos extremos de sensores resistentes.

Página 42


Los diodos D1 a través de D4 y del condensador C2 forman la fuente de alimentación. El arreglo de onda completa del puente permite que el accesorio del conectador de energía al RCX esté en cualquier orientación. Te cercioras de observar la polaridad del C2. Los circuitos integrados U1 y U2 del Cmos tienen sus conexiones de la fuente de alimentación demostradas en tablas al lado de VCC y de la tierra. VCC debe medir por lo menos 6V durante la operación normal con las buenas baterías. 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 más 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 análogos usados para conectar un sensor con el RCX a la vez. U1A proporciona la regeneración al RCX para la sincronización. Si no, no podrías decir qué sensor fue conectado. El interruptor análogo U1A se cierra cuando U2 cuenta cero y éste conecta el RCX a través del diodo D5 o D6 y R1 con la tierra. La lectura creada en el RCX bajo esta condición es siempre 100. Los tres sensores conectan con R2, que es clasificó de modo que su lectura máxima 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 revés 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.

Página 43


3.4. Fabric ación de sensor es pasivos : Como curiosidad mostramos como se pueden fabricar otro tipo de sensores de forma barata y a la vez sencilla. Aquí te enseñamos como fabricar tres sensores pasivos: de contacto, de luz, y de temperatura. Todos los sensores pasivos necesitan sólo dos pines (sensor y tierra, como se muestra arriba).

3.4.1. Sensores de contacto: Los sensores de contacto son algunos de los más simples, pero son sin embargo los más ú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 continuación les presentamos algunos ejemplos de sensores de contacto. Papel y papel de aluminio: Es probablemente la manera más fácil 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 láminas. Después conectamos un conductor a cada hoja. Podemos, por supuesto, sustituir la lámina 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 más sólidos que el papel, por lo cual, al usarlos con una lámina de aluminio podemos fabricar sensores de contacto mucho más rígidos. La foto siguiente muestra un ejemplo.

Página 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 lámina 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 láminas entren en contacto al tocarlas.

Interruptores comerciales: También se puede comprar interruptores en las tiendas de productos electrónicos y ponerlos. Estos interruptores son de diferentes formas y tamaños. Los más comunes son los interruptores de palanca y los botones.

Página 45


3.4.2. Sensor es de luz: El sensor de luz más común es conocido como LDR (Light Dependant Resistor) (Resistencia dependiente de la luz). También se le conoce como "Célula fotoeléctrica" Un LDR es básicamente una resistencia, que cambia su resistencia cuando cambia la intensidad de la luz. Se ven a menudo en los sistemas automáticos de iluminación. 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 más electricidad. Así, las lecturas del sensor que obtendremos se modificarán 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 también para hacer una escayola a un paciente.

Página 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 alimentación extra para funcionar.

Página 47


3.5. 3.5.

Fabri Fabri cación de sensor es activo s:

A continuación continuación les presentamos presentamos algunos algunos ejemplos de de sensores activos activos útiles.

3.5. 3.5.1. 1. Senso Sensores res de luz l uz reflectantes: r eflectantes: Este tipo de sensor es útil cuando deseamos detectar detectar la presencia de objetos sin tocarlos. Por ejemplo, desea detectar cuando alguien camina a través 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 láser como fuente luminosa, su detección tendrá más alcance y sus lecturas serán 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 pequeña. Sin embargo, si un objeto bloquea la luz, ella reflejará más 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 alineación cuando cambiamos la dirección 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 detección es limitado (menos de 1 pulgada). Puede haber también muchas interferencias de fuentes luminosas externas.

Página 48


A continuación continuación mostramos un esquema de cómo fabricar este sensor. La resistencia se coloca para limitar la corriente que pasa a través del LED. Cuanto más pequeño es el valor de la resistencia más más brillante será el LED. LED.

Uso de luz infrarroja (IR): Puede conseguirse una mejor versión 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). 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 más sensible a la luz IR que un LDR. A continuación mostramos un esquema de cómo fabricar este sensor.

Página 49


Sensores Sensores reflectantes comerciales: También puede comprar los sensores reflectantes IR. Generalmente vienen en un tamaño compacto y las lecturas de los sensores son más fiables. Éste es un ejemplo de como preparar un sensor reflectante IR comercial (como el QRD1114ND).

Sensor Sensor de efecto Hall (campo magnético): 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 más fiables. Sin embargo, necesita tener un imán, mientras que la luz se encuentra en todas partes. Éste es un ejemplo de cómo montar un sensor de efecto Hall (de digikey.com, número de pieza DN6848-ND)

Página 50


Cálculo de las lecturas del sensor: Para aquéllos que se interesen por los detalles técnicos más 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 cómo se coloca la resistencia de referencia. El microcontrolador mide la caída de tensión a través del sensor, la cual puede calcularse mediante la siguiente ecuación. V = 5 x ( Rs / (33K + Rs)) Donde Rs = Resistencia del sensor

Sabemos que si la tensión cae de 5v obtenemos una lectura de 1023. Podemos usar la misma ecuación 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

Página 51


3.6. Bibl iogr afía parte de sensor es: 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

Página 52


4. Motores: 4.1. Descripción general

4.1.1. Motores ¿Para que? En numerosas ocasiones es necesario convertir la energía eléctrica en energía mecánica, esto se puede lograr, por ejemplo, usando los motores de corriente continua. Los usos más habituales pueden ser, Tracción y dirección. Orientación de sistemas sensoriales.

4.1.2. Principio de funcionamiento Los motores eléctricos, en general, basan su funcionamiento en las fuerzas ejercidas por un campo electromagnético y creadas al hacer circular una corriente eléctrica a través de una o varias bobinas. Si dicha bobina, generalmente circular y denominada estator, se mantiene en una posición mecánica fija y en su interior, bajo la influencia del campo electromagnético, se coloca otra bobina, llamada rotor, recorrida por una corriente y capaz de girar sobre su eje, esta última tenderá a buscas la posición de equilibrio magnético, es decir, orientará sus polos NORTE-SUR hacia los polos SUR-NORTE del estator, respectivamente. Cuando el rotor alcanza esta posición de equilibrio, el estator cambia la orientación de sus polos, aquel tratará de buscar la nueva posición de equilibrio; manteniendo dicha situación de manera continuada, se conseguirá un movimiento giratorio y continuo del rotor y a la vez la transformación de una energía eléctrica en otra mecánica en forma de movimiento circular.

4.1.3. Motor de Corriente Continua Tipos y funcionamiento. Servomotores. Motor que funciona con corriente eléctrica continúa. El campo magnético se crea en el inducido (rotor) y en el inductor (estator). Necesitan un colector en el rotor y escobillas para su alimentación eléctrica. Este tipo de motor fue el primero que se utilizó en la tracción de los vehículos eléctricos 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 tamaño llega a ser muy voluminoso. En lugar de un armazón con un núcleo de hierro y muchos bobinados, hay una única espira conductora cuadrada girando alrededor de un eje, el cual no se dibuja.

Página 53


Las flechas rojas indican el sentido convencional de la corriente (de más a menos). Las líneas de campo magnético aparecen en rojo, dirigiéndose 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 eléctrica situado en el seno de un campo magnético.

Una vez explicado lo que es un motor y para que nos sirva, pasamos a mostrar los motores que tiene Lego.

Página 54


4.2. Motor es Lego: Motor Eléctrico Technic 9V Lego 74569: El motor de 9v más antiguo de Technic (1990). Sin engranajes internos, esto le confiere alta velocidad de rotación y un momento de rotación bajo, por esto requiere para la mayor parte de usos una reducción de engranajes externa. Micromotor Eléctrico Technic Lego 70823: Aparecido en 1993, es pequeño, de poco peso y baja velocidad, ofrecen el momento de rotación bajo - pero respetable para su tamaño. Debe ser usado generalmente con la polea, la cima y la base, pero otras transmisiones de movimiento también son posibles. Mini-Motor Eléctric o Technic 9v Lego: 71427. Desde 1997, este motor sustituye al 2838. Engranado abajo y bastante eficiente, supone la mejor opción para la mayor parte de usos. Mini-Motor Eléctric o Technic 9v Lego 43362: En 2002, Lego substituyó el motor 71427 por un nuevo tipo, el 43362. Por fuera casi idéntico, su estructura interna es muy diferente. El funcionamiento es igual de bueno pero con un peso mucho inferior. Motor Eléctrico para Buggy RC Peeron 5292: Presentado en 2002, este motor apareció con el Coche de Carreras de RC. Resulta muy poderoso, pero consume mucha energía. 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. Sólo la salida exterior es probada debajo.

Página 55


Motor Eléctrico Technic 9V con engranajes Peeron 47154: Aparecido en 2003, este motor viene con un orificio en el eje de fricción, permitiendo escoger la longitud de eje sin la necesidad de un extensor. Permite un montaje plano inferior fácil. Motor NXT Este motor es específico del NXT, se pone a la venta en 2006. Incluye un codificador de rotación, volviendo al NXT la posición del eje con gran resolución. A causa del conector especial de este motor (el tipo de enchufe no estándar telefónico), 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 rotación lenta, reduciendo al mínimo 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 % más ligero. Esto es generalmente una ventaja, excepto cuando el motor es usado como un contrapeso, o para equilibrar la estructura.

Página 56


4.2.2. Características en vacío (sin carga): Condiciones de prueba: el motor es impulsado por una fuente de energía variable, regulada. Un amperímetro mide la corriente que fluye por el motor, un voltímetro supervisa la tensión a través. La velocidad de rotación 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 rotación

Corriente sin carga

4100 r.p.m.

35 mA

2986

71427

43362

35 r.p.m.

360 r.p.m. 340 r.p.m.

6 mA

3.5 mA

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 más alta sin carga que el 71427, probablemente causado por la gran fricción interna. El modelo 47154 tiene una corriente sin carga elevada, debido a su reducción de engranaje de 5 etapas. Para esto usa engranajes de diente grande en las últimas etapas, probablemente mucho más robusto que el de 2 etapas, con engranajes internos de diente delgado como 71427/43362. Los 5292 también exponen una corriente sin carga muy alta, aquí otra vez causado por la fricción interna. Como es habitual para motores de corriente continua, la velocidad de rotación es proporcional ala tensión aplicado a ellos.

4.2.3. Características en parado: El consumo de corriente parado es medido con el eje de motor para a mano. El momento de rotación en parado es medido para el peso máximo que puede ser levantado por la máquina. La medida del momento de rotación 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

Página 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 rápida subida de temperaturas. ¡¡Atención a los motores 71427 y 43362, equipados con un termisor, deben ser protegidos de las altas temperaturas!! El motor NXT también 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 sólo puede ser mantenida durante unos segundos.

4.2.4. Características en carga: Utilizando amperímetro y voltímetro para medir las condiciones del sistema en carga, vemos que el poder mecánico 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 aceleración inicial). El momento de rotación 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 reducción de engranaje de 1/5, que resulta muy necesaria para la mayor parte de usos. El momento de rotación mostrado por el motor corrige la r educción de engranaje. El motor 5292 es muy rápido, por lo que también tuvo que ser medido con una reducción de engranaje de 1/3.

Torque

o Velocidad

Poder

Poder

Mecánico

Eléctrico

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 rotación

rotación

6V

0.45 N.cm

580 rpm

7V

0.45 N.cm

9V 12 V

Corriente

Rendimiento

2838

Página 58


Torque

o Velocidad

momento

de

Corriente

de rotación rotación

Poder

Poder

Mecánico

Eléctrico

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

Mecánico

Eléctrico

Torque

o Velocidad

momento

de

de rotación

rotación

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

Mecánico

Eléctrico

Corriente

Rendimiento

43362

Torque

o Velocidad

momento

de

Corriente

Rendimiento

de rotación

rotación

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 %

47154

Página 59


12 V

2.25 N.cm

Torque

468 rpm

0.19 A

1.1 W

2.3 W

Poder

Poder

Mecánico

Eléctrico

0.04 A

0.021 W

0.36 W

16 %

0.04 A

0.038W

0.48 W

28 %

Poder

Poder

Mecánico

Eléctrico

o Velocidad

momento

de

de rotación

rotación

9V

1.28 N.cm

16 rpm

12 V

1.28 N.cm

Corriente

48 %

Rendimiento

2986

Torque

28 rpm

o Velocidad

momento

de

Corriente

Rendimiento

de rotación

rotación

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

Mecánico

Eléctrico

5292

Torque

o Velocidad

momento

de

Corriente

Rendimiento

de rotación

rotación

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 %

NXT

Página 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:

Página 61


4.3. Bibl iogr afía de la parte de moto res: www.philohome.com/motors/motorcomp.htm www.monografias.com mindstorms.lego.com/eng/products/ris/index.asp

Página 62


5. Transmisión de movimiento y esfuerzo: Transmisiones entre ejes paralelos: La transmisión 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 más, mientras que la segunda permite diseñar orugas que sustituyan las ruedas de un vehículo (o arrastrar otro conjunto de piezas). Este segundo elemento permite también diseñar 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 cónicos. LEGO ofrece engranajes cónicos de 12 dientes. Además, 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 combinación tornillo sinfín - corona (en nuestro caso la corona será un engranaje recto). Por medio de estas combinaciones se consiguen grandes relaciones de transmisión. En este engranaje el tornillo sinfín siempre será el conductor y la corona la conducida. El tornillo sinfín

Página 63


que suministra LEGO es de una entrada, por lo que las relaciones de transmisión serán las siguientes:

Número de dientes de la corona

8

16

24

40

Relación de transmisión

0.125

0.0625

0.042

0.025

Transformación del movi miento: El mecanismo piñón cremallera se utiliza para transformar un movimiento de rotación en un movimiento rectilíneo. El módulo de la cremallera que LEGO comercializa tiene un módulo de 3.175 mm, sí que, si utilizamos como piñón 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 límite no sufran daños.

Diferencial: Cuando un vehículo 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

Página 64


velocidades de las ruedas no podrán ser iguales. Cuando se monta un robot móvil 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 cónicos. 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 rectilíneo en máquina-herramientas (aunque hoy en día está siendo sustituido por el husillo a bolas). LEGO no ofrece elementos para montar este mecanismo, pero se puede conseguir algo similar utilizando tornillos sinfín y un engranaje recto. El tornillo sinfín será el conductor, mientras que el engranaje recto se encontrará bloqueado. De este modo pueden conseguirse desplazamientos rectilíneos con gran precisión. 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 rectilíneo en circular, o viceversa. Al contrario de los dos mecanismos anteriores, en este caso el movimiento rectilíneo es de vaivén. Un ejemplo de la transformación de movimiento rectilíneo en circular se encuentra en el motor de un automóvil (pistón - biela - cigüeñal) o en las viejas locomotoras a vapor. En el caso contrario se encuentran los compresores de aire alternativos.

Página 65


Mecanismo leva / seguidor : Una leva convierte un movimiento de rotación en un movimiento alternativo. En un motor de explosión las levas abren y cierran las válvulas 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 transmisión que se recogen en la tabla: (Las imágenes de los elementos LEGO de esta página están cogidos de la página Technic con el permiso de su autor) Los valores de la fila superior son el número de dientes de la rueda conductora, y los de la columna izquierda los de la conducida. 8

16

24

40

8

1

2

3

5

16

0.5

1

1.5

2.5

24

0.33

0.67

1

1.67

40

0.2

0.4

0.6

1

Página 66


Poleas: La segunda opción que se ofrece para transmitir movimiento y fuerza entre ejes paralelos es utilizar poleas. Este sistema permite aumentar la distancia entre ejes. Además, el sentido de giro de los dos ejes será el mismo. Sin embargo, la transmisión de movimiento y esfuerzos por medio de engranajes ofrece mayor precisión y capacidad para transmitir mayores esfuerzos. Las tres poleas que contiene Lego MindStorms tienen los siguientes diámetros: 8.6, 21.9 y 34.2. En la siguiente tabla se recogen las relaciones de transmisión teóricas que se pueden conseguir con estas poleas (en el caso en que no se produzca deslizamiento entre polea y goma).

Página 67


Los valores de la fila superior son el diámetro de la rueda conductora, y los de la columna izquierda, los de la conducida. 8.6

21.9

34.2

8.6

1

2.5

4

21.9

0.4

1

1.6

34.2

0.25

0.6

1

5.1. Bibl iogr afía parte transmi sion es: 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

Página 68


6. Programación 6.1. Introd ucc ión a la pro gramación para LEGO. Para programar el núcleo de Lego tenemos una amplia gama de lenguajes de programación de diversos niveles de dificultad y que nos ofrecen múltiples posibilidades y la opción de realizar aplicaciones complejas. Para programar el núcleo sin tener grandes conocimientos de programación se nos presentan diversos lenguajes: RCX y Robolab, que son herramientas muy útiles y con grandes posibilidades. Existen además otros lenguajes como NQC e Interactive C que nos permiten programar en el lenguaje C, muy conocido por la mayoría de usuarios. Lego nos ofrece a posibilidad de programar en Java o LabView siendo éste último un referente en los últimos años para programar RCX. Por último existe la posibilidad de programar en lenguajes orientados a objetos como Visual Basic, Visual C etc. Destacar además la posibilidad de programar directamente en C el núcleo a través del sistema operativo del núcleo: LegOS y BrickOS, siendo esto último el más utilizado en éstos últimos años.

6.2. RCX-Code

6.2.1. Introducción: RCX-Code es el entorno de programación gráfico suministrado con LEGO MindStorms para Windows. Está dirigido al mercado doméstico. Es fácil 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 parámetros para adaptarlos a nuestros deseos, el programa puede ser transferido al RCX por medio de la conexión de infrarrojos. A partir de ese momento, el robot podrá funcionar de modo autónomo sin depender del ordenador.

Desafortunadamente, tiene limitaciones que no lo hacen aconsejable para aplicaciones avanzadas, por lo que su aplicación se limita a un nivel básico. Una de las limitaciones es la imposibilidad de utilizar variables (sólo utiliza varios contadores). La última versión comercializada es la 2.0 comercializada en España y otros países, ofrece un entorno de programación que obtiene mayor provecho de las capacidades del RCX. No es software libre.

Página 69


Arquitectura de Software utilizando RCX-CODE

Partes del RCX-CODE Como este entorno de programación esta orientado a niños, y es muy sencillito de manejar, explicaremos las partes que lo componen mediante imágenes.

El almacenamiento de programas se haría de la siguiente forma:

Página 70


La pantalla de configuración es la siguiente:

A continuación continuación se muestran los bloques básicos; pueden ser de secuencia, de paralelismo, comandos, condiciones condiciones sensoriales, control de flujo, grupos de bloques...

Página 71


Como podemos observar un bloque se ejecuta detrás de otro, puede haber bucles y varias hebras que se puede ejecutar a la vez.

El panel de control tiene este aspecto:

Página 72


Accionándolo podremos realizar realizar las funciones funciones que se describen describen.

6.2.2. 6.2.2. Comandos Comand os Movimiento de motores . Este es el bloque que permite controlar el movimiento de los

motores. Sonidos:

Página 73


Varios tipos de bloques Contadores:

Temporizadores:

Página 74


Condiciones sensori ales

Ahora mostraremos lo bloques para controlar las condiciones sensoriales.

6.2.3. Bloques de control de flujo

Página 75


Bloques de rutinas propias

Página 76


Pros y contras del código RCX

    

Usa el firmware de LEGO No hay variables Es interpretado Visual, muy bueno para empezar Demasiado farragoso y limitado para hacer cosas complejas

Bibligrafía [1] Vicente Matellán Olivera, Jesús M. González Barahona, Pedro de las Heras Quirós, José Centeno González, Programación de Lego MindStorms bajo GNU/Linux, 11 de noviembre 2000, 7 de noviembre 2006, http://es.tldp.org/Presentaciones/200002hispalinux/conf-16/16html/. [2] Extraído 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,

7

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.

Página 77


[6] Paul Andrews Jürgen Stuber, José Solórzano, LejOs, W22 agosto del 2006, 7 de noviembre de 2006, http://lejos.sourceforge.net. [7] Alumnos de la URJC, Grupo de robótica 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. Guía rápida de Lego Mindstorms y LeJos 19/9/2004. http://robotit.it.uc3m.es/lego-guia.php

6.3. Introd ucc ión a ROBOLAB El lenguaje de programación ROBOLAB es el más fácil e intuitivo de los diversos lenguajes existentes para la programación del núcleo de lego. Presenta un entorno gráfico que es semejante a diagramas de flujo. Es un lenguaje desarrollado por LAB VIEW, el cuál nos ofrece opciones avanzadas como la realización de cálculos. Es el mejor entorno de programación para empezar a diseñar aplicaciones con lego ya que es muy educativo e intuitivo por la posibilidad de desarrollar las aplicaciones a través 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 través del cual nos comunicaremos con el núcleo de lego RCX. Para empezar a programar pinchamos en PROGRAMADOR, y posteriormente elegiremos el modo de programación que explicaremos a continuación.

6.3.1. MODOS DE PROGRAMACION Para familiarizarse con el entorno y la programación en ROBOLAB, el programa nos proporciona 3 modos con dificultad ascendente. Estos modos son:

Página 78


6.3.2. Modo PILOT Es el nivel básico. A través de plantillas introduce la lógica de la programación. Estas plantillas están 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 símbolos utilizados en el diagrama. Este modo consta de cuatro niveles de dificultad que se componen de ejemplos de menor a mayor complicación. Pilot nivel 1:

En este primer nivel nos muestran un programa muy sencillo. Cada símbolo nos indica una función:

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 botón de la flecha Pilot nivel 2:

Página 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 símbolos cuyas funciones son:

Lámpara. Se enciende y su potencia se determina por un número del 1 al 5. Está conectada en la salida C.

Sensor de contacto. Este símbolo nos indica que cuando es presionado este sensor, el programa avanza al siguiente paso.

Pilot Nivel 3:

Página 80


En este nivel nos encontramos la posibilidad de la recursividad, esto se consigue mediante este botón

Nos aparecen nuevos símbolos: Pone en off una determinada salida.

Sensor de luz. Continua con la ejecución del siguiente paso cuando detecta una zona oscua. Sensor de luz. Continua con la ejecución del siguiente paso cuando no detecta una zona oscura.

Pilot nivel 4:

Este nivel se diferencia del anterior en que puede programarse en múltiples pasos haciendo más extenso el programa.

6.3.3. Modo INVENTOR Este modo se refiere a la segunda fase del aprendizaje. Se desarrollarán aplicaciones con libertad de enlazarlos como se quiera, además de la inclusión de nuevas funciones que nos permitirán realizar bucles o realizar programas multitarea, es decir que se ejecuten en paralelo los flujos. Este modo también consta de cuatro niveles de dificultad.

Página 81


Inventor nivel 1:

En este nivel nos aparece un entorno de programación diferente a los ya vistos anteriormente en el modo pilot. A la derecha de la pantalla tenemos a nuestra disposición las diversas funciones que nos permite en este nivel, siendo el propio programador el que selecciona el orden de ejecución y realiza el diagrama. La mayoría de las funciones ya nos son conocidas por lo que explicaremos las nuevas. Cada programa siempre comienza con el símbolo del semáforo en verde y finaliza con el semáforo en rojo. Una función que no hemos visto anteriormente es la siguiente: Nos proporciona un sonido. Inventor nivel 2:

Página 82


En este nivel se nos ofrecen diversas funciones como cambio de dirección, saltar y aterrizar y tiempo al azar:

Cambiar de dirección. Esta función nos permite cambiar de dirección a un motor determinado que le asignemos. Ejemplo:

Cambia de dirección el motor C.

Saltar y aterrizar. Mediante estos símbolos 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 función 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 programación con este lenguaje. En este se incluye la posibilidad de realizar programas multitarea, sentencias condicionales, recursividad y música.

Página 83


A continuación explicaremos las diversas nuevas posibilidades en este nivel: Comando multitareas. Al introducirlo en nuestro programa nos ofrece dos flujos de ejecución, los cuales se ejecutarán aparentemente en paralelo. Veamos un ejemplo:

Como se puede observar en el siguiente ejemplo aparecen dos flujos de ejecución. En el primero (situado en la parte superior) juegan con los motores cambiando de dirección de modo recursivo. En el segundo reproduce notas musicales.

Este grupo de funciones representa una sentencia condicional que será ejecutada mientras cumpla la condición. 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 sitúen entre estos símbolos se ejecutarán un número predeterminado de veces. Ejemplo:

Se repite 30 veces.

Página 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 envía 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 versión adaptada del LABVIEW. Convierte el RCX en una herramienta de trabajo para la adquisición de datos. Este modo nos permite elaborar un procesado de los datos recogidos para la elaboración de un informe. Para mayor información consultar guías de programación para el uso de este modo de programación ya que para la realización de aplicaciones de lego es suficiente con saber manejar el modo inventor ya que se pueden realizar programas con bastante grado de dificultad.

Página 85


6.3.5. Bibliografía 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 programación gráfico para el diseño de sistemas de adquisición de datos, instrumentación y control. Labview permite diseñar interfaces de usuario mediante una consola interactivo basado en software. Usted puede diseñar especificando su sistema funcional, su diagrama de bloques o una notación de diseño de ingeniería. Labview es a la vez compatible con herramientas de desarrollo similares y puede trabajar con programas de otra área de aplicación, como por ejemplo Matlab. Tiene la ventaja de que permite una fácil integración con hardware, específicamente con tarjetas de medición, adquisición y procesamiento de datos (incluyendo adquisición de imágenes). Aplicaciones de LabVIEW Labview tiene su mayor aplicación en sistemas de medición, como monitoreo de procesos y aplicaciones de control, un ejemplo de esto pueden ser sistemas de monitoreo en transportación, Laboratorios para clases en universidades, procesos de control industrial. Labview es muy utilizado en procesamiento digital de señales (wavelets, FFT, Total Distorsión Harmonic TDH), procesamiento en tiempo real de aplicaciones biomédicas, manipulación de imágenes y audio, automatización, diseño de filtros digitales, generación de señales, entre otras, etc.

LabVIEW enfocado a LEGO MINDSTORMS Robolab esta basado en una versión sencilla de LabVIEW pero solo es valida para el NTX y no es tan potente como LabVIEW. Si queremos sacarle el máximo partido al NTX o incluso al RCX tenemos que hacernos con una versión

de

LabVIEW la versión básica seta disponible por 1249.00 € y la profesional por 4249.00 €. Además tendremos que comprar el toolkit de LabVIEW para LEGO MINDSTORMS por unos 18 €, National Instruments también pone a nuestra disposición tarjetas de adquisición

Página 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 continuación se explicará como utilizar LabVIEW genéricamente, de tal forma que el lector pueda comprender su uso y poder abordar la programación con LEGO MINDSTORMS.

6.4.2. Programación gráfica con Labview Cuando usted diseña 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 diseñe. Este VI puede utilizarse en cualquier otra aplicación como una subfunción dentro de un programa general. Los VI's se caracterizan por: ser un cuadrado con su respectivo símbolo relacionado con su funcionalidad, tener una interfaz con el usuario, tener entradas con su color de identificación de dato, tener una o varias salidas y por su puesto ser reutilizables. Diseñe la interfaz de usuario a partir d e su códi go. En el ambiente de trabajo de Labview existen dos paneles, el panel frontal y el panel de programación ó diagrama de bloques; en el panel frontal se diseña la interfaz con el usuario y en el panel de programación 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 programación usted puede diseñar de manera gráfica y como si fuera un diagrama de bloques el funcionamiento de su sistema. La programación gráfica se basa en la realización de operaciones mediante la asignación de iconos que representen los datos numéricos e iconos que representan los procedimientos que deben realizar los (VI's), con estos iconos y mediante una conexión simple como lo es una línea recta se enlazan para determinar una operación y/o una función. Al diseñar el programa de forma gráfica, se hace visible una programación orientada al flujo de datos, donde se tiene una interpretación de los datos también de forma gráfica, por ejemplo un dato booleano se caracteriza por ser una conexión verde, cada tipo de dato se identifica con un color diferente dentro de Labview; Página 87


también es necesario tener en cuenta que cuando se realiza una conexión a un VI esta conexión 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, además 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 mayoría de los casos si se cumple. El flujo de datos va de izquierda a derecha en el panel de programación y esta determinado por las operaciones o funciones que procesan los datos. Es fácil observar en el panel de programación como se computan los datos en cada parte del programa cuando se realiza una ejecución del programa paso a paso. En Labview las variables se representan mediante una figura tanto en el panel frontal como en el panel de programación, de esta forma se puede observar su respuesta en la interfaz del usuario y en el flujo de datos del código del programa. Otros objetos como gráficas y accesos directos a páginas web cumplen estas mismas condiciones.

6.4.3. Entorno LabVIEW La programación G (gráfica) de Labview consta de un panel frontal y un panel de código como se menciono antes. En el panel frontal es donde se diseña la interface de usuario y se ubican los controles e indicadores. En el panel de código se encuentran las funciones. Cada control que se utiliza en la interfaz tiene una representación en el panel de código, igualmente los indicadores necesarios para entregar la información procesada al usuario tienen un icono que los identifica en el panel de código o de programación. Los controles pueden ser booleanos, numéricos, strings, un arreglo matricial de estos o una combinación de los anteriores; y los indicadores pueden ser como para el caso de controles pero pudiéndolos visualizar como tablas, gráficos en 2D o 3D, browser, entre otros. Las funciones pueden ser VIs prediseñados y que pueden ser reutilizados en cualquier aplicación, estos bloques funcionales constan de entradas y salidas, igual que en un lenguaje de programación estándar las funciones procesan las entradas y entregan una o varias salidas, estos VI pueden también estar conformados de otros subVIs y así sucesivamente, de esta forma se pueden representar como un árbol genealógico donde un VI se relaciona o depende de varios SubVIs. Labview tiene VIs de adquisición de datos e imágenes, de comunicaciones, de procesamiento digital de señales, de funciones matemáticas 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 resolución de ecuaciones editando directamente estas como en lenguajes de programación tradicionales y definiendo las entradas y las salidas. Labview también se puede utilizar para graficar en tres dimensiones, en coordenadas polares y cartesianas, tiene disponibles herramientas para

Página 88


análisis 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 imágenes, como capturar una imagen a través de una tarjeta de adquisición como la PCI-1408 (monocromática), (monocromática), analizarla y entregar respuestas que difícilmente otros sistemas realizarían.

6.4.4. 6.4.4. Flujo Fluj o de d e Datos Otra característica se encuentra en el flujo de datos, que muestra la ejecución secuencial del programa, es decir, una tarea no se inicia hasta no tener en todos sus variables de entrada información o que las tareas predecesoras hayan terminado de ejecutarse. Debido al lenguaje gráfico el compilador con que cuenta Labview es más versátil ya que sobre el mismo código de programación se puede ver fácilmente el flujo de datos, así como su contenido.

Página 89


¿Cómo utilizar la ayuda? Para visualizar el cuadro de ayuda, simplemente se hace Help»Show Context Help o presionando presionando ; en este cuadro se mostrará la información del objeto sobre el cual nos paremos con el puntero del mouse. También se puede notar que en el cuadro de ayuda se observa un Link azul, el cual nos lleva al Labview help, donde encontramos una información mas completa del elemento; (haciendo clic derecho del mouse, también se puede observar el Labview help).

6.4.5. Manejo de puertos con LABVIEW Objetivo: Realizar una adquisición de datos mediante la tarjeta de adquisición de datos de National Instruments PCI 1200. 1. Seleccione en la paleta de funciones la opción "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

Página 90


La figura anterior muestra un detalle importante en la configuración 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 configuración de este VI es de la siguiente forma: Device: 1, significa que para un numero determinado de tarjetas de adquisición y cualquier otra tarjeta de National Instruments, la herramienta Measurement Measurement and Automatization 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.

También dependiendo de la tarjeta esta puede tener un determinado numero de canales análogos de entrada, dependiendo de nuestra conexión física a la tarjeta se puede escoger

Página 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 señal 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 máxima componente de frecuencia de la señal ha capturar, es decir, si la señal 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 condición, es mejor utilizar esta frecuencia límite para evitar procesamientos excesivos en el caso de implementar dentro de la aplicación filtros. 3. Por ultimo en el panel de control coloque un Waveform Graph, luego en el panel de programación realice la correspondiente conexión.

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 números 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 demás características correspondientes a cada puerto 2. Envío del comando VOLT020 para programar la fuente a un voltaje de 2Voltios. Mediante el VI de Serial Port Writer, se envía 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.

Página 92


Lea del puerto serial de la computadora la información de confirmación que envía la fuente El primer Vi corresponde a "Bytes at serial port" y es necesario para especificar al siguiente VI, Serail port read.

Ejemplo de Adqui sición 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 aplicación son IN PORT y OUT PORT (ubicadas en advanced/port i/o), que entran y sacan un byte o una palabra a una dirección específica de memoria. Por lo cual debemos saber cual es la dirección del puerto paralelo del PC, cuyo dato se encuentra en la información del sistema en el panel de control; por lo general es 0378-037B hex (888-891 dec). También es necesario configurar en el setup del PC el puerto paralelo en modo EPP, el cual, según sus especificaciones se encuentra que la dirección 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 además 5 bits libres para cualquier aplicación que se necesite como por ejemplo multiplexación. 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 número cualquiera entre 0-256 dec (debido a que sólo 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.

Página 93


Para lograr esto, se utiliza la estructura Secuence, que como su nombre lo indica, corre un número deseado de secuencias en forma cíclica y ordenada, por lo que es ideal para nuestra aplicación. 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 dirección de datos (888 dec) el dato deseado por medio del control.

Página 94


Hasta el momento se han sacado datos, pero ahora podemos leer éstos mismos configurando primero el puerto para lectura, enviando a la dirección de control un 1 al bit #1 (por ejemplo 2 dec). Por último con la ayuda de la función IN PORT leemos estos datos de la dirección 888 dec y los visualizamos en el indicador.

6.4.7. Bibliografía Labview http://www.ni.com/labview/ http://www.ni.com/academic/mindstorms/ http://www.lawebdelprogramador.com/cursos/ GABRIUNAS V. Apuntes de Electrónica. Universidad Distrital “Francisco José de Caldas”. 1999 RONCANCIO H., VELASCO. H. Una Introducción a Labview. Semana de Ingenio y Diseño. Universidad Distrital "Francisco José de Caldas". 2000.

6.5. Leng uaje NQC

6.5.1. Introducción a NQC: NQC es un entorno de programación con lenguaje C adaptado para poder programar el núcleo del robot de lego. Existen además otros entornos de programación 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 más adecuado es NQC

ya que es un entorno de programación que nos permite realizar

aplicaciones de diversos niveles, además de la ventaja de que NQC utiliza el firmware de LEGO.

Página 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 programación que soporta, tenemos disponible la utilidad RCX COMMAND CENTER, a través de la cual podemos programar nuestro robot en diversos lenguajes de programación basados en C como pueden ser NQC y BRICOS, además de otros lenguajes como por ejemplo visual basic o java ya que en este software viene incorporada la librería spirit.ocx, a través 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 núcleo de programación RCX. Si por el contrario sabemos la ubicación en la cual hemos conectado el RCX entonces marcaremos el puerto de comunicación correspondiente. En caso de no detectar la conexión del núcleo 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:

Página 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 rápido, 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 guía de los comandos más utilizados en NQC para la programación del robot. La guía nos permite conocer rápidamente el nombre de la función que necesitamos dependiendo que sea para el manejo de sensores, las diversas salidas para el manejo de motores o para generar sonidos.

Página 97


Para empezar a escribir nuestro código del programa que queremos realizar pinchamos en el símbolo de la hoja en blanco en la parte superior de la pantalla o accedemos al menú file y después marcamos new. Nos aparecerá la siguiente figura:

Página 98


Ya tenemos lista nuestra ventana para empezar a escribir el código 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 continuación 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.

Página 99


Cada programa en NQC está compuesto por tareas. Todo programa ha de tener como mínimo una tarea denominada main . la estructura básica del programa es la siguiente:

//declaración de constantes //declaración de variables

task main() //tarea principal { //inicialización de variables //órdenes

} Para la inclusión de comentarios basta con poner delante // y escribir la aclaración. El comentario se escribirá en color verde con el fin de poder distinguir cada función 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 mayúsculas y se inicializa a continuación con un valor: #def i ne 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 más legible y más fácil 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 función.

Página 100


Las variables locales en cambio, se declaran dentro de la función, tarea, subrutina o función, y sólo 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 v ar i

abl e;

Una vez definida dicha variable, la inicializamos a un valor dentro de la tarea:

task mai n( )

{ Vari abl e = 5; ........ ....... ...... }

6.5.4. Instrucciones El cuerpo de un bloque de código se compone de instrucciones. Todas las instrucciones siempre terminan con “;” La declaración de variables, como se ha descrito en la sección anterior, es un tipo de instrucción. Una variable se declara como local (con inicialización opcional) cuando ha de ser utilizada dentro de un bloque de código. Una vez declarada se le asigna un valor con el operador “=”, además de éste podemos utilizar otros operadores que admitidos por NQC estos son: = Asigna a una variable una expresión += Añade a una variable una expresión -= Resta a una variable una expresión *= Multiplica a una variable por una expresión /= Divide una variable por una expresión &= AND bit a bit de la expresión y la variable |= OR bit a bit de la expresión y la variable ||= Asigna a una variable el valor absoluto de una expresión +-= Asigna una variable el signo (-1, +1, 0) de una expresión >>= Desplaza a al derecha la variable en una cantidad constante <<= Desplaza a al izquierda la variable en una cantidad constante

Página 101


Posterior a la declaración y la inicialización de variables se procederá a escribir las diversas órdenes para el manejo del robot, las cuales las explicaremos en capítulos posteriores. Estas órdenes se marcan en un color azulado para poder distinguirlas. Para una buena optimización del código podemos incluir las diversas instrucciones dentro de diversas sentencias como por ejemplo bucles if, while, for, etc que explicaremos a continuación. Un ejemplo de código para el manejo de un robot puede ser el siguiente: #def i ne TI EMPO_GI RO 85 int

t i empo_de_avance;

//declaracion variable global

task mai n( )

{ t i empo_de_avance = 20; //inicializacion variable //instrucciones repeat(50) { OnFwd( OUT_A+OUT_C) ; Wai t ( t i empo_de_avance) ; OnRev( OUT_C) ; Wai t ( TI EMPO_GI RO) ; t i empo_de_ avance +=5; } Of f ( 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 más importantes: Sentencia if

if

(condi ci on)

{ . . . . //instrucciones .... } El se { ...

} Evalúa la condición 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 (

expr esi on)

{

Página 102

ROBOTS LEGO MINDSTORMS . . . . //instrucciones .... }

Esta sentencia ejecuta las instrucciones contenidas en ella el número correspondiente de veces como indique la expresión.

Sentencia while while

(condi ci on)

{ . . . . //instrucciones .... }

Esta sentencia ejecuta las instrucciones contenidas en ella tantas veces como se cumpla la condición.

Sentencia switch switch (x)

{

case 1 break;

: // se ejecuta cuando x es 1

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 evalúa el valor que se introduzca entre paréntesis 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 función, para posteriormente llamar a

Página 103


dicha función cuando la necesitemos y evitar así la repetición de código. Para declarar una función recurriremos a la siguiente expresión:

nombr e( ar gument os) void { . . . . . . . //instrucciones }

En la parte de argumentos declararemos las variables de tipo entero que necesitaremos recibir para realizar las operaciones correspondientes a dicha función. Un ejemplo de llamada a una función puede ser el siguiente: gi void

r a ( int t i empo_de_gi r o) //declaracion de la función

{ OnRev( OUT_C) ; Wai t ( t i empo_de_gi r o) ; OnFwd( OUT_A+OUT_C) ;

//instrucciones que explicaremos mas adelante

} task mai n( )

//tarea principal

{ OnFwd( OUT_A+OUT_C) ; Wai t ( 100) ; gi r a( 200) ; Of f ( OUT_A+OUT_C) ;

//instrucciones //llamada a la funcion con paso de parametro

}

Subrutinas: Por otro lado tenemos la subrutinas, que a diferencia de las funciones permiten que se comparta una única copia del fragmento de código ahorrando así espacio en la memoria del RCX. Una desventaja de las subrutinas es que posee diversas limitaciones debido al intérprete del código de bytes LEGO. Las dos desventajas más importantes de las subrutinas son: -A una subrutina no se le pueden pasar argumentos -Una subrutina no puede llamar a otra -El número máximo de subrutinas se limita a 8 en el RCX

La sintaxis para declarar una subrutina es parecida a la de una función:

sub

nombre_s ubrut i na( ) //declaracion de la subrutina

{ ... ...


}

Página 104

...


Veamos a continuación un ejemplo para el manejo de subrutinas:

sub

gi r a( ) //declaracion de la subrutina

{ OnRev( OUT_C) ; Wai t ( t i empo_de_gi r o) ; OnFwd( OUT_A+OUT_C) ;


} task mai n( )

//tarea principal

{ OnFwd( OUT_A+OUT_C) ; Wai t ( 100) ; gi r a( ) ; Of f ( OUT_A+OUT_C) ;

//instrucciones //llamada a la subrutina

}

6.5.7. Tareas Un programa en NQC nos permite declarar como máximo diez tareas. Siempre como mínimo debe haber una tarea que es la principal: main. Las demás tareas se ejecutarán cuando la función principal las llame utilizando la orden start. Una vez que se llama a otra tarea, se ejecuta simultáneamente 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 habíamos parado dicha tarea.

task mai n( )

//tarea principal

{ ....... ....... start t ar ea1;

start

t ar ea2;

} task

tarea1 ()

//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:

Página 105


SENSOR_1, SENSOR_2 y SENSOR_3. Estos nombres se pueden usar en cualquier función que requiera el nombre de sensor como argumento, pudiendo además 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 función 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 cómo se procesa el valor puro de un sensor. Algunos modos sólo tienen sentido para cierto tipo de sensores, por ejemplo SENSOR_MODE_ROTATION sólo es útil con sensores de rotación. 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 (parámetros), que es la que utilizaremos en los ejemplos para configurar los sensores.

Página 106


SetSensor (sensor, configuración) Establece el tipo y modo de un sensor dado en una configuración especificada, que debe ser una constante especial conteniendo el tipo y el modo de la información. 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 añadir, si se desea un argumento de umbral para conversión 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 –sólo afecta a los sensores que se configuran para medir una cantidad acumulativa tal como la rotación 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. Sólo 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);

Página 107


A continuación exponemos un ejemplo de código para la utilización de sensores: task mai n( )

{ Set Sensor ( SENSOR_1, SENSOR_TOUCH) ; OnFwd( OUT_A+OUT_C) ; until ( SENSOR_1 == 1) ; Of f ( OUT_A+OUT_C) ; }

A través de la orden SetSensor configuramos la ubicación 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. también 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, dirección y potencia. El modo se configura a través de la orden SetOutput (salida, modo). Modo admite las siguientes constantes:

Los demás atributos se pueden configurar con la orden SetDirection (salida, dirección). Dirección puede adquirir los siguientes valores:

A continuación exponemos diversas órdenes y su significado: SetOutput(salidas, modo) Establece la salida en el modo especificado. Salida es uno o más 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, dirección) Establece la salida en la dirección especificada. Salida es uno o más de los valores OUT_A, OUT_B, y OUT_C. Dirección tiene que ser OUT_FWD, OUT_REV, o OUT_TOGGLE. SetDirection(OUT_A, OUT_REV); // Hace girar A hacia atrás SetPower(salidas , potencia)

Página 108


Establece la potencia del motor especificado. Potencia puede ser una expresión, cuyo resultado debe ser un valor entre 0 y 7. Las constantes OUT_LOW, OUT_HALF, o OUT_FULL también pueden ser usadas. SetPower (OUT_A, OUT_FULL); // A la máxima 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 más 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 más de los valores OUT_A, OUT_B, y OUT_C. Off (OUT_A); // Apaga la salida A Float(salidas) Establece las salidas especificadas como float. Salida es uno o más de los valores OUT_A, OUT_B, y OUT_C. Float(OUT_A); // Detiene la salida A sin frenarla Fwd(salidas) Establece el sentido de giro de las salidas especificadas como avance. Salida es uno o más 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 más 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 más de los valores OUT_A, OUT_B, y OUT_C. Toggle(OUT_A); OnFwd(salidas) Establece el sentido de giro de las salidas especificadas como avance y las pone en marcha. Salida es uno o más 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 más 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

Página 109


continuación las detiene. Salida es uno o más de los valores OUT_A, OUT_B, y OUT_C. Tiempo se mide en incrementos de 10ms (one second = 100) y puede ser una expresión. 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

C lick de tec la Pitido Barrido de frec uencia decrec iente Barrido de frec uencia c rec iente Sonido de error Barrido de rápido 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:

Página 110


6.5.11.

Bibliografía 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.oc x y Visual Basic:

6.6.1. Introducción a Spirit.ocx El control spirit.ocx se copia automáticamente al ordenador cuando instalamos el software principal de lego. Por medio de este control podemos programar en diversos entornos de programación como por ejemplo visual java, visual c, visual basic… Como alternativa a diversos lenguajes como NQC o bricOS nos centraremos en el entorno de programación visual basic, ya que nos ofrece una gran cantidad de ventajas por su sencillez de programación y sus prestaciones. En los posteriores capítulos explicaremos el funcionamiento básico a seguir para poder realizar aplicaciones sencillas mediante este lenguaje.

6.6.2. Programación en VisualBasic INICIO Para poder realizar las aplicaciones, debemos instalar la versión visual basic 5.0 o superior. Visual basic es un entorno de programación orientado a objetos que nos permite realizar diversas aplicaciones gráficas. Una vez instalado, nos dispondremos a ejecutarlo mostrándonos la siguiente pantalla:

Página 111


En esta pantalla seleccionaremos el icono EXE estándar para poder realizar una aplicación y hacemos click en abrir.

Posteriormente nos aparecerá la siguiente pantalla:

Página 112


En la parte izquierda de la figura tenemos la barra de herramientas , desde la cuál podemos insertar los objetos que creamos necesarios para el desarrollo de la aplicación, 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 realización de aplicaciones para lego. Para una información generalizada de la utilización de este entorno de programación 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 botón derecho del ratón en la barra de herramientas apareciendo posteriormente esta pantalla:

Seguidamente pinchamos con el ratón en la opción componentes. Seguidamente nos aparecerá la pantalla que exponemos a continuación.

Página 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.

Página 114


Seguidamente nos dispondremos a preparar una aplicación 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 aplicación. En la parte inferior derecha de la pantalla observamos las propiedades del componente:

Página 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 código del programa. Otra propiedad a destacar es ComPortNo en la cuál elegimos el puerto de comunicaciones donde conectaremos el RCX. Por último en la propiedad LinkType elegimos el modo de transmisión de datos: 0 infrarrojos; 1 cable; 2 radio. Dejaremos la opción 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 cuál esta marcado con un círculo rojo:

Página 116


Posteriormente se incluirá en el formulario:

Observamos que el nombre por defecto del botón es Command1 por lo que podemos señalando el botón y situándonos en la ventana de propiedades para cambiar el nombre.

Propiedades del botón “command1”:

Página 117


Descripción de las propiedades más significativas que vamos a utilizar: (Name): nombre a través del cual nos referiremos al botón en la hoja de código. Caption: nombre que se asignará al aspecto externo del botón. Font: Tipo de letra que se le asignara al nombre del botón. Para el desarrollo de algunos ejemplos pondremos en la propiedad (Name) “inicio” y llamaremos al botón “inicio” en la propiedad caption. Lo demás lo dejamos como esta por defecto. A continuación agregamos otro botón 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 código de cada objeto. Para ello podemos comenzar por el botón “parada”.

Entraremos en el código del botón haciendo doble click sobre el mismo:

Página 118


Automáticamente nos aparecerá el código que apreciamos en la pantalla, y una función ejecuta el código que introduzcamos al hacer click con el ratón sobre el botón. Dentro del código escribiremos lo siguiente:

A través de “spirit1” nos referimos al componente para manejar lego que hemos visto anteriormente, seguido del “.” Y después nos referimos a la propiedad “CloseComm” , la cuál se encarga de cerrar el puerto de comunicaciones.

A continuación hacemos doble click en el formulario, para que nos aparezca el código correspondiente al iniciar nuestro programa:

Página 119


Nos mostrará el código asociado al objeto del botón “parada” y un nuevo código en la parte superior, dentro del cual podemos escribir las instrucciones que queremos ejecutar al iniciar el programa. A continuación introduciremos lo siguiente:

Posteriormente hacemos doble click en el botón inicio para incluir el código asociado a ese botón cuando pinchemos sobre él. En el espacio correspondiente al código del objeto “inicio” escribiremos lo que queremos que realice el robot mediante órdenes secuenciales. Veamos un ejemplo con el siguiente código:

En el código anterior se aprecia el manejo de las propiedades “SetFwd”, “on”, “wait” y “off”, dentro del objeto “Spirit1”

Página 120


Ya hemos finalizado la elaboración de nuestro primer programa. Para ejecutarlo simplemente hay que clickear el símbolo “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 botón “inicio”, el robot se desplazará hacia delante durante dos segundos y después se parará. Al pulsar el botón “parada”, se detendrá la comunicación con el robot por el puerto serie y saldremos del programa. En el siguiente capítulo explicaremos la función 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 l as salidas Spirit1.SetFwd : Con el parámetro “SetFwd” seguido de los motores: MOTOR_A, MOTOR_B ó MOTOR_C establecemos el sentido de giro del motor hacia delante. Spirit1.SetRwd : Con esta función configuramos los motores para que giren hacia atrás.

Página 121


Spirit1.AlterDir : La instrucción “AlterDir” provoca un cambio de dirección en el motor o motores que pasemos como argumento. Spirit1.On Activamos los motores que pasemos como argumento. Spirit1.Off Desactivamos los motores que pasemos como argumento. Spirit1.SetPower , , Esta función 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 máxima 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 ,

Con esta función configuramos el número 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 , , A través de esta orden configuramos el modo a través del cual recibimos los datos de un sensor determinado. El argumento NUMERO corresponde al número de sensor. El modo puede tomar los siguientes valores:

Página 122


El argumento SLOPE sólo se usa si hemos elegido el modo booleano, para cualquier otro modo marcaremos 0 en el argumento SLOPE.

Variable = Spirit1.Poll (SENVAL, ) 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 , Esta función espera un número de segundos determinados, asociándolos a una variable.

6.6.6. Sentencias de control Las sentencias de control nos son de gran utilidad para la optimización y posibilidades de nuestras aplicaciones. Las más importantes son: Sentencia if:

Página 123


Sentencia while:

A continuación modificaremos el código del objeto “inicio” con el fin de utilizar tanto los sensores como los motores. Para ello incluiremos el siguiente código en el botón:

Con esta aplicación el robot se moverá hacia delante hasta que choque.

6.6.7. Bibliografía 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

Página 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 configuración 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 mínimos 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 configuración)

Es conveniente dejarlos en un subdirectorio. Una vez terminada la instalación, 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 señalar que la vía de comunicación 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 configuración 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 además 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.

Página 125


Lo que se debe hacer ahora es reemplazar el firmware estándar 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. Programación en BrickOS El mini sistema operativo BrickOS tiene las siguientes características: 

Es un Sistema Operativo libre



Permite carga dinámica de programas



Permite gestión de memoria dinámica



Provee controladores para todos los subsistemas 

Posee un tamaño reducido de memoria y para almacenar programas



Permite la gestión de tareas con prioridad



Provee el uso de semáforos POSIX El funcionamiento BrickOS se basa en el kernel BrickOS es monolítico. 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. Después se carga el systime_handler, que es el encargado de revisar todos los

dispositivos en cada interrupción del timer cada 1 milisegundo, estos dispositivos son: 1. Motores 2. Sonido 3. Protocolo Comunicación IR 4. Botones 5. Indicador de Batera 6. Actualización del LCD 7. Manejo de tareas (cada 20 milisegundos por defecto).

Página 126


Entre las funciones básicas de BrickOS podemos destacar las de las de salida (output) y las de lectura (input), que serán explicadas a continuación. 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 construcción de un robot movil. Son los dispositivos que proveen de cinemática 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 Dirección y la Velocidad. Para ello provee las funciones motorXdir y motorXspeed. En la función motor_X_dir(Direccion_del_Motor) , X puede ser A, B o C, según corresponda al puerto a que esta conectado el motor que se desea controlar. El argumento de esta función corresponde a la orientación, esta puede ser: •

fwd: hacia adelante

•

rev: hacia atrás

•

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 función motor_X_speed( Velocidad_del_Motor), X es el puerto de salida que alimenta a algún motor, y su argumento es la velocidad. La velocidad para BrickOS es un número entero que se sitúa 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
Página 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 pequeña pantalla que posee el RCX la cual puede mostrar hasta 5 caracteres y símbolos de conexión 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 más 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(), función 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 también debe ser mencionada la LegoLamp, o lámpara 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.

Página 128


Funciones Input, lectura de sensores: Los sensores son el conjunto de dispositivos y herramientas que permiten al robot interactuar con el medio a través de la recepción de lecturas del medio. Existe una gran variedad de sensores propietarios de Lego y otras fábricas (compatibles con el RCX), los más utilizados son los sensores de: tacto, luz, rotación. Otros más específicos son los sensores de calor, sonido, ultrasonido, láser, de movimientos, etc. A continuación 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 leídos en modo Bruto o modo Procesado. Para acceder en modo Bruto se hace a través 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 través 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 más pequeños para luego normalizarlos a porcentajes. Este sensor además, 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 función ds_active(&SENSOR_X). En modo pasivo, los valores brutos van desde 220 a 280, se debe inicializar con la función ds_pasive(&SENSOR_X). El Sensor Rotacional, es un dispositivo lego que detecta 1/16 de una rotación manteniendo un contador. Los sensores de rotación pueden ser utilizados para la medición 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 revolución. Para utilizar el sensor rotacional brickOS provee las funciones:

Página 129

ROBOTS LEGO MINDSTORMS •

Ds_active(&SENSOR_X), sensor de rotación 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. Bibliografía 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

Página 130


6.8. Interact ive C

El entorno de programación C interactivo ha sido desarrollado para el proyecto MIT LEGO Robot Design. Es un compilador multitarea basado en el lenguaje C que incluye una línea de comandos de usuario que permite compilar y evaluar expresiones de modo interactivo. Originalmente fue creado para ser utilizado por estudiantes, su campo de aplicación se extendido a la investigación 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 versión 4 de este programa es de libre uso. Para su explicación nos remitimos al “The Interactive C Manual for the Handy Borrad”

6.8.1. Bibliografía 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

Página 131


6.9. LegOs

6.9.1. INTRODUCCIÓN LegOS es un sistema operativo libre diseñado para el LEGO Mindstorms, diseñado e implementado fundamentalmente por Markus Noga. Comparado con el sistema operativo original de LEGO, ofrece muchas ventajas además de mejores prestaciones y mayor flexibilidad.

6.9.2. Aspectos generales de LegOS Entre las características más importantes de la versión legOS 0.2 se pueden destacar: Sistema operativo libre (Markus L. Noga). La carga dinámica de programas y módulos (desde la versión 0.2.x). El protocolo de comunicación basado en el transmisor infrarrojo. La posibilidad de realizar programas multitarea. La gestión de memoria dinámica (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. Gestión de tareas (con prioridad). Semáforos POSIX. Permitir el uso completo del lenguaje de programación 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

Página 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 código para el H8 a partir del lenguaje de programación que deseemos y para el que existan las librerías adecuadas de LegOS. Para ilustrar el aspecto de dichas librerías se incluye a continuación un par de ejemplos de programas realizados en C: Ejemplo 1. #i #i #i #i

ncl ude ncl ude ncl ude ncl ude

/ *Decl ar o una f unci ón que se ej ecut ar á al det ect ar l a col i si ón*/ wakeup_t col i si on( wakeup_t dat o) ; i nt mai n( i nt ar gc, char *ar gv[ ] ) { i nt di r =0; whi l e( 1) { / * arr anco - Fi j o vel oci dad* / mot or _a_speed( MAX_ SPEED) ; mot or _c_ speed( MAX_ SPEED) ; / * - Avanzo*/ mot or _a_di r ( f wd) ; mot or _c_di r ( f wd) ; / * Esper o */ wai t _event ( &col i si on, 0) ; / * Me apunt o en que l ado f ue l a col i si ón*/ i f ( SENSOR_ 1<0xf 000) di r =0; el se di r =1; / * r ecul o * / mot or _a_di r ( r ev) ; mot or _c_di r ( r ev) ; / * - el r a t i t o que r ec ul o* / msl eep( 500) ; mot or _a_speed( MAX_ SPEED) ; mot or _c_ speed( MAX_ SPEED) ; / * Una vez r ecul ado, ahor a gi r o un pel í n*/ i f ( di r ==1) { mot or _c_di r ( f wd) ; } el se { mot or _a_di r ( f wd) ; } / * - r at i t o par a gi r ar * / msl eep( 500) ; } } wakeup_t col i si on( wakeup_t dat o) {

Página 133


l cd_ r ef r es h( ) ; / * Los sensor es est án conect ados a l os puert os 1 y 2 */ r et ur n SENSOR_ 1<0xf 000 | | SENSOR_ 2<0xf 000; }

Ejemplo 2.

#i ncl ude #i ncl ude #i ncl ude #i ncl ude

wakeup_t col i si on( wakeup_t dat o) { l cd_ r ef r e sh( ) ; r et ur n TOUCH_1 | | TOUCH_ 2; } mot or _a_speed( MAX_ SPEED) ;

i nt mai n( i nt ar gc, char *ar gv[ ] ) { whi l e( 1) { mot or _ a_s peed( MAX_SPEED) ; mot or _ c_ speed( MAX_SPEED) ; mot or _c_di r ( f wd) ; mot or _a_di r ( f wd) ; wai t _event ( &col i si on, 0) ;

i f ( SENSOR_1<0xf 000) di r = 0; el se di r = 1; mot or _a_di r ( r ev) ; mot or _c_di r ( r ev) ;

Página 134


msl eep( 500) ; mot or _ a_s peed( MAX_SPEED) ; mot or _ c_ speed( MAX_SPEED) ; i f ( di r ==1) mot or _c_di r ( f wd) ; cput s( "I zqda") ; el se mot or _a_di r ( f wd) ; cput s( "Dr cha") ; msl eep( 500) ; } }

La estructura del programa es equivalente al del NQC, pero en este caso sólo se utiliza una tarea que espera en un bucle infinito a que se produzca un evento, la pulsación del sensor, para realizar el giro. Se han añadido suficientes comentarios al código como para que no merezca la pena entrar en más detalles de su descripción. El entorno de programación 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 bi nut i l s . La distribución para GNU/Linux de LegOS incluye varias herramientas que permiten descargar el código de forma dinámica, descargar el firmaware o sistema operativo, así como varios ejemplos.

6.9.5. ¿Cómo se programa desde GNU/Linux? Se genera una versión 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 También existen distribuciones para MS-Windows

Además, alrededor del sistema operativo LegOS se han desarrollado múltiples herramientas auxiliares, como por ejemplo simuladores que hacen más fácil la depuración al permitir ejecutar programas en la propia plataforma de desarrollo usando un depurador tradicional de

Página 135


GNU/Linux como por ejemplo gdb. Algunas de estas herramientas se analizan en la próxima sección.

6.9.6. Herramientas relacionadas con legOS Se eligió legOS como base para la programación del RCX, lo que obliga a utilizar otras herramientas, algunas evidentes como el entorno de compilación cruzado. En este caso se ha utilizado el entorno de la FSF basado en las bi nut i l s y el compilador gcc . También se han utilizado otras herramientas como los simuladores. Algunas de estas herramientas las describimos a continuación:

LegoSim

LegoSim es un simulador para legOS cuya principal virtud, que le diferencia de Emulegos (descrito en la siguiente sección), es que el interfaz gráfico de usuario (GUI) se puede separar del simulador propiamente dicho. Esta separación permite utilizar el GUI como unidad de control no sólo como simulador, permitiendo por ejemplo, conectarlo a otros RCX vía infrarojos. Por supuesto, también permite ejecutar el GUI en una máquina distinta de la del simulador. El GUI es un applet de Java que se parece realmente al RCX. El simulador es sólo una biblioteca (librería). 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 aplicación en el proceso de compilación, generando una aplicación completa y ejecutable en la máquina de desarrollo. En la simulación, las tareas ( tasks) de legOS se traducen en threads POSIX. Las entradas y salidas, que resultan vitales, se simulan mediante cadenas de texto sobre s t di n y st dout siguiendo una sintaxis particular. LegoSim se distribuye bajo licencia MPL, es decir, es software libre. Sus diseñadores e implementadores principales han sido Frank Mueller, Thomas Röblitz, y Oliver Bühn.

6.10. EmuLegOS EmuLegOS es otro simulador de legOS. Su objetivo de diseño fue proporcionar un entorno más confortable para probar y depurar programas. EmuLegOS es, en esencia, un conjunto de código escrito en C++ que se puede compilar y enlazar junto con cualquier aplicación para legOS, generando como resultado de ese proceso una aplicación que emula el comportamiento de ese código al que tuviese si estuviese ejecutándose en un RCX real. El nivel de programación o API ( Application Program Interface ) emula las rutinas de legOS. La mayoría de legOS está implementado en EmuLegOS, incluyendo por ejemplo el soporte de tareas, o la comunicación por infra-rojos.

Página 136


El aspecto externo de una aplicación 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 ejecución, por ejemplo simulando eventos externos. El interfaz también muestra el estado de los hasta tres motores que se pueden ``pinchar virtualmente'' en los puertos A, B y C del RCX. EmuLegOS también permite que se emule el mundo real, proporcionando un lugar donde insertar código que imite algunas de las características físicas del robot. Por ejemplo, se puede incorporar un sensor de rotación que gire mientras un determinado motor virtual está en marcha, o hacer que un sensor de colisión 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 categoría de herramientas relacionadas con legOS son las que se pueden catalogar como herramientas de terceras partes. Así por ejemplo, existen compiladores para legOS accesibles vía Web, como el que se analiza en la siguiente sección.

Página 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 página web, elegir el lenguaje de programación y seleccionar la forma en que se quiere recibir el fichero que se genera. A continuación, con pulsar el botón de ``compilar'' se produce el envío del fichero fuente y su compilación cruzada remota a legOS. El fichero obtenido está en formato S- r ecor d (un formato diseñado para permitir la descarga de datos desde un ordenador a otro diferente). Una vez que el fichero S- r ecor d se ha obtenido a través del compilador web es posible descargarlo en el RCX utilizando el canal de infra-rojos habitual.

6.12. Programación en Java para los Lego-Minds tor ms (LeJos)

6.12.1.

Introducción

LeJOS es un sistema operativo basado en la TinyVM desarrollado por José Solorzano. Actualmente leJOS está mantenido por Paul Andrews Jürgen Stuber. El lenguaje de programación que utiliza es Java. Puedes descargarlo directamente desde su página oficial http://lejos.sourceforge.net/ El sistema operativo incluye threads, arrays multidimensionales, recursividad, operaciones en coma flotante, funciones trigonométricas, etc. Además 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 prácticas para programar bajo Java son el RCXDownload y el RCXDirectMode.

6.12.2.

¿Cómo uso leJOS bajo Linux?

Antes de empezar deberás 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 conexión 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

Página 138


con su propio sistema operativo. (NOTA: si quitas las pilas durante un periodo de tiempo largo, deberás 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 común 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 ajústalo a tus necesidades.

Instalar el firmware OJO: Esto sólo lo tendrás que hacer si el RCX no tenía pilas o se han quitado durante más 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: Sitúa el sensor de infrarrojos del RCX frente a la torre USB Enciende el RCX Abre una consola del sistema Ejecuta

l ej os f i r mdl

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 batería Si la descarga no funciona, asegúrate 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 debería parpadear una vez en color verde al ejecutar l ej os f i r mdl .

Página 139


6.12.3.

Crear y ejecutar mi primer programa leJOS

Este es el programa más simple que puedes hacer con leJOS: el "Hola Mundo". Lo tienes también en la sección examples\hworld de la distribución de leJOS: import josx.platform.rcx.*;

/* Este programa, tras descargarlo, espera que pulses el botón 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 Hel l oWor l d. j ava copiando el texto mostrado anteriormente

Compílalo usando l ej os c en vez de javac: l ej osc Hel l oWor l d. j ava

Y transmítelo al RCX con el comando l ej os l ej os Hel l oWor l d

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 botón Run del RCX para ejecutar el programa Si los comandos l ej os c o l ej os no se encuentran, asegúrate de que la variable PATH está correctamente configurada. Si las clases leJOS no se encuentran, revisa el valor de la variable CLASSPATH.

Página 140


¡Enhorabuena! Has ejecutado tu primer programa leJOS en el RCX. Mi segundo programa con leJOS En esta sección echaremos un vistazo más detallado a otra aplicación 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

(lógicamente,

en

un

fichero

llamado

Si mpl eSampl e. j ava):

import josx.platform.rcx.*; public class SimpleSample { public static void main(String[] args) throws InterruptedException { // message TextLCD.print("DRIVE"); // drive forward Motor.A.forward(); // just run until RUN button is pressed again Button.RUN.waitForPressAndRelease(); } // main() } // class SimpleSample i mpor t j osx. pl at f or m. r cx. *;

Importa las clases esenciales para ejecutar los programas leJOS. publ i c st at i c voi d mai n( St r i ng[ ] ar gs) t hr ows I nt er r upt edExcept i on {

Como con la mayoría de los programa Java (¡menos los applets!), el punto de arranque es el método mai n( ) . In este caso, se declara la excepción I nt er r upt edExcept i on porque el método But t on. RUN. wai t For Pr essAndRel ease( ) puede lanzarla. Al lanzar una excepción, el RCX detiene la ejecución del programa y muestra un mensaje (bastante críptico) en la pantalla.

Página 141


Text LCD. pr i nt ( " DRI VE" ) ;

Muestra la cadena DRI VE en la pantalla del RCX, que, como habrás visto, es muy limitada (... esto hace difícil la depuración de los programas en algunos casos...). Fíjate en dos cosas importantes: leJOS tiene la clase habitual java.lang.String se está empleando un método estático 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 estáticas. Así no hay que construir objetos sino que se pueden usar directamente. Mot or . A. f or war d( ) ;

Este código pone en marcha el motor conectado al puerto A del RCX, hacia adelante ("forward"

en

inglés).

De nuevo, fíjate en que se está empleando una instancia estática de la clase Mot or - para ser más preciso, un miembro estático (llamado A) de la clase, que se refiere al "motor conectado al puerto A". Como es lógico, los otros motores serían el B y el C. But t on. RUN. wai t For Pr essAndRel ease( ) ;

¿Para qué se usa esto? ¿Es que no está funcionando todavía el robot? La respuesta es: sí y no. Si esta línea no estuviera: El motor arrancaría y el método Mot or . f or war d( ) terminaría, con lo que el programa seguiría por la siguiente instrucción. Como no habría ninguna, mai n( ) terminaría, y devolvería el control al sistema operativo. Como resultado, el motor se detendría. Es decir, si no estuviera el método But t on. RUN. wai t For Pr essAndRel ease( ) , el programa terminaría rápidamente y el motor se detendría. Lo que hay que hacer es mantener el programa en ejecución durante más tiempo. Esto se podría hacer de varias maneras, pero una muy sencilla es dejarlo esperando a que se pulse un botón, en este caso, el botón RUN, que es lo que hace el método But t on. RUN. wai t For Pr essAndRel ease( ) .

Página 142


A continuación se detalla más detenidamente las funciones asociadas a los diferentes componentes de los robots Lego

6.12.4.

Motores

La clase estática Mot or 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 estáticos de la clase Mot or : Motor.A Motor.B Motor.C Así, una llamada típica para arrancar el motor A (hacia adelante) sería: Mot or . A. f or war d( ) ;

O para ir hacia atrás: Mot or . 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 atrás, cambiar la dirección, 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 también existen los métodos siguientes para obtener información de estado: public static boolean isForward()

Página 143


public static boolean isBackward() public static boolean isFloating() public static boolean isMoving() public static boolean isStopped() y publ i c st at i c char get I D( ) , que devuelve 'A', 'B' or 'C'. Fíjate en que la dirección de giro real del motor (en sentido de las agujas del reloj, o al revés) depende de cómo 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 según esté programado. Existen un montón 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 estáticos de la clase Sensor : Sensor.S1 Sensor.S2 Sensor.S3 Así pues, una llamada típica para leer el valor del sensor sería: Sensor . S1. r eadVal ue( ) ;

Otra posibilidad sería acceder a los puertos mediante el array estático 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 cómo hay que leer los datos del sensor

Página 144


La

configuración

se

hace

mediante

el

método

publ i c

st at i c

voi d

set TypeAndMode( i nt aType, i nt aMode) , donde t ype es uno de los cinco tipos de

sensor disponibles: SensorConstants.SENSOR_TYPE_LIGHT: sensor de luz SensorConstants.SENSOR_TYPE_ROT: sensor de rotación SensorConstants.SENSOR_TYPE_TEMP: sensor de temperatura SensorConstants.SENSOR_TYPE_TOUCH: sensor de contacto SensorConstants.SENSOR_TYPE_RAW: sensor no específico OJO: En el pack, sólo hay disponibles los sensores de luz y de contacto. El parámetro mode puede ser: SensorConstants.SENSOR_MODE_ANGLE: medida de ángulos (sólo sensores de rotación) SensorConstants.SENSOR_MODE_BOOL:

pulsado/no

pulsado

(sensores

de

grados

centígrados

(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 número 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 numérica (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 . set Pr evi ousVal ue( 0) para reiniciar la cuenta. Al configurar el sensor, asegúrate de utilizar una combinación lógica del modo y tipo, o si no, el valor no tendrá sentido. Ac tivar un sensor Algunos sensores, como los de luminosidad, necesitan corriente para funcionar. La llamada al método Sensor . act i vat e( ) hace que el puerto en cuestión se "encienda", es decir, que reciba corriente. La llamada opuesta para "apagar" el sensor es Sensor . passi vat e( ) .

Página 145

ROBOTS LEGO MINDSTORMS Leer un sensor

La forma más sencilla y directa de leer el valor de un sensor es usar uno de los métodos r ead. . . ( ) :

public static boolean readBooleanValue() public static int readValue() public static int readRawValue() que devuelven el estado del sensor o el valor que están midiendo, en el momento de llamar al método. Recuerda que este valor depende del tipo y modo de sensor que se haya configurado, según se vio anteriormente. Existe otro método de bajo nivel, publ i c

st at i c

i nt

r eadSensor Val ue( i nt

aSensor I d, i nt aRequest Type) , donde aSensor I d es el identificador del sensor (0,1,2)

y aRequest Type es el tipo de datos a leer (0 = valor numérico, 1 = valor configurado, 2 = valor booleano). Sin embargo, en la mayoría de los casos, lo que interesa es recibir una notificación 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 propósito se emplean los manejadores de eventos: Para escuchar un evento, la clase tiene que implementar el método publ i c voi d st at eChanged( Sensor aSour ce, i nt aOl dVal ue, i nt aNewVal ue) de la interfaz j osx. pl at f or m. r cx. Sensor Li st ener , donde los dos parámetros indican el valor antes y

después 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 añadir esta clase como un escuchador del sensor en cuestión: Sensor . S1. addSensor Li st ener( mySensor Li st ener) ;

Así, cada vez que el sensor detecte un cambio en la medida, se ejecutará el método st at eChanged( ) de la clase MySensor Li st ener .

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 sería muy útil: así, el robot no tendría que chocar contra los objetos para detectar su

Página 146


existencia con un sensor de contacto, sino que podría evitarlos usando un sensor de luz para percibirlos. Para ello surgió el sensor Pr oxi mi t ySensor , 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 separación con el objeto que hace que se active el sensor: cuanto mayor es el valor, más se acerca el robot al objeto. El sensor se emplea llamando a wai t Ti l l Near ( l ong aMi l l i seconds) , que bloquea el programa hasta que se detecta un objeto; el parámetro indica cuánto 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 números o letras. La clase estática LCD ofrece varios métodos 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

códigos

de

segmento

son

constantes

definidas

en

la

interfaz

Segment

(Segment . BATTERY, Segment . WALKI NG, Segment . STANDI NG, etc.).. Recuerda que hay que llamar r ef r es h( ) tras poner un valor.

Página 147


Existe una versión simplificada: la clase Mi nLCD, que contiene sólo publ i c s t a t i c voi d set Number ( i nt aCode, i nt aVal ue, i nt aPoi nt ) y r ef r es h( ) , que ocupa menos

memoria. Otra clase disponible es Text LCD, que ofrece métodos 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 botón On/Off, los demás son accesibles con la API de leJOS. Como con el resto de clases relacionadas con el hardware, los botones se implementan como métodos estáticos de la clase But t on: Button.RUN Button.PRGM Button.VIEW Otra posibilidad es acceder mediante el array But t on[ ] , que contiene VIEW, PRGM y RUN, en este orden. Detectar cuando un botón 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.

Página 148


La forma más sencilla de detectar cuándo se pulsa un botón es llamar a wai t For Pr essAndRel ease( ) , con lo que el programa espera a que el usuario pulse y

suelte el botón: try { Button.RUN.waitForPressAndRelease(); } catch(InterruptedException e) { // quizás hacer algo aquí } Fíjate que hay que capturar o declarar la excepción I nt er upt edExcept i on. Otra manera es emplear un evento para recibir una notificación de cuándo un usuario pulsa o suelta un botón mientras que el programa está en ejecución. La clase manejadora tiene que implementar los dos métodos: public void buttonPressed(Button b) public void buttonReleased(Button b) de la interfaz j osx. pl at f or m. r cx. But t onLi st ener . public class MyButtonListener implements ButtonListener { public void buttonPressed(Button b) { // se ejecuta al pulsar el botón } // buttonPressed() public void buttonReleased(Button b) { // se ejecuta al liberar el botón } // buttonReleased() } // class MyButtonListener Para usar la clase en tu programa: But t on. RUN. addBut t onLi st ener ( myBut t onLi st ener ) ;

Así, cada vez que se apriete o suelte el botón RUN, se ejecutarán los métodos correspondientes de la clase MyBut t onLi st ener . Sonido El RCX contiene un pequeño altavoz que puede generar sonidos simples, que se accede mediante

la

clase

estática

Sound

Sound. beep( ) ;

Página 149

con

la

típica

llamada:


Existen varios métodos 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 duración (en centésimas de segundo) dadas, donde la duración máxima es 256 (=2,56 segundos). Las frecuencias bajo 31 Hz y sobre 25.000 Hz no son audibles por la mayoría 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 continúa mientras se está ejecutando el sonido en cuestión. OJO: Los sonidos se pueden usar como depuración de los programas, para controlar el punto de ejecución, por ejemplo. Timer (temporizador) La clase Ti mer se utiliza para ejecutar tareas que dependan del tiempo, está contenida en el paquete j osx. ut i l y funciona de forma similar a la clase j avax. swi ng. Ti mer : Un Ti mer Li st ener notifica de forma repetida a Ti mer a intervalos prefijados. La API para gestionarlo es así de sencilla: publ i c i nt get Del ay( ) obtiene el intervalo (en milisegundos) publ i c voi d set Del ay( i nt aDel ay) ajusta el intervalo publ i c voi d s t a r t ( ) arranca el temporizador publ i c voi d st op( ) lo detiene

El Ti mer Li st ener se le pasa al constructor publ i c Ti mer ( i nt aDel ay, Ti mer Li st ener aLi st ener )

y llama a su método publ i c voi d t i medOut ( )

cada vez que transcurre el intervalo. Un ejemplo ilustrativo del uso de la clase Ti mer :

Página 150


import josx.platform.rcx.*; import josx.util.*; public class TimerSample implements TimerListener { public static void main(String[] args) throws InterruptedException { // crear y arrancar el temporizador, con intervalo 1 segundo Timer timer = new Timer(1000,new TimerSample()); timer.start(); // ejecuta hasta pulsar el botón RUN Button.RUN.waitForPressAndRelease(); // detener el temporizador timer.stop(); } // main()

public void timedOut() { // sólo pitar Sound.beep(); } // timedOut() } // class TimerSample

6.12.8.

Bibliografía LegOS

-Vicente Matellán Olivera, Jesús M. González Barahona, Pedro de las Heras Quirós, José Centeno González, Programación de Lego MindStorms bajo GNU/Linux, 11 de noviembre 2000, 7 de noviembre 2006, http://es.tldp.org/Presentaciones/200002hispalinux/conf-16/16html/. -Extraído 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,

7

http://www.euskalnet.net/kolaskoaga/lehenak/programa_c.htm.

Página 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 Jürgen Stuber, José Solórzano, LejOs, W22 agosto del 2006, 7 de noviembre de 2006, http://lejos.sourceforge.net. - Alumnos de la URJC, Grupo de robótica de la URJC, 11 de octubre del 2006, 7 de noviembre de 2006, http://veo.dat.escet.urjc.es/robotica/index.php/Portada.

Página 152


7. Lego Mindstorms en la enseñanza En muchos países, el uso de elementos como la robótica en la enseñanza esta muy extendido, siendo España una rara excepción entre los países más desarrollados. Una herramienta muy útil a tal efecto es Lego Mindstorms, que desde su primera versión, RCX, se ha consolidado como un medio efectivo para cubrir áreas de la enseñanza tales como ciencia, tecnología, ingeniería o matemáticas; todo ello sin olvidar su evidente uso en el mundo extra-académico como mero entretenimiento. Actualmente con la nueva versión NXT, ayuda a alumnos desde 5 a 8 años a descubrir que la ciencia también pude ser entretenida; desarrollando progresivamente sus habilidades construyendo y programando simpáticos robots y motivándolos a investigar por sí mismos poniendo en práctica lo aprendido en desarrollos anteriores. Para ello se ha dotado a Lego Mindstorms de entornos de programación gráficos muy intuitivos y de gran cantidad de modelos con ayuda paso a paso. Sin embargo Lego Mindstorms también tiene salida fuera del entorno escolar (primaria y secundaria) donde se emplean con diversos fines empleando entornos de programación más 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 Minds tor ms en la enseñanza

7.1.1. Método de trabajo En el campo de la enseñanza Lego Mindstorms ha sido concebido como una herramienta con la que investigar y ser curioso, por tanto el profesor durante el trabajo con los niños 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 algún punto de vista alternativo. Se deberá por tanto: • Comprometer a los estudiantes con un problema relacionado con sus intereses y que se abordará tecnológicamente. Numerosas experiencias con niños 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 planteándoseles situaciones de cuentos populares del lugar, a continuación se les invitaba a reproducir el mismo mediante robots que

Página 153


recreaban combates o personajes del mismo. Se pudo observar como rápidamente los niños se involucraron con el problema. En otras ocasiones, con alumnos más mayores, se pudo comprobar lo contrario. Se hizo construir a los alumnos un robot capaz de competir en dos pruebas simultáneamente: sumo y seguimiento de una línea; se debía buscar un compromiso en las características 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 línea, haciendo un robot mediocre en este sentido; y se dedicara a la prueba de sumo con un mayor carácter 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 sólo 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 diseño está abierto, y por tanto hay múltiples soluciones "correctas" al problema, si bien habrán 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 género de los grupos, cabe descacar algunos aspectos importantes referidos a la enseñanza a niños de poca edad: Los chicos tienen generalmente más 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 están haciendo; ellas por su parte tienden a elegir cuidadosamente las piezas a usar y se muestran más dispuestas a compartir sus ideas. Un buen método para vencer estas diferencias se ha visto que es la elaboración de un plano previo, aunque no termine siguiéndose, habrá servido para promover la organización dentro del grupo. Otra forma de trabajo que se ha empleado ha sido la de hacer inicialmente grupo de sólo chicas y de sólo 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 podrán hacerse mixtos. En cuanto al trabajo cooperativo, como método de aprendizaje informal, podemos afirmar que es algo fundamental, no sólo en el trabajo con robots o en la enseñanza; sino en el desarrollo como persona de cara a un futuro, puesto que fomenta las capacidades de trabajo en equipo,

Página 154


el liderazgo y la toma de decisiones. En este sentido, de nuevo la utilización 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 explícita, las matemáticas, la ciencia, u otras ideas implícitas 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 construcción de un robot. • Fomentar la imaginación así como habilidades como el diseño y la construcción. • Introducir al alumno a la programación, ya sea en entornos gráficos o de más 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 través de la prueba y el error. • Fomentar la cooperación entre alumnos. • Y con todo ello a los alumnos que la ciencia es entretenida. Durante todo el proceso el profesor se convertirá en cómplice 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 práctico: Visita al grup o Complubot. El pasado 14 de Noviembre nos visitaron unos chicos del colegio Miguel Hernández y nos hablaron, de su experiencia con Lego Mindstorms. Al día siguiente nos acercamos nosotros los a fin de ver su trabajo más de cerca. A continuación resumimos el encuentro: Según llegamos pudimos ver cómo un padre intentaba apuntar a su hijo en la actividad, desafortunadamente, la demanda de las clases y la escasez de medios hacía imposible que este nuevo alumno se pudiese integrar. Primera lección aprendida, en España estamos a años luz de otros mucho países y lamentablemente si alguien quiere trabajar con en estos temas (robótica 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 España que imparte una asignatura de este tipo, aun con carácter extraescolar. Por esto mismo, ser los primeros, han tenido que empezar desde muy abajo.

Página 155


Al parecer todo comenzó gracias a la afición a estos temas del por entonces miembro del APA Fernando Gallego. En un viaje al extranjero comprobó lo integrado que estaba la robótica en la enseñanza de otros países y desde entonces se propuso crear una actividad extraescolar que fuese más allá del típico curso de ofimática que se imparte a los

alumnos.

Con un presupuesto inicial que no dio más 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, obstáculos de distinta índole que identificar/esquivar etc

Imagen obtenida de http://complubot.educa.madrid.org Actualmente están en la transición de los módulos RCX a NXT y el mayor problema para los alumnos es el cambio de filosofía en la construcción 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 travesaños. Tardarán todavía algún 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 continuación las organizan perfectamente en cajas según sus funcionalidades. - ¿A quienes va dirigida la actividad extraescolar? Actualmente hay dos grupos con niños de niños de 6º, 1º y 2º de la ESO por un lado; y un poco más mayores por otro; para el próximo año se pretende abrir un nuevo grupo para niños aún más pequeños.

Página 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 más que ponerse a pensar antes de hacer las cosas), esa es la gran ventaja. Sin embargo para los alumnos más 'mayores' ya se les está quedando pequeño el mundo de Lego puesto que, aunque hacen grandes diseños 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 relación resistencia-peso suficiente entre otros actores. Esto hace que se estén moviendo al uso de DSPs y estructuras más complejas de contrachapado para poder competir en certámenes 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 España son el único grupo que se

dedique al trabajo con robots, sin embargo en todo tipo de países esto esta muy avanzado. De sus experiencias nos cuentan que es muy divertido y gratificante el contacto con otros grupos de desarrollo, especialmente con países occidentales, otro tipo de países menos desarrollados como Irán etc al parecer hacen de su reconocimiento en el campo de la robótica una forma de darse a conocer y por tanto imponen un secretismo que les impide intercambiar conocimientos con ellos.

7.1.4. Algunas estadísticas 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 diseño y construcción que se espera del uso de esta herramienta.

-

Más del 77 % de los estudiantes está de acuerdo en que el trabajo con robots de Lego les ayuda a pensar de forma crítica y a cooperar con sus compañeros para el logro de los objetivos

En un entorno universitario de carácter técnico en que se usaba Lego para introducir al alumnado a la programación y a los sistemas empotrados se concluyó [2]: -

El 66% de los estudiantes tasó sus habilidades de programación como débil 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 Ciarán Mc Goldrick, Meriel Huggard. [2] The Qualitative Impact of Using LEGO MINDSTORMS Robots to Teach Computer Engineering Andrew B. Williams

Página 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 enseñanza 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 enseñanza de sistemas integrados.

-

Finalmente, el 60 % de los estudiantes dijo que recomendarían LEGO MINDSTORMS el laboratorio de Robot en el futuro. Y un 32 % dijo que también lo recomendarían para el empleo continuado durante el curso.

7.2. Lego Mind sto rms: versi ón educativa vs comerc ial Hay varias diferencias entre la versión comercial y la educativa. En España la primera diferencia puede ser la siguiente: mientras que la versión educativa estará disponible en breve en castellano, la versión comercial no saldrá a la venta al no estar prevista su traducción al Catalán, Gallego y Vasco. En el software, la principal diferencia es el tutorial de programación. El tutorial aparece dividido en dos partes: en la primera sólo se utilizan los bloques de programación presentes en la paleta básica (similar a la del NXT comercial) y está compuesta de 20 propuestas de programación; 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 simulación, una guía de montaje y otra de programación. 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 versión comercial los sensores y motores del RCX, mientras que con la educativa ya se puede hacer.

7.3.

Entornos

de

programación

por

franjas

de

edades:

Evolución Tanto la versión comercial como la educativa han sido desarrolladas por Nacional Instruments y las dos están basadas en LabView. Sin embargo, este no es el único software comercializado por LEGO para el NXT ya que también está disponible la versión 2.9 de Robolab. Esta versión de Robolab tiene como objeto facilitar la transición del RCX al NXT y dar soporte a los dos sistemas además de ofrecer un nuevo firmware para el RCX. No obstante en el plan de desarrollo de LEGO NXT Educación se puede observar que el horizonte de aprendizaje es el uso del NXT con LabVIEW. Página 158


De hecho, la nueva filosofía de Lego es la de crear entornos de programación adaptados a cada franja de edad a diferencia de lo que había 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 evolución prevista del software de Lego.

En 2010, ‘LEGO Education’ ofrecerá su línea de productos que irán desde la escuela elemental y primaria hasta el mundo real. Página 159


7.4.

LabView vs Robolab en el entorn o educativo

A continuación hacemos una pequeña comparativa entre los dos entornos más usados para la enseñanza con Lego. Por una parte Robolab y por otra LabView como herramienta más actual y con mayor perspectiva de futuro. Labview: Cambios respecto a Robolab Básicamente los cambios consisten en que han desaparecido los modos de programación Piloto e Investigador. Ahora sólo se dispone de un modo de programación que se corresponde con el antiguo modo Programador . El modo Piloto, era un modo dirigido al inicio en la programación con niños y niñas que se inician en la programación. Era un modo en el que se iban ofreciendo nuevas instrucciones con cuentagotas y en el que no se podían cometer errores. Era muy limitado pero facilitaba una introducción a la programación muy amigable. También ha desaparecido el modo Investigador . Este modo estaba dirigido principalmente a la investigación científica, registro sistemático de datos, tratamiento de datos y su posterior presentación. Era muy útil en el laboratorio de ciencias y para ello se comercializaban diferentes tipos de sensores ( DCP Instruments ). Su desaparición no es definitiva y quien necesite seguir utilizándolo 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 inalámbrico. Con el Bluetooth desaparecerán muchos de los problemas que se generaban en el aula cuando varios alumnos transferían sus programas al RCX. Es posible conectar de modo simultáneo más de uno a un mismo ordenador. También es posible conectarlo por medio USB. En Robolab el modo Programador ofrecía una amplia colección de bloques de programación que había que distribuir por el escritorio y unir por medio de cables para establecer las secuencias y relaciones en el programa. En LEGO NXT Educación se utilizan mucho menos los cableados, ya que el nexo de unión entre los distintos bloques de programación es una viga LEGO que aparece y se alarga automáticamente.

Página 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 además del cableado. Por otra parte también resulta más fácil desarrollar programas sin errores. En lo que sería la programación básica todos los programas funcionan, hagan o no lo que deseábamos.

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 hacía 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 programación: la primera es la básica 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 cuál es la posición 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 programación ya que permite hacer pruebas previas.

Ahora bien, si lo que tenemos en mente es el modo Programador de Robolab hay ciertas pérdidas de funcionalidad, sobre todo para los usuarios avanzados. Quizá las más evidentes son el uso de la cámara y tratamiento de imagen, el piano para composiciones musicales y el control remoto vía Internet. Tampoco se pueden programar eventos ni establecer prioridades entre tareas. Por otra parte el nuevo software no admite sensores genéricos como lo hacía Robolab.

7.5. Bibl iogr afía educación. 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 kid’s toy.

Página 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. Ciarán 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 Educación; 21 Noviembre, 2006 http://www.euskalnet.net/kolaskoaga/programz/nxt/nxt_g_edu.htm Aula Robótica del APA del C.P. Miguel Hernández, 24 de septiembre 2006 http://complubot.educa.madrid.org/inicio.php?seccion=principal

Página 162


8. Competiciones LEGO El diseño, la construcción y la programación de los robots son una actividad perfecta para la competición. ¿Se comportará el robot como esto debería? ¿Cómo puede esto funcionar más con exactitud, rápidamente, y más sofisticadamente? A los niños les gusta éste tipo de desafíos y sobretodo si les lleva a competir contra otros. En 2005, más de 100,000 niños y aproximadamente 8,000 equipos participaron en acontecimientos competitivos de robótica 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 participación de niños en la ciencia y la tecnología. Uno de los precursores es la PRIMERA Liga LEGO, FLL, en 1998. Otras competiciones, como la Olimpíada de Robot Mundial, WRO, han atestiguado un aumento dramático de la participación de forma que en 2005, tan sólo un año después de su creación, ya había inscritos más de 3700 equipos. Hoy en día existen centros de LEGO MINDSTORMS en países como los EE.UU., Singapur, Japón, Noruega, Suecia, Dinamarca, Irlanda, Alemania y el Reino Unido encargados de dirigir jóvenes en distintos temas del campo de la robótica.

8.1. First Lego League

www.firstlegoleague.com La FIRST Lego League (conocida por su acrónimo FLL) es una competición dirigida a estudiantes entre 9 y 14 años, organizada por la FIRST (r For Inspiration and Recognition of Science and Technology , también organiza la competición de robótica FRC). Cada año se

centra en un tema relacionado con la ciencia, y cada equipo debe presentar diseños acorde a el. Por ejemplo, en el año 2006, el tema era la nanotecnología, y debían de construir robots relacionados con situaciones tan dispares como la informática a la medicina. Deberán pasar diferentes clasificaciones, donde podrán entrar en contacto con los otros equipos, y compartir conocimientos e ideas.

Página 163


Los equipos participantes en la FLL usan Lego Mindstorms kits para construirse pequeños robots autónomos para construir su proyecto. La organización de la competición tiene un acuerdo con la compañía de LEGO. Hay cuatro fases en la competición. 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á diseñado 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 diseñado para competir en la cancha. Los estudiantes tienen ocho semanas para trabajar en su robot. Una vez construido deberán presentarlo a las competiciones locales, de dónde se podrán clasificar a las regionales, estatales y a la final mundial. El año 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 año también se va a celebrar una prueba clasificatoria en España, el día 17 de diciembre de 2006 en CosmoCaixa en Barcelona.

Página 164


8.2. Robocampeones www.robocampeones.com Robocampeones es una competición de robots organizada por el Grupo de Robótica de la Universidad Rey Juan Carlos, dirigida a colegios e institutos cuyo fin es fomentar la afición de los alumnos por la ciencia y la tecnología. Ésta competición se viene celebrando desde el 2003. El objetivo fundamental de Robocampeones es fomentar entre los alumnos de secundaria el interés por las carreras técnicas como las ingenierías (Informática, Telecomunicación, Industriales, etc.). Estas carreras normalmente se perciben como algo difícil y aburrido. Robocampeones sin embargo, presenta la tecnología como algo vistoso y divertido. Además, al plantearse en formato concurso, el aliciente de la competición lo hace más emocionante y atractivo. En la prueba sólo se pueden usar exclusivamente robots construido con LEGO, aunque excepcionalmente se permite el uso de algún sensor o adorno casero. En la competición celebrada éste año, se celebraron dos pruebas: Prueba “ El transportista” El propósito de esta prueba es construir un robot capaz de seguir una línea de forma que pueda coger y transportar dos latas de refresco de un extremo a otro de la línea. Gana aquel robot que lo haga en el menor tiempo posible.

Prueba de Fútbol 2+2 El propósito de esta prueba es realizar un pequeño partido de fútbol entre dos equipos formados por dos robots móviles cada uno, mediante el uso de un campo y pelota de juego especiales que permitan la orientación de los robots y la localización de la pelota en todo momento.

Página 165


9. ROBOTS Lego Una vez estudiados los robots LEGO, tanto su mecánica cómo su programación, veremos ejemplos prácticos de robots construidos con LEGO, dónde se puede ver toda su potencia.

9.1. Un ejemplo mecánic o. Este ejemplo está tomado de la dirección: http://www.telepresence.strath.ac.uk/jen/lego/demag_crane.htm (Realizado por Jennifer Clark)

¿Cuál es el modelo real y cuál es el modelo LEGO? Tal es la potencia de Mindstorms, que cualquier diseño que uno se proponga es posible. En éste ejemplo se ha construido con LEGO una fiel reproducción de la grúa modelo Demag AC535.El modelo en Lego pesa 3,6kg. Sólo nos centraremos en cómo se han construido los

elementos mecánicos más importantes con LEGO. La dirección: Al motor se le ha añadido una reductora con una relación 36:1(es decir, 36 vuelta del motor se convierten en una). Así se consiguen movimientos lentos pero potentes, necesario para controlar con precisión y firmeza la dirección de la grúa. El eje de la dirección

transmite

el

movimiento

circular a la goma, que es la que mueve a las ruedas directrices.

Página 166


La suspensión: Para la suspensión, 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 vehículo 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 fijarán el eje, absorbiendo las irregularidades del terreno.

Detalles de los tres ejes, y del eje delantero.

La configuración del eje delantero permite hasta una inclinación de 18º sin que el vehículo se incline. Apoyos Se usan para estabilizar a la grúa 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 grúa El movimiento del motor se transmite mediante engranajes a los cuatro apoyos.

Página 167


Ruedas Ruedas motri ces: Para mover la grúa, se utilizan dos motores de LEGO, a la salida de los dos motores se conecta una reductora con una relación 9:1 lo que permite una gran tracción a baja velocidad. El movimiento se transmite a las dos ruedas trasera, para tener mayor agarre y poder circular por los terrenos más difíciles.

Brazo grúa En éste caso se puede ver un ejemplo de cómo se pueden modificar los componentes de LEGO, para adecuarlos a las necesidades necesidades del robot.

Piezas de LEGO a las que se las han añadido roscas para poder controlar el tornillo.

Página 168


Para construir el brazo de la grúa, se ha utilizado un tornillo sinfín. El movimiento del motor hace girar el tornillo, que con su movimiento hace que se eleve el brazo de la grúa.

Chasis final con todos los componentes:

Página 169


9.2. 9.2. Un ejemplo ejemplo de pro gramación: ¿Quién 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 diseño ha sido diseñado por J.P.Brown (http://jpbrown.i8.com/cubesolver.html ( http://jpbrown.i8.com/cubesolver.html), ), construido e implementado con piezas LEGO. Én este ejemplo podremos comprobar la potencia del procesador de LEGO, y cómo se pueden construir diseños complejos, recibiendo gran cantidad de datos, y enviando órdenes.

Partes de la fotografía: -Pinza azul: Se encargará de rotar el cubo, con giros 90º, tanto a izquierda como a derecha. Además, deberá sujetar firmemente la fila central del cubo para evitar giros. Para ello lleva motores LEGO, uno para la pinza, y otro para la rotación. -Pinza amarilla y verde: Encargas del giro de las piezas del cubo. -Cámara de vídeo: Cámara Logitech (muy similar a la que viene con LEGO).Conectada al PC para el procesado de imágenes. -Transmisor de infrarrojos: Enviará la información del PC al RCX. -Bloque RCX, microcontrolador. microcontrolador.

Pasos Pasos d el 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 cámara.

Página 170


-Se posiciona una cara delante de la cámara, la cámara la graba, y manda la información a un PC. El ordenador se encarga de procesar la imagen y de detectar los colores, mediante el siguiente programa (escrito por el diseñador del robot)

Una vez que el programa ha detectado correctamente el color de cada ficha, envía la información, guardad en una matriz, al RCX, vía transmisor de infrarrojos.

-Una vez que el RCX ha obtenido la información, y sabe que color hay en cada cara, aplica el algoritmo de Herbert Kociemba (que resuelve el cubo en menos de 40 r otaciones). -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.

Página 171


10. PRECIOS ORIENTATIVOS A continuación mostramos un listado con precios de algunos de los componentes más 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€ Sólo en brick RCX 99.95€

1111 tecnopiezas 90.00€

Motor con reductora 26.00€

Página 172

Avanzado-Manual-LEGO.pdf

Recommend Documents