Manual de robótica FLL Euskadi

Este documento se publica bajo licencia de Creative Commons (Reconocimiento-No comercial-Compartir

bajo la misma licencia 3.0 Unported). Para cualquier duda respecto a la licencia contactar con el autor en

http://about.me/koldo_olaskoaga.

Contacto Si deseas ponerte en contacto con su autor (sugerencias, propuestas de mejora…) lo encontrarás en

http://about.me/koldo_olaskoaga.

LEGO®, TECHNIC®, MINDSTORMS®, y el logotipo LEGO® son marcas registradas de The LEGO® Group

Donostia, 16 de octubre de 2013

http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es

http://about.me/koldo_olaskoaga

http://about.me/koldo_olaskoaga

Contenido

1 INTRODUCCIÓN ................................................................................................................................................. 1

2 LA FLL ................................................................................................................................................................ 2

LOS EQUIPOS .............................................................................................................................................................. 2 EL RETO .................................................................................................................................................................... 2 CÓMO SE DESARROLLA LA COMPETICIÓN ........................................................................................................................... 2 LOS VALORES .............................................................................................................................................................. 2 EL JUEGO DEL ROBOT .................................................................................................................................................... 3 LA PRESENTACIÓN TÉCNICA ............................................................................................................................................ 3 EL PROYECTO CIENTÍFICO ............................................................................................................................................... 3 LOS RECONOCIMIENTOS ................................................................................................................................................ 4

3 POR DÓNDE EMPEZAR ....................................................................................................................................... 5

PRIMER PASO ............................................................................................................................................................. 5 ESTRATEGIAS .............................................................................................................................................................. 5 EVALUAR LAS IDEAS ...................................................................................................................................................... 5 PASO A PASO .............................................................................................................................................................. 6

4 EL ROBOT........................................................................................................................................................... 7

EL CENTRO DE GRAVEDAD .............................................................................................................................................. 7 SISTEMAS DE DIRECCIÓN ................................................................................................................................................ 7 UN POCO DE FÍSICA .....................................................................................................................................................10 RECURSOS ................................................................................................................................................................11

5 NAVEGACIÓN BÁSICA .......................................................................................................................................12

ALGORITMOS ............................................................................................................................................................12 PROGRAMACIÓN BÁSICA CON NXTPROGRAM ....................................................................................................................12 PROGRAMACIÓN CON NXT-G ........................................................................................................................................13 BLOQUES PARA MOVER EL ROBOT ...................................................................................................................................14 MOVIMIENTOS BÁSICOS ...............................................................................................................................................16 COMENTARIOS EN LOS PROGRAMAS.................................................................................................................................17 POTENCIA MÍNIMA DE ARRANQUE ...................................................................................................................................18 REINICIAR MOTORES ....................................................................................................................................................18 UNA PEQUEÑA MEJORA ...............................................................................................................................................19 CONTROL DEL FLUJO DEL PROGRAMA ...............................................................................................................................19 MIS BLOQUES ...........................................................................................................................................................22 COMPARTIR PROGRAMAS..............................................................................................................................................24 ACTIVIDADES .............................................................................................................................................................25 RECURSOS ................................................................................................................................................................25

6 MEJORAS EN LA NAVEGACIÓN ..........................................................................................................................27

CABLEADOS EN NXT-G ................................................................................................................................................ 27 MEJORA EN LA PRECISIÓN DE LOS GIROS ...........................................................................................................................28 ARRANQUE Y PARADA EN RAMPA ....................................................................................................................................29 USO DE FORMULAS MATEMÁTICAS ..................................................................................................................................30 MOVER HASTA EL TOPE ................................................................................................................................................31 CÓMO HACER DOS COSAS A LA VEZ ..................................................................................................................................32 ACTIVIDADES .............................................................................................................................................................32

7 USO BÁSICO DE SENSORES ...............................................................................................................................34

QUÉ ES UN SENSOR .....................................................................................................................................................34 CÓMO TESTEAR SENSORES ............................................................................................................................................34 CARACTERÍSTICAS DE LOS SENSORES ................................................................................................................................35 CÓMO MONITORIZAR SENSORES .....................................................................................................................................39

ROBOT QUE SIGUE UNA LÍNEA ........................................................................................................................................41 CALIBRACIÓN DEL SENSOR DE LUZ ...................................................................................................................................42 ERRORES FRECUENTES .................................................................................................................................................43 ACTIVIDADES .............................................................................................................................................................44 RECURSOS ................................................................................................................................................................44

8 USO COMBINADO DE SENSORES ......................................................................................................................45

ÁLGEBRA DE BOOLE ....................................................................................................................................................45 MONITORIZAR UN SENSOR ............................................................................................................................................48 CÓMO MONITORIZAR DOS SENSORES ...............................................................................................................................49 SEGUIR LÍNEA II ..........................................................................................................................................................50 MÚLTIPLE CALIBRACIÓN DE SENSORES DE LUZ.....................................................................................................................51 ACTIVIDADES .............................................................................................................................................................58 RECURSOS ................................................................................................................................................................59

9 NEUMÁTICA ......................................................................................................................................................60

NEUMÁTICA Y FLL ......................................................................................................................................................60 ELEMENTOS NECESARIOS ..............................................................................................................................................61

10 DIBUJO DE MODELOS LEGO ..............................................................................................................................62

POR QUÉ DIBUJAR .......................................................................................................................................................62 CON QUÉ DIBUJAR ......................................................................................................................................................62 LEGO DIGITAL DESIGNER .............................................................................................................................................63 LDRAW ....................................................................................................................................................................63 SR 3D BUILDER .........................................................................................................................................................64 RECURSOS ................................................................................................................................................................64

APÉNDICE 1: PIECERÍO ...............................................................................................................................................66

EL NXT ...................................................................................................................................................................66 MOTORES ................................................................................................................................................................68 SENSORES ................................................................................................................................................................68 ESTRUCTURAS ...........................................................................................................................................................70 ELEMENTOS DE UNIÓN .................................................................................................................................................75 TRANSMISIONES MECÁNICAS ......................................................................................................................................... 76 COMPRA DE NUEVAS PIEZAS ..........................................................................................................................................84 RECURSOS ................................................................................................................................................................86

Manual de robótica FLL 1

1 Introducción

Desde el inicio de la FLL Euskadi colaboro con Innobasque en su organización asumiendo responsabilidades en los

aspectos relacionados con la competición de la mesa y ofreciendo formación y soporte a los entrenadores. Disfruto de

ello y considero un lujo poder ser parte de este proyecto de personas e innovación.

Esta guía es una recopilación de recursos que he ido publicando en modo público o privado en el marco de la FLL

Euskadi y en la revista on-line Hispabrick Magazine y pretende ser una herramienta de ayuda para entrenadores y

entranadoras.


2 La FLL

La FLL es un programa de promoción de la ciencia y tecnología acompañado de un importante componente de

innovación. Fue puesto en marcha por FIRST (fundación que promueve el reconocimiento de la ciencia y tecnología) y

LEGO en 1998 en Estados Unidos y Canadá y ha ido creciendo al paso de los años para llegar en esta edición a superar

los 60 países.

Sí, pero ¿cómo hacen FIRST y LEGO para generar un contexto motivador de aprendizaje que haga que niños, niñas y

adolescentes a los que hasta entonces les parecía que la ciencia y tecnología era para otros piensen que ahí puede estar

su futuro?: Todos los años la organización internacional de la FLL elige un tema de alcance global, es decir, que nos

afecte a todos independientemente del país en que vivamos. Alrededor de este tema central establece dos líneas básicas de trabajo, el proyecto científico y el diseño del robot, a lo que hay que sumar el aglutinante de todo lo anterior que

suponen los valores de la FLL.

Los equipos

La mayoría de los equipos están creados en torno a centros escolares de secundaria, aunque también los hay promovidos

desde diferentes asociaciones o formados por grupos de amigos. Un equipo está constituido por un máximo de 10

jugadores que deben unir sus esfuerzos, con la ayuda de su entrenador, para enfrentarse a un problema y buscar

soluciones utilizando la creatividad y el pensamiento analítico.

Los equipos pueden recibir el apoyo de mentores que ofrecen de modo voluntario su apoyo al equipo en aspectos de

carácter técnico, científico o incluso en el diseño de elementos que identifiquen al equipo.

El reto

El punto de partida de la FLL es un desafío que todos los años es desvelado a los equipos participantes entre finales de

agosto e inicios de septiembre.

Aunque hay quin podría pensar que la FLL es sólo una competición de robots, es algo más que eso. El reto no se reduce

a la competición entre robots, aunque probablemente sea la parte que mayor motivación genera, sino que los equipos

han de investigar y presentar un proyecto científico relacionado con el tema central. Además de la parte técnica y científica la FLL cuenta con un código de comportamiento que resume el espíritu de esta competición

Todo esto se ve reflejado en la propia competición, la parte técnica, la científica y los valores se valoran por igual en la

valoración final. La organización de la FLL lo resume de la siguiente manera: el juego del robot y el proyecto son lo que

los equipos hacen, y los valores FLL el cómo lo hacen.

Cómo se desarrolla la competición

Tras un mínimo de 8 semanas de trabajo en equipo llega el día del torneo. Los equipos llegan a la sede del torneo con su

robot, ordenador y elementos de repuesto además de con ganas y muchos nervios. Para muchos equipos es la primera

vez, así que tienen mucho que aprender.

En el día de la competición, los equipos disponen de un espacio reservado en el que pueden hacer sus últimas pruebas y

ajustes. A partir del momento en que las pruebas comienzan, un exigente horario dirige los pasos de los equipos entre

las presentaciones y la competición con los robots.

Los valores

Los valores son básicos en la FLL y así ha de ser comprendido e interiorizado por equipos, entrenadores, escuelas,

familias… y han de impregnar toda la actividad que se desarrolla en la FLL:

Somos un equipo

Trabajamos para encontrar soluciones con la ayuda de nuestros entrenadores

Honramos el espíritu de una competencia amigable

Lo que descubrimos es más importante que lo que ganamos

Compartimos nuestras experiencias con los demás


Mostramos un profesionalismo atento en todo lo que hacemos

¡Nos divertimos!

Los valores son evaluados por los jueces de la misma manera que lo hacen con el proyecto científico y proyecto técnico.

El juego del robot

El juego del robot es la parte más llamativa de la FLL, en ella se concentra la mayor atención aunque, de hecho, no es

más importante que el proyecto científico o los valores.

Los equipos han de diseñar un robot que les permita enfrentarse a las misiones propuestas por la organización. Las

misiones son tareas que dan puntos y el equipo ha de tratar de completar todas las que pueda en un tiempo máximo de

dos minutos y medio. Cada equipo decide en función de su experiencia y de la valoración que hace de la dificultad de

las misiones cuáles tratará de resolver y en qué orden.

Hay un reglamento que impone una serie de restricciones que han de ser respetadas durante la competición, pero a la vez ofrece toda una serie de libertades que permiten a los equipos desarrollar muy diferentes soluciones así como

aplicar diferentes estrategias.

Cara a la creatividad hay un punto muy importante en el reglamento que dice así:

"Si un detalle no es mencionado, entonces no importa. Asumiendo que habéis leído todas las misiones, reglas, y

Preguntas y Respuestas…

Si no se requiere de un método en particular, entonces cualquier método está bien.

Si no se requiere específicamente algo, entonces no tenéis que hacerlo.

Si no hay restricciones contra algo, entonces está permitido

No hay requerimientos o restricciones escondidas.

Pero hay libertades escondidas – lo que las reglas no dicen."

El juego del robot no se acaba con la competición en la mesa, sino que los equipos han de presentara ante un jurado las soluciones elegidas en el diseño del robot, es lo que se conoce como la presentación técnica.

La presentación técnica

Si bien el resultado es importante, en un proceso de aprendizaje lo es mucho más el camino recorrido.

Este es un aspecto relacionado con la competición de robots, pero aquí lo importante no es la cantidad de puntos

conseguida sino la metodología y estrategias utilizadas para resolver los problemas y las soluciones innovadoras

aplicadas (incluso si su éxito ha sido limitado). Los equipos han de presentar al jurado aquello que ellos consideren

significativo en el proceso de diseño del robot: soluciones que consideren innovadoras, problemas que hayan

encontrado y estrategias utilizadas para resolverlos, resultados de aprendizaje...

Del mismo modo que sucede con el proyecto científico, el equipo tiene 5 minutos para exponer sus soluciones y otros 5

minutos para responder a las preguntas del jurado. La exposición se realiza en torno a una mesa de competición en la

que el jurado puede pedir que se muestre el resultado de alguna de las soluciones propuestas.

El proyecto científico

Cada equipo ha de identificar un problema relacionado con el tema central del reto. Se trata de un proceso de

observación, recogida de información y análisis en el entorno cercano.

Una vez que han seleccionado un problema hay que crear una solución innovadora. Ello exige poner a trabajar la imaginación y el ingenio. Siempre es posible encontrar nuevas soluciones. A veces tras desarrollar una idea nos

preguntaremos cómo no se le había ocurrido a nadie antes.

Durante este proceso de identificación de problemas y creación de soluciones innovadoras es importante buscar

contactos en otros países, equipos con los que compartir inquietudes, y tratar de buscar soluciones que puedan ser

válidas tanto en nuestro entorno como en otras comunidades.

Esto no es sólo un trabajo académico así que es importante compartir con la comunidad nuestras propuestas:

presentaciones a padres y madres, crear una web...


Durante este proceso el equipo puede recurrir a la colaboración de expertos sobre el tema (padres y madres cuya

profesión o formación tenga relación con el tema, profesionales de empresas del entorno...).

En el día del torneo los equipos presentan el proyecto ante un jurado compuesto por voluntarios y voluntarias, en

muchos casos ingenieros, científicos, docentes... El equipo dispone de 5 minutos para exponer su propuesta y durante

otros 5 minutos el jurado hará las preguntas que considere pertinentes. En la presentación es muy importante lo

siguiente:

describir el problema, la comunidad en la que se presenta y la solución.

mostrar que ha sido un trabajo del equipo e incluir las fuentes de información utilizadas

mostrar que ha sido compartida con alguien externo al equipo.

La presentación puede hacerse utilizando una presentación por ordenador, un póster, un poema, una canción, una

representación teatral... el límite únicamente lo pone la imaginación y la creatividad de cada equipo.

Los reconocimientos

Aunque en un programa de promoción de ciencia y tecnología como este lo importante es la experiencia, la oportunidad

de compartirla con jóvenes de otros orígenes… aquí también los equipos que han marcado la diferencia se ven

reconocidos.

Aproximadamente la mitad de los equipos participantes en un torneo reciben un trofeo. Entre ellos, los que hayan

conseguido un mejor resultado entre el juego del robot, el proyecto científico y los valores, tendrán la oportunidad de

pasar a la fase siguiente, nacional o internacional.

La falta de respeto a los valores FLL puede hacer que un equipo no reciba ningún trofeo a pesar de haber obtenido el

mejor resultado en alguna de las categorías.


3 Por dónde empezar

El primer año enfrentarse a la tarea que supone el reto de la FLL puede llegar a superarnos. Es por ello que me permito

dar algunas ideas que pueden ser útiles para algún equipo. Aquí s0olo me voy a referir a las misiones que ha de afrontar

el robot.

Primer paso

La lectura de los documentos básicos es algo que hay que hacer una y otra vez a lo largo del proceso de construir el

robot, programarlo, probarlo y mejorarlo. Conviene empezar por ahí, empaparse en el reglamento, conocer las

misiones… y aclarar las dudas que se han presentado en esas primeras lecturas.

Una técnica que se puede utilizar a la hora de estudiar las misiones puede ser la técnica del puzle, es decir: repartir las

misiones en grupos de tres para que cada grupo analice las misiones que les correspondan, para a continuación explicárselas a los demás.

Estrategias

Si el reto del robot fuese resolver una misión, no habría mucho que hablar, pero desde el momento que es un conjunto

de misiones a desarrollar en un tiempo limitado, es importante reflexionar, analizar diferentes opciones y decidir cuál

es la estrategia a desarrollar.

Pero alguno se preguntará, ¿Qué quiere decir con lo de la estrategia? Bueno, hay una serie de misiones que, en la

mayoría de los equipos, podemos pensar complicado resolver en su totalidad. Eso quiere decir que hay que analizarlas,

valorar su grado de dificultad, ordenarlas y establecer prioridades. El acuerdo que se llegue en el equipo ayudará a

planificar y repartir las tareas de construcción y programación del robot y a obtener un mayor rendimiento del esfuerzo

que se haga.

Podemos imaginar que somos una persona que ha perdido su visión y que como mucho tengo unas ayudas que me

permiten saber si me voy a chocar… pero nada más. Vamos a pensar en una sucesión de acciones que nos permitirá

conseguir el objetivo. Y si se nos ocurre más de una para cada misión, pues mucho mejor, siempre hay tiempo para optar por una u otra.

Y… todavía no hemos montado nada excepto la mesa. Para pensar en clave de estrategias no necesitamos ningún robot,

el robot nos va a distraer en el análisis. Antes de montar nada pensaremos en los mecanismos que necesitaremos diseñar

para aplicar las estrategias que hemos recogido en esta primera ronda: palancas, levas, mecanismos compuestos de

engranajes…

Evaluar las ideas

Una vez que tenemos un buen conjunto de ideas toca evaluar lo que supondrá el llevarlas a cabo en clave de los

requerimientos que implican:

Velocidad

Precisión

Potencia

Complejidad

Tamaño

Necesidad de sensores

Programación

El resultado de todo esto deberá ser una toma de decisiones que dará como resultado una serie de ideas a desarrollar,

con una planificación. Podemos empezar por las más sencillas y dejar las complicadas para más adelante.


Paso a paso

A la hora de resolver las misiones, conviene comenzar paso a paso, tratar de resolver problemas elementales de modo

que poco a poco podamos combinar soluciones para resolver problemas más complejos.

Conviene empezar intentando resolver misiones de modo independiente y, una vez seamos capaces de resolverlas,

podremos plantearnos cómo ordenarlas, y si es posible combinar más de una misión en un solo programa. Dependiendo

de las decisiones que tomemos, el resultado final podrá variar.

Hay que evitar empecinarse en resolver una misión que se nos resiste, los puntos conseguidos con una tienen el mismo

valor que con cualquier otra, y obsesionarnos con un problema en particular puede retrasarnos e impedir el progreso por

otros caminos.


4 El robot

El diseño de la estructura del robot es un factor que condiciona su comportamiento. Hay varios factores que hay que

tener en cuenta:

La rigidez limitará las deformaciones cuando se encuentre en movimiento y la robustez impedirá que haya

partes que se desmonten inesperadamente.

La combinación motor-transmisión-rueda hace que el robot sea más rápido o más lento y que sea capaz de

desarrollar mayores o menores esfuerzos.

El sistema de dirección junto al tipo de ruedas utilizadas hará que el robot tenga una mayor o menor maniobrabilidad.

La posición del centro de gravedad tanto de la base móvil como del conjunto base-cargo condicionará la

estabilidad del robot.

La estructura, sistema motor... tiene que estar adaptado a la función que ha de cumplir. En la FLL deberá de buscarse un

compromiso entre los diferentes factores anteriormente mencionados para conseguir un robot eficiente y fiable.

En este capítulo vamos a conocer las diferentes alternativas de control de dirección en robots móviles y aprender a

analizar una base móvil con criterios de movilidad, estabilidad y solidez.

El centro de gravedad

Hay un factor muy importante que siempre hay que tener en cuenta en cualquier diseño mecánico: la posición en que se

encuentra el centro de gravedad. El centro de gravedad va a condicionar el comportamiento del robot, sobre todo en los

arranques, paradas y giros. Un robot aparentemente estable puede balancearse o incluso volcar al arrancar si tiene el

centro de gravedad muy retrasado.

Puede volcar lateralmente al girar si lo tiene muy alto...

El centro de gravedad siempre se tiene que encontrar sobre el polígono que describen los apoyos del robot en el suelo

(triángulo, cuadrilátero…), pero no solo eso, cuando el robot se pone en marcha, se detiene o gira aparecen nuevas

fuerzas que pueden hacer que el robot se balancee o vuelque, esta es la razón de que, como con los coches, convenga

que el centro de gravedad esté lo más bajo posible.

Sistemas de dirección

Una de las primeras decisiones que hay que tomar al montar un robot es el sistema de locomoción que utilizará. Es algo

que condiciona tanto la complejidad de la construcción de un robot como su programación, pero no solo eso, sino que

también su maniobrabilidad.

Podemos fijarnos en nuestro entorno para ver los sistemas que utilizan los automóviles, los triciclos, las sillas de niños y


sillas de ruedas para discapacitados... Utilizan diferentes sistemas para desplazarse en línea recta y girar. Cada uno tiene

ventajas e inconvenientes que habrá que tener en cuenta en función de la aplicación.

Sin pretender ser exhaustivo, veamos algunos de los sistemas.

Dirección diferencial

Este sistema se basa en conectar un motor a la rueda o ruedas de cada uno de los lados del robot. Si los dos motores

giran a la misma velocidad el robot avanzará en línea recta, si giran a diferentes velocidades el robot girará a uno u otro

lado.

Es el sistema más sencillo de implementar, tanto si quiere controlarse la posición del robot en base a los giros de las

ruedas utilizando formulación matemática como si se controla a tanteo.

Es importante tener en cuenta tanto la superficie sobre la que se moverá el robot como la carga que ha de llevar antes de

decidirse por uno u otro. A continuación se presentan cuatro soluciones diferentes.

Robot con dos ruedas y apoyos deslizantes

Esta primera construcción es la más básica, sencilla de montar y programar, aunque no se mueve bien por superficies

irregulares o poco deslizantes. Los robots de la figura se apoyan en las dos ruedas y otros dos puntos que deslizarán

mejor o peor dependiendo de las características de la superficie sobre la que se mueva.

Robot con dos ruedas y un apoyo

El apoyo delantero del sistema anterior se puede sustituir por un tercer apoyo como el de la imagen, aunque su montaje

es más complejo. En este caso la base de apoyo es un triángulo.


¡¡¡Actualización!!!: LEGO ha creado una nueva pieza para el nuevo sistema LMS Educación EV3 que pone mucho

más fácil montar un robot con este sistema (referencia para pedidos 4610380). Dicha pieza está dotada de una esfera de

acero de 18mm de diámetro..

Robot con dos ruedas y rueda loca

En esta configuración el robot también tiene tres apoyos, pero en este caso se trata de una rueda que puede girar

libremente y se posiciona por sí misma para facilitar los giros. A consecuencia de ello, el tercer apoyo se desplaza hacia

uno y otro lado dependiendo del avance y la dirección. Si el robot va a llevar una carga que puede variar en el tiempo

(ya sea en magnitud o posición) hay que tenerlo muy en cuenta para que mantenga el equilibrio tanto cuando se mueve

en línea recta como cuando gira..

Por otra parte el diseño del mecanismo de la rueda loca condiciona su eficiencia, su tamaño, la distancia entre el eje

vertical de giro y el apoyo en el suelo...

Es posible también utilizar dos en lugar de una del mismo modo que lo hacen las sillas de ruedas y sillas para niños.

Este es el sistema de dirección del modelo básico de LMS Educación.

Robot con sistema de arrastre por orugas

Este sistema ofrece una base muy estable. Este es un robot sencillo de construir. Es un sistema de arrastre compatible

con diferentes tipos de suelo, alfombra, terrazo, parquet… y permite al robot superar pequeños obstáculos. En la imagen puede verse un modelo que lo usa.


Otros sistemas

Otro sistema bien conocido es el que utilizan los coches. Este sistema utiliza dos motores, uno para el avance-retroceso

y otro para el sistema de giro. Son robots estables pero de maniobrabilidad más reducida.

Los robots con patas merecen ser considerarlos aparte y corresponden a un nivel más avanzado.

Accesorios

El reglamento de la FLL define lo que es el robot a efectos de la competición (lo hace así a partir del reto Senior

Solutions). Toma como elemento central la controladora y establece que todo aquellos elementos que se hayan unido a

la controladora con las manos (durante el proceso de montaje del robot) y que está diseñado para no separarse de la

misma, excepto con las manos (desmontaje manual, no partes del robot diseñadas para ser liberadas por él mismo),

forman parte del robot.

Eso quiere decir que también son robot todos los accesorios que se vayan montando a lo largo de la ronda siempre y

cuando estén diseñados para no poder ser separados de otro modo que por las manos.

Es importante diseñar sistemas de enganche rápidos para los accesorios, de tal modo que se pierda el menor tiempo

posible.

Un poco de física

No está de más recordar algunos conceptos de mecánica útiles a la hora de analizar el comportamiento de un robot.

Distribución horizontal de cargas

La posición del centro de gravedad condiciona el modo en el que el peso del robot se distribuye entre ruedas y apoyos.

Hay que tener en cuenta que la fuerza de rozamiento es directamente proporcional a la normal y el coeficiente de

rozamiento.

La normal en cada apoyo dependerá de la posición del centro de gravedad. Conociendo la posición del centro de gravedad planteando un equilibrio de fuerzas y momentos se puede calcular la distribución del peso entre

los diferentes apoyos (para simplificar el ejercicio conviene que el robot sea simétrico, o al menos considerar

que lo es).

El coeficiente de rozamiento dependerá tanto del material con que está hecha la rueda o apoyo como del

material de la superficie sobre la que se moverá.

Distribución vertical de cargas

La posición en el eje vertical del centro de gravedad (su altura respecto al suelo) condicionará el comportamiento

dinámico del robot.

Arranque y parada: En el arranque y parada la fuerza aplicada por los motores producen una aceleración. La


segunda Ley de Newton establece que la aceleración es proporcional a la fuerza aplicada, mientras que la

tercera establece que "con toda acción ocurre siempre una reacción igual y contraria". Así que una fuerza igual

a la aplicada por los motores para acelerar el robot pero de sentido contrario aparecerá aplicada sobre el centro

de gravedad. Si su posición es muy elevada el robot podría llegar a volcar.

Giros: Mientras el movimiento sea rectilíneo uniforme no aparecerán fuerzas que generen problemas, pero

cuando un vehículo describe una curva se generan fuerzas derivadas de las aceleraciones que aparecen en

cualquier giro (incluso si el movimiento es circular uniforme). En todo giro se produce una aceleración

proporcional al cuadrado de la velocidad lineal e inversamente proporcional al radio de giro. Esta aceleración

apunta al centro de giro. Si tomamos en cuenta la tercera Ley de Newton se producirá una reacción igual y contraria que es la que genera que un vehículo pueda volcar en una curva. Si el centro de gravedad está en una

posición elevada habrá que tenerlo en cuenta en los giros.

Recursos

Blog BrickEngineer (http://goo.gl/zbN1cb): muestra cómo determinar el centro de gravedad de un motor, algo

que puede aplicarse para otros elementos o conjuntos de piezas.

Física en la wikipedia:

Leyes de Newwton (http://es.wikipedia.org/wiki/Leyes_de_Newton)

Movimiento rectilíneo uniforme (http://goo.gl/Ob9yj6)

Movimiento circular uniforme (http://goo.gl/YAxvTJ)

http://es.wikipedia.org/wiki/Leyes_de_Newton

http://goo.gl/YAxvTJ


5 Navegación básica

El hardware sin el software no es nada, así que una base móvil no se convertirá en un robot mientras no tenga un

programa que defina sus comportamientos.

En este capítulo vamos a ver cómo crear programas que permitan a un robot llegar a una posición determinada y evitar

obstáculos analizando los factores del entorno que puedan perturbar el movimiento. No hay que olvidar que cuando se

trabaja con robots que se mueven por un espacio real el entorno afecta a su comportamiento y hay pequeños factores

que pueden influir en la repetibilidad.

El proceso de crear un programa comienza por escribir un algoritmo por lo que veremos como escribir el algoritmo de

una tarea sencilla compuesta de pasos que se realizan de modo secuencial, por ejemplo, el algoritmo correspondiente al movimiento de un robot que sigue una trayectoria compuesta de tramos rectos y curvos combinados.

Algoritmos

La definición que da la wikipedia de algoritmo1 es la siguiente: "un algoritmo (...) es un conjunto pre-escrito de

instrucciones o reglas bien definidas, ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos

que no generen dudas a quien deba realizar dicha actividad".

Todos los días utilizamos algoritmos de modo más o menos consciente para vestirnos, asearnos, alimentarnos... A

continuación se pueden leer los pasos dados para limpiarse los dientes (fuente: Programación de Computadores con

Scratch Cuaderno de Trabajo para estudiantes 3ª Edición):

1. Coger la pasta de dientes

2. Destapar la pasta de dientes

3. Coger el cepillo de dientes

4. Aplicar la pasta de dientes al cepillo

5. Tapar la pasta de dientes

6. Abrir el grifo

7. Remojar el cepillo con la pasta de dientes

8. Cerrar el grifo

9. Frotar los dientes con el cepillo

10. Abrir el grifo

11. Enjuagarse la boca

12. Enjuagar el cepillo

13. Cerrar el grifo

14. Secarse la cara y las manos con una toalla

¡Reflexiona! ¿Hay un único algoritmo para cada tarea?

No, los puede haber muy diferentes del mismo modo que puede haber diferentes soluciones para un problema. A veces

decidirse por un algoritmo u otro será cosa de gustos, pero otras veces un algoritmo será más eficiente que otro. Por cierto, ¿Estaba completo el anterior algoritmo? ¿Dónde ha acabado el cepillo de dientes?

Programación básica con NXTProgram

El NXT dispone de una aplicación denominada NXTProgram que permite desarrollar pequeños programas sin

necesidad del ordenador. Es útil cuando se dan los primeros pasos en programación y para testear de un modo rápido el

robot montado.

Los programas constan de 5 pasos con la siguiente estructura:

1 Algoritmo: http://es.wikipedia.org/wiki/Algoritmo


1. Acción: esta acción puede ser movimiento (avance, giro, retroceso por un tiempo determinado o de

modo indefinido para combinarlo con tiempo o sensores), sonido o vacío.

2. Control: vacío, temporizador o hasta que un sensor cumple una condición

3. Acción: esta acción puede ser movimiento (avance, giro, retroceso por un tiempo determinado o de

modo indefinido para combinarlo con tiempo o sensores), sonido o vacío.

4. Control: vacío, temporizador o hasta que un sensor cumple una condición

5. Finalizar o Bucle (el programa se repite hasta que se detiene con el botón gris)

Para que el programa funcione correctamente es importante que las conexiones sean las siguientes (de otra manera no se

conseguirá el comportamiento deseado):

Puerto 1: sensor de contacto

Puerto 2: sensor de sonido

Puerto 3: sensor de luz

Puerto 4: sensor de ultrasonidos

Puerto B: motor izquierdo

Puerto C: motor derecho

Los programas se editan seleccionando de modo secuencial el contenido de los cinco pasos para ejecutarlo al final. Para

modificarlo hay que ir hacia atrás pulsando el botón gris. Estos programas no se pueden almacenar.

Actividad

Crea un programa que haga avanzar el robot hasta una posición y a continuación retroceda hasta encontrarse en la

posición inicial.

Programación con NXT-G

Una vez que ya están definidos los pasos que tiene que completar el robot para desarrollar su tarea (el algoritmo), es

hora de convertirlo en un programa que el robot pueda ejecutar. La oferta de lenguajes para programar un robot LEGO

MINDSTORMS es muy amplia, sin embargo aquí vamos a centrarnos en NXT-G ya que junto a Robolab es uno de los

dos únicos lenguajes permitidos en la FLL.

NXT-G es un entorno de programación gráfico desarrollado por National Instruments a partir de LabView. La primera

vez que se accede a NXT-G conviene ver los vídeos y tutoriales que ofrece el mismo programa.

Acceso al NXT

NXT-G ofrece acceso a los siguientes datos del NXT:

Nombre del NXT: es posible modificarlo. Conviene poner un nombre a cada uno (el nombre se visualiza en el

display del NXT).

Versión del firmware: la última 1.31.

Volumen de memoria libre

Directorio de archivos agrupados en Programas, Sonidos, Gráficos y Otros. Se pueden subir, descargar o

eliminar archivos.

Para acceder al panel de control pulsar sobre el botón superior izquierda del controlador que aparece en el escritorio

cuando se abre un programa.


A continuación podremos acceder primero a las conexiones:

y a continuación a la memoria:

Bloques para mover el robot

Para programar un robot para que se mueva, lo primero es conocer bien los motores que se van a utilizar para ello. Es

posible conectar al NXT diferentes motores pero en la FLL solo se permite utilizar el motor expresamente diseñado para

él.

El motor

El motor LMS tiene un motor de corriente continua y una reductora en su interior. Además de ello un encóder que envía

información a la controladora de tal modo que esta puede conocer la magnitud del giro realizado.

En la web de Philippe E. Hurbain (Philo en Internet) puede obtenerse completa información sobre el motor, con gráficas

de su eficiencia y fotos de su interior. Muy interesantes las gráficas potencia-velocidad en diferentes condiciones de uso.

El bloque "Motor"

El bloque Motor se encuentra en el menú Acción de la paleta Completa.


Este bloque controla el movimiento de un solo motor. Básicamente seleccionaremos en su panel el puerto en el que está

conectado el motor (A, B o C), el sentido de giro y la potencia (de 0 a 100).

Además también ofrece las siguientes opciones:

Acción:

Constante: al ponerse en marcha alcanza inmediatamente el nivel de potencia seleccionado

Rampa arriba: aumentará la velocidad lentamente hasta alcanzar la especificada

Rampa abajo: disminuirá la velocidad lentamente hasta detenerse.

Control: Si se selecciona Potencia del motor compensa la pérdida de potencia causada por la descarga de la

batería. Si se utiliza conviene que la potencia seleccionada sea inferior a 100.

Esperar: Si se selecciona la casilla el programa no continúa adelante mientras no finalice la ejecución del

bloque. En caso contrario inicia el movimiento y sin esperar a completarlo continúa la ejecución del programa

con el siguiente bloque.

Siguiente Acción: Siempre que no se ha seleccionado Duración ilimitada o que esté seleccionada la casilla

Esperar hasta la finalización, se puede optar por Freno (los motores se bloquean) o Flotación (deja de

alimentar los motores, así que puede continuar moviéndose a consecuencia de la inercia).

Ejemplo

Imaginemos que hemos diseñado un brazo que ha de girar un ángulo de 30º y que el motor está conectado directamente

al brazo. Habremos de calcular cuál es la potencia más adecuada para que no sea demasiado brusco, algo que se puede

hacer por tanteo. Dependiendo de la configuración lo detendremos frenando o en flotación. la solución podría ser la

siguiente:


El bloque "Mover"

El bloque Mover se encuentra en la paleta Común, aunque también es posible acceder a él por medio del menú Acción

de la paleta Completa.

Este bloque permite controlar dos motores de modo sincronizado. Dichos motores pueden ser seleccionados por medio

del panel de control estableciendo cuál es el de la izquierda y cuál el de la derecha, facilitando de esa manera el control

del giro. El resto de las opciones son similares a las del bloque Motor. Es un bloque muy útil para mover un robot móvil

aunque hay quien prefiere hacerlo utilizando dos bloques motor.

Movimientos básicos

Para fijar cuánto han de girar los motores, NXT-G permite hacerlo por tiempo, grados de giro del motor (con precisión

de 1 grado) y rotaciones. Además de estas tres opciones tiene una cuarta, ilimitado, muy útil para trabajar con sensores.

Los comportamientos más básicos a programar son el desplazamiento en línea recta y el giro.

Movimientos en línea recta

Cuando se desea que un robot se mueva en línea recta hay que tener en cuenta que hay diversos factores que pueden

generar desviaciones. No todos los motores son iguales así que conviene primero testearlos para conocer qué par de

ellos se comportan del modo más similar. Otro factor que también puede afectar al comportamiento es el relacionado

con los rozamientos internos: incluso con una estructura perfectamente simétrica, los roces no deseados pueden hacer

que se generen desviaciones.

A continuación se presentan dos opciones diferentes para hacer que un motor se mueva en línea recta la distancia

correspondiente a una rotación del motor. Si la rueda está directamente conectada al motor el desplazamiento será el

correspondiente a la longitud del perímetro de esta, mientras que si entre la rueda y el motor hay una transmisión con una relación de transmisión diferente a la unidad habrá que hacer el cálculo correspondiente para saber la magnitud del

desplazamiento esperado.


Este programa utiliza el bloque Mover, pero también puede hacerse utilizando el bloque Motor. El bloque Motor

ofrece una característica de la que el bloque Mover carece, la posibilidad del arranque en rampa, es decir, un arranque

gradual. Es importante que en el primero de los bloques la casilla correspondiente a Esperar hasta finalización no esté

seleccionada. Observar el comportamiento si se selecciona Freno o Flotación, varía.

Movimiento en curva

Si utilizamos un robot con dirección diferencial, lo único que hay que hacer para que gire es establecer diferentes

velocidades para los dos motores. En el bloque Mover se consigue desplazando el control deslizante de la opción

Volante del panel de control a uno u otro lado mientras que si se utilizan los bloques motor con configurarlos con

diferentes velocidades se conseguirá el objetivo. Los resultados deseados se pueden conseguir por tanteo.

Comentarios en los programas

Cuando se crea un programa y ese programa va creciendo, puede suceder que en algún momento no recordemos porqué hemos dado un paso de una manera y no de otro. Por otra parte, en la FLL se trabaja en grupo y un mismo programa

puede necesitar ser modificado una y otra vez por diferentes personas a lo largo de 8 semanas.

Para poder recordad porqué se ha hecho algo de una manera determinada y facilitar la lectura del programa conviene

comentarlos programas, es decir, escribir comentarios en el mismo programa. Para ello primero seleccionaremos la

herramienta Comentarios en la barra de herramientas:


En la imagen siguiente puede verse un ejemplo:

Potencia mínima de arranque

No toda la energía que desarrolla un motor se convierte se convierte en trabajo útil. Parte de ella se pierde se utiliza para

superar las resistencias internas de las transmisiones.

Cuando las transmisiones son complejas las perdidas pueden crecer debido al rozamiento entre los distintos elementos

que la componen. Ingenieros e ingenieras tratan con sus diseños mejorar el rendimiento de diferentes máquinas.

Por otra parte, el peso del robot también va a influir en el rendimiento. Estos dos factores harán que el robot requiera una potencia mínima para moverse, por debajo de ella no podrá ponerse en marcha.

Reiniciar motores

El bloque Reiniciar motor se encuentra en el menú Avanzado de la paleta Completa.

Este bloque que permite reiniciar los motores, es decir, poner los encoders (los que controlan el giro) a cero. Es un

bloque que conviene incluir entes de los bloques Motor o Mover si nos parece que hay problemas de control del giro

de los motores. Hay quien incluso recomienda meterlo entre los bloques de movimiento cada vez que los utilizamos..

En el panel de control de configuración se puede seleccionar uno, dos o los tres motores.


Una pequeña mejora

Si bien desarrolla la tarea asignada, el movimiento no es fluido, sino que cuando la ejecución pasa de un bloque al

siguiente los motores se paran y arrancan otra vez. Por defecto el bloque Mover tiene seleccionada la casilla Freno en

su panel de control, lo que hace que finalice su ejecución bloqueando los motores y poniéndolos en marcha otra vez con

el siguiente bloque.

Se puede mejorar algo su comportamiento seleccionando la casilla Flotación en lugar de la de Freno. De este modo al

final de la ejecución del bloque en lugar de bloquear los motores lo que hace es dejar de alimentarlos de tal modo que

incluso podría seguir moviéndose gracias a su inercia.

Control del flujo del programa

A veces el algoritmo para realizar una tarea puede ser tan sencillo como el siguiente:

1. Avanza un metro

2. Cierra la pinza

3. Retrocede un metro

Es una tarea con tres pasos a ejecutar de modo secuencial, no tiene más. Pero en otros casos, hay pasos que se repiten,

hay que esperar a que se cumpla alguna condición o se toman decisiones que dan lugar a una u otra acción.

En esos casos el flujo deja de ser lineal y se utilizan lo que se llaman estructuras de control, dos de las cuales vamos a

ver en este capítulo.

Los bloques que permiten programar utilizando estas estructuras se encuentran en el menú Flujo. Es importante observar que los bloques de este grupo tienen una franja naranja que los identifica, del mismo modo que los de sensores

la tienen amarilla.


Bloque "Bucle"

El bloque Bucle se encuentra en la paleta Común, aunque también es posible acceder a él por medio del menú Flujo de

la paleta Completa.

La función del bloque Bucle es ejecutar una y otra vez un conjunto de bloques mientras una condición se cumpla. Para

ello lo único que hay que hacer es arrastrar a su interior el conjunto de bloques cuya ejecución ha de repetirse.

En el panel de control la opción Control ofrece un menú desplegable por medio del cuál puede seleccionarse el

comportamiento deseado:

Siempre: El bucle se ejecutará sin fin, será necesario utilizar el botón gris del NXT para detenerlo. Aunque hay

una opción más avanzada que también permitiría detenerlo desde el mismo programa.

Sensor: El bucle repetirá su ejecución hasta que la lectura del sensor cumpla la condición establecida.

Tiempo: El bucle se repetirá durante el periodo de tiempo deseado. Una vez que el tiempo pase, el programa

continuará con el bloque que encuentre a continuación del Bucle.

Contar: El bucle se repetirá durante un determinado número.

Lógica: Es una opción avanzada de uso que se verá en próximas unidades.

Al seleccionar una u otra de las anteriores opciones, el panel de control muestra un aspecto adaptado a las necesidades

de configuración de cada una de ellas.

La opción Contador que puede verse en la parte inferior permite acceder al número de veces que se ha repetido el bucle

desde el programa y utilizar o visualizar dicho valor.

Ejemplo

Un ejercicio de iniciación con este bloque es hacer que un robot se mueva describiendo un cuadrado. Es algo que se

podría hacer utilizando el siguiente algoritmo:

1. Avanza

2. Gira 90º (a la derecha)

3. Avanza



5. Avanza


7. Avanza


No se escapa a nadie que la secuencia avance-giro se repite 4 veces, así que el algoritmo podría ser el siguiente:

1. Repite 4 veces

Avanza

Gira a la derecha

Si lo convertimos en un programa en NXT-G tendremos lo siguiente:

Bloque "Espera"

El bloque Espera se encuentra en la paleta Común, aunque también es posible acceder a él por medio del menú Flujo

de la paleta Completa.

En la paleta Común se puede elegir el bloque directamente adaptado al uso (espera tiempo o los diferentes sensores)

mientras que si lo utilizamos vía la paleta completa lo primero que deberemos hacer será seleccionar el control deseado,

sensor o tiempo.


La imagen a continuación es el aspecto del bloque cuando se selecciona la opción sensor de contacto.

Funcionamiento

Cuando el programa llega a un bloque Esperar, la ejecución no pasa al bloque siguiente hasta que la condición que

establece se cumpla. Puede ser tanto tiempo como la lectura de un sensor. Su uso más habitual está ligado a los

sensores.

Tanto el bloque Mover como el bloque Motor llevan incluido la función Espera (la duración en tiempo, giro en grados

o rotaciones) aunque no seamos conscientes de ello. No lo lleva si seleccionamos la opción Ilimitado.

Los dos programas siguientes son equivalentes en su funcionamiento solo que en el primero el tiempo de ejecución se

controla vía el bloque Espera.

Mis Bloques

Cuando se programa un robot para describir un recorrido determinado en la mesa de competición suele haber

fragmentos de programa que se repiten en varias misiones. NXT-G ofrece una herramienta que facilita la reutilización

de estos fragmentos de código permitiendo convertirlos en un nuevo bloque de programación que podremos utilizar

siempre que lo necesitemos en un mismo programa o en varios programas.

Convertir un fragmento de código en un nuevo bloque de programación ofrece las siguientes ventajas:

Comodidad: una vez creado cuando necesitemos ese fragmento de código no habrá que crearlo otra vez. Se

podrá utilizar desde cualquier programa.

Programa más legible: a la vez de reducir el número de bloques que constituye el programa lo estructura en pasos que permiten comprenderlo mejor.

Mejor uso de la memoria: el NXT tiene una memoria limitada. Cuando se crea un bloque propio y se reutiliza

en un programa el consumo de memoria es inferior al que supondría el mismo programa sin utilizar bloques

propios.


Los nuevos bloques pueden tener entradas y salidas de datos si es necesario. En la siguiente imagen se puede ver una

pequeña parte del bloque g_selecctlevel del programa anterior.

El proceso de crear un nuevo bloque de programación es bastante sencillo. Se empieza escribiendo el fragmento de

código que habrá de ejecutar el nuevo bloque. Por ejemplo una secuencia de notas que reproducirán una melodía.

A continuación se seleccionan el fragmento de código que ha de ejecutar el nuevo bloque y se selecciona Crear un

nuevo Mi bloque en el menú Edición.

En la ventana de diálogo que se abre se puede dar un nombre personalizado al bloque y escribir una descripción. Si a continuación se pulsa el botón Finalizar, NXT-G crea un nuevo bloque con un icono genérico. Si se desea modificar el


icono habrá de pulsarse el botón Siguiente.

A partir de este momento se podrá acceder al nuevo bloque desde la paleta Personalizada.

Compartir programas

Compartir un programa es una tarea bien sencilla, es suficiente con enviar el archivo del programa a quien deseemos,

pero esto no es así cuando se han utilizado bloques creados por uno mismo. En dicho caso hay que hacerlo como se

explica a continuación.

NXT-G incorpora a partir de la versión 2.0 la herramienta Pack and Go que permite crear un archivo que contenga el programa y los nuevos bloques. Para utilizarla primero hay que abrir el programa a empaquetar y acceder a

Herramientas > Crear Pack and Go.

La opción Crear Pack and Go abre un cuadro de diálogo que muestra los archivos que empaquetará. Es posible

modificar el nombre del archivo y el directorio donde lo ha de guardar. Pulsando Aceptar finaliza el proceso.


Actividades

Actividad 1

Programar un robot que sea capaz de desplazarse hasta un punto determinado de modo preciso evitando todo contacto

con los objetos que pueda haber en el camino. Se puede utilizar con campo de operaciones un suelo con varias sillas o la

misma mesa de la FLL.

Es muy importante que aun siendo una actividad sencilla se siga el procedimiento propuesto: crear primero el algoritmo y después el programa.

Una vez superada la actividad se testearán las consecuencias en el comportamiento del robot al añadir algún accesorio a

cargo.

Actividad 2

El robot ha de desplazarse utilizando como referencia la pared. La clave está en la estructura y apoyarse en la pared con

una ligera deriva hacia el lado en el que se encuentra la pared que se verá compensada con la resistencia de ella.

Actividad 3

El robot ha de desplazarse hasta cierto punto con rapidez. Es una actividad de compromiso entre rapidez y precisión.

Permite analizar los efectos de las aceleraciones e influencia de la posición del centro de gravedad en ello.

Los modos para obtener velocidad pueden ser utilizando ruedas grandes o por medio de una transmisión por engranajes.

Un ejercicio que se puede hacer de modo adicional es calcular las equivalencias entre un grado de giro del encóder y el

desplazamiento longitudinal.

Actividad 4

El robot ha de describir una trayectoria con giros precisos. Esta es una actividad de construcción y sistemas de giro que

permite apreciar el efecto de utilizar diferentes tipos de ruedas, el del rozamiento...

Si se hace con diferentes sistemas de dirección y diferentes posiciones del centro de gravedad facilita compararlos y

sacar conclusiones.

Recursos

Estos documentos son de carácter general, no hacen referencias a NXT-G, pero son muy útiles a la hora de iniciarse en

el aprendizaje de la programación. Los tres los ofrece Eduteka en su web.

“Guía de Algoritmos y Programación para docentes” en http://www.eduteka.org/modulos/9/298/

“Programación de Computadores con Scratch. Cuaderno de Trabajo para estudiantes (Tercera

Edición)” en http://www.eduteka.org/modulos/9/298/

“Currículum Algoritmos y Programación” en http://goo.gl/BmybBj

Los siguientes libros pueden ser adquiridos tanto en papel como en versión eBook.

"Winning Design!: LEGO MINDSTORMS NXT Design Patterns for Fun and Competition", James

Jeffrey Trobaug: Interesante libro dirigido a equipos de la FLL.

"Winning LEGO MINDSTORMS Programming LEGO MINDSTORMS NXT-G Programming for Fun

and Competition", James Trobaugh, Mannie Lowe: Este libro también dirigido a la FLL en el aspecto más

específico de la programación.

"The Art of LEGO MINDSTORMS NXT-G Programming", Terry Griffin: Libro sobre programación en

NXT-G

Vídeos:

“Presentación de NXT-G” http://youtu.be/swWzEI0CVoo

“Cómo crear un nuevo bloque” http://youtu.be/9SKzBTFQ8UA

http://www.eduteka.org/modulos/9/298/

http://www.eduteka.org/modulos/9/298/

http://goo.gl/BmybBj

http://youtu.be/swWzEI0CVoo

http://youtu.be/9SKzBTFQ8UA


Web

Web de Philippe E. Hurbain (http://www.philohome.com/nxtmotor/nxtmotor.htm): abundante información

sobre LEGO MINDSTORMS y en particular sobre las características de los motores.

http://www.philohome.com/nxtmotor/nxtmotor.htm


6 Mejoras en la navegación

Para mejorar en la navegación también hay que mejorar el conocimiento de las herramientas de programación.

En esta unidad se dan algunas ideas de mejora, pero todavía sin llegar a utilizar sensores.

Se introduce el uso de cableados, algo que da precisión y cuyo uso es necesario cuando se quiere programar con

variables y operaciones matemáticas.

Cableados en NXT-G

NXT-G está basado en LabView, un lenguaje de programación gráfico que utiliza “cables” para unir los diferentes

bloques de programación y transportar datos (valores numéricos, cadenas de texto, valores lógicos verdadero/falso...).

NXT-G también utiliza cables para transportar datos, aunque no son necesarios al iniciarse en su programación. Sin

embargo, si se quiere avanzar en el dominio de NXT-G y desarrollar programas más complejos es necesario dominar el

uso de cables de datos.

Para las conexiones hay que desplegar los concentradores de datos de los bloques de programación haciendo clic en su

parte inferior. En la siguiente imagen puede verse el bloque Visualizar con el concentrador cerrado y abierto.

Un ejercicio básico de cableado es el convertir un número en texto para poder mostrarlo en el monitor del NXT, por

ejemplo la lectura del sensor de ultrasonidos. El programa será el siguiente:


Los cables presentan diferentes colores en función del tipo de datos que transportan. El amarillo se corresponde a valores numéricos, el naranja a texto y el verde a valores lógicos. Si se realizan conexiones ilegales, las que unen

conectores de diferentes tipos, el cable adquiere el aspecto de la siguiente figura. En dicho ejemplo se ha intentado unir

una salida con valor numérico con una entrada que espera un texto.

Mejora en la precisión de los giros

El control deslizante del panel del bloque Mover ofrece 10 posiciones diferentes para giros a la izquierda y 10 para

giros a la derecha. Esto puede ser suficiente en muchas ocasiones, pero puede darse el caso de que en una posición se

pase y en la anterior no llegue.

El giro también puede establecerse con valores numéricos entre 0 y 100 en un sentido y entre 0 y -100 en el otro. Hay

que recordad que el valor 100 supone que el robot girará sobre sí mismo en un sentido y con -100 en el otro.

Para dar la entrada del valor deberemos utilizaremos una variable en la que almacenaremos la magnitud del giro

deseado. Una vez que tengamos abierto un nuevo programa iremos a Edición > Definir nueva variable. Crearemos

una nueva llamada Giro tipo Numérica (ha de almacenar un valor numérico).


En la siguiente imagen puede verse un pequeño fragmento de código que muestra cómo almacenar un valor en la

variable previamente definida y utilizarla para establecer la magnitud de giro (una curva más abierta o más cerrada). Se

puede cambiar el valor de una variable siempre que se desee.

El primer bloque guarda en la variable Giro el valor deseado. El segundo lee el contenido de la variable y vía el cable

amarillo asigna dicho valor a la toma de datos Volante.

Arranque y parada en rampa

Si bien conviene que el centro de gravedad esté bajo, en ocasiones la necesidad a cubrir puede impedir que esté tan bajo

como se desea. En dichos casos, los arranques y paradas pueden hacer que se balancee o vuelque (del mismo modo que

puede suceder con una motocicleta o una bicicleta al frenar en seco).

Un modo de evitar esta situación es utilizando un arranque en rampa, es decir, en lugar de meter toda la potencia a la vez hacerlo progresivamente hasta llegar al valor deseado. El bloque Motor tiene esta opción incluida, pero dado que el

bloque Mover no la tiene tendremos que hacerlo de otro modo. Veamos el algoritmo para que el robot arranque

acelerando progresivamente, avance durante dos segundos y frene de la misma manera.

1. Definir una variable que guarde el valor de la potencia a asignar al bloque Mover.

2. Asignar a la nueva variable el valor inicial 0

3. Repetir lo siguiente 100 veces (para llegar a potencia 100)

Asignar el valor almacenado a la toma de datos Potencia del bloque Mover

Sumar una unidad a la variable

Esperar 0,01s (así dado que se va a repetir 100 veces pasará de 0 a 100 en 1s).

4. Avanzar durante 2 segundos a potencia 100

5. Repetir lo siguiente 100 veces (para bajar a 0)

Asignar el valor almacenado a la toma de datos Potencia del bloque Mover (el último era 100)

Restar una unidad a la variable

Esperar 0,01s (así dado que se va a repetir 100 veces pasará de 100 a 0 en 1s).

Una vez que tengamos abierto un nuevo programa hemos de crear la nueva variable. Le he puesto como nombre

potencia y será del tipo Numérica (ya que ha de almacenar un valor numérico).

En la siguiente imagen pueden verse los pasos 2 y 3 del algoritmo.


Se asigna el valor 0 por medio del bloque Variable y se abre un bucle. En el panel de control del bucle se selecciona la

opción Control > Contar hasta 100 veces. En su interior la secuencia de bloques comienza asignando el valor

contenido en la variable al bloque Mover, le suma una unidad y espera una centésima antes de volver a empezar.

El resto del programa:

Para avanzar utilizaremos el bloque Mover con potencia 100 y la opción duración en ilimitado, y a continuación un bloque Esperar con la opción Tiempo 2s. Si en lugar de hacerlo así utilizásemos solo el bloque Mover con la opción

duración 2s no podríamos controlar la frenada de este modo. El resto es similar al bucle inicial, solo que en este caso se

resta una unidad en lugar de sumar.

Actividad

Ahora se trata de practicar, intenta hacer esto último sin utilizar una variable. Para ello fíjate lo que sucede cuando en el

panel de control de la estructura Bucle (Loop) hacemos clic sobre la casilla de la parte inferior Contador.

Uso de formulas matemáticas

Hay ocasiones en los que hay que realizar cálculos matemáticos de diferentes tipos. Veamos cómo se puede hacer con

NXT-G.

Imaginemos que tenemos un robot con unas ruedas de diámetro 40mm y queremos que el robot se desplace una

distancia de 210mm.

En lugar de tantear la magnitud del giro que la rueda ha de dar para ello utilizaremos las matemáticas para calcularlo en

grados. La fórmula a utilizar será la siguiente:

Giroen grados=Distancia

π∗Diametro∗360

Voy a utilizar dos variables para las entradas (distancia y diámetro), así que lo primero será crearlas, del modo en que se

ha visto en uno de los apartados anteriores. Estas variables serán del tipo numérico.

Para crear las fórmulas se utiliza en bloque Matemáticas del menú Datos. Este bloque permite hacer las siguientes


operaciones: suma, resta, multiplicación, división, valor absoluto y raíz cuadrada. El programa será el siguiente:

Mover hasta el tope

Cuando se quiere sujetar un objeto con una pinza o llevar un elemento móvil hasta que llegue a un tope, desconocemos la magnitud del giro con la que tenemos que configurar el bloque Motor (o Mover).

Reflexionemos un momento sobre cómo agarramos algo con la mano: la cerramos hasta que sentimos un nivel de

presión determinado en nuestros dedos, y cerramos cada uno de los dedos más o menos dependiendo de la forma del

objeto. El diseñar y fabricar sistemas de aprensión mecánicos cuya funcionalidad se acerque a la de una mano es un

importante reto tecnológico.

Imaginemos un dispositivo que ha de cerrarse alrededor de un objeto y sujetarlo. Cuando lo montamos con recursos

limitados normalmente su diseño es algo similar a una mandíbula que se cierra hasta que no puede más. Dependiendo si

el objeto queda más cerca o más lejos de la articulación el motor deberá girar más o menos para llegar al tope, así que la

magnitud del giro será desconocida.

Veamos cómo programar el motor para que gire hasta que llegue al tope. Lo que podemos hacer es leer el ángulo una y

otra vez y calcular la velocidad del giro. Cuando llegue al tope esta velocidad se reducirá drásticamente indicando que

ya ha llegado al tope. El algoritmo podría ser el siguiente:

1. Crear una variable que almacene la lectura del sensor de rotación

2. Poner en marcha el motor (en modo ilimitado)

3. Repetir hasta que el incremento de giro en una décima de segundo sea inferior a 5º

Leer el sensor de rotación y asignar su valor a la variable Lectura

Esperar una décima de segundo

Leer el sensor de rotación, restarle el valor de la variable Lectura. Calcular el valor absoluto

de la diferencia nos asegura que no vamos a tener un resultado negativo.

Comparar el resultado del cálculo anterior con 5

4. Detener el motor

El programa será el siguiente (no es una mala idea convertirlo en un Mi Bloque):

El bucle se configura con Control Lógica hasta Verdadero.


Cómo hacer dos cosas a la vez

NXT-G es un software multitarea, es decir, puede ejecutar más de una secuencia de bloques a la vez. Puede ser que

mientras el robot avance queramos que a la vez mueva un dispositivo dependiente del tercer motor. Esto se puede hacer

desde el inicio del programa o a partir de cualquier punto de él.

En la figura aparece un ejemplo en el que se ha convertido el código del apartado anterior en un nuevo bloque (Cierra a

tope) que se ejecuta dos veces en dos puntos diferentes del programa de modo simultáneo al movimiento.

Para ello colocaremos primero el bloque o bloques en paralelo con la línea principal de ejecución. Para el bloque de la

izquierda únicamente se trata de enganchar el bloque con el inicio haciendo clic en el botón izquierdo del ratón y

arrastrando la viga de enlace. Para el caso de la derecha tendremos que pulsar también de modo simultáneo la tecla

Mayúscula del teclado.

Actividades

Actividad 1

Si bien la potencia de los motores puede fijarse entre 0 y 100, el robot no comenzará a moverse con potencia 1 sino que

necesitará un mínimo para ponerse en marcha, algo que dependerá de su peso y diseño mecánico. Si el robot utiliza

diferentes accesorios para diferentes tareas, tal y como se hace en la FLL, esa potencia mínima puede variar. Desarrolla

un programa que permita conocerla, se puede utilizar la pantalla del NXT para mostrarla.

Actividad 2

Trazar un recorrido con varios obstáculos y tratar de que el robot lo recorra con precisión y vuelva al punto de inicio.

Se puede colocar una pelota sobre el robot, de un modo en el que si el arranque o parada es brusco la pelota caiga, e

intentar que se mueva sin que la pelota caiga.

Actividad 3

Cuando se utiliza una pinza o dispositivo asimilable, en la mayoría de los casos tiene una posición de inicio que

ajustamos a mano. Esto se puede hacer de modo automático al iniciar el programa de tal modo que se asegura que

siempre lo hace en la misma posición. Para ello lo que se puede hacer es primero cerrarla del modo que se ha visto en a

Mover hasta el tope y después abrirla el ángulo deseado. Es algo que incluso se puede hacer mientras el robot está ya en

marcha.

Crea el programa de inicializa una pinza y después conviértela en un nuevo bloque que puedes llamar "Inicializar

Pinza".


Actividad 4

A algún programa previamente creado añadirle una secuencia de sonidos que se reproduzca mientras se mueva.

Puede ser cualquiera de las siguientes ideas:

Cuando el robot se mueve hacia atrás reproduce un sonido intermitente al modo que lo hacen los camiones.

Mientras se mueve reproduce una secuencia al modo de sirena de ambulancia.


7 Uso básico de sensores

Un robot que únicamente disponga de una controladora programable y motores para moverse es un robot que ha de

desarrollar sus tareas a ciegas, no puede obtener ninguna información sobre su entorno.

En ocasiones es cierto que hay tareas que pueden realizarse de una manera más eficiente sin sensores e incluso sin

controladora (por ejemplo, el robot de la siguiente figura es capaz de seguir una pared sin necesidad de ningún sensor).

Sin embargo es importante conocer su uso, ya que a menudo va a ser el único modo de obtener información del entorno

y desarrollar la tarea asignada.

Qué es un sensor

Si vamos a la wikipedia2 encontramos la siguiente definición de sensor: "Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas (..) y transformarlas en variables eléctricas."

Entre ellos los hay más sencillos en su construcción y otros mucho más complejos. Estas magnitudes pueden ser de muy

diferentes tipos: distancia, luminosidad, nivel de ruido, temperatura...

Diariamente, aunque sea de modo inconsciente, utilizamos sensores: de temperatura en el calentador de agua para

regular la temperatura, el acelerómetro que detecta la orientación de un smartphone o tablet, el pulsador con el que

tocamos el timbre, y muchos más.

La oferta de sensores para utilizar con robots LEGO MINDSTORMS NXT es muy extensa, además de LEGO hay otras

empresas que los comercializan aumentando la potencialidad del sistema.

Cómo testear sensores

Cuando se usan sensores como el de color o ultrasonidos suele ser necesario tomar medidas de prueba antes de decidir

los valores límite que se utilizarán en los programas. El NXT ofrece dispone de dos pequeñas aplicaciones que permiten

leer los sensores y probar los motores: Try me y View. Se puede acceder a ellas al encender el NXT y navegar con las

flechas grises.

2 http://es.wikipedia.org/wiki/Sensor


View

Permite leer en tiempo real los sensores (incluidos los sensores de rotación de que disponen de modo interno los

motores). Para ello lo único que hay que hacer es lo siguiente:

1. Conecta el sensor al puerto deseado

2. Selecciona en el submenú View el tipo de sensor que deseas leer

3. Selecciona el puerto al que está conectado

4. la pantalla mostrará las lecturas en tiempo real

Try Me

Es otro modo de hacer pequeños test de un motor y sensores aunque es mucho menos útil que View. Su utilidad no vas

más allá se saber si un conjunto sensor-cable funcionan.

Para hacerlo es necesario que las conexiones sean las siguientes:

Motor: puerto A

Sensor de contacto: Puerto 1

Sensor de sonido: Puerto 2

Sensor de luz: Puerto 3

Sensor de color: Puerto 3

Sensor de ultrasonidos: Puerto 4

Características de los sensores

Es muy importante conocer las características de los sensores a utilizar y los factores que pueden perturbar las lecturas.

Los sensores pueden dar sorpresas inesperadas, así que hay que practicar con ellos.

Para empezar será suficiente con conectar el sensor al NXT y observar las lecturas en diferentes situaciones. Siempre

habremos de tener en cuenta que la actividad de un robot se va a desarrollar en el mundo real, eso quiere decir que el

entorno afectará a su funcionamiento en mayor o menor medida.

Sensor de contacto

Este sensor sirve para detectar un objeto cuando se choca con él. Es el más sencillo de todos, de hecho no es mas que un

pulsador que al apretar cierra un contacto y al soltarlo lo abre.

Además de para detectar obstáculos, también puede ser útil para actuar sobre un programa en lugar de utilizar los

botones del NXT, o para detectar cuando un robot llega al borde de una mesa y evitar caerse. Su posición de inicio

puede ser tanto pulsado como sin pulsar, dependiendo de lo que se desee hacer.

Valores de las lecturas

El valor que NXT-G ofrece como lectura del sensor de contacto es un 0 (no está presionado) o un 1 (presionado) aunque

normalmente no se necesita acceder al valor numérico.

Bloques de programación

Si bien hay dos bloques de programación que acceden a la lectura de los sensores, por ahora vamos a ver solo uno, el

que permite controlar el flujo de un programa utilizando sensores: el bloque Esperar que puede ser configurado tanto

para que el flujo de ejecución del programa se detenga durante un determinado periodo de tiempo como para que espere

hasta que el sensor elegido cumpla la condición que se desee.


Su función es detener el flujo del programa hasta que la condición que se establezca en el panel de control sea

verdadera.

La condición será una de las siguientes:

Presionado: el flujo del programa se detiene hasta que el sensor de contacto conectado en el puerto elegido sea

presionado.

Liberado: el flujo del programa se detiene hasta que el sensor de contacto conectado en el puerto elegido sea

liberado. En ocasiones la configuración de un sensor de contacto es que esté presionado mientras no se actúe

sobre él. En dichos casos esta será la condición a utilizar.

Chocado: el flujo del programa se detiene hasta que el sensor de contacto conectado en el puerto elegido sea presionado y liberado.

Factores perturbadores

Lo único con lo que hay que tener cuidado es que el mecanismo responda eficientemente. Habitualmente después de

chocar el sensor ha de volver a su posición original sin necesidad de realizar un esfuerzo.

Sensor de luz

El sensor de luz puede medir la intensidad de luz en un ambiente determinado o la luz reflejada por una superficie. Para

esto último dispone de un led rojo que emite la luz que dicha superficie reflejará. Si la superficie es oscura reflejará menos luz que si es clara. Si es necesario, es posible mantener este led emisor de luz apagado.


El valor que NXT-G ofrece como lectura del sensor está comprendido entre 0 y 100. El valor 0 se corresponde con una

baja luminosidad (poca luz) mientras que 100 es la lectura para altas luces. Son los límites que pocas veces veremos.



que permite controlar el flujo de un programa utilizando sensores: el bloque Espera que puede ser configurado tanto





verdadera. El panel de control permite apagar el led rojo del sensor.


Normalmente el robot va a desarrollar su tarea en entornos iluminados de un modo muy diferente. Incluso a medida que

el tiempo avanza, las condiciones de iluminación pueden variar: el sol se mueve, las nubes lo ocultan, se enciende una

luz...

Si el robot ha de seguir una línea, encontrar una zona oscura sobre un fondo claro... la luz del entorno va a ser un

elemento perturbador que alterará las lecturas del sensor provocando resultados inesperados.

¿Cómo evitarlos? Uno de los modos es montar el sensor lo más cerca posible del suelo y protegido de tal modo que el

mínimo de luz del entorno llegue al sensor. Además de ello conviene calibrar el sensor, es decir, indicarle lo que bajo

dichas condiciones de luz es blanco y lo que es negro.

¡¡¡Atención!!! Si el sensor está demasiado cerca del suelo no será capaz de ver el reflejo de la luz que genera el LED

rojo. Como consecuencia la lectura será siempre "oscuro" independientemente del color de la superficie a la que mira.

Sensor de color

El sensor de color es el resultado de la evolución del sensor de luz. Además de cumplir las funciones del sensor de luz

es capaz de identificar 4 color diferentes además del negro y blanco.


El sensor de color puede ser utilizado tanto como sensor de color o de luz. Si se utiliza como sensor de luz las lecturas

estarán comprendidas entre 0 y 100, de la misma manera que con el de luz.

Cuando se utiliza como sensor de color las lecturas serán Negro, Azul, Verde, Amarillo, Rojo o Blanco.







verdadera. El panel de control permite seleccionar el modo en el que se desea utilizar el sensor (color o luz) así como

los rangos de color que determinan la condición.



Dado que es un sensor que utiliza la luz, los problemas que puede generar son similares a los que genera el sensor de

luz. Así que es muy importante que además de estar perpendicular a la superficie cuyo color ha de apreciar, que la distancia sea reducida y esté protegido en la medida que se pueda de la luz ambiente.

Sensor de ultrasonidos

El sensor de ultrasonidos es muy útil para detectar objetos sin necesidad de tocarlos. Mide la distancia a los objetos que

se encuentran frente a él. Para ello, emite ultrasonidos que rebotan sobre los objetos que se interponen y mide el tiempo

que les cuesta volver tras rebotar. La medida de ese tiempo se convierte en distancia.


El valor que NXT-G ofrece como lectura del sensor de ultrasonidos la distancia al objeto que se interpone en

centímetros o pulgadas (máximo 2,50m).







verdadera. El panel de control permite seleccionar además de la distancia que define la condición en centímetros o

pulgadas.


Uno de los factores que puede generar problemas cuando se mide una distancia con un sensor de ultrasonidos es el

material del que está constituido el objeto interpuesto. Por ejemplo, ciertos tejidos no reflejan los ultrasonidos, así que el

robot no los ve. Las paredes tampoco son todas iguales y un sensor de ultrasonidos no daría el mismo valor de distancia


si la pared está fabricada en Pladour o ladrillo.

Sensor de rotación

Los motores LEGO MINDSTORMS NXT disponen de un sensor de rotación interno que ofrece una precisión de 1º. El

giro de estos sensores pueden ser monitorizados de modo independiente y es posible utilizar las mismas herramientas de programación que se utilizan con el resto de los sensores.


El valor que NXT-G ofrece como lectura del sensor de rotación en grados, aunque también puede pueden obtenerse las

lecturas por rotaciones.



que permite controlar el flujo de un programa utilizando sensores: el bloque Espera que puede ser configurado tanto




verdadera. El panel de control permite seleccionar además de el giro que define la condición tanto en grados como en

rotaciones.

Cómo monitorizar sensores

Cuando se programa con sensores en muchos casos lo significativo no es el valor que lee el sensor, sino saber si esa lectura cumple una condición, por ejemplo, si la distancia que mide el sensor de ultrasonidos es menor que 20 cm o no.

En otros casos el valor de lectura sí será importante, por ejemplo si queremos que un robot vaya reduciendo su

velocidad cuando se acerca a una pared.

Por ahora vamos a centrarnos en en el primero de los casos.

Algunos ejemplos de condiciones

Veamos algunos ejemplos de condiciones de la vida diaria que pueden ayudar a entender lo que va a continuación:

La temperatura en el balcón supera los 20º

La luz del baño está apagada

Ha sonado el timbre de la puerta

Han pasado más de 5 minutos desde que la clase ha empezado


Endika ha llegado tarde

Todas estas condiciones se cumplirán o no, es decir, el resultado al comprobarlas será Verdadero o Falso.

Ejemplo

El programa más básico con sensores es hacer avanzar un robot hasta que choque con una pared y que se detenga en ese momento. El algoritmo correspondiente sería el siguiente:

1. Poner en marcha el robot

2. Esperar a que el sensor de contacto choque con la pared

3. Detener el robot

Este algoritmo se convertirá en el siguiente programa (en este caso un bloque por cada línea de algoritmo, observar que

el bloque Mover está configurado con duración ilimitada, ya que al desconocer el espacio a recorrer será otro bloque el

que se encargue de detenerlo). En estos programas el uso del bloque Espera (visto en la unidad anterior) resulta

imprescindible.

Mejora nº 1

Veamos cómo hay que modificar el programa si queremos que después de chocar el robot retroceda cierta distancia y

gire. El nuevo algoritmo será el siguiente:

1. Poner en marcha el robot

2. Esperar a que el sensor de contacto choque con la pared

3. Detener el robot

4. Retroceder (por ejemplo una rotación)

5. Girar (por ejemplo una rotación)

El nuevo programa será el siguiente:

Mejora nº 2

Ahora vamos a hacer que se mueva por un entorno con obstáculos de modo continuo, es decir, que repita lo anterior sin

fin. Para ello utilizaremos el bloque bucle en el que incluiremos todo lo anterior.


Robot que sigue una línea

Montar y programar un robot sigue-líneas es un clásico. Se puede hacer con un sensor, con dos o se puede utilizar un

dispositivo como el de la figura que dispone de 8 sensores de luz en línea.

En el caso de la FLL deberemos hacerlo con sensores de luz o color. Si se hace con un solo sensor de luz el robot no

puede saber por qué lado se desvía de la línea así que hay que antes de nada hay que reflexionar y definir una estrategia

que nos permita hacerlo. Veamos un par de ellas:

Seguir el borde: El robot sigue uno de los bordes de la línea, por ejemplo, el lado izquierdo de la línea. De

este modo a la izquierda del sensor está el fondo blanco mientras que a la derecha está la línea negra. Se puede programar el robot de tal modo que cuando vea negro gire a la izquierda y cuando vea blanco gire a la derecha.

De este modo se puede seguir la linea.

Seguir la línea: El robot sigue la línea. Cuando lee blanco busca la línea otra vez, girando primero hacia un

lado durante un determinado plazo de tiempo y si no la encuentra gira hacia el otro lado hasta encontrarla.

En general el primero será más eficiente y aquí veremos el modo básico de abordarlo.

El algoritmo

Imaginemos que el robot tiene el motor izquierdo conectado al puerto A mientras que el derecho al puerto C.

El algoritmo para que el robot siga el borde izquierdo de la línea será el siguiente:

1. Repetir los siguientes pasos una y otra vez

Si se ve oscuro girar a la izquierda (esto se puede hacer deteniendo el motor izquierdo)

Si se ve claro girar a la derecha (esto se puede hacer deteniendo el motor derecho)

Mediremos la luz reflejada en una zona negra y en una zona blanca y tomaremos como referencia un valor intermedio.

En el ejemplo ese valor es 40. Si el valor supera 40 será que está sobre blanco y habrá girar a la derecha, en caso

contrario a la izquierda.

El programa

Que en NXT-G será lo siguiente:


Calibración del sensor de luz

Cuando se utiliza un sensor de luz, la luz ambiente, y su variabilidad en el tiempo y el espacio, pueden generar

resultados inesperados. No es lo mismo que el robot desarrolle su tarea en un espacio u otro, la iluminación es un factor

importante.

Para mejorar su comportamiento por una parte conviene proteger el sensor de tal manera que le llegue la menor

cantidad de luz ambiente. Por otra, conviene calibrar el sensor en el mismo espacio en el que el robot desarrollará su

tarea.

Calibrar un sensor es adaptarlo a las condiciones de luz del entorno particular en el que va a desarrollar su tarea, es decirle al robot lo que es blanco y lo que es negro en ese lugar. La calibración conviene hacerla al inicio de cada ronda

si se sospecha que ha podido haber algún cambio en el nivel de luminosidad: en la FLL Euskadi hay un ventanal a un

lado del escenario, así que a lo largo de la mañana la luminosidad varía en mayor o menor medida.

El software NXT-G dispone de un bloque de programación específico para calibrar sensores que facilita desarrollar un

pequeño programa para ello. Este programa almacena un pequeño archivo en el NXT que se convierte en referencia

para los programas que utilizan el sensor de luz (o en su caso el de sonido). Sin embargo, dado que se ha observado que

en ocasiones este sistema de calibración bloquea el robot, es mejor hacerlo tal y como se propone a continuación.

Procedimiento de calibración

Para calibrar el sensor desde el NXT se utiliza el siguiente bloque que puede encontrarse en la paleta de bloques

Completa > Avanzado.

Este bloque se puede configurar vía el panel correspondiente (puede verse en la siguiente imagen).


El programa a utilizar podría ser el siguiente:

El primer bloque elimina la calibración previa.

El segundo bloque inicia una espera para permitir colocar el sensor sobre una zona oscura. No está en espera hasta que

se pulse sino que hasta que se pulse y se suelte, esto es imprescindible en los dos bloques espera sensor, ya que sino, el

programa se ejecuta de un tirón sin permitir moverlo de una zona negra a una blanca..

El tercer bloque establece el límite inferior de luz (oscuro).

El cuarto bloque inicia una nueva espera para dar tiempo a colocar el sensor en una zona blanca.

El quinto lee el sensor y establece el límite superior (altas luces). En la ayuda del NXT-G se explican todos los aspectos

relacionados con el uso de este bloque.

Errores frecuentes

Los dos bloques de programación tienen un aspecto muy similar lo que hace que sea una fuente de errores.

El primero de ellos tiene una franja amarilla sobre él. Su función es conocer la lectura del sensor en el momento que el

programa pasa por él.

El segundo tiene una franja naranja y un reloj de arena sobre la mano. Su función es detener la ejecución del programa

hasta que la condición se cumpla (Espera), en este caso hasta que el sensor de contacto sea presionado.

Lo mismo ocurre con el resto de los sensores, así que en el caso de que se de un comportamiento inesperado

relacionado con sensores y flujo de programa conviene comprobar cuál de los bloques se ha utilizado.


Actividades

Actividad 1

Conecta las luces a los puertos A, B y C y un sensor de contacto a uno de los puertos de sensores.

Crea un programa que reproduzca el siguiente comportamiento tras poner en ejecución el programa:

al pulsar el sensor se enciende la luz conectada al puerto A

al pulsar de nuevo el sensor se apaga la luz conectada al puerto A y se enciende la conectada al B

al pulsar de nuevo el sensor se apaga la luz conectada al puerto B y se enciende la conectada al C

al pulsar de nuevo el sensor las tres se encienden y apagan tres veces en periodos de 0,3 segundos tras lo que el

programa finaliza.

Actividad 2

El robot ha de desplazarse hasta la pared este y detenerse en contacto con ella. Sin eliminar ningún obstáculo has de

programar una sucesión de movimientos de tal manera que llegue a la pared este sin derribar nada y se quede pegado a ella.

Lo importante en esta actividad es trabajar con los encóders y crear nuevos bloques que agrupen fragmentos de

programa que pudiesen sen reutilizados en otro momento. Utilizará un sensor de contacto para determinar cuando entra

en contacto con el muro pero hay que tener cuidado para que no rebote, ya que en ese caso no acabará en contacto

Actividad 3

Material necesario: un robot móvil con un un sensor de luz apuntando hacia el suelo para detectar zonas claras y

oscuras.

Escenario: una hoja de papel blanco, puede ser una de tamaño A4, pegada a un fondo oscuro (puede ser una mesa de

madera, cualquiera que ofrezca un contraste claro-oscuro).

Comportamiento deseado: Colocar el robot sobre el papel. Al poner en ejecución el programa el robot hace lo siguiente:

1. el robot avanza hasta el borde del papel

2. el robot retrocede hasta el otro borde del papel

3. el robot repite lo anterior indefinidamente

Actividad 4

El robot ha de avanzar hasta cruzar dos líneas negras, hacer un giro de 180º y detenerse.

Recursos

Oferta de sensores para el NXT (http://lrobotikas.net/wiki/index.php?title=Sensores): listado y características

de sensores utilizables con LEGO MINDSTORMS NXT.

http://lrobotikas.net/wiki/index.php?title=Sensores


8 Uso combinado de sensores

El siguiente paso en el uso de sensores es aprender a mirar a varios sensores de modo simultaneo (monitorizar varios

sensores). Para ello es necesario conocer cómo operar con datos lógicos y cómo transportar datos por medio de

cableados.

Aunque sea una propuesta con un solo sensor, se ha incluido también un nuevo modo de seguir una línea con un solo

sensor, ya que pienso que no era adecuado para la unidad de uso básico de sensores.

Álgebra de Boole

Las funciones del álgebra de Boole son muy útiles en programación y NXT-G permite utilizar varias de ellas. Estas

funciones permiten operar con valores lógicos, es decir, con valores tales como Verdadero o Falso (estos valores

también pueden ser representados como 1 o 0).

Los resultados de las condiciones mencionadas anteriormente (por ejemplo, la temperatura en el balcón ha superado 220º) son valores lógicos. Si se utiliza una sola condición, o un solo sensor, se puede programar sin recurrir a estas

funciones, pero cuando se combinan dos o más condiciones, como en este reto, las funciones del álgebra de Boole son

muy útiles.

En los cuatro operadores que se presentan a continuación, se indica cómo se calcula el resultado y se presenta la

correspondiente tabla la verdad. Una tabla de verdad es algo similar a lo que en aritmética es la tabla de multiplicar,

esta tabla nos da el resultado de aplicar estos operadores para distintos valores de entrada.


Los bloques a utilizar con valores lógicos se encuentran en el menú Datos que puede verse desplegado en la siguiente

figura. En los siguientes ejemplos se utilizará el primero de ellos, denominado Lógica.

Operador Y (AND)

El operador Y relaciona dos entradas. Para que el resultado sea Verdadero las dos entradas deberán tener el valor

Verdadero. Si cualquiera de las dos es Falso la salida también será Falso. La tabla de verdad de este operador es la

siguiente:

A B Resultado

Verdadero Verdadero Verdadero

Verdadero Falso Falso

Falso Verdadero Falso

Falso Falso Falso

En la imagen siguiente puede verse el modo en el que se utiliza este operador. Los maletines representan variables que

contienen valores lógicos.


Operador O (OR)

El operador O relaciona dos entradas. La salida es Verdadero en el caso en que al menos una de las entradas sea

Verdadero. La tabla de verdad de este operador es la siguiente:

A B Resultado

Verdadero Verdadero Verdadero

Verdadero Falso Verdadero

Falso Verdadero Verdadero

Falso Falso Falso



Un ejemplo de uso de este operador es el caso en el que un robot tiene dos sensores de contacto en la parte frontal uno en cada lado. Utilizando este operador el robot podrá controlar los dos sensores a la vez tal y como se muestra en el

siguiente programa:


El robot se pone en marcha y lee continuamente los dos sensores, combina sus lecturas por medio de la función O y

repite este proceso hasta que el resultado de la operación es Verdadero.

Operador O exclusivo

En este caso para que el resultado sea Verdadero una y solo una de las condiciones ha de ser Verdadero, en el resto de

los casos el resultado será Falso.

A B Resultado

Verdadero Verdadero Falso

Verdadero Falso Verdadero

Falso Verdadero Verdadero

Falso Falso Falso



Operador NO (NOT)

El operador NO da como resultado el valor opuesto al de entrada, es decir, si la entrada es Verdadero, la salida será Falso.


La tabla de verdad de este operador será la siguiente:

A Resultado

Verdadero Falso

Falso Verdadero

En la siguiente imagen puede verse un ejemplo con NXT-G:

Monitorizar un sensor

Aunque ya se vio en el capítulo anterior cómo utilizar el bloque de programación Espera para controlar el flujo de un

programa utilizando sensores, vamos a ver aquí otro modo que será muy útil cuando se necesite monitorizar más de un

sensor de modo simultáneo.

Si utilizamos el sensor de contacto para controlar cuándo un robot choca con un obstáculo podemos utilizar el bloque

Esperar, aunque también lo podemos hacer de los otros dos modos que se ven en la figura:

La funcionalidad es exactamente la misma, sin embargo, la tercera opción nos abre el camino para la monitorización de

varios sensores de modo simultáneo.

Si se monta un robot que deba evitar obstáculos detectándolos por medio de un sensor de contacto el programa podría ser el siguiente:


Cómo monitorizar dos sensores

En ciertas ocasiones es necesario controlar la lectura de más de un sensor de modo simultáneo. En el apartado anterior

el robot evitaba obstáculos utilizando un solo sensor de contacto. Con dos sensores el robot podrá saber si el obstáculo

está a su izquierda o derecha y obrar en consecuencia.

Para saber si uno u otro de los dos sensores ha hecho contacto utilizaremos el siguiente fragmento de código:

En el interior del bucle lee continuamente los dos sensores y por medio de una operación lógica (en este caso O),

combina dichas lecturas generando un valor lógico que será Verdadero si alguno de los dos sensores o los dos de modo

simultaneo detectan un contacto.

Una vez detectado un contacto el robot girará hacia un lado u otro en función de cuál de los dos sensores ha entrado en

contacto. El fragmento de código para ello será el siguiente (se encontrará en el programa a continuación del anterior):


Si el sensor conectado al puerto 1 detecta un contacto, retrocederá y girará hacia la derecha, sino (será el caso en el que

el sensor conectado al puerto 2 ha detectado el contacto) retrocederá y girará a la izquierda. Este código no contempla el

caso en que los dos sensores detectan contacto de modo simultáneo, algo que requeriría trabajar más el código.

Seguir línea II

Aunque esta propuesta utilice un solo sensor, se ha querido presentarla aquí ya que superaba los objetivos del uso básico

de sensores.

El robot tiene el motor izquierdo conectado al puerto A y el derecho al B. El sensor de luz está conectado al puerto 3.

Vamos a seguir la línea por el borde izquierdo pero vamos a intentar que el movimiento sea más fluido que lo

conseguido en la unidad didáctica 4. En ese caso el motor detenía el motor derecho o izquierdo para volver al borde. Lo

que vamos a hacer ahora es definir más situaciones intermedias entre el blanco y negro.

Primero calibraremos el sensor de luz para que negro sea 0 y blanco 100. Dividiremos 100 entre 5 para definir 5 estados (se podría hacer con otros valores). A partir de ello definiremos un comportamiento para cada tramo de valores que se

presentan en la tabla siguiente:

Rango de valores Comportamiento

0 Detener motor izquierdo para un giro brusco a la izquierda

1 Velocidad reducida del motor izquierdo para un giro suave a la izquierda

2 Seguir recto con velocidades iguales

3 Velocidad reducida del motor derecho para un giro suave a la derecha

4 Detener motor derecho para un giro brusco a la derecha

El programa será el siguiente:

El valor de lectura se divide entre 20, el valor se redondeará al entrar en el bloque Bifurcación. Para poder configurar el bloque Bifurcación para que pueda elegir el comportamiento en función del varios valores, tras seleccionar Control por

Valor, Visualizar Vista Plana deberá configurarse como en la figura.

Junto a la condición 5 aparece una marca que señala que si alguno de los resultados difiere de los de la lista esa será la

opción que ejecutará.


Múltiple calibración de sensores de luz

Hay dos métodos estándar para calibrar un sensor de luz en NXT-G. El primero es por medio de la opción Calibrar

sensores que podemos encontrar en el menú Herramientas de NXT-G y la segunda creando un pequeño programa con

el bloque de programación Calibrar del menú Avanzado.

Estos dos métodos permiten una única calibración para todos los sensores de luz conectados al NXT, así que si

deseamos una distinta calibración para diferentes sensores o dos diferentes para uno de ellos tendremos que recurrir a

otra estrategia; lo haremos utilizando la capacidad que tiene el NXT de registrar datos en un archivo y después leerlos.

Antes de entrar en cómo hacerlo vamos a ver cómo utilizar archivos.

Uso de archivos con NXT-G

NXT-G permite almacenar información en archivos de texto. Estos archivos se pueden leer desde el mismo u otro

programa y ser transferidos al ordenador para su posterior tratamiento.

Esta información puede ser tanto de tipo numérico como textual, por ejemplo, las lecturas de un sensor...

Con carácter general, los pasos para utilizar archivos son los siguientes:

1. Escribir en el archivo

2. Cerrar el archivo

3. Leer los datos. En todos los casos se utiliza el mismo bloque de programación, Acceso a archivos, configurado del modo que se necesite en cada caso.

Crear un archivo

El primer paso será crear el archivo. Dado que probablemente ejecutaremos el programa en más de una ocasión, lo

primero que habrá que hacer será eliminar el archivo creado previamente, en caso contrario, añadirá los nuevos datos al

archivo antiguo.

En la imagen se puede ver el bloque Acceso a archivos configurando para que elimine el archivo de nombre


MiArchivo.

Una vez eliminado el archivo podemos crear el nuevo y comenzar a escribir en él. No hay un modo de configurar el

bloque específico para la creación de un archivo, el archivo se crea cuando se escribe el primer dato en él.

Los datos que puede almacenar un archivo pueden ser de tipo texto o numérico. El bloque de la imagen siguiente

escribe un valor numérico en un archivo denominado Datos.

Utilizaremos este dato tantas veces como sea necesario para almacenar nuevos valores en el archivo.

Cerrar el archivo

Antes de leer los datos hay que cerrar el archivo, configurando el bloque Acceso a archivos tal y como se ve en la

siguiente imagen.

Ejemplo

Veamos cómo se puede aplicar lo anterior por medio de un ejemplo. La idea es registrar la variación de la temperatura a

lo largo del tiempo: durante un proceso de enfriamiento o calentamiento, la temperatura atmosférica... Para ello se

utiliza el sensor de temperatura para LEGO MINDSTORMS NXT.

Una vez registrados los valores, transferiremos el archivo al ordenador y los convertiremos en un gráfico que ayude en

su interpretación.

Esto es algo que se puede hacer de un modo más sencillo con la aplicación de registro de datos de NXT-G Educación,

no así con su versión comercial. Por otra parte el uso de archivos permite un registro de datos más flexible.

En el ejemplo, cuyo código puede verse en la siguiente imagen, se mide la temperatura cada segundo durante 100

segundos. Esto significa que se registrarán 100 valores.


Este programa, tras eliminar el archivo (denominado en este caso DatosTemp), abre un bucle (bloque Bucle configurado

en modo Contador) que se repetirá 100 veces. En el bucle lee el sensor de temperatura conectado al puerto 1, registra el

valor en el archivo y espera 1 segundos antes de volver al inicio del bucle. Tras la repetición número 100 cierra el

archivo y finaliza el programa.

Para transferir el archivo al ordenador primero deberemos abrir la ventana NXT, pulsando sobre el botón superior

izquierdo del controlador.

En la ventana NXT seleccionaremos la pestaña Memoria y en ella Otros y podremos ver varios de los archivos que

contiene el NXT, entre ellos el creado en este ejemplo.

Si pulsamos sobre el botón Cargar, podremos transferir el archivo (DataTemp.txt) al directorio que deseemos en nuestro

ordenador.

Una vez hecho esto, abriremos el archivo desde una hoja de cálculo, en mi caso desde LibreOffice Calc. Una vez

abierto podremos observar que el separador que utiliza NXT-G para los decimales es un punto, por lo que la versión

española de LibreOffice Calc no interpretará como valores numéricos las temperaturas; así que tendremos que sustituir

los puntos por comas (Buscar y reemplazar). Utilizando la herramienta Insertar Gráfico podremos obtener una

representación gráfica de las temperaturas, tal y como puede verse en la siguiente imagen.


Leer los datos

Veamos ahora cómo podemos leer los datos almacenados previamente en un archivo. Antes de ello cabe señalar que la

lectura será secuencial, es decir, se leerán en el orden en que han sido registrados, no podremos leer el tercer dato sin

antes haber leído el primero y el segundo.

Se pueden leer los datos almacenados en un archivo desde el mismo programa que los registra o desde cualquier otro

programa. En este caso lo vamos a hacer desde el segundo programa; vamos a leer los valores almacenados en el

archivo DataTemp y los vamos a representar en la pantalla del NXT.

El programa es el siguiente:

El programa consta de un bucle que se repite tantas veces como datos ha de leer. Para permitir que se visualice el

gráfico todo el tiempo que se desee se ha añadido un bloque Espera configurado para un sensor de contacto. En

realidad no hace falta montar ninguno, ya que de este modo se mantendrá la ejecución del programa hasta que se pulse

el botón gris del NXT.

El bloque Visualizar permite dibujar puntos en la posición que se desee a partir de las coordenadas x e y del punto. En

este caso la “x” será el número de orden de la toma de temperatura y la “y” la temperatura. Se configura el bloque

Acceso archivos en modo lectura y se conecta su toma de salida Número de salida con la toma de entrada “y” del bloque Visualizar. La “x” la obtendremos del contador del bucle.

De este modo tendremos el mismo gráfico que anteriormente hemos representado en el ordenador, en la misma pantalla

del NXT.


Calibración de más de un sensor

Ahora que ya tenemos una idea de cómo utilizar archivos desde NXT-G vamos a ver otro modo de calibrar un sensor.

En los modos de calibración mencionados al principio del artículo, el programa crea automáticamente un archivo y lo

lee cada vez que se utiliza un sensor de luz sin que siquiera seamos conscientes de ello. Ahora lo que vamos a hacer es

crear un archivo con los datos necesarios para la calibración y utilizarlo cada vez que lo necesitemos.

Crear el archivo de calibración

Para crear el archivo de calibración hemos de leer y registrar los valores máximos y mínimos que pueda leer el sensor

en la situación real. Habitualmente se hace posicionando el sensor sobre la zona más clara y a continuación sobre la más oscura, pero aquí lo vamos a hacer de otra manera: moveremos el robot del mismo modo que se moverá cuando realice

su tarea y registremos los valores máximo y mínimo. A continuación los guardaremos en el archivo correspondiente.

Veamos primero cuáles son los pasos a dar:

1. Crear dos variables (valorMAX y valorMIN) que almacenarán los valores máximo y mínimo de luminosidad

leída.

2. Inicializar las variables con los valores valorMAX=0 y valorMIN=1023 (en lugar de utilizar el valor de lectura

porcentual, utilizaremos el valor directo que está comprendido entre 0 y 1023).

3. Eliminar el archivo de calibración (Calibra1).

4. Iniciar un bucle, que se ejecutará durante 5 segundos, con los pasos siguientes:

a. leer el valor del sensor de luz

b. comparar la lectura con la variable valorMAX, si es mayor que ella almacenar la nueva lectura en la

variable

c. comparar la lectura con la variable valorMIN. Si es menor que ella almacenar la nueva lectura en la

variable.

5. Una vez cerrado el bucle escribir el contenido de la variable valorMIN en el archivo de nombre Calibra1 y a

continuación lo mismo con valorMAX.

6. Cerrar el archivo Calibra1.

Una vez hecho esto el archivo de calibración estará almacenado en el NXT. Este sería el algoritmo básico, al que si se

quiere se puede añadir movimiento, para que en lugar de ser el usuario el que mueve el robot sobre las zonas clara y

oscura, sea el mismo robot el que se mueva (así se asegura que el movimiento del robot sobre la línea será

completamente real).

Tras crear las variables vía la opción Definir variables del menú Edición, haremos los pasos 2 y 3 tal y como se ve en la


figura anterior.

Se puede ver en este fragmento de código (pasos 3a y 3b) cómo se obtiene el valor directo de la lectura del sensor de luz

conectado al puerto 1 y se compara con el valor almacenado en la variable valorMIN. Si es menor que dicho valor lo

almacena en ella, sino sigue adelante (los cableados aparecen en la imagen un poco revueltos debido a la organización

automática que les da NXT-G).

A continuación compara con el contenido de la variable valorMAX y si es mayor almacena la lectura en la variable

(paso 3c).

Una vez que se registren los dos contenidos de las variables en el archivo y se cierre, esta primera parte del proceso se

puede dar como finalizada.

Esto mismo lo podríamos hacer con más sensores conectados a otros puertos del NXT, crearíamos un nuevo archivo de

calibración para cada sensor que deseemos calibrar de un modo diferente. Cara al programa que va a hacer uso de estas

calibraciones he tomado como regla para los nombres de archivo Calibra1 para el sensor conectado al puerto 1,

Calibra2 para el segundo...

Uso del archivo de calibración

Vamos a ver primero cómo vamos a utilizar los valores registrados en el archivo. Tenemos almacenados los valores

máximo y mínimo de las lecturas tomadas en unas condiciones específicas de iluminación. Ahora vamos a utilizar las

matemáticas para que esos dos valores se conviertan uno en 0 (que se corresponderá con la lectura más oscuro “negro”)

y el otro en 100 (la lectura de mayor luminosidad o “blanco”).


Para llegar a ello tenemos que dar dos pasos:

1. Tras medir el nivel de luminosidad con el sensor, aplicar una regla de proporcionalidad que calcule el resultado

deseado con un rango entre 0 y 100.

2. El valor directo de luminosidad que provee el sensor está comprendido entre 0 y 1023 (dado que al crear el

archivo hemos utilizado este valor, aquí habremos de hacer lo mismo) pero el valor 0 se corresponde a alta

luminosidad (blanco) y 1023 a ausencia de luz (negro). Si queremos convertirlo al estándar que utiliza NXT-G

(de 0 oscuro a 100 brillante) habremos de restar el valor anterior de 100. Veamos un programa ejemplo que sirve para testear todo lo anterior, y que puede ser reciclado para cualquier otra aplicación. El programa, véase la siguiente figura, lo que hará será mostrar en pantalla el valor calibrado de una lectura

en tiempo real.

En el programa de la imagen, el nuevo bloque denominado Calibra lee el sensor conectado al puerto 1 y devuelve el

valor calibrado. El resto del código es para mostrar de modo continuo las lecturas en la pantalla del NXT. Así que

vamos a ver cómo es por dentro el nuevo bloque Calibra.

Este bloque tiene como entrada un número que se corresponde al puerto al que está conectado el sensor que queremos

leer. Si hemos nombrado los archivos del modo anteriormente mencionado, podrá devolver el valor calibrado de sensores conectados en diferentes puertos con diferentes calibraciones.

El algoritmo correspondiente a este bloque es el siguiente:

1. Crea el nombre de archivo a leer por medio de una operación de texto: convierte el número de entrada en texto

y se lo suma a la palabra Calibra de tal manera que si el sensor es el 1 el archivo a leer será Calibra1.

2. Lee el primer dato del archivo y lo almacena en la variable Vmin previamente creada.

3. Lee el segundo dato del archivo y lo almacena en la variable Vmax previamente creada.

4. Cierra el archivo.

5. Lee el sensor de luz conectado al puerto correspondiente al número de entrada (Valor directo)..

6. Convierte la lectura en un valor calibrado entre 0 y 100 para almacenarlo en la variable Vcal, para lo que

aplica la siguiente fórmula:

7. Comprueba si el resultado es inferior a 0, en cuyo caso lo convierte en 0

8. Comprueba si el resultado es superior a 100, en cuyo caso lo convierte en 100.

9. Resta de 100 el valor anterior para conseguir el valor de salida.


En esta primera imagen podemos ver los 5 primeros pasos.

A continuación se hace el cálculo.

Para acabar comprobando que el resultado está dentro del rango deseado y normalizando el resultado.

A partir de aquí cada uno ha de adaptarlo a sus necesidades, diferentes calibraciones para diferentes sensores o

diferentes calibraciones para un mismo sensor. Esto supondrá que serán necesarios tantos archivos como diferentes

calibraciones se necesiten.

Actividades

Actividad 1

El robot se mueve por la mesa y llegado a una posición determinada ha de posicionarse perpendicular a la pared sur orientado hacia el norte. Para ello una vez que alcanza la posición de giro gira y retrocede hacia atrás hasta encontrar la

pared con uno de los sensores. Se gira hasta que el otro contacta con la pared.

Actividad 2

El robot ha de avanzar hasta cierta posición cruzando una línea negra (cuando lo haga que emita un sonido para señalar

que la ha detectado) y deteniéndose cuando llega a la segunda. En ese momento se posicionará perpendicular a ella

utilizando dos sensores de luz.

Una actividad alternativa puede ser alinear el robot con la línea, para lo que necesitará una configuración diferente de los sensores.

Actividad 3

Monta y programa un robot que siga una línea utilizando dos sensores de luz.


Recursos

“Qué es una tabla de verdad”: http://es.wikipedia.org/wiki/Tabla_de_verdad

http://es.wikipedia.org/wiki/Tabla_de_verdad


9 Neumática

Los actuadores que utilizan los robots pueden utilizar diversas fuentes de energía. Esta energía puede estar acumulada

en baterías a modo de energía química o también en un depósito de aire comprimido.

La energía almacenada en un depósito de aire comprimido puede ser transformada en trabajo utilizando diversos

actuadores, entre ellos los cilindros de simple o doble efecto. Para su control se utilizan válvulas de diferentes tipos que

abren y cierran el paso del aire.

LEGO ofrece diversos elementos que facilitan el montaje de circuitos neumáticos y vamos a ver aquí en qué modo

pueden ser utilizados en la FLL.

Neumática y FLL

Vamos a ver algunos de los puntos que hay que tener en cuenta para utilizar la neumática en un robot para la FLL.

Producción de aire

Cuando se diseña un circuito neumático una de las cosas en las que hay que pensar es en la producción de aire

comprimido. LEGO ofrece para ello un cilindro que de modo manual permite producirlo y otro destinado a ser

motorizado. Dado que el uso de motores en un robot FLL está limitado a tres parece que lo más adecuado será elegir la

primera opción, es decir, producirlo a mano.

Dado que no se puede tocar el robot una vez que sale de la base, la producción de aire deberá ser previa, así que será

necesario un depósito para almacenarlo. Para ello se utilizará uno o más depósitos de aire. Si se utiliza más de un

depósito pueden ser montados en serie o paralelo.

Control

La segunda cosa en la que hay que pensar es en el control, para lo que se utilizan las válvulas. Las válvulas son las que

dejarán pasar el aire de tal modo que el actuador haga su trabajo.


¿Pero cómo cambiar la posición de la válvula? De la misma manera que hemos dicho en el punto anterior, el

motorizarla no es una buena solución así que hay que pensar otra cosa. ¿Cuáles pueden ser las soluciones? En esto se

trata de darle a la imaginación, un elemento que al chocar con una pared modifique la posición de la válvula podría ser

una solución.

Otra solución podría ser conectar directamente el cilindro al depósito, y diseñar un mecanismo que mantenga el cilindro

en una posición de tal modo que al chocar con algo... lo libere y desarrolle su trabajo.

Los actuadores

LEGO ofrece cilindros de doble efecto de dos tamaños diferentes aunque en un robot FLL probablemente haya que

utilizarlos para que trabaje solo en un sentido.

Elementos necesarios

Los elementos imprescindibles para montar un circuito neumático para la FLL son los siguientes:

Un cilindro compresor manual

Tubo

Un depósito

Un cilindro de doble efecto (grande o pequeño)

Además de estos elementos puede haber otros opcionales, por ejemplo una unión T si se quieren montar dos depósitos

en paralelo, o incluso un manómetro como el que se puede encontrar en la caja "Set adicional de neumática LEGO

Educación" de referencia 9641. Esta caja ofrece todo lo necesario mas algunas piezas adicionales.


10 Dibujo de modelos LEGO

En cualquier proyecto de ingeniería su representación es un paso muy importante. A la hora de abordar la FLL no es un

paso imprescindible, pero sí recomendable por las razones que se presentan en esta unidad.

Por qué dibujar

El dibujo es una herramienta de registro y comunicación en los proyectos en ingeniería. Permite ir registrando los pasos

que se dan en un diseño así como comunicar una solución con todos los datos necesarios para su fabricación.

En la FLL puede haber diversas razones para dibujar un robot montado con LEGO, veamos algunas:

Experimentar y generar ideas: probablemente la mayoría de los participantes en la FLL no disponen de

material propio para montar robots. Solo pueden explorar ideas cuando se juntan con el resto del equipo en la

escuela o local que utilicen. Los programas de dibujo permiten representar ideas sin necesidad de ninguna

pieza.

Registrar prototipos: teniendo en cuenta que normalmente se desarrollan las ideas con recursos limitados,

cuando se monta un prototipo y se quieren hacer cambios no queda otra que desmontar. El dibujo de los

modelos junto al uso de las cámaras digitales permite registrar el modelo, de tal modo que podremos volver

atrás si es lo que queremos.

Utilizar el dibujo en la presentación del proyecto técnico: mostrar en la presentación del proyecto técnico

dibujos del robot o de prototipos desechados puede ser algo interesante. También puede hacerse con fotos, pero

el dibujo en ocasiones puede llegar a marcar la diferencia con una buena justificación de su uso.

Con qué dibujar

Hay varios programas que permiten dibujar proyectos. Algunos de ellos están especialmente creados para dibujar

modelos con piezas LEGO, mientras que hay otros de uso profesional que también permiten hacerlo.

Aquí nos vamos a centrar en tres programas de uso libre aunque primero vamos a ver una lista de otros tres que también

pueden ser muy interesantes:

Pro/ENGINEER y SolidWorks: La Robotics Academy de Carnegie Mellon University ofrece en su web las piezas del NXT para dibujar robots LEGO con el software de dibujo 3D profesional Pro/ENGINEER tanto

en su versión comercial como educativa y con SolidWorks.

Google SketchUp: Google SketchUp es una herramienta de software de 3D de Google. Una vez que tienes

instalado Google SketchUp hay que descargar las piezas LEGO Technic y MINDSTORMS NXT.


LEGO Digital Designer

LEGO Digital Designer (LDD de aquí en adelante) es el software oficial para dibujo con piezas LEGO. Se trata de un

software de dibujo en 3D en el que se pueden ensamblar las piezas como se hace en la realidad, aunque aquí pierden

toda su elasticidad, son completamente rígidas. Esto quiere decir que hay cosas que se pueden hacer en el mundo real

que LDD no permite.

Ofrece un conjunto de piezas basado en sus modelos. Se puede encontrar entre ellos LEGO MINDSTORMS NXT

educación y otros.

Está preparado para generar instrucciones, tanto animadas en el monitor como en formato HTML aunque es un aspecto

en el que tiene que mejorar.

Su uso es muy intuitivo, aunque no está de más acceder a la ayuda para ver qué es lo que se puede hacer con él. El uso

de combinación de teclas y del ratón con el teclado hace más ágil la creación de nuevos modelos.

Descarga e Instalación

La aplicación puede descargarse de la web de LDD (http://ldd.lego.com/). Existen versiones para Windows y Mac,

desde Linux puede utilizarse el programa mediante el emulador Wine. La instalación no ofrece ninguna dificultad.

Si la aplicación se ejecuta mientras se está conectado a Internet, comprueba automáticamente la existencia de

actualizaciones.

Ventajas e Inconvenientes

LDD es un programa fácil de usar, probablemente el más sencillo de todos los que se presentan aquí, así que de entrada

es el más recomendable.

Sin embargo adolece de varios inconvenientes. Por una parte la limitación en las piezas, aunque va mejorando con el

tiempo, hay piezas que no se encuentran. Por otra parte el control sobre el modo que genera las instrucciones de

montaje es nulo, algo que debería mejorar.

LDraw

LDraw es un proyecto colectivo que ha ido creciendo en el tiempo. A lo largo de los años ha contado con las

aportaciones desinteresadas de una amplia comunidad que ha trabajado en el desarrollo de este software. Se pueden

utilizar diferentes interfaces con LDraw, dependiendo de gustos: MLCad o LeoCAD.

Una vez que se ha representado un proyecto es posible generar instrucciones o renderizarlo para conseguir un aspecto

más real.

LDraw no trabaja directamente en 3D, sino que lo hace sobre las proyecciones diédricas (alzado, planta y perfil). Además, de modo complementario, muestra una vista en isométrico que nos permite tener una visión del modelo en 3D.

http://ldd.lego.com/



LDraw ofrece un instalador que contiene las diferentes aplicaciones necesarias para dibujar, renderizar modelos y

generar instrucciones. Este instalador ofrece diferentes opciones, desde la instalación básica hasta la instalación de un

completo conjunto de aplicaciones. Para empezar es mejor quedarse con lo básico.

Periódicamente se publican actualizaciones de piezas.


LDraw permite poner las piezas como se quieran y es posible controlar las coordenadas de las piezas con precisión. Es

posible montar submodelos que pueden ser reutilizables, además de facilitar un montaje modular. Para montajes grandes

es más sencillo de manejar que LDD gracias al montaje modular. El conjunto de aplicaciones generado alrededor de él

ha aumentado su potencial, siendo una herramienta excelente para generar instrucciones de montaje.

Entre sus pegas una es que no evita interferencias entre piezas, así que es posible colocar más de una pieza en el mismo

lugar. Por otra parte, se trabaja sobre proyecciones diédricas en lugar de sobre una vista 3D.

SR 3D Builder

SR 3D Builder es un programa de dibujo de modelos LEGO en 3D que entre otras cosas permite generar animaciones a

partir de modelos. El software está en desarrollo y promete seguir creciendo de la mano de Sergio Reano, su autor.

Está disponible un manual de uso en castellano en la misma web del autor.


Descarga el fichero de instalación de la web de SR 3D Builder y sigue las instrucciones del instalador. Si tienes algún

problema comprueba primero las indicaciones que Sergio ofrece en su web. Es un software en desarrollo así que puede

dar ciertos problemas.

El software se puede descargar de modo gratuito, aunque habrá versión de pago.


Uno de los mayores puntos a favor de este software es la posibilidad de generar animaciones de mecanismos.

La pega es que no es tan intuitivo y el aprendizaje es más largo.

Recursos

Hispabrick Magazine (http://goo.gl/li5BWv): hay varios artículos sobre el uso de Ldraw en la revista

Wiki Lrobotikas (http://wiki.lrobotikas.net): dispone de una sección sobre herramientas de dibujo

http://goo.gl/li5BWv

http://wiki.lrobotikas.net/


Robotics Academy de Carnegie Mellon University (http://goo.gl/i7jDHQ)

Piezas del NXT para dibujar robots LEGO con el software de dibujo 3D profesional Pro/ENGINEER tanto

en su versión comercial como educativa y con SolidWorks (http://goo.gl/uRHIC5)

Sketchup (http://www.sketchup.com/intl/es/)

Piezas LEGO Technic y MINDSTORMS NXT(http://goo.gl/DgMniD)

Wine (http://www.winehq.org/)

Instalador de Ldraw (http://www.ldraw.org/article/104.html)

SR3Builder (http://sr3dbuilder.altervista.org/)

http://goo.gl/i7jDHQ

http://goo.gl/uRHIC5

http://www.sketchup.com/intl/es/

http://goo.gl/DgMniD

http://www.winehq.org/

http://www.ldraw.org/article/104.html

http://sr3dbuilder.altervista.org/)


Apéndice 1: Piecerío

Antes de comenzar a montar un robot es importante conocer para qué sirven las piezas que ofrece el sistema, en este

caso las que se encuentran en LEGO MINDSTORMS Educación (en adelante LMS Educación).

En este capítulo se presentan las piezas agrupadas en base a su uso más común. Eso no quiere decir que sea su único

uso, ya que ello queda a la imaginación de cada usuario.

Además se han incorporado a la relación de piezas otras piezas, no presentes en LMS Educación, que pueden resultar

muy útiles en el montaje de los robots (aquellas que la celda que contiene la referencia aparece coloreada). Se sugieren

diferentes vías para conseguir nuevas piezas y se ofrecen recursos en formato libro o web que pueden ser útiles a la hora

de combinar las piezas de distintas maneras.

El NXT

NXT es el nombre de la controladora de LEGO MINDSTORMS. Se puede decir que es un pequeño ordenador (procesador, memoria, salidas, entradas...) que podemos programar para que realice diferentes tareas.

Así como un ordenador necesita de su sistema operativo, el NXT necesita de su firmware que es susceptible de ser

actualizado (conviene tenerlo actualizado a la última versión disponible).

Una vez que se descargue un programa en el NXT (vía conexión USB o bluetooth), ya no se necesitará del ordenador

para ejecutar el programa y el robot podrá actuar de modo autónomo.

Especificaciones técnicas

Microprocesador principal de 32 bits ARM7TDMI|AT91SAM7S256 (256 KB de memoria flash y 64 KB

RAM)

Microcontrolador de 8-bit Atmel AVR|ATmega48 @ 4 MHz (4 KB de memoria flash y 512 Bytes RAM)

Pantalla matricial LCD de 100x64 pixeles

Puerto USB 2.0

Conectividad inalámbrica vía Bluetooth (Class II)

4 puertos de entrada (1,2,4 y 4), cable digital de 6 hilos

3 salidas (A, B y C), cable digital de 6 cables

Altavoz, calidad de sonido de 8 KHz

Alimentación, 6 pilas AA o batería recargable

Actualización del firmware

Periódicamente y cuando se compra un nuevo NXT conviene comprobar si el firmware está actualizado.

Se puede comprobar la versión del firmware instalada en el NXT por medio del menú Settings en el mismo NXT. Uno

de los submenús es NXT Versión que en la primera línea presenta la versión del firmware del siguiente modo: FW

1.31.

También se puede comprobar desde el software de programación de LEGO (en adelante NXT-G). Para ello

conectaremos el NXT al ordenador con el cable USB, lo encenderemos y abriremos NXT-G. Tras iniciar un nuevo

programa pulsaremos sobre el botón Ventana NXT.


De este modo se abrirá el cuadro de diálogo que entre otras cosas muestra la versión del firmware.

Cómo actualizar el firmware

Lo primero que hay que hacer es acceder al cuadro de diálogo correspondiente vía Herramientas > Actualizar

firmware del NXT.

Para comprobar si hay alguna versión nueva y descargarla pulsar sobre Comprobar. En una ventana del navegador de

Internet se abre la página de actualizaciones de LEGO Educación. Seleccionar en el menú de la parte izquierda

Firmware y la página se verá del siguiente modo:


Si es necesario descargar el archivo deseado. A continuación en NXT-G seleccionarlo e instalarlo vía el botón

Descargar. A lo largo del proceso el NXT se apagará y volverá a encender. Conviene hacerlo con la batería cargada y

no desconectarlo durante el proceso.

Nota: La página de LEGO Educación también ofrece actualizaciones para NXT-G (vía la opción Software Updates /

Patch).

Motores

Un motor NXT es un conjunto formado por un motor de corriente continua, una reductora y un sensor de rotación

interno.

Gracias a la reductora interna es posible conectarlo directamente a una rueda sin necesidad de reducir más su velocidad.

El sensor de rotación interno permite que controlar el movimiento con una precisión de 1º. Estos motores pueden

configurarse para que giren en un sentido u otro un número determinado de vueltas, grados o tiempo.

Además del motor des sistema NXT también puede ser utilizado el nuevo motor del LEGO MINDSTORMS EV3, más

compacto que el anterior (su referencia para pedidos es 6008577).

Sensores

Los sensores disponibles en LEGO NXT Educación son dos sensores de contacto, uno de luz, el de ultrasonidos y el de

sonido. Además de estos hay otro sensor oficial de LEGO que es el de color.

Además de LEGO, hay otras empresas que también comercializan sensores para el NXT con los que se pueden medir

muy diversas magnitudes. Sin embargo en la FLL únicamente se pueden utilizar los sensores fabricados por LEGO.

Dado que el de sonido no es útil en un ambiente de alto nivel de ruido no se presenta aquí.


Sensor de contacto

El sensor de contacto incluido en LMS Educación es básicamente un pulsador como el que se utiliza para llamar el

timbre de casa. Tiene un orificio en la parte frontal que permite encajar ejes u otras piezas con la misma sección. En la

figura puede verse cuál es su funcionamiento interno.

Sensor de luz

El sensor de luz mide el nivel de luminosidad que llega a él. Dispone de un led rojo que emite luz y que es muy útil para

detectar zonas negras y blancas en el suelo sin depender de la luz ambiente midiendo la luz reflejada. Este led puede ser

apagado vía software de tal modo que pueda medir la luz ambiente de su entorno.

Cuando se utiliza para seguir una línea sobre el suelo, hay que prever la influencia de la luz ambiente. Para ello, por una

parte conviene proteger el sensor de la luz externa y posicionarlo de tal modo que vaya lo más cerca del suelo posible

(aunque tampoco en exceso ya que en ese caso no el sensor no podrá ver la luz reflejada). Por otra parte también conviene calibrarlo en el lugar en el que debe realizar su tarea ya que las condiciones del entorno influyen en el

resultado.

Da valores bajos cuando recibe poca luz (oscuridad o línea negra) y altos cuando el brillo es alto (ofrece valores entre 0

y 100).

Sensor de color

Este sensor puede identificar hasta seis colores: Negro, Azul, Verde, Amarillo, Rojo y Blanco.

También puede ser utilizado como sensor de luz. En este caso puede utilizarse para medir la luz ambiente o la luz reflejada (en este caso se puede seleccionar que emita luz roja, verde o azul).

Algunas versiones de NXT-G no disponen del bloque de programación de este sensor, en ese caso habrá que

descargarlos de la web de LEGO Educación3 (seleccionar Blocks en el menú de la izquierda).

Sensor de ultrasonidos

Este es un sensor capaz de medir distancias por medio de ultrasonidos. Emite ultrasonidos y espera su retorno (el cuál se

produce si encuentra algún obstáculo intermedio). Basándose en el tiempo

transcurrido entre la emisión y la recepción puede determinar la distancia.

Con este sensor es más fácil montar robots que eviten obstáculos sin tener que chocar contra ellos o encontrar objetos

sin tener que tocarlos previamente.

Los mejores resultados los obtiene cuando el objeto está en frente, aunque también puede medir distancias a objetos en

una posición lateral.

Hay que tener en cuenta que no todos los objetos reflejan del mismo modo los ultrasonidos, por ejemplo paredes de

pladour o ladrillo no los reflejan igual e incluso hay otros materiales (como ciertos tejidos) que no se pueden detectar

por medio de estos sensores. Así que conviene hacer algún test si los valores son inesperados.

Sensores RCX

El RCX fue la primera generación de LEGO MINDSTORMS. Tanto el RCX como los motores y sensores que lo

acompañaban estaban adaptados al sistema clásico de construcción LEGO y fueron renovados para facilitar su montaje

con las nuevas piezas de construcción Technic (diferentes a los tradicionales ladrillos de LEGO).

Los sensores del RCX pueden ser utilizados con el NXT conectados vía el cable adaptador que contiene la caja de

LEGO MINDSTORMS Educación (es el mismo cable que se utiliza para conectar las bombillas).

Son sensores más pequeños que en algún caso podrían ser utilizados sustituyendo a los sensores del NXT.

3 http://goo.gl/J7SekV

http://goo.gl/J7SekV


Sensor Descripción

Sensor de contacto: sus características son las mismas que las del sensor de

contacto NXT.

Sensor de luz: sus características básicas las mismas que las del sensor de luz

NXT.

Sensor de rotación: Con este sensor es posible controlar giros con una precisión

de 22º30', es decir, 16 puntos por giro. Si se utiliza este sensor en la FLL no

puede ser utilizado de modo simultáneo con más de dos motores (el límite es

utilizar tres sensores de rotación en un robot y dado que los motores ya contienen

uno, el uso de un sensor como este reduce el número de motores que se pueden

utilizar).

Para poder utilizarlos desde NXT-G habrá que instalar primero los bloques de programación correspondientes que

pueden ser descargados desde la web de LEGO Educación4 (seleccionar Blocks en el menú de la izquierda y buscar

RCX Legacy Sensor Blocks for NXT).

Estructuras

Un robot necesita de una estructura que soporte los motores, sensores, controladora... Estas estructuras pueden tener

diferente apariencia en función de las tareas que el robot haya de desarrollar y del entorno en el que se mueva.

Uno de los puntos a tener en cuenta cuando se diseña una estructura es la rigidez. Siempre dentro de los límites de

tamaño y peso deseados, es importante que sea una estructura robusta y que así se mantenga cuando se somete a

esfuerzos deformándose lo menos posible. También conviene ofrecer buenos apoyos a los ejes para que al apoyarlo

sobre el suelo se mantengan rectos y no se doblen por el peso.

Se tratará de limitar los grados de libertad de los mecanismos que se construyan a los estrictamente necesarios con el

objeto de conseguir una mayor precisión en los movimientos.

Vigas rectas

Vigas rectas útiles para montar estructuras aunque las dos primeras, por su corta longitud, son básicamente para uniones

entre otras piezas. Se muestra solo la imagen de la de 7.

Código Descripción

4177444 Víga de 2

4142822 Víga de 3

4142135 Víga de 5

4495935 Víga de 7

4645732 Víga de 9

4156150 Víga de 11

4522933 Víga de 13

4542573 Víga de 15

4 http://goo.gl/J7SekV

http://goo.gl/J7SekV


Otras vigas

Estas vigas, además de facilitar el cambio de dirección de una estructura, pueden utilizarse para aumentar la rigidez.

El ángulo en la 4ª, 5ª y 6ª es de 53,13º.

Pieza Código Descripción

4552349 Viga en T 3x3

4120017 Viga en L 2x4

4142823 Viga en L 3x5

4128593 Viga en ángulo 4x4



4210668 Viga con doble ángulo 3x3,8x7

Otros elementos para estructuras

Las dos piezas de este grupo, no presentes en LMS Educación, pueden utilizarse para crear estructuras rígidas con

mayor facilidad y menos piezas. Las dos últimas pueden ser útiles tanto para construir estructuras como para diseñar

dispositivos para empujar, arrastrar, recoger, contener... modelos de misión.



4539880 Viga 5x7 con abertura central 3x5

4540797 Viga 5x11 con abertura central 3x5

4566243 Panel 1x5x11

4525727 Panel Cuarto de Cilindro 11 x 3

Elementos para cambios de dirección

Con las siguientes se pueden cruzar vigas en estructuras de tal modo que la cara agujereada ya no esté en el mismo

plano.


6008527 Conector en escuadra

4121667 Conector perpendicular con 2 ejes

4210857 Conector perpendicular con 2

agujeros

4211775 Conector perpendicular

4210655 Conector perpendicular doble

4538007 Conector perpendicular triple

4211714 Conector perpendicular 2x2

agujeros

4162857 Conector perpendicular doble

partido


Estructuras con ejes

Estos conectores pueden utilizarse para montar estructuras con ejes más o menos rígidas. El agujero del que disponen

facilita la conexión con otras partes del robot.

También puede ser utilizado con todos ellos un Conector-eje con fricción o sin ella (ver Elementos de unión >

Conectores básicos).


4512360 Conector de ejes liso: Se puede utilizar para unir dos ejes.

4113805 Conector de ejes: Básicamente su uso es el mismo que el anterior, pero también

se utiliza en sistemas de cambio de marcha.

4107085 Conector angular #1: Elemento inicial o final de una estructura con ejes.

4107783 Conector angular #2: Este y los siguientes permiten unir dos ejes con la

posibilidad de fijarlos a la estructura del robot.

4610666 Conector angular #3




Ejes flexibles

Los ejes flexibles pueden ser útiles para construir dispositivos que ayuden a realizar diferentes misiones. Pueden ser

combinados con las piezas del grupo Estructuras para ejes además de con los diferentes tipos de conectores, ya que el

extremo de estos ejes encajan en ellos (solo se muestra el de longitud 7)



4569751 Eje flexible de 7






Ladrillos Technic

Si bien estas piezas han sido sustituidas en muchos casos por las nuevas vigas, todavía están presenten en LEGO

MINDSTORMS Educación.

Si la resistencia de la estructura a construir es un factor crítico, se pueden consultar los estudios que comparan la

resistencia de las vigas y los ladrillos Technic (ver Recursos).

Cuando se utilizan los Ladrillos Technic es necesario asegurar la estructura por medio de vigas dispuestas en sentido

perpendicular a las primeras. Pero para ellos hay que intercalar placas para que la distancia entre los agujeros sea la

adecuada (solo se muestran el dey 4 de longitud).


4211440 Ladrillo Technic de 2








Placas

A estas piezas se les puede dar diferentes usos, entre ellos intercalarlas entre los ladrillos Technic para crear una

estructura fuerte y resistente.

Las hay de diferentes longitudes y anchuras, y dada su abundancia aquí solo se dan ejemplos de ellas. En Peeron se

puede ver la variedad existente. Las hay también de mayor anchura.


Pieza Descripción

Placa de 1x2. De una unidad de ancho las hay de las siguientes longitudes: 1, 2, 3, 4, 6, 8, 10, 12

Placa de 2x2. De dos unidades de ancho las hay de las siguientes longitudes:2,

3, 4, 6, 8, 10, 12, 16. También las hay de mayor anchura.

Placa Technic de 2x6. La diferencia con las anteriores son los agujeros. Las

hay de las siguientes longitudes:4, 6, 8, 10

Elementos de unión

De la misma manera que en otros ámbitos de la tecnología se utilizan sistemas de unión tornillo-tuerca, remaches,

soldadura, colas... en las construcciones LEGO hay una serie de elementos cuya función es unir los distintos elementos

que las conforma.

Aunque no aparezcan en esta sección los ejes también pueden ser utilizados para uniones.

Conectores básicos

Las siguientes piezas se utilizan como elementos de unión. Por sí solas pueden mantener unidas otras dos piezas.

Hay que tener en cuenta que además de las siguientes piezas, los ejes de cualquier medida también pueden mantener

unidas piezas con agujeros en forma de cruz.


4121715 Conector con fricción: Permite unir dos piezas entre sí. Utilizando varias de

ellas puede conseguirse una unión rígida

4211807 Conector: Si bien pueda parecer que sea igual al anterior, el color gris indica la

ausencia de fricción con la pieza en la que se inserte. Ello hace que este conector se utilice en articulaciones.

4514553 Conector largo con fricción: Permite unir hasta tres piezas. No sirve para

uniones articuladas.

------- Conector largo con fricción: Igual que el anterior pero en color negro (color

antiguo).

4514554 Conector largo: Si bien puede utilizarse como el anterior, su diseño está

destinado a uniones articuladas.

------- Conector largo: Igual que el anterior pero en color antiguo

4206482 Conector-eje con fricción: Para unir una pieza con un agujero en forma de cruz

y otra con agujero cilíndrico.

4186017 Conector-eje: Lo mismo que el anterior pero para cuando la unión va a ser una

articulación. Anteriormente eran grises.

4140801 Conector largo con separador con tope: Además de poder unir dos piezas

puede combinarse con el conector-eje o con un eje para prolongar la unión.

Otros conectores

Los siguientes conectores además de facilitar la unión de piezas, pueden ser combinadas con los conectores básicos para

unir piezas en sus laterales. Los dos primeros son muy útiles para construir estructuras.



4296059 Escuadra 3 x 3 con conectores: Esta pieza sí está presente en la caja de LMS que se comercializa actualmente, no así en la primera

versión. Muy útil para unir vigas perpendiculares entre sí además

de permitir acoplar otras en los laterales.

4225033 Conector cruzado con 4 conectores: muy útil para crear

estructuras rígidas. Montando dos conectores largos en los dos

agujeros, permite montar estructuras muy rígidas.

4560175 Conector largo con agujero central: permite tener un agujero orientable entre las dos vigas que conecta.

4211688 Viga 3 x 0,5 con conector y encaje para eje: El conector puede

ser utilizado como articulación.

4119589 Conector largo doble con agujero en cruz: útil para dar rigidez a

estructuras.

Transmisiones mecánicas

La transmisión de movimiento y esfuerzos es un aspecto muy importante en la concepción de un robot. Engranajes,

poleas, mecanismos biela-manivela, levas, palancas... son sistemas que permiten generar una ganancia o modificar el

movimiento (circular a lineal...).

En esta sección se presentan una serie de piezas diseñadas expresamente para transmitir movimiento. Sin embargo, hay

otras piezas que combinadas de diferentes maneras también pueden ser utilizadas con el mismo propósito.

Engranajes

Los engranajes permiten reducir o aumentar la velocidad ofrecida por los motores así como cambiar la dirección o

sentido del movimiento.

Para hacer moverse el robot, en la mayoría de los casos, no hace falta utilizar engranajes pudiendo conectarse las ruedas

directamente a los motores.

No es recomendable utilizar largos trenes de engranajes ya que las holguras harán que pierdan precisión.

Transmisión entre ejes paralelos 1

Los siguientes engranajes permiten obtener una amplia gama de relaciones de transmisión, aunque puede adolecer de

excesivas holguras. No está de más probar las diferentes combinaciones de engranajes antes de decidirse por una de

ellas.


4514559 Engranaje de 8 dientes





Transmisión entre ejes paralelos 2

Los engranajes de este grupo pueden utilizarse tanto para transmitir movimiento entre ejes paralelos como entre ejes

que se cortan entre sí. Su uso presenta menos holguras que los del grupo1.





Transmisión entre ejes no paralelos

Si lo que se desea es cambiar la dirección del movimiento se puede hacer utilizando diferentes combinaciones de

engranajes.

Para transmitir el movimiento entre ejes perpendiculares que se cortan se pueden utilizar los del grupo "Transmisión

entre ejes paralelos 2", con cualquier combinación entre ellos. Además están los siguientes:


4565452 Engranaje cónico de 12 dientes: Este engranaje puede combinarse tanto con el cónico de 20 dientes como con cualquiera del grupo "Transmisión entre ejes paralelos

2", y por supuesto, consigo mismo.

4514557 Engranaje cónico de 20 dientes: Este engranaje puede combinarse tanto con el

cónico de 12 dientes como con cualquiera del grupo "Transmisión entre ejes paralelos

2", y por supuesto, consigo mismo.

4558690 Engranaje cónico de 20 dientes con agujero: A diferencia del anterior no arrastra o

es arrastrado por el eje que lo atraviesa.

4248204 Engranaje de 4 dientes: Este engranaje ha de ser combinado con sí mismo, tanto si

se usa entre ejes paralelos como entre ejes perpendiculares entre sí.

4211434 Corona de 24 dientes: Este engranaje puede ser combinado con cualquiera del grupo

"Transmisión entre ejes paralelos 1" para transmitir el movimiento a un eje

perpendicular.

Si lo que se desea es conseguir una reducción muy importante en la velocidad de un eje, lo más adecuado es utilizar una

combinación sinfín-corona. Para ello LEGO dispone de un engranaje sinfín que puede combinarse con cualquiera del

grupo "Transmisiones entre ejes paralelos 1".



4211510 Engranaje sinfín de 1 entrada

Cremallera

Combinando la cremallera y un engranaje se puede convertir un movimiento circular generado por un motor en un

movimiento rectilíneo o un desplazamiento rectilíneo en un giro. O viceversa. Se pueden combinar con cualquier engranaje del grupo Trasmisión entre ejes paralelos 1.


3743 (Peeron) Cremallera 1x4

4562009 Cremallera 1x7 con agujeros y agujeros eje

4540906 Cremallera 1x13 con agujeros y agujeros eje

Limitador de par

El engranaje de la figura permite limitar el par transmitido. De este modo el motor podrá seguir girando sin dañar partes

del robot cuando la resistencia supera un valor determinado. Conviene hacer pruebas con él.


4540381 Engranaje limitador de par: Este engranaje de 24 dientes limita el par a unos

valores comprendidos entre 2,5 y 5 Nxcm. Este engranaje se puede combinar con

cualquiera del grupo "Transmisiones entre ejes paralelos 1".


Otros engranajes

Las siguientes ruedas dentadas no encajan en ninguno de los grupos anteriores y tienen un uso muy específico.


4237267 Engranaje de 24 dientes con embrague: Este engranaje puede girar libremente

alrededor de un eje, lo cuál permite montarlo sobre un eje que gire de modo

independiente. Asimismo es útil cuando se quiere montar un cambio de marchas o

asociar a un solo motor dos mecanismos diferentes que que podrán ser seleccionados

de modo manual.

4525184 Diferencial: Junto a tres engranajes cónicos de 12 dientes facilita montar un

diferencial.

4624645 Corona giratoria: permite montar una estructura en cada uno de sus lados de tal

modo que una puede girar respecto a la otra.

Cadena

En los casos en que la distancia entre los ejes entre los que hay que transmitir el movimiento sea grande, una de las

soluciones es utilizar una cadena para ello. No es un elemento que soporte grandes esfuerzos pero puede ser útil en

ocasiones. Estas piezas se combinan con los engranajes del grupo Transmisión entre ejes paralelos 1.


371126 Eslabón de cadena

387326 Eslabón de cadena para oruga

4566742 Eslabón para oruga: esta última pieza se usa

básicamente para montar una oruga que facilite el

movimiento de una máquina por superficies irregulares.

Sin embargo, gracias a los agujeros de que dispone es

posible darle otras utilidades, por ejemplo, como cinta

transportadora.

6036424 Combinando esta pieza con el eslabón para oruga se

puede conseguir un sistema de avance con orugas con

gran adherencia.

Piezas complementarias

Las piezas del primer grupo han sido diseñadas para montar engranajes de un modo compacto, mientras que las del

segundo se utilizan para montar cambios de marcha.



4142824 Caja Reductora: Se utiliza para montar una reductora sinfín-corona (utiliza un engranaje de 24 dientes del grupo

Transmisión entre ejes paralelos 1)

4558692 Conector en U para engranajes cónicos: tanto este como

el siguiente facilitan el montaje de una transmisión entre ejes

perpendiculares tal y como puede verse en las siguientes

imágenes.

48496 (Peeron) Conector en U para engranajes cónicos con conectores

Las siguientes piezas se utilizan para cambio de marchas en modelos Technic así como en mecanismos en los que con

un solo motor de desee conseguir diferentes efectos (no de modo simultaneo y con necesidad de modificar la función de

modo manual). Para este propósito también son necesarios el engranaje de 24 dientes con embrague (véase en el grupo Otros Engranajes) y el conector de ejes (véase en el grupo Accesorios para ejes; el liso no, el otro). Pueden

encontrarse muy buenos ejemplos de cómo montar estos mecanismos en las instrucciones de montaje de la mayoría

de las cajas de LEGO Technic (a excepción de las pequeñas).


4278957 Anillo de embrague: la palanca de cambio actúa sobre esta pieza para

seleccionar el eje al que hay que transmitir el movimiento

4278756 Extensión del anillo de embrague: se combina a la anterior si se necesita

extender el acoplamiento del que dispone en los dos lados.

4270473 Palanca de cambio: permite controlar la posición del anillo de embrague a lo

largo de un eje.

Ejes

Además del uso como ejes, las siguientes piezas pueden utilizarse como elementos de unión, como separadores o

incluso para dar rigidez a estructuras.


En la FLL se utilizan a menudo para construir elementos que faciliten la recolección de modelos de misión. Se ofrecen

únicamente las imágenes de los 7 primeros.


4142865 Eje de 2

4211815 Eje de 3

4566927 Eje de 3 con stud

370526 Eje de 4

4560177 Eje de 4 con tope

4211639 Eje de 5

4508553 Eje de 5,5 con tope

370626 Eje de 6

4211805 Eje de 7

370726 Eje de 8

4499858 Eje de 8 con tope

4535768 Eje de 9

373726 Eje de 10

370826 Eje de 12

50451 (Peeron) Eje de 16

4233937 Eje de 32

Accesorios para ejes

Estos elementos de unión permiten unir dos ejes de tal modo que giren de modo solidario.


4525904 Junta Cardan: para unir ejes no alineados entre sí y mantener la

transmisión de movimiento entre ellos.

4512360 Conector de ejes liso: une dos ejes.

4207456 Conector de ejes: Básicamente su uso es el mismo que el anterior,

pero también se utiliza en sistemas de cambio de marcha.


Separadores

Estas piezas se pueden utilizar para mantener en su posición un engranaje, rueda o cualquier otro elemento que se

monte en un eje, tanto como tope como separador. La anchura del segundo es la misma que la de los engranajes, vigas...

mientras que la de la primera es la mitad.


4239601 Separador de 1/2: esta pieza puede encontrarse en color gris o

amarillo, siendo su uso el mismo en los dos casos.

4211622 Separador

Poleas

Se pueden utilizar poleas para transmitir movimiento, aunque hay que comprobar que cumple su función de modo adecuado. En caso contrario son más eficientes las transmisiones por engranajes.

Se pueden utilizar las siguientes piezas junto a gomas como elemento de transmisión.


4239601 Separador 1/2: Esta pieza puede utilizarse tanto como separador o elemento de fijación para ejes como polea. Puede combinarse con otra

pieza igual o con la siguiente.

4494222 Polea: Esta pieza puede utilizarse tanto como polea como rueda.

Puede combinarse con la anterior para conseguir una reducción de

velocidad.

Ruedas

Siendo LEGO la empresa que mayor número de ruedas fabrica al año en el mundo (380 millones anuales), el número de

diferentes ruedas disponibles para los modelos LEGO es extenso. Sin embargo, no todas ellas son adecuadas para

construir robots. Veamos los factores que hay que tener en cuenta en su selección.

La anchura del apoyo de la rueda en el suelo: Las ruedas anchas con un buen apoyo sobre el suelo (como lo son las

de F1) ofrecen muy buen agarre y una excelente tracción. Para vehículos que han de moverse rectos y que al girar lo

hacen con grandes radios de giro son muy eficientes, no así para robots que giran en espacios reducidos.


La razón es que cuando el robot gira, el recorrido de los puntos de apoyo más cercanos al centro de giro es más corto

que el de los puntos más alejados. En consecuencia, parte del apoyo de la rueda deberá deslizar. Por ello, conviene

seleccionar ruedas con un perfil circular (apoyo estrecho) en lugar de ruedas con un perfil rectangular (apoyo ancho).

El diámetro de la rueda: El diámetro de la rueda condiciona la velocidad, con ruedas mayores el robot podrá

desplazarse más rápido, aunque la precisión puede disminuir.

Otras ruedas

A parte de las ruedas que se encuentran en la caja de LMS Educación, hay un tipo muy interesante por su tamaño y

forma. Esta rueda también se encuentra en la Caja de Recursos LMS Educación. Otra opción es el sistema de oruga.


290226 Neumático 81.6 x 15: este neumático tiene un perfil

redondeado, así que el apoyo es estrecho.

290301 Llanta 81,6 x 15: esta llanta se monta con el neumático 81,6 x

15

680c01 (Peeron) Oruga: Esta pieza puede ser combinada con las llantas

contenidas en la caja LMS Educación para construir un

sistema de movimiento basado en oruga.


Levas

A esta pieza pueden se le pueden dar diferentes usos. Entre ellos se encuentra el de leva pudiendo conectarla a un eje

por cualquiera de los 4 agujeros que dispone.


4210759 Leva

Neumática

Una instalación neumática necesita de un sistema que genere aire comprimido, un recipiente en el que almacenar el aire

comprimido y un actuador que será capaz de realizar trabajo cuando se le suministra aire comprimido.

LEGO dispone de todos estos elementos que con un poco de imaginación se pueden motorizar para diseñar un sistema

automático. Dada la limitación en el uso de motores en la FLL no es posible utilizar dichos motores para generar el aire

comprimido (a no ser que un motor se utilice para más de una función de modo simultáneo). Pero eso no quiere decir

que no sean útiles para la FLL como se verá en la Unidad correspondiente.


74720 Cilindro compresor de uso manual

4652842 Cilindro compresor (el código corresponde al nuevo

cilindro compresor de color gris y algo más largo)

4563144 Cilindro neumático

4625540 Cilindro neumático pequeño

4211508 Unión T para circuito neumático

67c01

(Peeron)

Depósito de aire comprimido

4631293 Tubo flexible para circuito neumático

Compra de nuevas piezas

Si se necesitan más piezas, ya sea porque no se dispone de ninguna de un tipo o porque se necesitan más, hay diferentes

medios para conseguirlas.

El primero para quien solo dispone de la caja de LMS Educación es comprar la Caja de Recursos MINDSTORMS

Educación (ref. 9695) con un precio por debajo de 100 euros. En este enlace puede verse el listado de piezas que

contiene.


En esta sección se presentan otros medios alternativos para conseguir piezas.

Servicio de atención al cliente LEGO

LEGO ofrece piezas sueltas por medio de su Servicio de Atención al Consumidor (vía telefónica en castellano y

llamada gratuita 00-800-5346-1111) y por medio de su página web (Pick-a-Brick).

En el caso de piezas nuevas este es el mejor medio, ya que al ser escasas en Bricklink suelen estar caras. Para hacer el

pedido es necesario conocer el código de las piezas.

Dichos códigos aparecen en el listado de piezas que se encuentra en las instrucciones de montaje de LEGO Technic que

puedes descargar de la web de LEGO Technic. Si no se dispone del código de LEGO, también es posible utilizar el

código Peeron. Peeron es un repositorio no oficial de modelos y piezas de LEGO, de tal modo que es posible ver qué piezas contiene una caja. La fuente de estos inventarios son los propios usuarios así que no hay un 100% de garantía de

que no contengan errores pero a pesar de ello son muy útiles. Si encontramos la referencia de la pieza que buscamos la

podemos utilizar en Bricklink para localizarla.

Bricklink

BrickLink es un portal que reúne un amplio conjunto de tiendas on-line que venden piezas LEGO por unidades. Se

encuentran en más de 60 países y muchas de ellas aceptan pedidos internacionales. En realidad cualquiera puede poner

sus piezas en venta en Bricklink.

Los precios los pone cada vendedor y la disponibilidad de piezas varía de un vendedor a otro. Esto quiere decir que es

importante explorar, y tras encontrar lo que buscamos valorar los precios, sin olvidar los gastos de envío (siempre hay

que mirar en más de una tienda).

La búsqueda se puede hacer de distintas maneras, por el nombre, el código de pieza de LEGO o utilizando el código

Peeron de la pieza. ¿Qué es Peeron? Es un repositorio no oficial de modelos y piezas de LEGO, de tal modo que es

posible ver qué piezas contiene una caja. La fuente de estos inventarios son los propios usuarios así que no hay un 100% de garantía de que no contengan errores pero a pesar de ello son muy útiles. Si encontramos la referencia de la

pieza que buscamos la podemos utilizar en Bricklink para localizarla.

Los precios suelen estar en dólares americanos, así que en las tiendas europeas conviene comprobar primero cuál es el

cambio que aplica el vendedor para evitar sorpresas. Cada vendedor establece los medios de pago que considera

conveniente.

Una vez se hace el pedido se recibe una notificación automática. Tras ella, al poco tiempo, el vendedor se pone en

contacto con el comprador para que efectúe el pago. Generalmente el proceso es rápido.


Cajas de LEGO Technic

Comprar cajas de LEGO Technic es un buen modo de conseguir nuevas piezas además de que permiten conocer cómo

utilizan las diferentes piezas los diseñadores de LEGO. La pega es que si necesitamos alguna pieza en particular en una

cantidad determinada (y en algunos casos de un color determinado) puede suceder que este medio no resulte el más adecuado.

eBay

eBay es un portal en el que se pueden encontrar piezas de LEGO de segunda mano. A veces son modelos completos y otras son diversas cantidades de piezas (individuales o mezcladas de múltiples orígenes). Aquí la pega, o la ventaja, es

que en muchos casos hay que pujar por ellas. A veces hay suerte y se puede conseguir material muy interesante. Tanto

en eBay como en Bricklink conviene mirar primero la reputación del vendedor basada en la opinión de los usuarios que

le han comprado algo.

Recursos

Resultados de la investigación sobre resistencia de las vigas y ladrillos Technic (http://eprints.usq.edu.au/20528/)

“Eficiencia en estructuras LEGO. Mediciones y consejos en mecánica Technic” artículo publicado en el

número 12 de Hispabrick Magazine (http://goo.gl/WjRh2f)

"LEGO Technic Tora no Maki" by ISOGAWA Yoshihito 2007 (http://goo.gl/WhrMWe): Este libro es un

compendio de pequeñas mecanismos con piezas LEGO que puede ser muy útil para obtener ideas sobre cómo

combinar las piezas. Se puede obtener tanto en formato digital como en papel. Organiza los contenidos de

modo sistemático basándose en el tipo de transmisión. Es un libro para ver imágenes, sin texto, imprescindible.

Los manuales de instrucciones de los modelos de LEGO Technic ofrecen muchas ideas útiles a la hora de

montar robots. (http://goo.gl/HkgIeQ)

Bricklink (http://www.bricklink.com/)

Peeron (http://www.peeron.com)

http://eprints.usq.edu.au/20528/

http://goo.gl/WjRh2f

http://goo.gl/WhrMWe

http://goo.gl/HkgIeQ

http://www.bricklink.com/

http://www.peeron.com/

Documents

Manual de robótica FLL Euskadi