Manual de robótica FLL Euskadi by Olaskoaga Koldo

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

Contenido 1

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

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 L A PRESENTACIÓN TÉCNICA ............................................................................................................................................ 3 EL PROYECTO CIENTÍFICO ............................................................................................................................................... 3 LOS RECONOCIMIENTOS ................................................................................................................................................ 4

POR DÓNDE EMPEZAR ....................................................................................................................................... 5 PRIMER PASO ............................................................................................................................................................. 5 ESTRATEGIAS .............................................................................................................................................................. 5 EVALUAR LAS IDEAS ...................................................................................................................................................... 5 PASO A PASO .............................................................................................................................................................. 6

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

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

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

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

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

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

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.

Manual de robótica FLL

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 Manual de robótica FLL

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... Manual de robótica FLL

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.

Manual de robótica FLL

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.

Manual de robótica FLL

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.

Manual de robótica FLL

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

Manual de robótica FLL

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.

Manual de robótica FLL

¡¡¡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.

Manual de robótica FLL

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

Manual de robótica FLL

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)

Manual de robótica FLL

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

Destapar la pasta de dientes

Coger el cepillo de dientes

Aplicar la pasta de dientes al cepillo

Tapar la pasta de dientes

Abrir el grifo

Remojar el cepillo con la pasta de dientes

Cerrar el grifo

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:

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

Manual de robótica FLL

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.

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

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.

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

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.

Manual de robótica FLL

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.

Manual de robótica FLL

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:

Manual de robótica FLL

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.

Manual de robótica FLL

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:

Manual de robótica FLL

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.

Manual de robótica FLL

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

Cierra la pinza

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.

Manual de robótica FLL

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

Gira 90º (a la derecha)

Avanza

Gira 90º (a la derecha)

Manual de robótica FLL

Avanza

Gira 90º (a la derecha)

Avanza

Gira 90º (a la derecha)

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.

Manual de robótica FLL

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.

Manual de robótica FLL

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 Manual de robótica FLL

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.

Manual de robótica FLL

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 Manual de robótica FLL

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.

Manual de rob贸tica FLL

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:

Manual de robótica FLL

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).

Manual de robótica FLL

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.

Asignar a la nueva variable el valor inicial 0

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).

Avanzar durante 2 segundos a potencia 100

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. Manual de robótica FLL

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:

Giro en grados=

Distancia ∗360 π ∗Diametro

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

Manual de robótica FLL

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

Poner en marcha el motor (en modo ilimitado)

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

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.

Manual de robótica FLL

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".

Manual de robótica FLL

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.

Manual de robótica FLL

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.

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

Manual de robótica FLL

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

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

Selecciona el puerto al que está conectado

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.

Manual de robótica FLL

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. Valores de las lecturas 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. 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 Espera 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.

Manual de robótica FLL

Su función es detener el flujo del programa hasta que la condición que se establezca en el panel de control sea verdadera. El panel de control permite apagar el led rojo del sensor.

Factores perturbadores 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. Valores de las lecturas 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. 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. 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.

Manual de robótica FLL

Factores perturbadores 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. Valores de las lecturas 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). 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. El panel de control permite seleccionar además de la distancia que define la condición en centímetros o pulgadas.

Factores perturbadores 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 Manual de robótica FLL

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. Valores de las lecturas 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. 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 Espera 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. 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

Manual de robótica FLL

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

Esperar a que el sensor de contacto choque con la pared

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

Esperar a que el sensor de contacto choque con la pared

Detener el robot

Retroceder (por ejemplo una rotación)

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.

Manual de robótica FLL

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:

Manual de robótica FLL

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).

Manual de robótica FLL

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.

Manual de robótica FLL

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

el robot retrocede hasta el otro borde del papel

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.

Manual de robótica FLL

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. Bloques de programación 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

Resultado

Verdadero

Falso

Verdadero

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.

Manual de robótica FLL

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

Resultado

Verdadero

Falso

Verdadero

Falso

Verdadero

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.

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:

Manual de rob贸tica FLL

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

Resultado

Verdadero

Falso

Verdadero

Falso

Verdadero

Falso

Verdadero

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 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.

Manual de robótica FLL

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

Resultado

Verdadero

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:

Manual de robótica FLL

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

Manual de robótica FLL

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

Detener motor izquierdo para un giro brusco a la izquierda

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

Seguir recto con velocidades iguales

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

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

Manual de robótica FLL

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. 2.

Escribir en el archivo 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

Manual de robótica FLL

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.

Manual de robótica FLL

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.

Manual de robótica FLL

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.

Manual de robótica FLL

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

Manual de robótica FLL

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”). Manual de robótica FLL

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. 8. 9.

Comprueba si el resultado es inferior a 0, en cuyo caso lo convierte en 0 Comprueba si el resultado es superior a 100, en cuyo caso lo convierte en 100. Resta de 100 el valor anterior para conseguir el valor de salida.

Manual de robótica FLL

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.

Manual de robótica FLL

Recursos “Qué es una tabla de verdad”: http://es.wikipedia.org/wiki/Tabla_de_verdad

Manual de robótica FLL

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.

Manual de robótica FLL

¿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.

Manual de robótica FLL

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.

Manual de robótica FLL

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.

Manual de robótica FLL

Descarga e Instalación 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.

Ventajas e Inconvenientes 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 e Instalación 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.

Ventajas e Inconvenientes 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

Manual de robótica FLL

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

Manual de rob贸tica FLL

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.

Manual de robótica FLL

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:

Manual de robótica FLL

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í.

Manual de robótica FLL

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.

http://goo.gl/J7SekV

Manual de robótica FLL

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

http://goo.gl/J7SekV

Manual de robótica FLL

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

4281516

Viga en ángulo 3x7

4112282

Viga en ángulo 4x6

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.

Manual de robótica FLL

Pieza

Código

Descripció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.

Pieza

Manual de robótica FLL

Código

Descripción

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).

Pieza

Código

Descripción

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

4210688

Conector angular #4

4107084

Conector angular #5

4107767

Conector angular #6

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)

Manual de robótica FLL

Código

Descripción

4569751

Eje flexible de 7

4234438

Eje flexible de 11

4296264

Eje flexible de 12

4501304

Eje flexible de 14

4566049

Eje flexible de 16

4614802

Eje flexible de 19

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).

Código

Descripción

4211440

Ladrillo Technic de 2

4211441

Ladrillo Technic de 4

4211466

Ladrillo Technic de 6

4211442

Ladrillo Technic de 8

273001

Ladrillo Technic de 10

4210963

Ladrillo Technic de 12

4107558

Ladrillo Technic de 14

4211443

Ladrillo Technic de 16

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.

Manual de robótica FLL

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.

Pieza

Código

Descripción

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.

Manual de robótica FLL

Pieza

Código

Descripción

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.

Pieza

Manual de robótica FLL

Código

Descripción

4514559

Engranaje de 8 dientes

4640536

Engranaje de 16 dientes

4514558

Engranaje de 24 dientes

4285634

Engranaje de 40 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.

Pieza

Código

Descripción

4177431

Engranaje de 12 dientes

4211635

Engranaje de 20 dientes

4255563

Engranaje de 36 dientes

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:

Pieza

Código Descripción 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".

Manual de robótica FLL

Pieza

Código

Descripción

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.

Pieza

Código

Descripción

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.

Pieza

Código Descripción 4540381

Manual de robótica FLL

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.

Pieza

Código

Descripción

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.

Pieza

Código Descripción 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.

Manual de robótica FLL

Pieza

Código

Descripción

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).

Pieza

Código

Descripción

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.

Manual de robótica FLL

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.

Pieza

Código

Descripción

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. Pieza

Código Descripción 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.

Manual de robótica FLL

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.

Pieza

Código Descripción 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.

Pieza

Código Descripció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.

Manual de robótica FLL

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.

Pieza

Manual de robótica FLL

Código

Descripción

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.

Pieza

Código

Descripción

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.

Pieza

Código

Descripción

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. Manual de robótica FLL

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.

Manual de robótica FLL

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 (http://eprints.usq.edu.au/20528/)

sobre

resistencia

las

vigas

ladrillos

Technic

“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)

Manual de robótica FLL