robotics with the boe bot

Robótica con el Boe-Bot Guía para el Estudiante v2.2

VERSION EN CASTELLANO 1.0

GARANTÍA Parallax garantiza sus productos contra defectos en sus materiales o debidos a la fabricación por un período de 90 días. Si descubres un defecto, Parallax según corresponda, reparará, reemplazará o regresará el valor de la compra. Simplemente pide un número de autorización de regreso de mercancía (Return Merchandise Authorization, “RMA”), escribe el número en el exterior de la caja y envíala a Parallax. Por favor incluye tu nombre, número telefónico, dirección, y una descripción del problema. Nosotros te regresaremos tu producto o el reemplazo, usando el mismo método de correo que usaste para enviar el producto a Parallax.

GARANTÍA DE 14 DÍAS DE REGRESO DE DINERO Si dentro de los 14 días en que recibiste tu producto, encuentras que no es conveniente para tus necesidades, puedes regresarlo y recibir un reembolso. Parallax regresará el precio de compra del producto, excluyendo los costos de manipulación y envío po correo. Esto no aplica si el producto ha sido alterado o dañado. Refiérete a la sección anterior (Garantía) para instrucciones de cómo regresar el producto a Parallax. DERECHOS DE COPIA Y MARCAS REGISTRADAS Esta documentación (la versión en inglés) tiene derechos reservados de autor Copyright 2003-2004 por Parallax, Inc. Al descargar u obtener una copia impresa de esta documentación o software aceptas su uso exclusivo con productos Parallax. Algún otro uso no está permitido y puede representar una violación de los derechos de copia de Parallax, punible por la ley de acuerdo con las leyes Federales de copyright o de propiedad intelectual. Alguna duplicación de esta documentación para usos comerciales esta explícitamente prohibido por Parallax Inc. Duplicación para uso educacional es permitido, sujeto a las siguientes Condiciones de Duplicación: Parallax Inc., concede al usuario derecho condicional para descargar, duplicar, y distribuir este texto sin el consentimiento de Parallax. Este derecho está basado en las siguientes condiciones: el texto, o cualquier porción del mismo, no podrá ser duplicado para uso comercial; podrá ser duplicado únicamente para uso educacional y solamente en conjunción con productos Parallax, y el usuario podrá cargar al estudiante solo el costo de la duplicación. Este texto está disponible en formato impreso por medio de Parallax Inc. Porque imprimimos este texto en volumen, el precio al consumidor es usualmente menor que el típico precio al detal por duplicación. BASIC Stamp (“Estampilla BASIC”), Stamps in Class (“Estampilla en el Aula”), Board of Education (“Plaqueta de de Educación”), SumoBot, y SX-Key (“Llave-SX”) son marcas registradas de Parallax Inc. Si decides usar marcas registradas de Parallax Inc. en su página web o en material impreso, debes declarar que “(marca registrada) es una marca registrada de Parallax Inc.” inmediatamente al aparecer dicha marca registrada por primera vez en cada documento impreso o página web. Nuestra marca y nombre de productos son marcas registradas de sus dueños particulares.

ISBN TBD

DESVINCULACIÓN DE RESPONSABILIDAD Parallax, Inc. no es responsable de daños por consecuencias, incidentes o daños especiales que resulten de cualquier violación de la garantía, bajo cualquier teoría legal, incluyendo pérdida de beneficio, tiempo, daño o reemplazo de equipo o propiedad y cualquier costo, recuperando, reprogramando o reproduciendo cualquier dato guardado o usado dentro de los productos Parallax. Parallax tampoco es responsable de cualquier daño personal, incluyendo vida o muerte, resultado del uso de cualquiera de nuestros productos.

ACCESO EN INTERNET Y LISTAS DE DISCUSION La página web de Parallax Inc. (www.parallax.com) contiene numerosos descargues, productos, aplicaciones para el consumidor, y un sistema de encargo en línea para los componentes usados en este texto. También mantenemos diversas listas de discusión por correo electrónico para personas interesadas en el uso de productos Parallax. Estas listas son accesibles a través de www.parallax.com en el menú Support → Discussion Groups. Estas son las listas que operamos actualmente:

BASIC Stamps (en inglés) – Esta lista es utilizada ampliamente por ingenieros, aficionados y estudiantes quienes comparten sus proyectos con el BASIC Stamp y hacen preguntas.

Stamps in Class (en inglés) – Creada para educadores y estudiantes, aquí los suscritos discuten el uso de los textos “Stamps en el Aula” en sus cursos particulares. Esta lista provee una oportunidad tanto para estudiantes como educadores de hacer preguntas y obtener respuestas.

Parallax Educators (en inglés) – Exclusivamente para educadores y aquellos quienes contribuyen al desarrollo de “Stamps en el Aula”. Parallax creó este grupo para obtener feedback en cuanto a los textos y para proveer un forum para que educadores desarrollen y obtengan Guías para la Enseñanza.

Parallax Translators (en inglés) – El propósito de esta lista es establecer un vínculo entre Parallax y aquellos quienes traducen nuestra documentación a idiomas distintos del inglés. Parallax facilita a los traductores documentos editables de Word y realiza esfuerzos para coordinar las traducciones con las publicaciones de la empresa.

Toddler Robot (en inglés) – Un cliente creó esta lista de discusión para discutir las aplicaciones y la programación del robot Toddler de Parallax.

SX Tech (en inglés) – Discusión sobre la programación del microcontrolador SX con las herramientas de lenguaje ensamblador de Parallax y terceras partes para BASIC y C.

Javelin Stamp (en inglés) – Discusión sobre la aplicación y diseño con Javelin Stamp, un módulo de Parallax programado usando un subconjunto del lenguaje Java® de Sun Microsystems.

ERRATA (TEXTO EN INGLÉS) A pesar de los esfuerzos realizados para asegurar la exactitud de nuestros textos, es posible encontrar errores en ellos. Si encuentras algún error puede notificarlo a través de un correo electrónico, el cual agradecemos que envíe a nuestra dirección [email protected]. Realizamos un constante esfuerzo para mejorar nuestro material y documentación educativa, a través de la continua revisión de nuestros textos. Ocasionalmente, se publica en nuestra página web www.parallax.com una errata que contiene una lista con los errores y las correcciones en un texto determinado. Para cada producto, el archivo de errata puede encontrarse en la parte de descargas gratis de la página del producto.

NOTAS DEL TRADUCTOR (VERSION EN CASTELLANO) Gracias por descargar la versión en Castellano de “Robotics with the Boe-Bot” por Andy Lindsay. Este documento es una traducción literal de este libro. Como toda traducción literal de un idioma a otro, muchos aspectos quedan a la interpretación del traductor. En este caso, aunque el traductor es familiar con la robótica, desconoce algunos de los términos usados en castellano para describir ciertos componentes electrónicos. Por ello, en ocasiones se ha escogido la palabra que mejor corresponda de acuerdo al contexto. Adicionalmente, para minimizar los problemas acarreados por el cambio de idioma, se ha tomado las siguientes medidas:

Conservación de ciertos términos en inglés: Ciertos términos como por ejemplo Basic Stamp o HomeWork Board se han dejado escritos en inglés. A pesar de poder ser traducidos sin ambigüedades (Estampilla Basic y Plaqueta para Tareas respectivamente), consideramos conveniente que si los lectores de esta traducción necesitan información adicional acerca de los productos, sería mas fácil identificarlos por su nombre original.

Glosario: Un pequeño Glosario ha sido incluído en este texto donde explicamos expresiones tanto en castellano como en inglés que puedan ser ambiguas.

Programas: Todos los programas en este texto están siendo traducidos al castellano. Sin embargo, para esta primera versión hemos decidido dejar los programas en inglés ya que el código para dichos programas se encuentra disponible en el sitio web de Parallax. Una vez que terminemos de traducir todo el código, los programas enlistados en esta traducción serán actualizados para coincidir con sus respectivas versiones en castellano.

Listas de Discusión (en español) – Gracias al esfuerzo de ciertos miembros del equipo Parallax, la compañía ha abierto sus puertas hacia Latinoamérica a través de la página http://www.microsparallax.com.ar/ donde encontrarás varias listas de discusiones en español donde podrás hacer las preguntas que desees.

Finalmente, como traductor de este texto, te pido que me contactes con cualquier sugerencia, pregunta, comentario o insulto que puedas tener acerca de este documento. La dirección de correo es: [email protected]

ERRATA (EN CASTELLANO) Sugerencias y comentarios acerca de esta traducción serán compilados en una lista de Errata (en Español) la cual será publicada conjuntamente con este documento para que todos nuestros lectores estén al tanto de las últimas modificaciones a este texto.

· Página i

Tabla de Contenidos Prefacio........................................................................................................................5

Prólogo ...........................................................................................................................5 Audiencia ........................................................................................................................6 Soporte y Grupos de Discusión ......................................................................................6 El Curriculum Stamps In Class .......................................................................................7 Traducciones en Otros Idiomas......................................................................................9 Contribuciones Especiales .............................................................................................9

Capítulo 1: El Cerebro de tu Boe-Bot .......................................................................1 Hardware y Software ......................................................................................................2 Actividad #1: Obteniendo el Software.............................................................................4 Actividad #2: Instalando el Software.............................................................................10 Actividad #3: Preparando el Hardware y Probando el Sistema....................................13 ActivIdad #4: Tu Primer Programa ...............................................................................23 Actividad #5: Buscando Respuestas ............................................................................30 Actividad #6: Introducción al Código ASCII ..................................................................33 Actividad #7: Cuando Hayas Terminado ......................................................................35 Resumen ......................................................................................................................37

Capítulo 2: Los Servomotores de Tu Boe-Bot.......................................................41 Introducción del Continuous Rotation Servo ................................................................41 Actividad #1: Cómo Registrar el Tiempo y Repetir Acciones .......................................42 Actividad #2: Registrando el Tiempo y Repitiendo Acciones con un Circuito ..............45 Actividad #3: Conectando los Servo Motores...............................................................58 Actividad #4: Calibrando los Servos .............................................................................67 Actividad #5: Cómo Guardar Valores y Contar.............................................................71 Actividad #6: Probando los Servos...............................................................................76 Resumen ......................................................................................................................87

Capítulo 3: Ensambla y Prueba tu Boe-Bot ...........................................................93 Actividad #1: Ensamblando tu Boe-Bot ........................................................................93 Actividad #2: Probando los Servos Nuevamente .......................................................104 Actividad #3: Circuito y Programa Indicador Start/Reset............................................107 Actividad #4: Probando el Control de Velocidad con el Debug Terminal ...................114 Resumen....................................................................................................................121

Capítulo 4: Navegación del Boe-Bot.....................................................................127 Actividad #1: Maniobras Básicas con el Boe-Bot .......................................................127 Actividad #2: Entonando las Maniobras Básicas........................................................133 Actividad #3: Calculando Distancias...........................................................................137 Actividad #4: Maniobras – Aceleración Gradual.........................................................142 Actividad #5: Simplificando la Navegación con Subrutinas ........................................145

Página ii · Robótica con el Boe-Bot

Actividad #6: Tópico Avanzado – Construyendo Maniobras Complejas en EEPROM....................................................................................................................................151 Resumen ....................................................................................................................163

Capítulo 5: Navegación Táctil con Bigotes ......................................................... 171 Navegación Táctil .......................................................................................................171 Actividad #1: Construyendo y Probando los Bigotes..................................................172 Actividad #2: Verificando los Bigotes en el Campo ....................................................180 Actividad #3: Navegación con Bigotes .......................................................................183 Actividad #4: Inteligencia Artificial y Decidiendo Cuándo Estás Atascado.................188 Resumen ....................................................................................................................194

Capítulo 6: Navegación Sensitiva a Luz con Fotoresistores............................. 199 Introduciendo el Fotoresistor ......................................................................................199 Actividad #1: Construyendo y Probando Circuitos de Fotoresistores ........................200 Actividad #2: Navegación Libre y Evasión de Objetos Tipo Sombra .........................206 Actividad #3: Un Boe-Bot Controlado por Sombras mas Responsivo........................209 Actividad #4: Obteniendo mas Información de tus Fotoresistores .............................211 Actividad #5: Boe-Bot Seguidor de Rayo de Luz de Linterna ....................................217 Actividad #6: Navegando Libremente Hacia la Luz....................................................226 Resumen ....................................................................................................................234

Capítulo 7: Navegando con Luces Delanteras Infrarrojas................................. 243 Usando Luces Delanteras Infrarrojas para Ver la Vía ................................................243 Actividad #1: Construyendo y Probando los Pares IR................................................245 Actividad #2: Prueba de Campo para Detección de Objeto e Interferencia Infrarroja250 Actividad #3: Ajustes del Rango de Detección Infrarroja ...........................................255 Actividad #4: Detección y Evasión de Objetos ...........................................................257 Actividad #5: Navegación IR con Alto Desempeño ....................................................260 Actividad #6: El Detector de Caída.............................................................................263 Resumen ....................................................................................................................271

Capítulo 8: Control de Robot con Detección de Distancia ................................ 279 Determinando la Distancia con el Mismo Circuito IR LED/Detector ...........................279 Actividad #1: Verificando el Barrido de Frecuencia....................................................279 Actividad #2: Vehículo Boe-Bot Sombra ....................................................................287 Actividad #3: Siguiendo una Banda............................................................................296 Resumen ....................................................................................................................305

Apéndice A: Resolución de Problemas de Comunicación entre la PC y el BASIC Stamp ...................................................................................................................... 313 Apéndice B: Componentes y Características del BASIC Stamp y la Plaqueta de Soporte.................................................................................................................... 319

· Página iii

Apéndice C: Código de Colores de un Resistor .................................................323 Apéndice D: Reglas para Uso de la Protoboard..................................................325 Apéndice E: Lista de Partes del Boe-Bot.............................................................331 Apéndice F: Balanceando Fotoresistores ...........................................................335 Apéndice G: Entonando la Detección de Distancia con IR................................343 Apéndice H: Concursos de Navegación para el Boe-Bot ..................................349 Apéndice I: Glosario...............................................................................................355 Indice .......................................................................................................................359

Página iv · Robótica con el Boe-Bot

Prio · Página v

Prefacio

PROLOGO Los robots son utilizados en la industria automotriz, médica y manufacturera, en todos los tipos de vehículos de exploración, y, por supuesto, en numerosas películas de ciencia ficción. La palabra "robot" apareció por primera vez en una obra de teatro checoslovaca, Rossum Universal Robots, de Karel Capek en 1920. Los robots de esta obra satírica asemejaban seres humanos. Desde ese momento, varias historias de ciencia ficción trataban el tema de los robots tratando de integrarse a la sociedad y de darle sentido a las emociones humanas. Esto cambió cuando General Motors instaló los primeros robots en su fábrica en 1961. Estas máquinas autómatas tenían una imagen totalmente diferente a la de los robots “humanoides” de la ciencia ficción. Construir y programar un robot envuelve una combinación de mecánica, electrónica y capacidad de resolución de problemas. Lo que aprenderás mientras realizas las actividades y proyectos de este texto tendrá relevancia en aplicaciones en “el mundo real” del control robótico, solamente con discrepancias en cuanto al tamaño y el nivel de sofisticación. Los principios mecánicos, programas de ejemplo y los circuitos que usarás son muy similares y en ocasiones iguales a aplicaciones industriales desarrolladas por ingenieros. El objetivo de este texto es lograr que los estudiantes se interesen con entusiasmo en las áreas concernientes a la ingeniería, la mecatrónica y el desarrollo de software, mientras diseñan, construyen y programan un robot autónomo. Esta serie de proyectos y actividades manuales servirá a los estudiantes como una introducción a los conceptos básicos de robótica a través del uso del robot Parallax Boe-Bot™, llamado el "Boe-Bot". Su nombre se debe a la plaqueta Board of Education® que se encuentra montada en su chasis sobre ruedas. Un Boe-Bot de ejemplo, con circuito infrarrojo integrado para detección de obstáculos en la protoboard de la Board of Education se muestra en la Figura P-1.

Página vi · Robótica con el Boe-Bot

Figura P-1 Boe-Bot™ de Parallax Inc. Robot autónomo sobre ruedas.

Las actividades y los proyectos de este texto comienzan con una introducción sobre el cerebro de tu Boe-Bot, el microcontrolador BASIC Stamp® 2 de Parallax, para pasar luego a la construcción, prueba y calibración del Boe-Bot. Después, programarás el Boe-Bot para realizar maniobras básicas, y luego procederás a añadir sensores y escribir programas para que el robot responda de acuerdo a su entorno y realice tareas autónomas.

AUDIENCIA La guía para el estudiante Robótica con el Boe-Bot está dirigida a personas mayores de 13 años, como continuación del texto Whats a Microcontroller? (¿Qué es un microcontrolador?). Como todos los textos del curriculum Stamps in Class (Estampillas en la Clase), esta serie de experimentos enseña técnicas y circuitos nuevos en su gran mayoría con respecto a los otros textos. Los temas generales en esta serie son: navegación básica del Boe-Bot bajo control de programa, navegación utilizando diversos datos proporcionados por sensores, navegación utilizando feedback (retroalimentación) y diversas técnicas de control, y navegación utilizando inteligencia artificial programada. Cada tema está diseñado en un formato introductorio para lograr un entendimiento conceptual, complementado con algunos experimentos prácticos. Los experimentos de cada tema también pueden beneficiar en gran medida a quienes deseen profundizar en la tecnología industrial, la robótica o la electrónica.

SOPORTE Y GRUPOS DE DISCUSION Los siguientes Grupos de Discusión de Yahoo! (en inglés) para quienes deseen ayuda para utilizar este texto. Puedes acceder a estos grupos a través de www.parallax.com en Discussion Groups del menú Support. Stamps In Class Group: Disponible para estudiantes, educadores y usuarios independientes; este foro permite a sus miembros intercambiar preguntas y respuestas acerca de las distintas actividades, ejercicios y proyectos de este texto.

Prio · Página vii

Parallax Educator’s Group: Este foro moderado provee apoyo a los educadores y recibe feedback, mientras nosotros seguimos desarrollando nuestro curriculum Stamps in Class. Para ingresar a este grupo Parallax debes verificar tu estatus como educador. La guía del profesor de este texto está disponible de manera gratuita en este foro. Educational Support: [email protected] En caso de tener alguna dificultad para suscribirse a alguno de estos grupos de Yahoo! contacta directamente al equipo de Stamps in Class de Parallax, o si tienes preguntas acerca del material en este texto, nuestro Stamps in Class Curriculum, nuestro Educator’s Courses o cualquiera de nuestro servicios educativos. Educational Sales: [email protected] Contacta a nuestro equipo de ventas para información sobre descuentos educativos y paquetes escolares de nuestro Stamps in Class y otros productos seleccionados. Technical Support: [email protected] Contacta a nuestro equipo de soporte técnico en caso de tener preguntas generales con respecto a la instalación y el uso de cualquiera de nuestros productos de hardware o software.

EL CURRICULUM STAMPS IN CLASS Este texto puede ser completado satisfactoriamente sin prerrequisitos. Sin embargo, se recomienda el texto Whats a Microcontroller? como introducción al Stamps in Class curriculum.

“What’s a Microcontroller?”, Student Guide, Version 2.2, Parallax Inc., 2004 Después de terminar este texto podrás continuar sus estudios con cualquiera de los paquetes y guías de estudiantes, u otros manuales discutidos más adelante. Todas estas publicaciones están disponibles para descargar de manera gratuita en la página www.parallax.com. Las versiones mencionadas a continuación estaban vigentes cuando se imprimió este material. Contínuamente nos esforzamos para mejorar nuestro programa educativo. Por favor, busca las últimas versiones en nuestras páginas web www.parallax.com y www.stampsinclass.com.

Página viii · Robótica con el Boe-Bot

Guías para el estudiante Stamps in Class:

Para logar obtener una introducción completa a las prácticas de diseño utilizadas en dispositivos y maquinarias modernas se recomienda trabajar con las actividades y proyectos de las siguientes guías para el estudiante (en inglés):

“Applied Sensors”, Student Guide, Version 1.3, Parallax Inc., 2003 “Basic Analog and Digital”, Student Guide, Version 1.3, Parallax Inc., 2004 “Process Control”, Student Guide, Version 2.0, Parallax Inc., 2004

Más kits robótica:

Después de completar este texto estarás preparado para los siguientes textos y kits de robótica más avanzados (en inglés):

“Advanced Robotics: with the Toddler”, Student Guide, Version 1.2, Parallax Inc., 2003 “SumoBot” Manual, Version 2.0, Parallax Inc., 2004

Kits de proyectos educativos:

Elements of Digital Logic, Understanding Signals y Experiments with Renewable Energy están más orientados hacia temas de electrónica, mientras que Stamp Works provee diseños proyectos útiles para aficionados, inventores y diseñadores de productos.

“Elements of Digital Logic”, Student Guide, Version 1.0, Parallax Inc., 2003 “Experiments with Renewable Energy”, Student Guide, Version 1.0, Parallax Inc., 2004 “StampWorks”, Manual, Version 1.2, Parallax Inc., 2000-2001 “Understanding Signals”, Student Guide, Version 1.0, Parallax Inc., 2003

Referencia El BASIC Stamp Manual es una referencia indispensable para todas las guías para el estudiante Stamps in Class. Incluye información acerca de los microcontroladores del BASIC Stamp, el editor del BASIC Stamp, y el lenguaje de programación de PBASIC.

“BASIC Stamp Manual”, Version 2.0c, Parallax Inc., 2000

Prio · Página ix

TRADUCCIONES EN OTROS IDIOMAS Los textos educacionales de Parallax pueden ser traducidos a otros idiomas con nuestro permiso (e-mail [email protected]) si planeas traducir alguno de nuestros textos, contáctanos, para que podamos enviarte los documentos en un formato correcto de MS Word, imágenes, etc. También mantenemos un grupo de discusión para traductores de Parallax al que puedes unirte. Se llama Parallax Translators Yahoo! Group y las instrucciones para encontrarlo están incluidas en este texto. Ve la sección: ACceso en internet y listas en la página precedente a la Tabla de Contenidos. Este texto es una traducción literal en Castellano del texto “Robotics with the Boe-Bot” por Andy Lindsay. Para mayor información acerca de esta versión, lee la sección Notas del Traductor (versión en Castellano) que precede a la Tabla de Contenidos.

CONTRIBUCIONES ESPECIALES El doctor Chuck Schoeffler es autor de porciones del v1.2 del texto (en inglés) en conjunto con Parallax, Inc. Cuando el texto fue escrito, el Dr. Schoeffler se desempeñaba como profesor en el departamento de Educación de Tecnología Industrial en la Universidad de Idaho. El diseñó el Board of Education Robot (Boe-Bot) original que se muestra en la Figura P-2 junto con otros robots derivados similares, con varias funciones únicas. Después de varias revisiones, el diseño de Chuck fue adoptado como la base para el Boe-Bot de Parallax que se usa en este texto. Russ Miller de Parallax diseñó el Boe-Bot basado en este prototipo.

Figura P-2 Prototipo original del Boe-Bot

Andrew Lindsay, Jefe Roboticista de Parallax, desde entonces ha reescrito este texto y sus actividades con tres metas en mente. Primero, acompañar todas las actividades en el texto con instrucción del tipo “cómo se hace”, escritas cuidadosamente. Segundo, exponer al lector y el estudiante a conceptos referentes al nuevo circuito, programación,

Página x · Robótica con el Boe-Bot

ingeniería y robótica en cada capítulo. Tercero, asegurar que los experimentos puedan ser realizados con un alto grado de éxito usando los equipos más actualizados de Parallax. En lo que concierne a esta versión, el equipo más avanzado es la Board of Education Rev C o la BASIC Stamp HomeWork Board. Gracias a Dale Kretzer por la revisión editorial, la cual fue incluída en la v1.4. Gracias también a los siguientes participantes del e-group de Stamps in Class por sus colaboraciones: Richard Breen, Robert Ang, Dwayne Tunnell, Marc Pierloz y Nagi Babu. Estos participantes nos suministraron una o más de las siguientes contribuciones: correcciones de errores, útiles sugerencias editoriales o nuevo material para la v1.4. Gracias a la estudiante Laura Wong y a Rob Gerber por sus respectivas contribuciones a la v1.5. Un agradecimiento especial para el personal de Parallax, Inc. Cada uno de los miembros del equipo de Parallax ha contribuido de alguna manera para hacer del programa Stamps in Class un éxito. La versión 2.0 de esta Guía para el estudiante fue una revisión a gran escala y una reescritura completa que incluye nuevas actividades, soporte para PBASIC 2.5 y para la BASIC Stamp HomeWork Board. Esta revisión no hubiera sido posible sin las siguientes personas. Parallaxianos: Andy Lindsay – autor, Rich Allred – ilustraciones técnicas, Stephanie Lindsay – edición técnica, Kris Magri – corrector y gurú de la robótica. También, gracias a los correctores y colaboradores externos de Stamps in Class Robert Ang y Sid Weaver. Si tienes alguna sugerencia, piensas que encontraste algún error o quieres contribuir con alguna actividad o capítulo en próximas versiones de Robotics with the Boe-Bot (en inglés) o próximos textos de More Robotics with the Boe-Bot (en inglés), contáctenos a través de [email protected]. Subscríbete y mantente en contacto con el StampsInClass Yahoo! Group para las últimas ofertas de hardware gratis por contribuciones con Robotics with the Boe-Bot. Ve la sección ACceso en internet y listas en la página anterior a la Tabla de contenidos.

Capítulo 1: Cerebro de tu Boe-Bot · Página 1

Capítulo 1: El Cerebro de tu Boe-Bot El robot Boe-Bot™ de Parallax, Inc. es el centro de las actividades, proyectos y competencias en este libro. En la Figura 1-1 se muestra el Boe-Bot y su cerebro microcontrolador programable BASIC Stamp® 2 en detalle. El módulo BASIC Stamp 2 es tanto poderoso como fácil de usar, especialmente con un robot.

Figura 1-1 Módulo BASIC Stamp® 2 en un robot Boe-Bot®.

Las actividades en este texto serán tu guía para escribir programas simples para que el BASIC Stamp y tu Boe-Bot realicen cuatro tareas robóticas esenciales:

1. Monitorear sensores para detectar su entorno 2. Tomar decisiones basándose en lo que captan los sensores 3. Controlar su movimiento (operando los motores que permiten girar las ruedas) 4. Intercambiar información con su roboticista (¡Nos referimos a ti!)

El lenguaje de programación que utilizarás para lograr estas tareas se llama PBASIC, cuyas siglas significan:

• Parallax - La compañía que inventó y fabrica los microcontroladores del BASIC Stamp

• Beginners (principiantes, en inglés) - Desarrollado para que los principiantes aprendan cómo programar computadoras

• All-purpose (multifuncional, en inglés) - Muy eficiente y funcional para resolver diferentes tipos de problemas

• Symbolic (simbólico, en inglés) - Usa símbolos (términos semejantes a palabras o frases en inglés)

• Instruction (instrucción, en inglés) - Para enseñar a una computadora cómo solucionar problemas

• Code (código, en inglés) – En términos de que tú y la computadora entiendan

Robótica con el Boe-Bot

¿Qué es un microcontrolador? Es un dispositivo programable que está diseñado en tu reloj digital, teléfono celular, calculadora, radio despertador, etc. En estos dispositivos, el microcontrolador ha sido programado para responder cuando presionas un botón, emitir sonidos electrónicos y controlar lo que se muestra en la pantalla digital. También están integrados en maquinarias industriales, carros, submarinos y naves espaciales porque pueden ser programados para recibir información de sensores, tomar decisiones y hacer funcionar dispositivos que controlen mecanismos de movimiento.

La Guía para el estudiante What’s a microcontroller? es recomendada como el primer texto para los principiantes. Tiene múltiples ejemplos sobre cómo usar microcontroladores y sobre cómo convertir el BASIC Stamp en el cerebro de sus inventos dependientes de microcontroladores. Está disponible para descargar gratuitamente desde la página www.parallax.com, así como en el CD de Parallax. Los kits de What’s a Microcontroller? así como las Guías para el estudiante en versión impresa se pueden encontrar en distintas tiendas de electrónica. En caso de tener dificultades para conseguirlas en tu mercado local, también pueden ser compradas directamente a Parallax, a través de la compra en línea en www.parallax.com o a través del teléfono (888) 512-1024.

HARDWARE Y SOFTWARE Iniciarse en la programación con el BASIC Stamp resulta similar a los primeros pasos con una nueva PC o laptop. Lo primero que la mayoría hace luego de comprar una PC o una laptop es sacarla de la caja, enchufarla, instalar y probar algún software, y tal vez escribir software usando un lenguaje de programación. Si esta es tu primera vez usando microcontroladores BASIC Stamp, realizará esas mismas actividades. Este capítulo te mostrará cómo comenzar a programar con BASIC Stamp con las siguientes actividades:

• Encontrar e instalar el software de programación • Conectar el módulo de tu BASIC Stamp a una fuente de alimentación • Conectar el módulo de tu BASIC Stamp a la computadora para poder programar • Escribir algunos programas en PBASIC • Desconectar la fuente de alimentación cuando termines el trabajo

Si estás en clase, puede que el BASIC Stamp ya esté preparado para ti. De ser así, puede que tu profesor tenga otras instrucciones. En caso contrario, las actividades de este capítulo te guiarán paso a paso para activar tu microcontrolador BASIC Stamp.

√ Si ya completaste la Guía del estudiante What’s a microcontroller?, avanza al siguiente capítulo.

√ De igual manera, si ya conoces tu BASIC Stamp y la Board of Education o √ BASIC Stamp HomeWork Board, avanza al siguiente capítulo.


Tanto este texto como What’s a microcontroller? contienen instrucciones sobre como comenzar a manejar el hardware y software del BASIC Stamp en el Capítulo 1. Estas instrucciones son prácticamente idénticas.

Introducción al BASIC Stamp y la Board of Education Un módulo BASIC Stamp 2 y un Board of Education® carrier board pueden ser apreciados en la Figura 1-2. Como fue mencionado anteriormente, un módulo BASIC Stamp es como una computadora muy pequeña. Esta pequeña computadora va enchufada a la plaqueta portadora Board of Education . Pronto te darás cuenta de que la Board of Education facilita la conexión a una fuente de alimentación y un cable serial al módulo BASIC Stamp. Con actividades que realizarás más adelante se verá cómo la Board of Education facilita la construcción de circuitos y su conexión al BASIC Stamp.

Figura 1-2 Módulo BASIC Stamp® 2 (izquierda) Board of Education® Carrier Board (derecha)

Introducción a la BASIC Stamp HomeWork Board La Figura 1-3 muestra la plataforma de proyecto BASIC Stamp® HomeWork Board™. Esta plaqueta es como una Board of Education con el microcontrolador BASIC Stamp 2 integrado. Puedes usar tanto el módulo BASIC Stamp 2 con la Board of Education carrier board o el BASIC Stamp HomeWork Board como su plataforma de proyectos para las actividades de este texto. Asegúrate de seguir las instrucciones para la plataforma de proyectos que estés usando, debido a que tienen ciertas diferencias.


Figura 1-3 Plataforma de proyectos BASIC Stamp® HomeWork Board™.

¿Cuál es la diferencia?

Usar una plaqueta de soporte Board of Education y el módulo BASIC Stamp le proporciona características adicionales tales como cabezales para conectar servomotores, control sobre el tipo de fuente de alimentación que los servos reciben, y un interruptor de 3 posiciones que resulta muy útil para controlar qué partes del sistema reciben energía. El módulo BASIC Stamp 2 es removible y puede ser reemplazado.

La BASIC Stamp HomeWork Board no tiene puertos para servos, salida externa para fuente de alimentación ni interruptor de energía, pero es más barata. Debes construir sus respectivas conexiones para servos y controlar la fuente de alimentación desconectándola de la plaqueta, o construyendo tus propios circuitos de control de energía. El microcontrolador BASIC Stamp 2 está incorporado en la misma plaqueta y cada pin I/O está protegido por un resistor de 220 Ω montada en la superficie de la plaqueta.

Ver también: Apéndice B: Componentes y Características del BASIC Stamp y la Plaqueta de Soporte

ACTIVIDAD #1: OBTENIENDO EL SOFTWARE El BASIC Stamp Editor (versión 2.0 o superior) es el software que usarás en la mayoría de las actividades y proyectos de este texto. Este software le permite escribir programas en tu computadora y descargarlos en el cerebro de tu Boe-Bot BASIC Stamp. También despliega mensajes en la pantalla de tu computadora enviados por el BASIC Stamp dando a tu Boe-Bot una manera de reportarte a ti, el roboticista, lo que hace y capta a través de los sensores.


El BASIC Stamp Editor es un software libre, y las dos maneras más fáciles de obtenerlo son:

• Descargarlo de la Internet: Busca “BASIC Stamp Windows Editor Version 2.0…” en la página www.parallax.com → Downloads → BASIC Stamp Software.

• Incluido en el CD de Parallax: Sigue el enlace Software que aparece en la página de Bienvenida. Asegúrate de que la fecha impresa en el CD es posterior a abril de 2003.

¿Tienes prisa? Obtén tu copia del BASIC Stamp Windows Editor versión 2.0 (o superior) e instálela en tu PC o laptop. Luego, avanza hasta: Preparando el hardware y probando el sistema.

Si se te presentan interrogantes, la Actividad #1 puede ser usada como una guía paso a paso para obtener el software y la Actividad #2 puede ser usada como referencia para instalarlo en tu PC o laptop.

Requerimientos del Sistema

Necesitarás una PC o una laptop para ejecutar el software del BASIC Stamp Editor. Iniciarse con el BASIC Stamp es más fácil si tu PC o laptop cumple con los siguientes requerimientos:

• Windows 98 o un sistema operativo más reciente • Un puerto serial o USB • Una unidad de CD-ROM, acceso a la Internet, o ambos

Adaptador para el puerto USB: Si tu computadora sólo dispone de puertos USB, necesitarás un adaptador de USB a Serial. Ve el cuadro de información de la página 14 para más detalles.

Descargando el Software de la Internet

Es fácil descargar el software del BASIC Stamp Editor desde la página web de Parallax. La página web mostrada en la Figura 1-4 puede ser diferente a la que veas cuando visite el sitio. Sin embargo, los pasos para descargar el software deben ser parecidos a los siguientes:

√ Usando un buscador en Internet, accede a www.parallax.com (mostrada en la Figura 1-4).

√ Diríjete al menú Downloads para desplegar las opciones. √ Diríjete al enlace de BASIC Stamp Software y haz clic para seleccionarlo.


Figura 1-4 La página web de Parallax: www.parallax.com

√ Cuando entres a la página del BASIC Stamp Software, busca la descarga del

BASIC √ Stamp Windows Editor con un número de versión igual o superior al 2.0. √ Haz clic en el icono Download. En la Figura 1-5, el icono Download parece una

carpeta de archivos a la derecha de la descripción: “BASIC Stamp Windows Editor Version 2.0 Beta 1 (6MB)”.

Figura 1-5 La página web de descargas de Parallax

√ Cuando aparezca la ventana de descarga de archivos mostrada en la Figura 1-6,

selecciona: Save this program to disk (guardar este programa en disco, en inglés). √ Haz clic en el botón OK.


Figura 1-6 Ventana de descarga de archivos

La Figura 1-7 muestra la ventana Save As (guardar como, en inglés) que aparece a continuación. Puedes utilizar el campo Save in (guardar en, en inglés) para seleccionar la carpeta que más te convenga dentro de sus discos duros.

√ Luego de seleccionar donde guardar el archivo que estás bajando, haz clic en el botón Save (guardar, en inglés).

Figura 1-7 Ventana Save As Seleccionando el lugar para guardar el archivo

√ Espera mientras se descarga el programa de instalación del BASIC Stamp Editor

(mostrado en la Figura 1-8). Esto puede tardar unos cuantos minutos si usas una conexión por módem.


Figura 1-8 Ventana de progreso de la descarga

√ Cuando se complete la descarga, deja abierta la ventana que se muestra en la

Figura 1-9 mientras que avanza a la siguiente sección - Actividad #2: Instalando el Software.

Figura 1-9 Ventana de descarga completa Pasa a la Actividad #2: Instalando el Software.

Otras descargas gratuitas que están incluidas en la página web de Parallax son:

• Este texto y otros textos Stamps in Class • Videos de robots • Más software gratuito • ¡Cientos de aplicaciones y experimentos que puedes usar!

Encontrando el Software en el CD de Parallax

También puedes instalar el BASIC Stamp Editor desde el CD de Parallax, pero la versión del CD debe ser posterior a la de abril de 2003, para que puedas obtener la versión del BASIC Stamp Editor compatible con los ejemplos en este texto. Puedes encontrar el año y el mes del CD de Parallax CD examinando la etiqueta en la cubierta del CD.

√ Introduce el CD de Parallax en tu computadora. El buscador del CD de Parallax es la aplicación Welcome (bienvenida, en inglés). Esta aplicación se muestra en


la Figura 1-10 y debería correr inmediatamente después de introducir el CD en tu computadora.

√ Si la aplicación Welcome no corre automáticamente, haz doble clic en Mi PC, luego doble clic en la unidad de CD y luego doble clic en la aplicación Welcome.

√ Haz clic en el enlace Software mostrado en la Figura 1-10.

Figura 1-10 Buscador del CD de Parallax

√ Haz clic en el + al lado de la carpeta del BASIC Stamps que se muestra en la

Figura 1-11. √ Haz clic en el + al lado de la carpeta de Windows. √ Haz clic en el ícono del floppy diskette con el nombre “Stamp 2/2e/2sx/2p/2pe

(stampw.exe)”. √ Continúa con la Actividad #2: Instalando el Software.


Figura 1-11 El buscador del CD de Parallax Selecciona el programa de instalación del BASIC Stamp Editor desde la página de software.

Las descargas gratis en la página web de Parallax están incluidas en el CD de Parallax, pero sólo las actualizaciones hasta la fecha de edición del CD. La fecha en la cubierta del CD indica cuando fue editado. Si el CD sólo tienes uno o dos meses de haber sido editado, probablemente dispongas del material más actualizado. Si el CD es más viejo, deberías considerar pedir uno nuevo a Parallax o descargar los archivos que necesites desde la página web de Parallax.

ACTIVIDAD #2: INSTALANDO EL SOFTWARE En estos momentos, ya has descargado el BASIC Stamp Editor Installer desde la página web de Parallax o lo localizaste en el CD de Parallax. Ahora debes ejecutar el BASIC Stamp Editor Installer.

Instalando el Software Paso a Paso

√ Si descargaste el BASIC Stamp Editor Installer desde la Internet, haz clic en el botón Open (abrir, en inglés) en la ventana de descarga completa mostrada en la Figura 1-12.


Figura 1-12 Ventana de descarga completa Si avanzaste hasta acá desde la sección “Descargando el software desde Internet” haz clic en el botón Open (abrir, en inglés) ahora.

√ Si localizaste el software en el CD de Parallax, haz clic en el botón Install

(instalar, en inglés) que se muestra en la Figura 1-13.

Figura 1-13 El buscador del CD de Parallax Botón Install (instalar, en inglés) cerca del final de la ventana.

√ Cuando la ventana del InstallShield Wizard del BASIC Stamp Editor se abra,

haz clic en el botón Next (siguiente, en inglés) que se muestra en la Figura 1-14.


Figura 1-14 InstallShield Wizard del BASIC Stamp Editor

√ Selecciona Typical (típica, en inglés) para tu configuración, como se muestra en la

Figura 1-15. √ Haz clic en el botón Next.

Figura 1-15 Tipo de configuración

√ Cuando el InstallShield Wizard te anuncie que está “Ready to Install the

Program” (listo para instalar el programa, en inglés), haz clic en el botón Install, mostrado en la Figura 1-16.


Figura 1-16 Preparado para la instalación Haz clic en el botón Install.

√ Cuando la ventana del InstallShield Wizard te anuncie “InstallShield Wizard

Completed” (InstallShield Wizard completado, en inglés), como se muestra en la Figura 1-17, haz clic en Finish (finalizar, en inglés).

¡Felicitaciones! Tu BASIC Stamp Editor ya está instalado.

Figura 1-17 InstallShield Wizard completado

ACTIVIDAD #3: PREPARANDO EL HARDWARE Y PROBANDO EL SISTEMA El BASIC Stamp necesita estar conectado a una fuente de alimentación para funcionar. También necesita estar conectado a una PC para poder ser programado. Luego de realizar estas conexiones, puedes utilizar el BASIC Stamp Editor para probar el sistema. Esta actividad te enseñará cómo.


Configuración del Cable Serial de la Computadora

La Board of Education o la BASIC Stamp HomeWork Board debe estar conectada a tu PC o laptop por cualquier cable serial o adaptador de USB a Serial .

√ Si estás usando un cable serial, conéctalo a un puerto COM disponible en la parte trasera de tu computadora como lo muestra la Figura 1-18.

Com

Figura 1-18 Puerto COM de la PC o laptop Enchufa el cable serial en un puerto COM disponible en tu PC o laptop.

√ Si estás utilizando un adaptador de USB a Serial, sigue las instrucciones de

instalación del hardware y software suministradas junto con el producto.

Adaptador de USB a Serial US232B/LC de FTDI:

Para el momento de la impresión de esta guía, el adaptador de USB a Serial US232 fabricado por Parallax es el recomendado para utilizar con los productos Parallax. El adaptador viene con el hardware mostrado en la Figura 1-19. Los conductores de VCP se incluyen en la versión más última del software de BASIC Stamp Editor, transferencia directa de www.parallax.com.


Figura 1-19

Adaptador de USB a Serial RS232

Este adaptador tiene el número de stock en Parallax 28031. Los conductores de VCP se incluyen en la versión más última del software de BASIC Stamp Editor, transferencia directa de www.parallax.com.

Ahora que tu cable de programación está conectado a tu computadora, es hora de ensamblar el hardware.

√ Si posees un BASIC Stamp y una Board of Education, sigue las instrucciones de la siguiente sección, Instrucciones para la Conexión de la Board of Education .

√ Si posees una plaqueta BASIC Stamp HomeWork, avanza hasta las Instrucciones para la conexión del BASIC Stamp HomeWork Board en la página 19.

√ Si tu equipo ya está conectado, avanza hasta la sección en la página 21.

Instrucciones para la Conexión de la Board of Education

Si posees un BASIC Stamp y una Board of Education, la Figura 1-20 te muestra el hardware necesario para comenzar.

Hardware Requerido

(1) Banda con cuatro patas de goma (1) Paquete de baterías (1) BASIC Stamp 2 (1) Board of Education (4) Baterías alcalinas AA (no incluidas)


Figura 1-20 Hardware para comenzar con el BASIC Stamp y la Board of Education

Conectando el Hardware

Las patas de goma se muestran en la Figura 1-21, y deben ser fijadas en la parte de abajo de tu Board of Education. La Board of Education tiene círculos en la parte de abajo donde deben fijarse las patas de goma.

√ Retira cada pata de goma de la banda y fíjela en la parte de abajo de la Board of Education.

Figura 1-21 Patas de goma (izquierda) fijadas en la parte de abajo de la Board of Education (derecha)

La Board of Education Rev C tiene un interruptor de 3 posiciones (ver Figura 1-22). La posición 0 es para apagar completamente la energía en la Board of Education. Aunque la Board of Education Rev C esté conectada a una batería u otra fuente de alimentación, cuando el interruptor de 3 posiciones esté en 0, el dispositivo estará apagado.

√ Coloca el interruptor de 3 posiciones de la Board of Education en la posición 0.


0 1 2

Figura 1-22 Interruptor de tres posiciones Colóqcalo en 0 para apagarlo.

Sólo la Board of Education Rev C tiene un interruptor de 3 posiciones. Si posees una Board of Education Rev A o B:

• Cuando te indiquemos colocar el interruptor de 3 posiciones en 0, apágalo desconectando el paquete de baterías (al contrario de la Figura 1-24, paso 3).

• Cuando te indiquemos colocar el interruptor de 3 posiciones en 1 o 2, conecta el paquete de baterías como se indica en la Figura 1-24, paso 3.

√ Coloca las baterías en el paquete de baterías como se muestra en la Figura 1-23. Asegúrate de seguir las marcas de polaridad (+ y -) dibujadas dentro de la cubierta plástica del paquete de baterías, al momento de insertar cada batería.

Figura 1-23 Paquete de baterías Indicadores de polaridad en la cubierta plástica (izquierda) para colocar correctamente las baterías (derecha).

√ Si tu BASIC Stamp todavía no está conectado al Board of Education, insértalo en el enchufe mostrado en la Figura 1-24, paso 1.

¡Asegúrate de que tu BASIC Stamp esté correctamente posicionado (como se muestra en la Figura 1-24) antes de insertarlo en el enchufe! Si el BASIC Stamp es enchufado al revés, puede dañarse al conectar la energía.


√ Asegúrate de que los pines estén alineados correctamente con los agujeros del enchufe, luego presione firmemente para que encaje. El módulo debe entrar aproximadamente 1/8 de pulgada (3 mm).

2

1

www.stampsinclass.com

Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC

SoutSinATNVssP0P1P2P3P4P5P6P7

P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1

VssP1P3P5P7P9P11P13P15Vin

VssP0P2P4P6P8P10P12P14Vdd

U1

TM

0 1 2

© 2000-2003

Vdd

P15P14P13P12P11P10P9P8P7P6P5P4P3P2P1P0

X2

X3Vdd VssVin3

Figura 1-24 Board of Education, BASIC Stamp, Batería y cable Serial Conecta los componentes en el orden indicado en el diagrama.

√ Enchufa el cable serial en la Board of Education tal como se muestra en la Figura

1-24, paso 2. √ Enchufa el paquete de baterías en la salida de batería 6-9 VDC como se muestra

en la Figura 1-24, paso 3. √ Mueve el interruptor de 3 posiciones a la posición 1 para encender la energía.

0 1 2

Figura 1-25 Interruptor de 3 posiciones Colóquelo en la posición uno para volver a encender la energía.

√ La luz verde que dice Pwr en la Board of Education debe estar encendida.


Figura 1-26 BASIC Stamp y Board of Education conectados y listos para programar

√ Avanza a la sección en la página 21.

Instrucciones para la Conexión del BASIC Stamp HomeWork Board

Esta sección te guiará para conectar el BASIC Stamp a tu computadora y a una fuente de alimentación si tienes un BASIC Stamp HomeWork Board.

Hardware Requerido

√ Toma las siguientes partes de tu kit, mostradas en la Figura 1-27 (1) Basic Stamp HomeWork Board (1) Banda de cuatro patas de goma (1) Pila de 9 V nueva (no incluida) (1) BASIC Stamp HomeWork Board

Figura 1-27 Hardware para comenzar a utilizar el BASIC Stamp HomeWork Board

√ Retira cada pata de goma de la banda y fíjela en la parte de abajo del HomeWork

Board al lado de cada agujero chapado en cada esquina de la plaqueta, como se indica en la Figura 1-28, asegurándose de no tapar los agujeros.


Figura 1-28 Patas de goma

√ Conecta el cable serial y la batería al HomeWork Board (Figura 1-29, pasos 1 y

2).

1

Reset

(916) 624-8333www.parallaxinc.comwww.stampsinclass.com

Rev ASTAMPS CLASS

in

© 2002

Power

BASIC Stamp HomeWork Board®


X2

X3Vdd VssVin

2

Alkaline Battery

Powercell

Figura 1-29 HomeWork Board y Cable Serial Conecte el cable serial y la pila de 9 V en el HomeWork Board.

La Figura 1-30 muestra la BASIC Stamp HomeWork Board conectada a tu fuente de alimentación y al cable de programación serial.

La luz que dice Pwr no se enciende cuando conecta la batería. Sólo se encenderá cuando un programa esté corriendo.


Ya estás listo para probar la conexión de programación entre el BASIC Stamp y tu PC/laptop.

Figura 1-30 BASIC Stamp HomeWork Board listo para programar

Probando la comunicación

√ Primero, ejecuta el BASIC Stamp Editor haciendo doble clic en el acceso directo que está en tu escritorio. Debe parecerse a la Figura 1-31.

Figura 1-31 Acceso directo al BASIC Stamp Editor Busca un acceso directo similar a este en el escritorio de tu computadora

También se puede ejecutar el BASIC Stamp Editor a través del menú de inicio de Windows. Haz clic en el botón Inicio de Windows, luego selecciona Programas → Parallax, Inc. → Stamp Editor 2…, luego haz clic en el icono del BASIC Stamp Editor.

La ventana de tu BASIC Stamp Editor debe ser similar a la que se muestra en la Figura 1-32.


La primera vez que ejecutes el BASIC Stamp Editor, puede que despliegue algunos mensajes y listas de los puertos COM encontrados por el software.

√ Si conoce el número del puerto COM al que tu BASIC Stamp está conectado, asegúrate de que está incluido en la lista.

√ Si no está incluido en la lista, sigue las instrucciones del BASIC Stamp Editor para añadir un puerto COM.

√ Si no estás seguro de cuál es el puerto COM, haz clic en OK, por ahora. √ Para asegurarte de que tu BASIC Stamp se está comunicando con tu

computadora, haz clic en el menú Ejecutar, luego selecciones Identify (identificar, en inglés).

Figura 1-32 BASIC Stamp Editor

Aparecerá una ventana de identificación similar a la que se muestra en la Figura 1-33. El ejemplo en esta imagen muestra un BASIC Stamp 2 detectado en el COM2.

Figura 1-33 Ventana de identificación Ejemplo: BASIC Stamp 2 encontrado en el COM2.

√ Verifica la ventana de identificación para estar seguro de que el BASIC Stamp 2

ha sido detectado en alguno de los puertos COM. Si el BASIC Stamp 2 ha sido detectado, estás listo para la Actividad #4: Tu Primer Programa.

√ Si la ventana de identificación no detecta el BASIC Stamp 2 en ninguno de los puertos COM, diríjase a la página 313 (Apéndice A: Resolución de Problemas de Comunicación entre la PC y el BASIC Stamp).


ACTIVIDAD #4: TU PRIMER PROGRAMA El primer programa que escribirás y probarás le ordenará al BASIC Stamp que envíe un mensaje a tu PC o laptop. La Figura 1-34 muestra cómo el BASIC Stamp envía una secuencia de unos y ceros para comunicar los caracteres que son desplegados por tu PC o laptop. Este conjunto de ceros y unos es lo que llamamos código binario. El software del BASIC Stamp Editor tiene la habilidad de detectar y mostrar estos mensajes, como lo verás a continuación.

1 0 0

1 1 0

1 0

1 1 1 0 01

1 0 0 0 0 0 0 0 1 1 0 0 0 0

1 1 0

1 0

1 0

1 0

0 1

0 0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 0 1 0 1 00


STAMPS CLASSin

9 VdcBattery

6-9VDC


P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

1

U1

TM

Figura 1-34 Mensajes del BASIC Stamp a tu computadora

Tu primer programa

Los programas ejemplo que escribirás en el BASIC Stamp Editor y descargarás en el BASIC Stamp estarán presentados siempre con un fondo gris. He aquí un ejemplo:


Programa de ejemplo: HelloBoeBot.bs2 ' Robotica con el Boe-Bot - HelloBoeBot.bs2 ' BASIC Stamp envia un mensaje a tu PC/laptop. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Hello, this is a message from your Boe-Bot" END

Introducirás este programa desde el BASIC Stamp Editor. Algunas líneas del programa aparecen automáticamente al presionar algunos botones de la barra de herramientas. Otras líneas aparecen al escribirlas con el teclado.

√ Comienza haciendo clic en el ícono BS2 (el chip diagonal verde) en la barra de herramientas, el cual está resaltado en la Figura 1-34, si mantienes el cursor sobre este botón, aparecerá el mensaje de descripción “Stamp Mode: BS2”.

√ Luego, haz clic en el ícono en forma de engranaje “2.5” que aparece resaltado en la Figure 1-35. El mensaje de descripción es “PBASIC Language: 2.5”.

Figura 1-34 Icono BS2 Hacer clic en este botón desplegará automáticamente '$STAMP BS2 al principio del programa.

Figure 1-35 Icono PBASIC 2.5 Hacer clic en este botón desplegará automáticamente '$PBASIC 2.5 al principio del programa..

¡SIEMPRE usa estos botones de la barra de herramientas para agregar estas dos líneas al principio del programa! Las direcciones para el compilador deben estar entre

. Al momento de escribir en estas partes del programa, puede que accidentalmente

uses paréntesis ( ) o corchetes rectos [ ]. Si lo haces, tu programa no funcionará.


√ Escribe el resto del programa en el BASIC Stamp Editor exactamente como está mostrado en la Figura 1-36. Nota que las dos primeras líneas están antes de las direcciones para el compilador, y el resto del programa está después de ellas.

Figura 1-36 Programa HelloBoeBot.bs2 introducido en el BASIC Stamp Editor

√ Guarda tu trabajo haciendo clic en File (archivo, en inglés) y seleccionando Save

(guardar, en inglés), (Figura 1-37).

Figura 1-37 Guardando el programa HelloBoeBot.bs2

√ Introduce el nombre HelloBoeBot.bs2 en el campo File name (nombre de archivo, en

inglés) cerca del final de la ventana Save As (guardar como, en inglés) tal como se muestra en la Figura 1-38.

√ Haz clic en el botón Save.


Figura 1-38 Introduciendo el nombre del archivo

La próxima vez que hagas clic en guardar, el BASIC Stamp Editor guardará el archivo automáticamente con el mismo nombre (HelloBoeBot.bs2) a menos que hagas clic en File y selecciones Save As (en lugar de Save), para elegir otro nombre.

√ Haz clic en Run (ejecutar, en inglés), y selecciona Run del menú que aparece (al

hacer clic en el primero) como se muestra en la Figura 1-39.

Figura 1-39 Ejecutando tu primer programa HelloBoeBot.bs2

Una ventana de progreso de descarga aparecerá brevemente mientras el programa es trasmitido desde la PC o laptop a tu BASIC Stamp. La Figura 1-40 muestra el Debug Terminal que debería aparecer cuando la descarga se complete. Puedes comprobar que este es un mensaje del BASIC Stamp presionando y soltando el botón Reset en tu Board of Education o HomeWork Board. Cada vez que efectúas esta operación, el programa volverá a ejecutarse, y verás otra copia del mensaje desplegado en el Debug Terminal.


√ Presiona y suelta el botón Reset. ¿Viste un segundo mensaje “Hello…” desplegado en el Debug Terminal?

Figura 1-40 Debug Terminal El Debug Terminal muestra los mensajes enviados a la PC/laptop por el BASIC Stamp.

El editor BASIC Stamp Editor tiene accesos directos para la mayoría de las tareas. Por ejemplo, para ejecutar un programa, puedes presionar las teclas ‘Ctrl’ y ‘R’ al mismo tiempo. También puedes hacer clic en el botón Run. Es el triángulo azul mostrado en la Figura 1-41 que parece el botón Play de un reproductor de CD. El mensaje de descripción aparecerá si coloca el cursor sobre el botón Run. Puedes ver mensajes similares para saber que función representa cada botón colocando el cursor sobre ellos.

Figura 1-41

BASIC Stamp Editor

Botones de acceso directo

Funcionamiento del Programa HelloBoeBot.bs2

Las dos primeras líneas del programa de ejemplo son comentarios. Un comentario es una línea de texto ignorada por el BASIC Stamp Editor, porque están escritos para ser leídos por personas, no por el BASIC Stamp. En PBASIC, todo lo que siga a un apóstrofe es considerado un comentario por el BASIC Stamp Editor. El primer comentario dice de qué libro es el programa de ejemplo y cuál es el nombre del programa. La segunda línea contiene información útil y breve sobre qué hace el programa.

' Robotica con el Boe-Bot - HelloBoeBot.bs2 ' BASIC Stamp envia un mensaje a tu PC/laptop.


Existen varios mensajes especiales que puedes enviar al BASIC Stamp Editor colocándolos dentro de comentarios (a la derecha de un apóstrofe en cualquier línea). Estos son llamados directivas para el compilador, y todos los programas de este texto utilizan dos directivas:

' $STAMP BS2 ' $PBASIC 2.5

La primera se llama directiva Stamp, y le indica al BASIC Stamp Editor que descargarás el programa a un BASIC Stamp 2. La segunda es la directiva PBASIC , y le indica al BASIC Stamp Editor que estás usando la versión 2.5 del lenguaje de progamación PBASIC. Un comando es una palabra que usas para indicarle al BASIC Stamp que ejecute alguna tarea. El primero de los dos comandos en este programa se llama comando DEBUG:

DEBUG "Hello, this is a message from your Boe-Bot."

Este es el comando que le indica al BASIC Stamp que envíe e mensaje a la PC usando el cable serial. El segundo comando es el comando END:

END

Este comando es útil porque coloca al BASIC Stamp en modo de baja energía cuando termina de ejecutar el programa. En modo de baja energía, el BASIC Stamp espera que se presione el botón Reset, o que el BASIC Stamp Editor cargue un nuevo programa. Si se presiona el botón Reset en tu plaqueta, el BASIC Stamp ejecutará nuevamente el programa cargado anteriormente. Si se carga un nuevo programa, el anterior será borrado y el nuevo se comenzará a ejecutar.

Tu Turno – Formateadores DEBUG y Caracteres de Control

Un formateador DEBUG es una palabra-código utilizada para hacer que el mensaje envíado por el BASIC Stamp tenga un aspecto determinado en el Debug Terminal. DEC es un ejemplo de formateador que hace que el Debug Terminal muestre un valor decimal. Un ejemplo de caracater de control es de CR, que manda un Retorno de Línea al Debug Terminal. Los textos o números que siguen a CR aparecerán en la línea siguiente a la de los caraceteres antes del caracater de control. Puede modificar tu programa de tal manera que contenga más comandos DEBUG junto con algunos comandos formateadores y caracteres de control. He aquí un ejemplo de cómo hacerlo:


√ Primero, guarda el programa con un nuevo nombre haciendo clic en File y

seleccionando Save As. √ Un buen nombre para el nuevo archivo puede ser HelloBoeBotYourTurn.bs2. √ Modifica los comentarios del principio de la siguiente manera:

' Robotica con el Boe-Bot - HelloBoeBotYourTurn.bs2 ' BASIC Stamp realiza operaciones matematicas simples y envia ' los resultados al Debug Terminal.

√ Agregue estas tres líneas entre el primer comando DEBUG y el comando END: DEBUG CR, "What's 7 X 11?" DEBUG CR, "The answer is: " DEBUG DEC 7 * 11

√ Guarda los cambios haciendo clic en File y seleccionando Save. Tu programa debe verse como la Figura 1-42. Ejecuta tu programa modificado. Consejo: tendrás que hacer nuevamente clic en Run desde el menú Run, tal como lo muestra la Figura 1-39, o tendrás que hacer clic en el botón Run tal como lo muestra la Figura 1-41.

Figura 1-42 Programa HelloBoeBot.bs2 Modificado Compara tu trabajo con el programa con el ejemplo aquí mostrado.


Tu Debug Terminal ahora debe parecerse a la imagen en la Figura 1-43.

Figura 1-43 Salida de la Debug Terminal del programa HelloBoeBot.bs2 modificado Asegurese de obtener los resultados esperados al volver a ejecutar el programa.

¿Dónde está mi Debug Terminal? A veces la Debug Terminal queda escondida detrás de la ventana del BASIC Stamp Editor. Puede volver a colocarla en frente usando el menú Run como se muestra en la Figura 1-44, el botón de acceso directo de la Debug Terminal 1 mostrado en la parte derecha de la imagen, o la tecla F12 de tu teclado.

Figura 1-44

Debug Terminal 1 visible en el escritorio

Usando el menú (izquierda) y usando el acceso directo (derecha).

ACTIVIDAD #5: BUSCANDO RESPUESTAS El programa de ejemplo que acaba de terminar te permitió conocer dos comandos de PBASIC: DEBUG y END. Puedes conocer más acerca de estos comandos y cómo usarlos, buscándolos en la ayuda del BASIC Stamp Editor o en el manual de BASIC Stamp. Esta actividad te guiará para realizar un ejemplo de búsqueda de DEBUG usando la ayuda del BASIC Stamp Editor y el Manual de BASIC Stamp.


Usando la Ayuda del BASIC Stamp Editor

√ En el BASIC Stamp Editor, haz clic en Help, luego selecciona Index como se

muestra en la Figura 1-45.

Figura 1-45 Seleccionando Index desde menú de ayuda

√ Escribe DEBUG en el campo donde dice Type in the keyword to find: (Figura 1-46). √ Cuando la palabra DEBUG aparezca en la lista debajo del campo en donde estás

escribiendo, haz doble clic en la palabra, luego haz clic en el botón Display.

Figura 1-46 Buscando el comando DEBUG usando la ayuda

Tu Turno

√ Usa la barra de búsqueda para leer el artículo sobre el comando DEBUG. Observa que contiene varias explicaciones y programas ejemplos que puedes probar.

√ Haz clic en la pestaña Contents, y busca DEBUG allí. √ Haz clic en la pestaña Search, y haz una búsqueda de la palabra DEBUG.


√ Repite este proceso para el comando END.

Obteniendo y usando el Manual del BASIC Stamp

El BASIC Stamp Manual está disponible para ser descargado de manera gratuita desde la página web de Parallax y también está incluido en el CD de Parallax. También lo puedes comprar como material adicional y manual impreso.

Descargar el Manual de BASIC Stamp desde la página Web de Parallax

√ Usa un explorador de Internet para entrar en www.parallax.com. √ Coloca el cursor sobre el menú Downloads para desplegar las opciones. √ Señala el enlace Documentation y haz clic para seleccionarlo. √ Cuando llegues a la página de BASIC Stamp Documentation, busca el BASIC Stamp

Manual. √ Haz clic en el icono Download con forma de carpeta de archivo que está a la derecha

de la descripción: “BASIC Stamp Manual Version 2.0 (3.2 MB)”.

Viendo el Manual del BASIC Stamp en el CD de Parallax

√ Haz clic en el enlace Documentation. √ Haz clic en el + al lado de la carpecta de BASIC Stamps. √ Haz clic en el icono en forma de libro del BASIC Stamp Manual. √ Haz clic en el botón View.

√ La Figura 1-47 muestra un extracto de la sección de contenidos del BASIC Stamp Manual (página 2). Muestra que la información sobre el comando DEBUG se puede encontrar en la página 97.

Figura 1-47 Buscado el comando DEBUG en la Tabla de contenidos

La Figura 1-48 muestra un extracto del BASIC Stamp Manual. Allí se explica detalladamente el comando DEBUG.


√ Ve brevemente la explicación sobre el comando DEBUG en el BASIC Stamp Manual.

√ Cuenta el número de programas ejemplo en la sección de DEBUG ¿Cuántos hay?

Figura 1-48 Revisando el comando DEBUG debug en el BASIC Stamp Manual

Tu Turno

√ Usa el índice del BASIC Stamp Manual para buscar el comando DEBUG. √ Busca el comando END en el BASIC Stamp Manual.

ACTIVIDAD #6: INTRODUCCION AL CÓDIGO ASCII En la Actividad #4: Tu Primer Programa, usaste el formateador DEC con el comando DEBUG para mostrar un número decimal en la Debug Terminal. ¿Pero, qué pasa si no usa el formateador DEC con un número? Si usas el comando DEBUG seguido de un número sin formateador, el BASIC Stamp leerá ese número como un código ASCII. Programando con el código ASCII ASCII son las siglas de American Standard Code for Information Interchange. La mayoría de los microcontroladores y PC usan este código para asignar un número a cada función del teclado. Algunos números corresponden a acciones del teclado, tales como arriba, abajo, espacio o borrar. Otros números corresponden a caracteres y símbolos impresos. Los números del 32 al 126 corresponden a esos caracteres y símbolos que el BASIC Stamps puede mostrar en la Debug Terminal. El siguiente programa usará el código ASCII para mostrar las palabras “BASIC Stamps 2” en la Debug Terminal.


Programa de ejemplo – AsciiName.bs2

√ Introduce, guarda y ejecuta el programa AsciiName.bs2.

¡Recuerda utilizar los iconos de la barra de herramientas para lograr colocar las directivas del compilador en tus programas!

'$STAMP BS2 - Usa el icono del chip electrónico diagonal verde. '$PBASIC 2.5 – Usa el icono en forma de engranaje que dice 2.5. Puedes volver a ver una imagen de estos iconos en la página 24.

' Robotica con el Boe-Bot - AsciiName.bs2 ' Usar codigo ASCII en un comando DEBUG para mostrar las palabras ' BASIC Stamp 2. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG 66,65,83,73,67,32,83,116,97,109,112,32,50 END

Funcionamiento del Programa AsciiName.bs2

Cada letra en el comando DEBUG corresponde a un símbolo del código ASCII que apareció en la Debug Terminal.

DEBUG 66,65,83,73,67,32,83,116,97,109,112,32,50 El 66 es el código ASCII para la “B” mayúscula, el 65 para la “A” mayúscula y así sucesivamente. El 32 es el código para un espacio entre caracteres. Observa que cada número código esta separado por comas. Las comas permiten que DEBUG ejecute cada símbolo como comandos separados. Esto es mucho más fácil de escribir que 12 comandos de DEBUG separados.

Tu Turno – Explorando el Código ASCII

√ Guarda el programa AsciiName.bs2 como AsciiRandom.bs2 √ Selecciona 12 números al azar entre el 32 y 127. √ Reemplaza los números del código ASCII del programa por los que elegiste. √ ¡Ejecuta el programa modificado y ve qué obtienes!


El Appendix A (Apéndice A, en inglés) del BASIC Stamp Manual contiene un cuadro con los números del código ASCII y sus símbolos correspondientes. Puedes buscar los números correspondientes a las letras de tu nombre.

√ Guarda el programa AsciiRandom.bs2 como YourAsciiName.bs2 √ Busca el cuadro de ASCII en el BASIC Stamp Manual. √ Modifica el programa para escribir tu nombre. √ Ejecuta el programa para ver si escribiste tu nombre correctamente. √ Si fue así, ¡buen trabajo y guarda tu programa!

ACTIVIDAD #7: CUANDO HAYAS TERMINADO Es importante desconectar la energía de tu BASIC Stamp y de la Board of Education o HomeWork Board por diversas razones. Primero, tus baterías durarán más tiempo si el sistema no está recibiendo energía mientras no está siendo usado. Segundo, en experimentos posteriores, construirás circuitos en el área de prototipos de la Board of Education o la HomeWork Board.

Nunca debes dejar de vigilar los prototipos de circuitos mientras la batería o la fuente de alimentación esté conectada. Nunca sabes que clase de accidente puede ocurrir mientras no estás.

Siempre desconecta la fuente de alimentación de tu Board of Education o HomeWork Board, incluso si nada más piensas dejarlo solo durante uno o dos minutos.

Si estás en un salón de clases, puede que tu instructor tenga más instrucciones, tales como desconectar el cable serial, guardar tu Board of Education/HomeWork Board en un lugar seguro, etc. Aparte de esos detalles, el paso más importante que debes seguir siempre es desconectar la fuente de alimentación cuando termines. Desconectando la Energía Con la Board of Education Rev C, desconectar la energía es fácil:

√ Si estás usando la Board of Education Rev C, mueve el interruptor de 3 posiciones a la posición 0 moviéndolo hacia la izquierda como se muestra en la Figura 1-49.



Reset

Board of Education


P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

X1

P11P13P15Vin

P10P12P14Vdd

U1

0 1 2

© 2000-2003

P10P9P8P7P6P5P4P3P2P1P0

X2

Figura 1-49 Apagando la energía en la Board of Education Rev C

¡No desconectes el BASIC Stamp de su enchufe en la Board of Education! Resiste el impulso de guardar la Board of Education y el BASIC Stamp por separado. Cada vez que el BASIC Stamp es desconectado y reconectado en la Board of Education, pueden ocurrir errores que podrían dañarlo. A pesar de que el BASIC Stamp puede ser movido de un enchufe a otro durante un proyecto largo, esto no será necesario durante las actividades de este texto.

Desconectar la energía de la BASIC Stamp HomeWork Board también es fácil:

√ Si estás usando la BASIC Stamp HomeWork Board, desconecta la batería como se muestra en la Figura 1-50.

Reset© 2002

Power

BASIC Stamp HomeWork Board®


X2

X3Vdd VssVin

Alkaline

BatteryPow

ercell

Figura 1-50 Desconectando la energía de la HomeWork Board

La energía de la Board of Education Rev A o B también debe ser desconectada, quitando la batería o desenchufando el suministro de CC del jack.

Tu Turno

√ Desconecta la energía ahora.


RESUMEN Este capítulo te guió a través de los siguientes puntos:

• Una introducción al BASIC Stamp • Dónde obtener el software gratuito del BASIC Stamp Editor que usarás en casi

todos los experimentos de este texto • Cómo instalar el software del BASIC Stamp Editor • Una introducción al BASIC Stamp, la Board of Education y la HomeWork

Board • Cómo configurar el hardware del BASIC Stamp • Cómo probar tu software y hardware • Cómo escribir y ejecutar un programa de PBASIC • Usar los comandos DEBUG y END • Usar el caracter control CR y el formateador DEC • Usar códigos ASCII para transmitir caracteres • Cómo usar el menú de ayuda del BASIC Stamp Editor y el BASIC Stamp

Manual • Cómo desconectar la energía de tu Board of Education o HomeWork Board

cuando termines

Preguntas

1. ¿Qué dispositivo será el cerbero de tu Boe-Bot? 2. Cuando el BASIC Stamp envía un mensaje a tu PC/laptop ¿Qué tipo de números

se usan para enviar el mensaje a través del cable serial? 3. ¿Cuál es el nombre de la ventana que muestra mensajes enviados desde el

BASIC Stamp a tu PC/laptop? 4. ¿Qué comandos de PBASIC aprendiste en este capítulo?

Ejercicios

1. Explica lo que puedes hacer con cada comando de PBASIC que aprendiste en este capítulo.

2. Explica qué hace el caracter asterisco en la siguiente línea: DEBUG DEC 7 * 11


3. Hay un problema con estos dos comandos. Cuando ejecutas el código, los números que muestran aparecen uno al lado del otro lo que hace que parezca un sólo número en vez de dos separados. Modifica estos dos comandos para que las respuestas aparezcan en dos lineas diferentes en el Debug Terminal. DEBUG DEC 7 * 11 DEBUG DEC 7 + 11

Proyectos

1. Escribe un programa que use la instrucción DEBUG para que muestre la solución al siguiente problema matemático: 1 + 2 + 3 + 4.

2. Anticipa que se verá si quitas el formateador DEC de este comando. Usa el programa PBASIC para verificar tu predicción. DEBUG DEC 7 * 11

3. ¿Qué lineas puedes borrar en el programa HelloBoeBotYourTurn.bs2 si colocas el comando mostrado a continuación, en la línea inmediatamente anterior al comando END del programa? Verifica tu hipótesis (tu predicción de lo que va a pasar). Asegúrate de guardar el programa HelloBoeBotYourTurn.bs2 con un nuevo nombre para que te ayude a hacerle seguimiento, como HelloBoeBotCh01Project03.bs2. Haz entonces tu modificación, guarda y ejecuta tu programa. DEBUG "What's 7 X 11?", CR, "The answer is: ", DEC 7 * 11


Soluciones

Q1. El módulo microcontrolador BASIC Stamp 2. Q2. Números binarios. Q3. El Debug Terminal. Q4. DEBUG y END.

E1. DEBUG – Este comando se usa para enviar un mensaje del BASIC Stamp a la PC.

La información se muestra en el Debug Terminal. END – Este comando se usa para terminar un programa de PBASIC y para poner al módulo BASIC en modo de energía baja.

E2. El asterisco multiplica los operadores 7 y 11, resultando el producto 77. El asterisco es el operador de multiplicación.

E3. Para arreglar el problema, añade un caracter de retorno, el caracater controlador CR.

DEBUG DEC 7 * 11 DEBUG CR, DEC 7 + 11

P1. He aquí un programa que soluciona el problema matemático:

' Robotica con el Boe-Bot - HelloBoeBotCh01Project01.bs2 ' Suma 4 numeros con DEBUG '$STAMP BS2 '$PBASIC 2.5 DEBUG "Cuanto es 1+2+3+4?" DEBUG CR, "La respuesta es: " DEBUG DEC 1+2+3+4 END

P2. Predicción: Imprimirá el caracater "M". Este programa verifica tu predicción:

' Robotica con el Boe-Bot - HelloBoeBotCh01Project02.bs2 ' Muestra 7 * 11 en ASCII ' $STAMP BS2 ' $PBASIC 2.5 DEBUG 7 * 11 END


P3. Las tres últimas lineas de DEBUG se pueden borrar. Se necesita un CR adicional

después del mensaje "Hello".

' Robotica con el Boe-Bot – HelloBoeBotCh01Project03.bs2 ' Envía un mensaje al Debug Terminal y realiza unos calculos. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Hola, este es un mensaje de tu Boe-Bot.", CR DEBUG "Cuanto es 7 X 11?", CR, "La respuesta es: ", DEC 7 * 11 END

La salida del Debug Terminal es:

Hola, este es un mensaje de tu Boe-Bot. Cuanto es 7 X 11? La respuesta es: 77

Esta salida es la misma que produce con las tres lineas. Esto es un ejemplo del uso de comas para mostrar bastante información usando sólo una declaración DEBUG.

Capítulo 2:Los Servomotores de tu Boe-Bot · Page 41

Capítulo 2: Los Servomotores de tu Boe-Bot Este capítulo te guíara para que puedas conectar, ajustar y probar los motores del Boe-Bot. Para poder lograrlo, deberás comprender ciertos comandos y técnicas de programación de PBASIC que controlarán la velocidad y duración del movimiento de los servomotores. Por lo tanto, las Actividades #1, #2 y #5 te servirán como introducción a estas herramientas de programación, luego las Actividades #3, #4 y #6 te servirán para ver cómo aplicarlas a los servos. Dado que un control preciso es la clave para el desempeño exitoso del Boe-Bot, es importante y necesario que completes estas actividades antes de montar los servos en el chasis del Boe-Bot.

INTRODUCCION DEL CONTINUOUS ROTATION SERVO Los Continuous Rotation Servos (Servos de Rotación Contínua, en inglés) de Parallax mostrados en la Figura 2-1 son los motores que harán que las ruedas del Boe-Bot giren. Esta imagen destaca las partes externas del servo. Se hará referencia a muchas de estas partes a lo largo de las instrucciones de este capítulo. Figura 2-1 Continuous Rotation Servo de Parallax

Consejo: Puede resultarte útil marcar esta página para referencias posteriores.

Cable para el control de energía y

de señal

Orificio de acceso para centrar e feedback del potenciometro

Control horn

Tornillos Phillips

Pestaña de montaje

Pestaña de montaje

La etiqueta debe decir

“Continuous Rotation”

Contiene motor, circuitos

y engranajes

Toma para la conexión del RC servo en la Board of Education


Standard Servos vs. Continuous Rotation Servos: Los Standard Servos están diseñados para recibir señales eléctronicas que les indican que posición deben mantener. Estos servos controlan las posiciones de los alerones de los aviones a control remoto, timones de barcos y volantes de carros. Los Continuous Rotation Servos reciben las mismas señales electrónicas, pero en lugar de mantener ciertas posiciones, giran a ciertas velocidades en ciertas direcciones. Los Continuous Rotation Servos son ideales para controlar ruedas y poleas.

ACTIVIDAD #1: COMO REGISTRAR EL TIEMPO Y REPETIR ACCIONES Controlar la velocidad y dirección de un servomotor envuelve un programa que hace que el BASIC Stamp envíe el mismo mensaje una y otra vez. El mensaje debe repetirse unas 50 veces por segundo para que el servo mantenga su velocidad y dirección. Esta actividad tiene algunos programas ejemplo en PBASIC para demostrar cómo repetir el mismo mensaje una y otra vez, y cómo controlar el tiempo para la repetición del mensaje.

Mostrando Mensajes a Velocidade Humanas

Puedes utilizar el comando PAUSE para indicarle al BASIC Stamp que debe esperar para ejecutar el comando que sigue.

PAUSE Duration

El número que coloques al lado del comando PAUSE se llama argumento Duration, y es el valor que le indica al BASIC Stamp cuánto tiempo debe esperar para continuar con el siguiente comando. Las unidades para el argumento de Duration son las milésimas de segundo (ms). Por lo tanto, si quieres esperar un segundo, usa el valor 1000. He aquí cómo debe verse el comando:

PAUSE 1000

Si deseas esperar el doble de tiempo, intenta: PAUSE 2000

Un segundo se abrevia “s”. En este texto, cuando ves 1 s, significa un segundo.

Un milisegundo es la milésima parte de un segundo, y se abrevia “ms”. El comando PAUSE 1000 retrasa el programa en 1000 ms, lo que equivale a 1000/1000 de segundo, lo cual es equivalente a un segundo, o 1 s. ¿Entendiste?


Programa de ejemplo: TimedMessages.bs2

Existen diversas maneras de usar el comando PAUSE. Este programa de ejemplo usa PAUSE para retrasar la aparición de mensajes impresos que le indican cuanto tiempo ha pasado. El programa debe esperar un segundo antes de desplegar el mensaje “One second elapsed…” y otros dos segundos antes del mensaje “Three seconds elapsed...”.

√ Si posees una Board of Education Rev C, cambia el interruptor de 3 posiciones de la posición 0 a la posición 1

√ Si posees un HomeWork Board, reconecta la batería de 9 V. √ Introduce el siguiente programa en el BASIC Stamp Editor. √ Guarda el programa bajo el nombre “TimedMessages.bs2”. √ Ejecuta el programa, luego observa el retraso entre los mensajes.

' Robotica con el Boe-Bot - TimedMessages.bs2 ' Muestra como el comando PAUSE puede ser usado para mostrar mensajes ' a velocidades humanas. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Start timer..." PAUSE 1000 DEBUG CR, "One second elapsed..." PAUSE 2000 DEBUG CR, "Three seconds elapsed..." DEBUG CR, "Done." END

De aquí en adelante, las tres instrucciones escritas antes de este programa serán resumidas en una frase como esta: Introduce, guarda y ejecuta el programa TimedMessages.bs2.

Tu Turno – Duraciones de Pause Diferentes

Puedes cambiar el tiempo de retraso entre mensajes cambiando el valor del argumento Duration del comando PAUSE.


√ Intenta cambiar los argumentos Duration del comando PAUSE de 1000 y 2000 a 5000 y 10000, por ejemplo:

DEBUG "Start timer..." PAUSE 5000 DEBUG CR, "Five seconds elapsed..." PAUSE 10000 DEBUG CR, "Fifteen seconds elapsed..."

√ Ejecuta el programa modificado. √ También intenta con números como 40 y 100 para los argumentos Duration;

van a pasar muy rápido. √ El argumento Duration más largo es 65535. Si dispones de un minuto, intenta

PAUSE 60000.

Una y Otra Vez

Uno de los mejores aspectos de los microcontroladores y las computadoras es que nunca se quejan por hacer las mismas tareas aburridas una y otra vez. Puedes colocar comandos entre las palabras DO y LOOP si deseas que se ejecuten una y otra vez. Por ejemplo, digamos que quieres imprimir un mismo mensaje una vez por segundo. Simplemente coloca sus comandos DEBUG y PAUSE entre las palabras DO y LOOP de la siguiente manera:

DO DEBUG "Hello!", CR PAUSE 1000 LOOP

Programa de ejemplo: HelloOnceEverySecond.bs2

√ Introduce, guarda y ejecuta el programa HelloOnceEverySecond.bs2. √ Verifica que el mensaje “Hello!” aparezca una vez cada segundo.


' Robotica con el Boe-Bot - HelloOnceEverySecond.bs2 ' Muestra el mensaje una vez por segundo. ' $STAMP BS2 ' $PBASIC 2.5 DO DEBUG "Hello!", CR PAUSE 1000 LOOP

Tu Turno – Un Mensaje Diferente

Puedes modificar tu programa para que una parte se ejecute una vez y la otra se ejecute una y otra vez.

√ Modifique el programa para que los comandos queden de esta manera: DEBUG "Hello!" DO DEBUG "!" PAUSE 1000 LOOP

√ ¡Ejecútalo y observa qué sucede! ¿Esperabas ese resultado?

ACTIVIDAD #2: REGISTRANDO EL TIEMPO Y REPITIENDO ACCIONES CON UN CIRCUITO En esta actividad, construirás circuitos que emitirán luz que te permitirán “ver” la clase de señales que se usan para controlar los servomotores del Boe-Bot.

¿Qué es un microcontrolador? Extractos – Esta actividad contiene extractos seleccionados de la Guía para el Estudiante What’s a Microcontroller? Student Guide v2.0.

√ Incluso si estás familiarizado con el texto What’s a Microcontroller?, no obvies esta actividad.

En la segunda mitad de esta actividad, examinarás las señales que controlan tus servos y los diagramas de tiempo desde un punto de vista distinto al de What’s a Microcontroller?

Introducción del LED y el Resistor

Un resistor es un componente que ‘resiste’ el flujo de la electricidad. Este flujo de electricidad se llama corriente. Cada resistor tiene un valor que indica cuán fuerte es la


resistencia a la corriente eléctrica. Este valor de resistencia se llama ohm y el símbolo del ohm es la letra griega Omega - Ω. El resistor con el que estará trabajando en esta actividad es un resistor de 470 Ω mostrado en la Figura 2-2. El resistor tiene dos conectores (llamados patas), uno saliendo de cada extremo. Hay un casco de cerámica entre las dos patas y esa es la parte que resiste la corriente. La mayoría de los diagramas de circuitos que muestran resistores usan el símbolo de la izquierda con las líneas en zig-zag para indicarle a la persona que construye el circuito que debe usar un resistor de 470 Ω. A esto se le llama símbolo esquemático. El dibujo de la derecha es un dibujo de partes utilizado en algunos niveles de principiantes en los textos Stamps in Class para ayudarte a construir los circuitos.

470 ΩYellow

VioletBrown

GoldSilverorBlank

Figura 2-2 Dibujo de Parte del Resistor de 470 Ω Símbolo esquemático (izq.) y dibujo de parte (der.)

Las bandas de colores indican los valores de resistencia. Ver Apéndice C: Código de Colores de un Resistor para información sobre cómo determinar el valor de un resistor por las bandas de colores del casco de cerámica.

Un diodo es una válvula de corriente unidireccional y un diodo emisor de luz (LED, por sus siglas en inglés) emite luz cuando la corriente pasa a través de él. A diferencia del código de colores de los resistores, el color del LED simplemente indica cual es el color de la luz que se enciende cuando pasa la corriente eléctrica. Las marcas importantes en un LED tienen que ver con su forma. Dado que un LED es una válvula de corriente unidireccional, debes asegurarte de conectarlo de la manera correcta, de lo contrario no funcionará como esperas. La Figura 2-3 muestra el símbolo esquemático de un LED y su dibujo de parte. Un LED tiene dos terminales. Una es el ánodo y la otra es el cátodo. En esta actividad, tendrás que integrar el LED en un circuito y deberás prestar atención y asegurarte de que el ánodo y el cátodo estén correctamente conectados al circuito. En el dibujo de parte, el ánodo está señalado con el signo (+). En el símbolo esquemático, el ánodo es la parte ancha del triángulo. En este dibujo de parte, el cátodo está señalado con el signo (-) y en el símbolo esquemático, el cátodo es la línea tangente al vértice del triángulo.


+ _

LED

Figura 2-3 Dibujo de parte y símbolo esquemático del LED Dibujo de parte (arriba) y símbolo esquemático (abajo). Dibujos de parte posteriores del LED tendran un + al lado de la pata ánodo.

Cuando comiences a construir un circuito, asegúrate de compararlo con el símbolo esquemático y el dibujo de parte. Si observa detalladamente el casco plástico del LED en el dibujo de partes, tiene forma redondeada, pero tiene una parte plana cerca de uno de las patas que señala el cátodo. Nota también que las patas del LED son de tamaños diferentes. En este texto, el ánodo se mostrara con el signo + y el cátodo con el signo –.

Siempre revisa el casco plástico del LED. Generalmente, la pata mas larga está conectada al ánodo y el más corto al cátodo. Sin embargo a veces las patas son cortadas del mismo tamaño o el fabricante no sigue esta convención. Por lo tanto, siempre es mejor buscar la parte plana del casco. Si conectas el LED al contrario, no se dañará, pero la luz no se encenderá.

Partes del Circuito de Prueba para el LED

(2) LEDs – rojos (2) Resistores – 470 Ω (amarillo-violeta-marrón)

¡Siempre desconecta la energía de tu plaqueta antes de construir o modificar circuitos! Para la Board of Education Rev C, coloca el interruptor de 3 posiciones en la posición 0. Para el BASIC Stamp HomeWork Board, desconecta la batería de 9 V. Siempre verifica dos veces el circuito antes de reconectar la energía.


Circuitos de Prueba para el LED

Si completaste el texto What’s a Microcontroller?, seguramente estás familiarizado con el circuito mostrado en la Figura 2-4. El lado izquierdo muestra el esquema del circuito y el lado derecho muestra un ejemplo de diagrama de conexión del circuito construido en el área de prototipos de tu plaqueta.

√ Construye el circuito mostrado en la Figura 2-4. √ Asegúrate de que los pines más corto de cada LED (los cátodos) estén

conectados en los enchufes negros marcados Vss. √ Asegúrate de que los pines más largos (los ánodos, marcados con un ⊕ en el

diagrama de conexión) estén conectados en los enchufes del protoboard exactamente como se muestra.

P12

P13

Vss Vss

LEDLED

470 Ω

470 Ω

P15P14

P11P10P9P8P7P6P5P4P3P2P1P0

P13P12

X2

X3Vdd VssVin

++

Figura 2-4 Dos LEDs conectados a los pines I/O P13 y P12 del BASIC Stamp Diagrama esquemático (izquierda) y diagrama de conexión (derecha).

¿Qué es un pin I/O? I/O significa entrada/salida, por sus siglas en inglés. El BASIC Stamp tiene 24 pines, 16 de los cuales son pines I/O. En este texto, programarás el BASIC Stamp para usar pines I/O como salidas para lograr que las luces del LED se apaguen y se prendan, controlen la velocidad y dirección de giro de los Continuous Rotation servos de Parallax, reproduzcan tonos con altavoces y preparen sensores para detectar luces y objetos. También programarás el BASIC Stamp para que use pines I/O como entradas para monitorear sensores que indiquen contacto mecánico, niveles de luz, objetos en el camino del Boe-Bot e incluso sus distancias.

¿Es nuevo construyendo circuitos? Ver Apéndice D: Reglas para Uso de la Protoboard.


La Figura 2-5 muestra lo que hará el BASIC Stamp en el circuito del LED después de que lo programes. Imagina que tienes una batería de 5 voltios (5 V). A pesar de que una batería de 5 V no es común, la Board of Education posee un dispositivo llamado regulador de voltaje que suministra un equivalente a una batería de 5 V al BASIC Stamp. Cuando conectas un circuito a Vss, es como conectar el circuito al extremo negativo de una batería de 5 V. Cuando conectas el otro extremo del circuito a Vdd, es como conectarlo al extremo positivo de una batería de 5 V.

-

-

- -

-

-

-

-

-

-

--

-

-

-

-+

_--

+

+

-

---++

+

---++

+

--+

+

-

N

NNN+

=

NN

N

+

_ -

+

---++

+

---++

+

--+

NNN+

NN

N

Vdd

Vss

5 V

Vdd

Vss

5 V

Figura 2-5 BASIC Stamp cambiando la conección

El BASIC Stamp puede ser programado para conectar internamente la entrada del circuito de LED a Vdd o Vss.

Voltios se abrevia V. Esto significa que 5 voltios se abrevia 5 V. Cuando aplicas voltaje a un circuito, es como aplicar presión eléctrica.

Corriente se refiere a la velocidad con la que los electrones pasan a través de un circuito. A menudo verás medidas de corriente expresadas en amperios, que se abrevia A. La cantidad de energía que un motor eléctrico consume generalmente se mide en amperios, por ejemplo 2 A, 5 A, etc. Sin embargo, las corrientes que usarás en tu Board of Education son medidas en milésimas de amperios, o miliamperios. Por ejemplo, 10.3 mA pasan a través del circuito de la Figura 2-5.

Cuando se realizan estas conexiones, 5 V de presión eléctrica son aplicados al circuito, causando el flujo de electrones y que el LED emita una luz. Tan pronto como desconectes la pata del resistor del extremo positivo de la batería, la corriente dejará de fluir y el LED dejará de emitir la luz. Puedes ir un paso más allá conectando la pata del resistor a Vss, lo cual tendrá el mismo resultado. Esta es la acción para la cual programarás al BASIC Stamp, es decir, para que se encienda el LED (emita luz) y se apague (no emita luz).


Programas de Control para Los Circuitos de Prueba para el LED

Los comandos HIGH y LOW son usados para hacer que el BASIC Stamp conecte un LED alternamente a Vdd y Vss. El argumento Pin es un número entre 0 y 15 que le indica al BASIC Stamp cuál pin I/O debe conectar a Vdd o Vss.

HIGH Pin

LOW Pin

Por ejemplo, si usas el comando HIGH 13

le indicas al BASIC Stamp que conecte el pin I/O P13 a Vdd, lo cual enciende el LED. De igual manera, si usas el comando

LOW 13

le indicas al BASIC Stamp que conecte el pin I/O P13 a Vss, lo cual apaga el LED. Intentemos lo siguiente.

Programa de ejemplo: HighLowLed.bs2

√ Reconecta la energía a tu plaqueta. √ Introduce, guarda y ejecuta el programa HighLowLed.bs2. √ Verifica que el circuito de LED conectado al P13 se encienda y se apaga cada

segundo. ' Robotica con el Boe-Bot – HighLowLed.bs2 ' Prender/Apagar el LED conectado a P13 una vez cada segundo. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "The LED connected to Pin 13 is blinking!" DO HIGH 13 PAUSE 500 LOW 13 PAUSE 500 LOOP


Funcionamiento del Programa HighLowLed.bs2

La Figura 2-6 muestra cómo el BASIC Stamp puede conectar un circuito de LED alternamente a Vdd y Vss. Cuando está conectado a Vdd, el LED emite una luz. Cuando está conectado a Vss, el LED no emite ninguna luz. El comando HIGH 13 indica al BASIC Stamp que conecte P13 a Vdd. El comadno PAUSE 500 indica al BASIC Stamp que deje el circuito en ese estado durante 500 ms. El comando LOW 13 indica al BASIC Stamp que conecte el LED a Vss. Nuevamente, el comando PAUSE 500 indica al BASIC Stamp que lo deje en ese estado durante 500 ms. Dado que estos comandos están escritos entre DO y LOOP, son ejecutados una y otra vez.

SOUTSINATNVSS

P0P1P2P3P4P5P6P7

VINVSSRESVDD (+5V)P15P14P13P12P11P10P9P8

24

23

22

21

20

19

18

17

16

15

14

13

1

2

3

4

5

6

7

8

9

10

11

12

BS2-IC

BS2

Vdd

Vss

SOUTSINATNVSS

P0P1P2P3P4P5P6P7

VINVSSRESVDD (+5V)P15P14P13P12P11P10P9P8

24

23

22

21

20

19

18

17

16

15

14

13

1

2

3

4

5

6

7

8

9

10

11

12

BS2-IC

BS2

Vdd

Vss

Figura 2-6 BASIC Stamp cambiando la conexión

El BASIC Stamp puede ser programado para conectar internamente la entrada del circuito de LED a Vdd o Vss.

Una Prueba Diagnóstico para tu Computadora

Muy pocas computadoras, tal es el caso de algunas laptops, detienen el programa de PBASIC después de la primera vez en un bucle DO...LOOP. Estas computadoras tienen un diseño de puerto serial no estándar. Al colocar un comando DEBUG al programa LedOnOff.bs2, el Debug Terminal abierta evita que esto suceda. A continuación volverás a ejecutar este programa sin el comando DEBUG para ver si tu computadora tiene este problema de diseño de puerto serial no estándar. No es probable, pero sería importante saber si lo tiene.

√ Abre el programa HighLowLed.bs2. √ Borra la instrucción DEBUG por completo. √ Ejecuta el programa modificado mientras observas el LED.

Si el LED titila continuamente, al igual que cuando ejecutaste el programa normal con el comando DEBUG, tu computadora no tiene ese problema.


Si el LED sólo titiló una vez y se detuvo, tienes una computadora con un diseño de puerto serial no estándar. Si desconectas el cable serial de tu plaqueta y presionas el botón Reset, el BASIC Stamp ejecutará el programa correctamente sin detenerse. En programas escritos por ti mismo, deberías añadir el comando:

DEBUG "Program Running!" Justo después de las directivas del compilador. Esto abrirá el Debug Terminal y mantendrá abierto el puerto COM. Esto evitará que tus programas se detengan después de una repetición del ciclo DO…LOOP, o cualquier otro comando de bucle que aprendas en capítulos posteriores. Verás este comando en algunos de los programas de ejemplo que de otra manera no necesitarían la instrucción DEBUG. Por lo tanto, deberías ser capaz de ejecutar el resto de los programas de este libro aunque tu computadora no haya pasado la prueba diagnóstico.

Introducción al Diagrama de Control de Tiempo

Un diagrama de control de tiempo es un gráfico que relaciona las señales altas (Vdd) y las bajas (Vss) con el tiempo. En la Figura 2-7, el tiempo aumenta de izquierda a derecha, y las señales altas y bajas están alineadas con Vdd (5 V) o Vss (0 V). Este diagrama de control de tiempo muestra un fragmento de 1000 ms de la señal alta/baja con la que acabas de experimentar. La línea punteada (. . .) a la derecha de la señal es una forma de indicar que la señal se repite.

Vdd (5 V)

Vss (0 V)

500 ms

1000 ms

…

500 ms

Figura 2-7 Diagrama de control de tiempo para el programa HighLowLed.bs2 El estado LED encendido/apagado se muestra arriba del diagrama.


Tu Turno – Encendido y Apagado del Otro LED

Hacer que el otro LED (conectado a P12) se encienda y se apague se logra simplemente cambiando el argumento Pin en los comandos HIGH y LOW y volviendo a ejecutar el programa.

√ Modifica el programa para que los comandos queden de la siguiente manera: DO HIGH 12 PAUSE 500 LOW 12 PAUSE 500 LOOP

√ Ejecuta el programa modificado y verifica que el otro LED se enciende y se apaga.

También puedes hacer que ambos LEDs titilen al mismo tiempo.

√ Modifica el programa para que los comandos queden de la siguiente manera: DO HIGH 12 HIGH 13 PAUSE 500 LOW 12 LOW 13 PAUSE 500 LOOP

√ Ejecuta el programa modificado y verifica que ambos LEDs se encienden y se apagan casi simultáneamente.

Puedes volver a modificar el programa para hacer que un LED se encienda y se apague, y también puedes cambiar el ritmo del titileo ajustando el argumento Duration del comando PAUSE, más alto o más bajo.

√ ¡Inténtalo!


Viendo una Señal de Control de Servo con un LED

Las señales altas y bajas que el BASIC Stamp enviará a los servomotores, después de que lo programes para ello, deben durar períodos muy precisos de tiempo. Esto se debe a que los servomotores miden la cantidad de tiempo que la señal se mantiene alta y la usan como una instrucción que les indica hacia dónde girar. Para un control preciso de servomotores, el tiempo durante el que estas señales se mantienen altas debe tener mucha más precisión de la que se puede lograr con un comando HIGH y uno PAUSE. Sólo puede cambiar el argumento Duration del comando PAUSE en 1 ms (recuerda, eso es 1/1000 de segundo) a la vez. Existe un comando diferente llamado PULSOUT que puede enviar señales altas durante períodos de tiempo precisos. Estas cantidades de tiempo son valores que se usan en el argumento Duration y se miden en unidades que equivalen a ¡dos millonésimas de segundo!

PULSOUT Pin, Duration

Un microsegundo es la millonésima parte de un segundo. Se abrevia μs. Debes ser cuidadoso al escribir este valor, no es la letra ‘u’ de nuestro alfabeto; es la letra griega mu ‘μ’.

Por ejemplo, 8 microsegundos se abrevia 8 μs.

Puedes mandar una señal HIGH que enciende el LED conectado a P13 durante 2 μs (dos millonésimas de segundo) usando este comando:

PULSOUT 13, 1

Este comando encenderá el LED durante 4 μs PULSOUT 13, 2

Este comando enviará una señal alta que podrás ver: PULSOUT 13, 65000

¿Por cuánto tiempo permanecerá el circuito de LED conectado a P13 encendido cuando envíe este pulso? Deduzcámoslo. El período de tiempo equivale a 65000 veces 2 μs. Eso es:

s13.0s000002.065000

s265000Duration

=×=×= μ

lo cual sigue siendo bastante rápido, trece centésimas de segundo.


El valor más alto que puedes usar en un argumento Duration es 65535.

Programa de ejemplo: PulseP13Led.bs2

El diagrama de control de tiempo en la Figura 2-8 muestra la serie de pulsos que estás a punto de enviar al LED con este nuevo programa. Esta vez, la señal alta dura 0.13 segundos y la señal baja dura 2 segundos. Esto es 100 veces más lento que la señal que el servo necesita para controlar sus movimientos.

Vdd (5 V)

Vss (0 V)

0.13 s 0.13 s

2.0 s

Figura 2-8 Diagrama de control de tiempo para el programa PulseP13Led.bs2

√ Introduce, guarda y ejecuta el programa PulseP13Led.bs2. √ Verifica que el circuito de LED esté conectado a pulsos P13 durante trece

centésimas de segundo, una vez cada dos segundos. ' Robotica con el Boe-Bot – PulseP13Led.bs2 ' Envia un pulso de 0.13 segundos al circuito LED conectado a P13 cada 2 s. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 13, 65000 PAUSE 2000 LOOP

Programa de ejemplo: PulseBothLeds.bs2

Este programa de ejemplo enviará un pulso al LED conectado a P13 y luego manda un pulso al LED conectado a P12 como lo muestra la Figura 2-9. Después, para durante dos segundos.


Figura 2-9 Diagrama de control de tiempo para el programa PulseBothLeds.bs2 Los LEDs emiten luz durante 0.13 segundos, mientras la señal es alta.

Los voltajes (Vdd y Vss) en este diagrama de control de tiempo no están señalados. Con el BASIC Stamp, se entiende que la señal alta es de 5 V (Vdd) y que la señal baja es de 0 V (Vss).

Esto es una práctica común en documentos que explican el control del tiempo de las señales altas y bajas. Muchas veces hay uno o más documentos de este tipo para cada componente del circuito que un ingeniero está diseñando. Los ingenieros que crearon el BASIC Stamp tuvieron que buscar en varios documentos este tipo información necesaria para ayudarles a tomar decisiones mientras diseñaban el producto.

A veces el tiempo no se incluye, o simplemente no se muestra explícitamente thigh y tlow. Entonces, los valores de tiempo deseados para thigh y tlow se encuentran en una tabla a continuación del diagrama. Este concepto se discute en más detalle en Basic Analog and Digital, otra Guía para el estudiante del curriculum Stamps in Class de Parallax.

√ Introduce, guarda y ejecuta el programa PulseBothLeds.bs2. √ Verifica que circuitos de LED emiten pulsos simultáneamente durante unas trece

centésimas de seguno, una vez cada dos segundos. ' Robotica con el Boe-Bot – PulseBothLeds.bs2 ' Envia un pulso de 0.13 segundos a P13 y P12 cada 2 segundos. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!"

0.13 s 0.13 s

P12

0.13 s 0.13 s

2.26 s

P13


DO PULSOUT 13, 65000 PULSOUT 12, 65000 PAUSE 2000 LOOP

Tu Turno – Observando la Señal del Servo a Velocidad Completa

Recuerda que la señal del servo es 100 veces más rápida que el programa que acabas de ejecutar. Primero, probemos ejecutar el programa 10 veces más rápido. Eso signidica dividir todos los argumentos Duration (PULSOUT y PAUSE) por 10.

√ Modifica el programa para que quede como el siguiente: DO PULSOUT 13, 6500 PULSOUT 12, 6500 PAUSE 200 LOOP

√ Ejecuta el programa modificado y verifica que los LEDs titilan 10 veces más rápido.

Ahora, probemos 100 veces más rápido (una centésima de la duración). En lugar de parecer un titileo, el LED simplemente parecerá ser menos brillante que con la señal alta normal. Esto se debe a que el LED está titilando tan rápido y por períodos de tiempo tan breves que el ojo humano no puede detectar el titileo, sólo detecta un cambio en el brillo.

√ Modifica el programa para que quede como el siguiente: DO PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 LOOP

√ Ejecuta el programa modificado y verifica que los LEDs producen el mismo brillo.

√ Intenta substituir 850 en el argumento Duration para el comando PULSOUT que

va a P13. DO PULSOUT 13, 850


PULSOUT 12, 650 PAUSE 20 LOOP

√ Ejecuta el programa modificado y verifica que el LED P13 se ve un poco más brillante que el LED P12. Puede ser que tengas que colocar sus manos alrededor de los LEDs y mirar dentro para notar la diferencia. Son diferentes porque la cantidad de tiempo que el LED conectado a P13 permanece encendido es más larga que la del LED conectado a P12.

√ Intenta substituir 750 en el argumento Duration para el comando PULSOUT que

va a ambos LEDs. DO PULSOUT 13, 750 PULSOUT 12, 750 PAUSE 20 LOOP

√ Ejecuta el programa modificado y verifica que el brillo de ambos LEDs es el mismo otra vez. Puede que no sea obvio, pero el nivel de brillo está entre los niveles obtenidos con los argumentos Duration de 650 y 850.

ACTIVIDAD #3: CONECTANDO LOS SERVOMOTORES En esta actividad, construirás un circuito que conecta al servo a una fuente de alimentación y a un pin I/O del BASIC Stamp. Los circuitos de LED que desarrollaste en la actividad previa serán usados posteriormente para monitorear las señales que el BASIC Stamp envía a los servos para controlar sus movimientos.

Partes para Conectar los Servos

(2) Continuous Rotation Servos de Parallax (2) Circuitos de LED construidos y probados de la actividad anterior

Encontrando las Instrucciones de Conexión para tu Carrier Board

Existen tres diferentes Revs de la Board of Education y un Rev de la BASIC Stamp HomeWork Board. Los Boards of Education pueden ser Rev A, B o C. El HomeWork Board es Rev B. La Figura 2-10 muestra ejemplos de las etiquetas que puedes encontrar en tu plaqueta.


√ Examina la etiqueta de tu carrier board y determine si tienes un BASIC Stamp HomeWork Board Rev B o una Board of Education Rev C, B o A.


Rev B

X3Vdd VssVin

Board of Education © 2000-2003

P3P2P1P0

X2

Rev C

BASIC Stamp Board of Education Rev C HomeWork Board Rev B

Rev B

BlackRed

X3Vdd VssVin

X4 X5

15 14 13 12

STAMPS CLASSin

Vdd VssVR1

5X2

X3 nc

Rev A

Board of Education Rev B Board of Education Rev A

Figura 2-10 Ejemplos de etiquetas Rev en la BASIC Stamp HomeWork Board y la Board of Education

√ Sabiendo la revisión de tu carrier board, avanza a las instrucciones (enumeradas

a continuación) para conectar el servo a tu plaqueta:

Página 60 → Board of Education Rev C Página 63 → BASIC Stamp HomeWork Board

Board of Education Rev B

Si posees una Board of Education Rev B, sigue las instrucciones para la Board of Education Rev C a lo largo del texto, recordando siempre estos dos puntos:

• La Board of Education Rev B no tiene interruptor de tres posiciones. Deberás desconectar la salida del paquete de baterías de la salida de energía de la Board of Education cuando se indique colocar el interruptor de 3 posiciones en la posición 0. Cuando se indique colocar el interruptor de tres posiciones en la posición 1 o 2, deberá conectar la energía.

• La Board of Education Rev B no tiene una configuración de puentes para la energía. Tan sólo utiliza el paquete de baterías de 6 V como fuente de alimentación para los proyectos del Boe-Bot con una Board of Education Rev B.

Board of Education Rev A

Si posees una Board of Education Rev A, sigue las instrucciones para el BASIC Stamp HomeWork Board a lo largo del texto.


√ Cuando termines, avanza a la Actividad #4: Calibrando los Servos en la página 67.

Conectando los Servos a la Board of Education Rev C

√ Apaga la energía colocando el interruptor de 3 posiciones de la Board of Education en la posición 0 (ver Figura 2-11).

Reset

0 1 2

Figura 2-11 Desconecta la energía

La Figura 2-12 muestra el cabezal del servo en la Board of Education Rev C. Esta plaqueta tiene un puente que puede ser utilizado para conectar la fuente de alimentación del servo a Vin o Vdd. Para moverlo, debes halarlo hacia arriba y fuera de los pines sobre los que está y luego empujarlo sobre el par de pines sobre los que quieres que esté.

√ Si está usando el paquete de baterías de 6 V, asegúrate de que el puente entre los puertos de servo y la Board of Education está fijado en Vin como se muestra a la izquierda en la Figura 2-12.

Usa sólo baterías alcalinas AA (1.5 V). Evite baterías recargables porque son de 1.2 V en vez de 1.5 V.

√ Si está utilizando una fuente de CC 1000 mA center positive de 7.5 V, fije el

puente eléctrico a Vdd como se muestra en la parte derecha de la Figura 2-12.


PRECAUCIÓN – El uso incorrecto de fuentes AC powered DC puede dañar sus servos.

Si no tienes experiencia con fuentes de CC, considere usar sólamente el paquete de baterías de 6 V que viene con el Boe-Bot.

Usa sólamente fuentes de CC con sálidas de voltaje entre 6 y 7.5 V, y salidas de corriente de 800 mA o más.

Sólo usa fuentes de CC equipadas con el mismo tipo de enchufe que el paquete de baterías del Boe-Bot (2.1 mm, center-positive).

BlackRed

X4 X5

15 14 13 12Vdd

Vin

Selecciona Vin si estás usando el paquete de baterías que viene con los kits del Boe-Bot.

Selecciona Vdd si estás usando una fuente de alimentación DC que se conecta a un enchufe AC (adaptador AC).

BlackRed

X4 X5

15 14 13 12Vdd

Vin

Figura 2-12 Seleccionando la fuente de alimentación de tu servo en la Board of Education Rev C

Todos los ejemplos e instrucciones de este libro usan el paquete de baterías. La Figura 2-13 muestra el esquema del circuito que construirás en la Board of Education Rev C. El puente eléctrico está colocado en Vin.

√ Conecta los servos al Board of Education Rev C como se muestra en la Figura 2-13.


Vin

Vss

P13 WhiteRedBlack

Vin

Vss

P12 WhiteRedBlack

Figura 2-13 Diagrama esquemático de la conección del Servo y diagrama de conexión para la Board of Education Rev C

¿Cómo determinar cuál servo está conectado a P13 y cuál servo está conectado a P12? Acabas de conectar los servos a cabezales que tienen unos números sobre ellos. Si el número del cabezal en el que está conectado el servo es 13, significa que el servo está conectado a P13. Si el número es 12, significa que está conectado a P12.

√ Cuando termines de ensamblar el sistema, debería verse como la Figura 2-14.

(los circuitos LED no aparecen en la imagen).

Figura 2-14 Board of Education con los servos y el paquete de baterías conectado

√ Si retiraste los circuitos de LED después de la Actividad #2, asegúrate de

reconstruirlos como lo indica la Figura 2-15. Estos serán los circuitos de monitoreo de señal de los servos.

WhiteRedBlack

BlackRed

X4 X5

15 14 13 12Vdd

WhiteRed

Black


P12

P13

Vss Vss

LEDLED

470 Ω

470 Ω

P15P14

P11P10P9P8P7P6P5P4P3P2P1P0

P13P12

X2

X3Vdd VssVin

++

Figura 2-15 Cicuito de monitoreo de la señal del servo con el LED

Desconectando la Energía – Instrucciones Especiales para la Board of Education Rev C

Nunca dejes la energía conectada a tu sistema cuando no estés trabajando con él.

√ Para desconectar la energía de tu Board of Education Rev C, coloca el interruptor de 3 posiciones en la posición 0.

√ Avanza hasta la página 67 (Actividad #4: Calibrando los Servos).

Conectando los Servos a la BASIC Stamp HomeWork Board

Si estás conectando los servos a la BASIC Stamp HomeWork Board, necesitarás las partes enumeradas a continuación y mostradas en la Figura 2-16:

Lista de partes:

(1) Paquete de baterías con conexiones estañadas (2) Continuous Rotation Servos de Parallax (2) Cabezales de 3 pines macho-macho (4) Cables para puente eléctrico (4) Baterías AA – 1.5 V alcalinas (2) Circuitos de LED construidos y probados en la actividad anterior


Figura 2-16 Partes para el centrado de servos con la HomeWork Board

La Figura 2-17 muestra un esquema de circuitos de servos en la HomeWork Board. Antes de comenzar a construir este circuito, asegúrate de que la energía esta desconectada del BASIC Stamp HomeWork Board.

√ La batería de 9 V debe desconectarse del clip de la batería y el paquete de baterías con conexiones estañadas no debe tener ninguna batería adentro.

Vbp

Vss

P12 WhiteRedBlack

Vbp

Vss

P13 WhiteRedBlack

Figura 2-17 Diagrama esquemático de la conexión de servos para la BASIC Stamp HomeWork Board.

√ Retira los dos circuitos de LED/resistors y guarda las partes. √ Construye los puertos de servos mostrados en la parte izquierda de la Figura 2-

18.


√ Verifica dos veces para asegurarte de que el cable negro esté conectado junto con el cable blanco a Vss.

√ Verifica dos veces para asegurarte de que todas las conexiones para P13, Vbp, Vss, Vbp y P12 coinciden exactamente con el diagrama de conexión.

√ Conecta los enchufes de los servos en el cabezal macho como se muestra en la parte derecha de la Figura 2-18.

√ Verifica dos veces para asegurarte de que los colores de los cables del servo coinciden con la leyenda de la imagen.

Vbp son las siglas de Voltage battery pack (Voltaje del paquete de baterías, en inglés). Esto se refiere a 6 VDC generados por las baterías de 1.5 V. Esto es suministrado directamente a la protoboard para dar energía a los servos en los Boe-Bots construidos con el HomeWork Board o Board of Education Rev A. La fuente de alimentación de tu BASIC Stamp sigue siendo la batería de 9 V.

P15P14

P11P10P9P8

P13P12

X3Vdd VssVin


Rev B

P15P14

P11P10P9P8

P13P12

X3Vdd VssVin


Rev B

Figura 2-18 Diagrama de conexión indicando la conexión de los servos en la BASIC Stamp HomeWork Board Izquierda (construye los puertos de servos). Derecha (conecta los servos).

Conexiones en puertos Conexiones de servos por color Tu configuración debe ser similar a la Figura 2-19.

Blanco Rojo Negro Rojo Blanco

P13 Vbp Vss Vbp P12

Cable negro Cable negro con

banda negra


Figura 2-19 Suministros de alimentación duales y servos conectados

√ Reconstruye el circuito de LED como se muestra en la Figura 2-20.

P15P14

P11P10P9P8P7P6P5P4P3

P1P0

P13P12

P2

X2

X3Vdd VssVin


HomeWork Board

Rev B

© 2002

+Vss

+

P12

P13

Vss Vss

LEDLED

470 Ω

470 Ω

Figura 2-20 Circuito de monitoreo de señal del servo con el LED


√ Cuando todas tus conexiones estén construidas y hayan sido verificadas dos veces, coloca las baterías en el paquete de baterías y reconecta la batería de 9 V al clip de batería de la HomeWork Board.

Desconectando la energía – Instrucciones especiales para la HomeWork Board

Nunca dejes la energía conectada a tu sistema cuando no esté trabajando con él. De aquí en adelante, desconectar la energía requiere de dos pasos:

√ Desconecta la batería de 9 V del clip de batería para desconectar la energía de la HomeWork Board. Esto desconecta la energía del BASIC Stamp incorporado y las tomas de energía que se encuentran sobre el protoboard (Vdd, Vin, y Vss).

√ Retira una batería del paquete de baterías. Esto desconecta la energía de los servos.

ACTIVIDAD #4: CALIBRANDO LOS SERVOS En esta actividad, ejecutarás un programa que manda una señal a los servos, ordenándoles quedarse quietos. Debido a que los servos no están preajustados de fábrica, en lugar de no moverse, comenzarán a girar. Entonces utilizarás un destornillador para ajustarlos de tal manera que se detengan completamente. Este proceso se llama calibrar (o centrar) los servos. Luego de este ajuste, probarás los servos para comprobar que funcionan adecuadamente. Los programas de prueba enviarán señales para ordenar a los servos que se muevan conreloj (CNR) y contrareloj (CTR) a diferentes velocidades.

Herramientas y Partes de los Servos

El destornillador de Parallax mostrado en la Figura 2-21 es la única herramienta adicional que necesitará paras esta actividad. Sin embargo, cualquier destornillador de punta plana de Estría #1 con un eje de 1/8" (3.18 mm) sirve.

Figura 2-21 Destornillador Parallax

Enviando la Señal de Centrado

La Figura 2-22 muestra la señal que debe ser enviada al servo conectado a P12 para calibrarlo. Esta señal es llamada señal de centrado y después de que el servo ha sido debidamente ajustado, esta señal le indica al servo que no se mueva. La instrucción consiste en pulsos de 1.5 ms con pausas de 20 ms entre cada pulso.


P12

1.5 ms 1.5 ms

20 ms

Figura 2-22 Diagrama de control de tiempo para el programa CenterServoP12.bs2 Los pulsos de 1.5 ms indican al servo que no se mueva.

El programa para esta señal será un comando PULSOUT y un comando PAUSE dentro de un DO…LOOP. Calcular el comando PAUSE para el diagrama de control es fácil, será PAUSE 20 para los 20 ms entre cada pulso. Calcular el argumento Pin del comando PULSOUT también es fácil, será 12, para el pin I/O P12. Luego, calculemos cuál debe ser el argumento Duration del comando PULSOUT para lograr 1.5 ms pulsos. 1.5 ms es equivalente a 1.5 milésimas de segundo, o 0.0015 s. Recuerda que el número que esté en el argumento Duration del comando PULSOUT, se multiplica por 2 μs (2 dos milésimas de segundo = 0.000002 s), y así sabrás cuánto tiempo va a durar. También puedes calcular cual debe ser el argumento Duration del comando PULSOUT si deseas saber cuánto durará cada pulso. Simplemente divide 2 μs por el tiempo que quieres que dure. Con este cálculo:

750s000002.0

s0015.0s2

durationPulseargumentDuration =μ

=

sabemos que el comando para un pulso de 1.5 ms a P12 debe ser PULSOUT 12, 750. Lo mejor es centrar sólo un servo a la vez, porque así puedes escuchar cuándo el motor se detiene mientras lo ajustas. Este programa sólo enviara la señal de centrado al servo conectado a P12 y las instrucciones a continuación te guíaran durante el proceso de ajuste. Después de completar el proceso con el servo conectado a P12, repetirás el proceso con el servo conectado a P13.

√ Si posees una Board of Education Rev C, asegúrate de colocar el interruptor de 3 posiciones en la posición 2 como se muestra en la Figura 2-23.


0 1 2

Figura 2-23 Coloca el interruptor de 3 posiciones en la posición 2

√ Si estás utilizando la HomeWork Board, verifica las conexiones de energía de tu

BASIC Stamp y de sus servos. La batería de 9 V debe estar conectada al clip de batería, y el paquete de baterías de 6 V debe tener las cuatro baterías puestas.

Si los servos comienzan a girar (o moverse levemente sin control) apenas conecta la energía

Probablemente se deba a que el BASIC Stamp está ejecutando el programa que ejecutaste en la actividad anterior.

√ Asegúrate de introducir, guardar y ejecutar el programa CenterServoP12.bs2 antes de avanzar hasta las instrucciones para centrar el srvo que siguen al programa de ejemplo.

√ Introduce, guarda y ejecuta el programa el programa CenterServoP12.bs2, luego

continúa con las instrucciones que siguen después del programa.

Ejemplo Program: CenterServoP12.bs2 ' Robotica con el Boe-Bot - CenterServoP12.bs2 ' Este programa envia pulsos de 1.5 ms al servo conectado a P12 para ' centrarlo manualmente ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 12, 750 PAUSE 20 LOOP

Si el servo todavía no ha sido centrado, el cuerno comenzará a girar y podrás escuchar el motor haciendo un ruido como un silbido.

√ Si el servo todavía no está centrado, usa un destornillador para ajustar suavemente el potenciómetro en el servo como se muestra en la Figura 2-24. Ajusta el potenciómetro hasta que el servo deje de moverse.


Precaución: ¡No presiones demasiado fuerte el destornillador! El potenciómetro que se encuentra dentrro del servo es muy delicado, por lo tanto debes procurar no ejercer más presión de la necesaria cuando estés ajustando el servo.

Figura 2-24 Centrando el servo

√ Verifica que el circuito de señal de monitoreo de LED, conectado a P12, muestre actividad. Debe estar emitiendo una luz, indicando que los pulsos están siendo transmitidos al servo conectado a P12.

Si el servo ya ha sido centrado, no girará. Es improbable, pero un servo dañado o defectuoso tampoco girará. La Actividad #6 descartará esta posibilidad antes de que los servos sean instalados en el chasis de tu Boe-Bot.

√ Si el servo no gira, avanza hasta la sección Tu Turno en la página 70 para que puedas probar y centrar el otro servo que está conectado a P13.

¿Qué es un Potenciómetro? Un potenciómetro es una especie de resistor ajustable. El resistor de un potenciómetro se ajusta con una parte movible. En algunos potenciómetros, esta parte movible es una perilla o una barra corrediza, otros tienen salidas que pueden ser ajustadas con un destornillador. El resistor del potenciómetro dentro del Continuous Rotation servo de Parallax se ajusta con la punta de un destornillador de Estría #1 de punta plana. Puede aprender más acerca de potentiometers en las guías para el estudiante What's a Microcontroller? y Basic Analog and Digital.

Tu Turno – Centrando el Servo Conectado a P13

√ Repite el proceso para el servo conectado a P13 usando el siguiente programa:

Inserta la punta del destornillador Phillips en el orificio de acceso al potenciómetro.

Gire suavemente el destornillador para ajustar el potenciómetro


Programa de ejemplo: CenterServoP13.bs2 ' Robotica con el Boe-Bot - CenterServoP13.bs2 ' Este programa envia pulsos de 1.5 ms al servo conectado a P13 para ' centrarlo manualmente ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 13, 750 PAUSE 20 LOOP

Recuerda desconectar completamente la energía cuando termines.

Si posees una Board of Education Rev C.

√ Coloca el interruptor de 3 posiciones en la posición 0.

Si posees un BASIC Stamp HomeWork Board:

√ Desconecta la batería de 9 V battery del clip de batería para desconectar la energía de la HomeWork Board.

√ Retira una de las baterías del paquete de baterías.

ACTIVIDAD #5: COMO GUARDAR VALORES Y CONTAR Esta actividad introduce variables, que son usadas por programas escritos en PBASIC para almacenar valores. En este libro, estos valores serán de importancia fundamental para programas posteriores del Boe-Bot. Lo más importante de poder almacenar valores es que el programa puede usarlos para contar. Tan pronto como tu programa sea capaz de contar, podrá controlar y hacer seguimiento del número de veces que algo sucede.

Tus servos no necesitan estar conectados a una fuente de alimentación para la siguiente actividad.

√ Si posees una Board of Education Rev C, coloca el interruptor de 3 posiciones en la posición 1. Esto desconecta la energía de los puertos de los servos sólamente. El BASIC Stamp, Vdd, Vin y Vss permanecerán conectados a la fuente de alimentación.

√ Si posees una BASIC Stamp HomeWork Board, retira una batería del paquete de baterías, pero mantén la batería de 9 V conectada al clip de batería. Esto desconecta la energía de los puertos de servo, pero la energía permanece conectada al BASIC Stamp incorporado, Vdd, Vin y Vss.


Usando Variables para Almacenar Valores, Realizar Operaciones Matemáticas y Contar

Las variables pueden ser utilizadas para almacenar valores. Antes de poder utilizar una variable en PBASIC, debes darle un nombre y especificar su tamaño. A este proceso se le llama declarar la variable.

variableName VAR Size

Puedes declarar cuatro tamaños diferentes para las variables de PBASIC:

Tamaño – Capacidad de almacenamiento Bit – 0 a 1 Nib – 0 a 15 Byte – 0 a 255 Word – 0 a 65535 ó -32768 a+ 32767

El siguiente programa de ejemplo incluye nada más un par de variables de tamaño Word:

value VAR Word anotherValue VAR Word

Después de haber declarado una variable, también puedes inicializarla, o en otras palabras, asignarle un valor inicial.

value = 500 anotherValue = 2000

Valor por defecto – Si no inicializas una variable, el programa comenzará automáticamente asignando el número cero a esa variable. A esto se le llama el valor por defecto de la variable.

El signo “=” en la línea value = 500 es un ejemplo de un operador. Puedes utilizar otros operadores para realizar operaciones matemáticas con variables. He aquí unos ejemplos:

value = 10 * value anotherValue = 2 * value

Programa de ejemplo: VariablesAndSimpleMath.bs2

Este programa muestra como declarar, inicializar y realizar operaciones con variables.


√ Antes de ejecutar el programa, trata de imaginar lo que cada comando DEBUG mostrará.

√ Introduce, guarda y ejecuta el programa VariablesAndSimpleMath.bs2. √ Compara los resultados con tus predicciones y explica las diferencias.

' Robotica con el Boe-Bot - VariablesAndSimpleMath.bs2 ' Declara variables y las usa para resolver unos pocos problemas de ' aritmetica. ' $STAMP BS2 ' $PBASIC 2.5 value VAR Word ' Declara las variables anotherValue VAR Word value = 500 ' Inicializa las variables anotherValue = 2000 DEBUG ? value ' Muestra los valores DEBUG ? anotherValue value = 10 * anotherValue ' Realiza operaciones DEBUG ? value ' Muestra valores nuevamente DEBUG ? anotherValue END

Funcionamiento del Programa VariablesAndSimpleMath.bs2

Este código declara dos variables de palabra, value y anotherValue. value VAR Word ' Declara las variables anotherValue VAR Word

Estos comandos son ejemplos de inicialización de variables con los valores que determines. Luego de que estos dos comandos sean ejecutados, value almacenará 500 y anotherValue almacenará 2000.

value = 500 ' Inicializa las variables anotherValue = 2000

Los comandos DEBUG te ayudarán a ver qué almacenan las variables después de ser inicializadas. Dado que a value se le asignó 500 y a anotherValue 2000, estos comandos DEBUG envían el mensaje “value = 500” y “anotherValue = 2000” al Debug Terminal.


DEBUG ? value ' Muestra los valores DEBUG ? anotherValue

El formateador “?” del comando DEBUG puede ser usado delante de una variable para hacer que el Debug Terminal despliegue su nombre (de la variable), el valor decimal que está almacenando y un caracter de retorno. Resulta útil para ver los contenidos de una variable.

El acertijo en las siguientes tres líneas es ¿Qué aparecerá en pantalla? La respuesta es que value será diez veces el valor de anotherValue. Dado que anotherValue es 2000, value se fijará en 20,000. La variable anotherValue no cambia.

value = 10 * anotherValue ' Realiza operaciones DEBUG ? value ' Muestra valores nuevamente DEBUG ? anotherValue

Tu Turno – Cálculos con Números Negativos

Si quieres realizar cálculos que incluyan números negativos, puede usar el formateador SDEC del comando DEBUG para que aparezcan en pantalla. He aquí un ejemplo realizado con una modificación de VariablesAndSimpleMath.bs2.

√ Elimine este fragmento del programa VariablesAndSimpleMath.bs2: value = 10 * anotherValue ' Realiza operaciones DEBUG ? value ' Muestra valores nuevamente

√ Sustitúyala por el siguiente: value = value - anotherValue ' Respuesta = -1500 DEBUG "value = ", SDEC value, CR ' Muestra valores nuevamente

√ Ejecuta el programa modificado y verifica que value cambia de 500 a -1500.

Contando y Controlando Repeticiones

La manera más conveniente de controlar el número de veces que una porción de un código se ejecuta es con un bucle FOR…NEXT. He aquí la sintáxis:

FOR Counter = StartValue TO EndValue STEP StepValue…NEXT


Los tres puntos ... indican que puedes colocar uno o más comandos entre FOR y NEXT. Asegúrate de declarar la variable para usarla en el argumento Counter. Los argumentos StartValue y EndValue pueden ser tanto números como variables. Cuando veas algo entre llaves en una descripción de sintáxis, significa que es un argumento opcional. En otras palabras, el bucle FOR…NEXT trabajará sin él, pero puedes utilizarlo para un fin específico. No es necesario nombrar la variable “counter”. Por ejemplo, puedes llamarla “myCounter”.

myCounter VAR Word

He aquí un ejemplo de un bucle FOR…NEXT que usa la variable myCounter para contar. También muestra el valor de la variable myCounter cada vez que el bucle realiza una iteración.

FOR myCounter = 1 TO 10 DEBUG ? myCounter PAUSE 500 NEXT

Programa de ejemplo: CountToTen.bs2

√ Introduce, guarda y ejecuta el programa el programa CountToTen.bs2. ' Robotica con el Boe-Bot – CountToTen.bs2 ' Usa una variable en un bucle FOR...NEXT. ' $STAMP BS2 ' $PBASIC 2.5 myCounter VAR Word FOR myCounter = 1 TO 10 DEBUG ? myCounter PAUSE 500 NEXT DEBUG CR, "All done!" END


Tu Turno – Diferentes valores iniciales y finales, y contando en escalas

Puedes utilizar diferentes valores para los argumentos StartValue y EndValue.

√ Modifica el bucle FOR…NEXT para que quede de la manera siguiente: FOR myCounter = 21 TO 9 DEBUG ? myCounter PAUSE 500 NEXT

√ Ejecuta el programa modificado. ¿Notaste que el BASIC Stamp contó en orden decreciente en vez de creciente? Hará esto cada vez que el argumento StartValue sea mayor que el argumento EndValue.

√ ¿Recuerdas el argumento opcional STEP StepValue? Puedes utilizarlo para que myCounter cuente en escalas. En lugar de 9, 10, 11…, puede hacer que cuente de dos en dos (9, 11, 13…) o de cinco en cinco (10, 15, 20…), o cualquier StepValue que le asignes, en orden creciente o decreciente. He aquí un ejemplo que lo usa para contar de 3 en 3 en orden decreciente:

√ Añade STEP 3 al bucle FOR…NEXT para que quede de la siguiente manera: FOR myCounter = 21 TO 9 STEP 3 DEBUG ? myCounter PAUSE 500 NEXT

√ Ejecuta el programa modificado y verifica que cuenta de 3 en 3 en orden decreciente.

ACTIVIDAD #6: PROBANDO LOS SERVOS Hay una tarea más para realizar antes de ensamblar tu Boe-Bot, y esa es probar los servos. En esta actividad, ejecutarás programas que harán los servos giren a diferentes velocidades en diferenetes direcciones. De esta manera, you podrás verificar si los servos están funcionando apropiadamente antes de ensamblar tu Boe-Bot. Esto es un ejemplo de una prueba de subsistema. Hacer pruebas de subsistemas es una costumbre que vale la pena desarrollar, porque no es para nada divertido desarmar completamente un robot para solucionar un problema que pudo haber sido identificado antes de armarlo.


Una prueba de subsistema se refiere a la práctica de probar los componentes por separado antes de integrarlos en un dispositivo mayor. Es una valiosa estrategia que le puede ayudar a ganar concursos de robótica. También es una habilidad esencial usada por ingenieros alrededor del mundo para desarrollar productos desde juguetes, carros y videojuegos, hasta cohetes espaciales y robots para realizar exploraciones en Marte. Especialmente en dispositivos complejospuede resultar casi imposible decifrar un problema si no se ha probado de antemano cada uno de sus componentes. En proyectos de aeronáutica, por ejemplo, desmontar un prototipo para solucionar un problema puede costar cientos de miles o, incluso, millones de dólares. En ese tipo de proyectos, las pruebas de subsitemas son rigurosas y exhaustivas.

Controles de Ancho de Pulso, Velocidad y Dirección

Recuerda que cuando centraste los servos aprendiste que una señal con un ancho de pulso de 1.5 ms daba como resultado que los servos no se movieran. Esto se logró utilizando el comando PULSOUT con Duration de 750. ¿Qué pasaría si el ancho del pulso de la señal es diferente a 1.5 ms? En la sección Tu Turno de la Actividad #2, programaste al BASIC Stamp para que mandará series de pulsos de 1.3 ms s un LED. Examinemos en más detalle esa serie de pulsos y decifremos cómo puede ser usada para controlar un servo. La Figura 2-25 muestra como un Continuous Rotation Servo de Parallax gira a toda velocidad conreloj cuando le envías pulsos de 1.3 ms. La velocidad máxima oscila entre los 50 y 60 RPM.

Vdd (5 V)

Vss (0 V)

1.3 ms 1.3 ms

20 ms

www.parallax.com

standard servo

Figura 2-25 Un tren de pulsos de 1.3 ms indica al servo ir a toda velocidad conreloj

¿Qué significa RPM? Revoluciones por minuto. Es el número de vueltas completas que se realizan en un minuto.

¿Qué es un tren de pulsos? Tal como un tren es una serie de vagones, un tren de pulsos es una serie de pulsos.


Puedes usar el programa ServoP13Clockwise.bs2 para enviar este tren de pulsos al servo conectado a P13.

Programa de ejemplo: ServoP13Clockwise.bs2

Todo tu sistema, incluyendo los servos debe estar conectado a una fuente de alimentación para esta actividad.

√ Si posees una Board of Education Rev C, coloca el interruptor de 3 posiciones en la posición 2. Esto conecta la energía a los puertos de los servos además de la energía de la posición 1 del BASIC Stamp, Vdd, Vin, y Vss.

√ Si posees un BASIC Stamp HomeWork Board, reemplaza la batería que retiraste del paquete de baterías. Esto restaurará la energía a los puertos de los servos. También, conecta la batería de 9 V al clip de batería. Esto suministrará energía al BASIC Stamp incorporado, Vdd, Vin, y Vss.

√ Introduce, guarda y ejecuta el programa el programa ServoP13Clockwise.bs2. √ Verifica que el cuerno del servo está rotando conreloj, a una velocidad entre 50 y

60 RPM. ' Robotica con el Boe-Bot – ServoP13Clockwise.bs2 ' Mueve el servo conectado a P13 a velocidad maxima conreloj. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 13, 650 PAUSE 20 LOOP

Nota que un pulso de 1.3 ms requiere un argumento Duration del comando PULSOUT de 650, el cual es menor a 750. Todos los anchos de pulso son menores que 1.5 ms, y por lo tanto los argumentos Duration del comando PULSOUT son menores que 750, esto causará que el servo gire conreloj.

Programa de ejemplo: ServoP12Clockwise.bs2

Al cambiar el argumento Pin del comando PULSOUT de 13 a 12, puede hacer que el servo conectado a P12 gire a toda velocidad conreloj.

√ Guarda el programa ServoP13Clockwise.bs2 como ServoP12Clockwise.bs2.


√ Modifica el programa actualizando los comentarios y el argumento Pin del comando PULSOUT a 12.

√ Ejecuta el programa y verifica que el servo conectado a P12 está girando conreloj a una velocidad de entre 50 y 60 RPM.

' Robotica con el Boe-Bot – ServoP12Clockwise.bs2 ' Mueve el servo conectado a P12 a maxima velocidad conreloj. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 12, 650 PAUSE 20 LOOP

Programa de ejemplo: ServoP12Counterclockwise.bs2

Probablemente ya adivinaste que cambiando el argumento Duration del comando PULSOUT a más de 750 causará que el servo gire contrareloj. Un Duration de 850 enviará pulsos de 1.7 ms como se muestra en la Figura 2-26. Esto ocasionará que el servo gire a toda velocidad contrareloj.

Figura 2-26 Un tren de pulsos de 1.7 ms indica al servo ir a toda velocidad Contrareloj

√ Guarda el programa ServoP12Clockwise.bs2 como

ServoP12Counterclockwise.bs2. √ Modifica el programa cambiando el argumento Duration del comando PULSOUT

de 650 a 850. √ Ejecuta el programa y verifica que el servo conectado a P12 está girando

contrareloj a una velocidad de entre 50 y 60 RPM.

Vdd (5 V)

Vss (0 V)

1.7 ms 1.7 ms

20 ms

www.parallax.com

standard servo


' Robotica con el Boe-Bot – ServoP12Counterclockwise.bs2 ' Mueve el servo conectado a P12 a velocidad maxima contrareloj. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 12, 850 PAUSE 20 LOOP

Tu Turno – Programa P13Clockwise.bs2

√ Modifica el argumento Pin del comando PULSOUT para que haz que el servo conectado a P13 gire contrareloj.

Programa de ejemplo: ServosP13CcwP12Cw.bs2

Puedes utilizar dos comandos PULSOUT para hacer que ambos servos se muevan al mismo tiempo. Incluso puedes hacer que giren en direcciones opuestas.

√ Introduce, guarda y ejecuta el programa el programa ServosP13CcwP12Cw.bs2. √ Verifica que el servo conectado a P13 está girando a toda velocidad contrareloj

mientras que el servo conectado a P12 está girando a toda velocidad conreloj.

' Robotica con el Boe-Bot - ServosP13CcwP12Cw.bs2 ' Mueve el servo conectado a P13 a maxima velocidad contrareloj ' y el servo conectado a P12 a maxima velocidad conreloj. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" DO PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 LOOP

Pronto esto será importante. Piénsalo: cuando los servos estén montados en cada uno de los lados del chasis, uno tendrá que rotar conreloj mientras que el otro rota en el sentido contrario para hacer que el Boe-Bot ruede en línea recta. ¿Te parece extraño? Si no puedes imaginarlo, entonces prueba lo siguiente:


√ Sostén los servos uno contra el otro, en direcciones opuestas y vuelve a ejecutar el programa.

Tu Turno – Ajustando la Velocidad y la Dirección

Existen cuatro combinaciones diferentes de argumentos Duration del comando PULSOUT que se usarán en repetidas ocasiones cuando programes los movimientos de tu Boe-Bot en los capítulos siguientes. El programa ServosP13CcwP12Cw.bs2 envía una de estás combinaciones, 850 a P13 y 650 a P12. Probando varias combinaciones posibles y llenando la columna Descripción de la Tabla 2-1, te familiarizarás con ellas y crearás una referencia tú mismo. Llenarás la columna Comportamiento luego de haber ensamblado completamente tu Boe-Bot, cuando te puedas dar cuenta de cómo influye cada combinación en el movimiento del Boe-Bot.

√ Prueba las siguientes combinaciones de Duration de PULSOUT, y llena la columna Description con sus resultados.


Tabla 2-1: Combinaciones de PULSOUT Duration

Durations P13 P12 Descripción Comportamiento

850 650 Maxima velocidad, P13 servo contrareloj, P12 servo conreloj.

650 850

850 850

650 650

750 850

650 750

750 750

Ambos servos deben permanecer quietos gracias a los ajustes que hiciste en la Actividad #4.

760 740

770 730

850 700

800 650


FOR…NEXT para Controlar el Tiempo de Funcionamiento del Servo

Por ahora deberías entender completamente que el ancho de los pulsos controla la velocidad y la dirección del Continuous Rotation servo de Parallax. Es una forma muy simple de controlar la velocidad y dirección de un motor. También existe una manera simple de controlar la cantidad de tiempo durante la cual un motor está en funcionamiento, y esto se logra con un bucle FOR…NEXT. He aquí un ejemplo de un bucle FOR…NEXT que hará que el servo gire por unos segundos:

FOR counter = 1 TO 100 PULSOUT 13, 850 PAUSE 20 NEXT

Calculemos la cantidad exacta de tiempo durante la cual este código hará que el servo gire. Cada vez que se completa el bucle, el comando PULSOUT dura 1.7 ms, el comando PAUSE dura 20 ms y el bucle completo se ejecute en aproximadamente 1.3 ms. Tiempo en el que se completa el bucle = 1.7 ms + 20 ms + 1.3 ms = 23.0 ms. Dado que el bucle se ejecuta 100 veces, eso es 23.0 ms por 100.

s30.2s0230.0100

ms0.23100time

=×=×=

Digamos que quieres que el servo se mueva durante 4.6 seconds. Tu bucle FOR…NEXT deberá ejecutarse el doble de veces:

FOR counter = 1 TO 200 PULSOUT 13, 850 PAUSE 20 NEXT

Programa de ejemplo: ControlServoRunTimes.bs2

√ Introduce, guarda y ejecuta el programa el programa ControlServoRunTimes.bs2.

√ Verifica que el servo en P13 gire contrareloj durante 2.3 segundos aproximadamente, seguido por el servo en P12 el cual girará el doble del tiempo.

' Robotica con el Boe-Bot - ControlServoRunTimes.bs2


' Mueve el servo P13 a velocidad maxima contrareloj por 2.3 s, luego ' mueve el P12 servo por el doble del tiempo. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Byte FOR counter = 1 TO 100 PULSOUT 13, 850 PAUSE 20 NEXT FOR counter = 1 TO 200 PULSOUT 12, 850 PAUSE 20 NEXT END

Digamos que quieres que ambos servos giren, el servo en P13 con un ancho de pulso de 850 y el servo en P12 con un ancho de pulso de 650. Ahora, cada vez que se cumpla el bucle completo transcurrirán: 1.7ms – Servo conectado a P13 1.3 ms – Servo conectado a P12 20 ms – Pausa 1.6 ms – Ejecucion del código --------- ------------------------------ 24.6 ms – Total Si quieres que los servos giren durante un período de tiempo determinado, puedes calcularlo de la siguiente manera: Numero de pulsos = Time s / 0.0246s = Time / 0.0246 Digamos que quieres hacer que los servos giren durante 3 segundos. Eso es

Numero de pulsos = 3 / 0.0246 = 122 Ahora, puedes usar el valor 122 en EndValue del bucle FOR…NEXT, y quedará de la siguiente manera:


FOR counter = 1 TO 122 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT

Programa de ejemplo: BothServosThreeSeconds.bs2

He aquí un ejemplo de cómo hacer que los servos giren en una dirección durante 3 segundos y luego inviertan su dirección.

√ Introduce, guarda y ejecuta el programa BothServosThreeSeconds.bs2. ' Robotica con el Boe-Bot - BothServosThreeSeconds.bs2 ' Mueve ambos servos en direcciones opuestas por tres segundos, ' luego invierte la direccion de ambos servos y los mueve por ' otros tres segundos. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Byte FOR counter = 1 TO 122 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 1 TO 122 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT END

Verifica que cada servo giró en una dirección durante 3 segundos y luego en dirección inversa durante tres segundos más. ¿Notaste que los servos al cambiar de dirección al mismo tiempo siempre giraron en direcciones opuestas? ¿Por qué puede resultar esto útil?


Tu Turno – Predecir el tiempo de funcionamiento del servo

√ Elige el tiempo (seis segundos o menos) durante el que quieres que giren tus servos.

√ Divide el número de segundos por 0.024. √ Tu respuesta es el número de bucles que necesitará. √ Modifica el programa BothServosThreeSeconds.bs2 para que haga que ambos

servos giren durante la cantidad de tiempo que seleccionaste. √ Compara el tiempo que predijiste con la cantidad de tiempo durante la que en

realidad giraron. √ Recuerda desconectar la energía de tu sistema (plaqueta y servos) cuando

termines. Eso quiere decir colocar el interruptor de 3 posiciones en la posición 0 si posees una Board of Education Rev C. Si posees un HomeWork Board, desconecta la batería de 9 V del clip de batería y retira una de las baterías del paquete de baterías.

CONSEJO – Para medir el tiempo de funcionamiento, mantén presionado el botón Reset en tu Board of Education (o BASIC Stamp HomeWork Board). Cuando estés listo para comenzar a tomar el tiempo, suelta el botón Reset.


RESUMEN Este capítulo te guío para conectar, ajustar y verificar los Continuous Rotation Servos de Parallax. A lo largo del capítulo, una variedad de comandos de PBASIC fueron introducidos. El comando PAUSE hace que el programa se detenga brevemente o por períodos largos de tiempo, dependiendo del argumento Duration que uses. DO…LOOP hace que un comando o un grupo de comandos de PBASIC se repitan una y otra vez de manera eficiente. HIGH y LOW fueron introucidos como formas de hacer que el BASIC Stamp se conecte a un pin I/O Vdd o Vss. Se vieron señales altas y bajas con la ayuda de un circuito de LED. Estas señales se usaron para introduciar Diagramas de Control de Tiempo. Se introdujo el comando PULSOUT como una forma más precisa de enviar señales altas o bajas; también se usó un circuito de LED para ver las señales enviadas por el comando PULSOUT. DO…LOOP, PULSOUT y PAUSE se usaron para enviar la señal de permanecer quieto a los Continuous Rotation Servos de Parallax; dichos pulsos son de 1.5 ms con intervalos de 20 ms. Se ajustó el servo con un destornillador mientras recibía los pulsos de 1.5 ms hasta que permaneciera sin movimiento. A este proceso se le denomina “centrando” el servo. Después de haber centrado los servos, se introdujeron variables como una forma de almacenar valores. Las variables se pueden usar en actividades en operaciones matemáticas y para contar. Se introdujeron los bucles FOR…NEXT como una forma de contar. Los bucles FOR…NEXT controlan el número de veces que se ejecutan las declaraciones FOR y NEXT. Se usaron los bucles FOR…NEXT para controlar el número de pulsos enviados al servo, lo que a su vez controla el tiempo durante el que servo funciona.

Preguntas 1. ¿En qué se diferencian los Continuous Rotation Servos de Parallax de los servos

standard? 2. ¿Cuánto dura un milisegundo? ¿Cómo se abrevia? 3. ¿Qué comandos de PBASIC puedes usar para que se ejecuten otros comandos de

PBASIC una y otra vez? 4. ¿Qué comandos ocasionan qu el BASIC Stamp conecte uno de sus pines I/O a

Vdd? ¿Qué comandos hacen la misma clase de conexión pero a Vss?


5. ¿Cuáles son los nombres de los diferentes tamaños de variable que se pueden declarar en un programa de PBASIC? ¿Qué rango de valores puede almacenar cada tamaño de variable?

6. ¿Cuál es la clave para controlor la velocidad y dirección de un Continuous Rotation Servo de Parallax? ¿Cómo se relaciona esto con los diagramas de control de tiempo? ¿Cómo se relaciona esto con los comandos de Comandos PBASIC? ¿Cuáles son los comandos y argumentos que se pueden ajustar para controlar la velocidad y dirección de un Continuous Rotation Servo?

Ejercicios 1. Escribe un comando PAUSE que haga que el BASIC Stamp no haga nada por 10

segundos. 2. Modifica este bucle FOR…NEXT para que cuente de 6 a 24 de 3 en 3. También,

escribe la delaración de variable que necesitarás para hacer que este programa funcione.

FOR counter = 9 TO 21 DEBUG ? counter PAUSE 500 NEXT

Proyectos 1. Escribe un programa que ocasione que el LED conectado a P14 emita una luz

suave (encendido/apagado con cada pulso) mientras el servo P12 gire. 2. Escribe un programa que lleve a los servos a cada una de las cuatro

combinaciones de rotación durante tres segundos. Consejo: necesitarás cuatro bucles FOR…NEXT diferentes. Primero, ambos servos deben rotar contrareloj, luego conreloj. Ahora, el servo P12 debería rotar conreloj mientras el servo P13 rota contrareloj, y finalmente, el servo P12 servo debería contrareloj mientras el servo P13 rota conreloj.


Soluciones Q1. En vez de mantener un posición como un servo normal, los Continuous Rotation

servos de Parallax giran en ciertas direcciones a ciertas velocidades. Q2. Un milisegundo dura una milésima de segundo. Milisegundo se abrevia "ms". Q3. El comando DO…LOOP se usa para hacer que otros comandos de PBASIC se

ejecuten una y otra vez. Q4. HIGH conecta a un pin I/O a Vdd, LOW a Vss. Q5. Los tamaños de variables son bit, nib, byte y word.

Bit – Almacena de 0 a 1 Nib – Almacena de 0 a 15 Byte – Almacena de 0 a 255 Word – Almacena de 0 a 65535 o de -32768 a +32767

Q6. El ancho del pulso determina la velocidad y control del servo. Visto en un diagrama de control de tiempo, el ancho del pulso es el tiempo durante el cual la señal permanece alta. En PBASIC, el pulso se puede generar con un comando PULSOUT. El argumento Duration del comando PULSOUT ajusta la velocidad y la dirección.

E1. PAUSE 10000 E2. La clave para escribir una declaración de variable es elegir un tamaño de variable

lo suficientemente grande para almacenar el valor de 24. Un Nib (nibble) no va a ser suficiente, ya que el valor máximo que un Nib puede almacenar es 15. Por lo tanto, elige una variable Byte.

counter VAR Byte FOR counter = 6 TO 24 STEP 3 DEBUG ? counter PAUSE 500 NEXT

P1. La clave para resolver este problema es enviar un tren de pulsos al LED y al servo.

' Robotica con el Boe-Bot - Ch02Prj01_DimlyLitLED.bs2 ' Mueve el servo y envia la misma senal al LED conectado a P14, ' para hacer que ilumine suavemente. '$STAMP BS2 '$PBASIC 2.5 DEBUG "Program Running!"


DO PULSOUT 12, 650 ' P12 servo conreloj PULSOUT 14, 650 ' P14 LED ilumina suave PAUSE 20 LOOP

P2. Primero, calcula el número de bucles necesarios para hacer que los servos

avancen durante tres segundos, para cada combinación de rotación. Como se vio en la página 79, se usa 1.6 ms. Cuatro combinaciones (1,2,3,4). Cada combinación: Determina los argumentos Duration del comando PULSOUT: 1. Ambos contrareloj (CCW): 12, 850 y 13, 850 2. Ambos conreloj (CW): 12, 650 y 13, 650 3. 12 CW y 13 CCW: 12, 850 y 13, 650 4. 12 CCW y 13 CW: 12, 650 y 13, 850 Cada combinación: Calcula cuánto tiempo dura cada bucle: 1. un bucle = 1.7 + 1.7 + 20 ms + 1.6 = 25.0 ms = 0.025 s 2. un bucle = 1.3 + 1.3 + 20 ms + 1.6 = 24.2 ms = 0.0242 s 3. un bucle = 1.7 + 1.3 + 20 ms + 1.6 = 24.6 ms = 0.0246 s 4. un bucle = 1.3 + 1.7 + 20 ms + 1.6 = 24.6 ms = 0.0246 s Cada combinación: Calcula el número de pulsos que se necesitan para 3 s de movimiento: 1. número de pulsos = 3 s / 0.025 s = 120 2. número de pulsos = 3 s / 0.0242 s = 123.9 = 124 3. número de pulsos = 3 s / 0.0246 s = 121.9 = 122 4. número de pulsos = 3 s / 0.0246 s = 121.9 = 122 Ahora escribe cuatro bucles FOR…NEXT, usando el número de pulsos que calculaste para el argumento EndValue. Incluye los argumentos PULSOUT correctos para la combinación de rotación.


' Robotica con el Boe-Bot - Ch02Prj02_4RotationCombinations.bs2 ' Mueve servos a traves de 4 combinaciones de rotacion ' conreloj/contrareloj. '$STAMP BS2 '$PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FOR counter = 1 TO 120 ' Bucle por 3 segundos PULSOUT 13, 850 ' P13 servo contrareloj PULSOUT 12, 850 ' P12 servo contrareloj PAUSE 20 NEXT FOR counter = 1 TO 124 ' Bucle por 3 segundos PULSOUT 13, 650 ' P13 servo conreloj PULSOUT 12, 650 ' P12 servo conreloj PAUSE 20 NEXT FOR counter = 1 TO 122 ' Bucle por 3 segundos PULSOUT 13, 650 ' P13 servo conreloj PULSOUT 12, 850 ' P12 servo contrareloj PAUSE 20 NEXT FOR counter = 1 TO 122 ' Bucle por 3 segundos PULSOUT 13, 850 ' P13 servo contrareloj PULSOUT 12, 650 ' P12 servo conreloj PAUSE 20 NEXT END

Capítulo 3: Ensambla y Prueba tu Boe-Bot · Página 93

Capítulo 3: Ensambla y Prueba tu Boe-Bot Este capítulo contiene instrucciones para construir y probar tu Boe-Bot. Es especialmente importante completar la parte de pruebas antes de continuar con el siguiente capítulo. Realizando las pruebas, podrás evitar algunos errores comunes que podrían descontrolar el comportamiento del Boe-Bot en capítulos posteriores. He aquí un resumen de las actividades que realizarás en este capítulo:

Actividad Resumen

1 Construir el Boe-Bot 2 Volver a probar los servos para asegurarte de que están conectados

adecuadamente 3 Conectar y probar una bocina que te permitirá saber cuándo Boe-Bot se

están descargando 4 Usar el Debug Terminal para controlar y probar la velocidad del servo

ACTIVIDAD #1: ENSAMBLANDO TU BOE-BOT Esta actividad te guíara en el proceso de ensamblar el Boe-Bot, paso a paso. En cada paso, recolectarás algunas de las partes y las ensamblarás de tal manera que concuerden con las imágenes. Cada imagen tiene una instrucción correspondiente; asegúrate de seguirlas cuidadosamente.

Herramientas y Partes del Servo

Todas las herramientas mostradas en la Figura 3-1 son de uso común y pueden ser encontradas en casi cualquier tienda escolar o de electrodomésticos. También pueden ser adquiridas en tu ferretería más cercana.

Herramientas

(1) Destornillador Parallax (Phillips #1 point screwdriver 1/8″ (3.18 mm) shaft) (1) Llave de 1/4″ (opcional) (1) Tenazas puntiagudas (opcional)


Figura 3-1 Herramientas para ensamblar el Boe-Bot

Montando el Hardware de la Parte Superior

√ Comienza por recolectar las siguientes partes. √ Luego, sigue las instrucciones.

Lista de partes:

Ver Figura 3-2. (1) Chasis del Boe-Bot (4) Espaciador de 1″ (4) Tornillos de cabeza plana con ranura, 1/4″ 4-40 (1) Ojal de goma, 13/32″

Instruciones:

√ Inserta el ojal de goma 13/32″ en el orificio central del chasis del Boe-Bot.

√ Asegúrate de que el surco de la parte exterior del ojal de goma quede sobre el borde del orificio del chasis.

√ Usa los tornillos de 1/4″ 4-40 para sujetar los espaciadores al chasis como se muestra en la imagen.


Figura 3-2 Hardware del chasis y la parte superior Partes (izquierda); ensamblado (derecha).

Partes del Boe-Bot – Las partes del Boe-Bot están incluidas en el kit completo del Boe-Bot o en una combinación de los kits completos de la Board of Education y de Robotics Parts. Ver Apéndice E: Lista de Partes del Boe-Bot para más información.

Retirando los Cuernos de los Servos

√ Desconecta la energía de tu BASIC Stamp y de los servos. √ Retira todas las baterías AA del paquete de baterías. √ Desconecta los servos de tu plaqueta.

Lista de partes:

Ver Figura 3-3. (2) Continuous Rotation Servos de Parallax, previamente centrados

Instrucciones:

√ Usa un destornillador de Estría para retirar los tornillos que sostienen los cuernos de control del servo de sus respectivos ejes.

√ Hala cada cuerno hacia arriba y fuera del eje del servo.

√ Guarda los tornillos; Se usarán en un paso posterior.


Figura 3-3 Removiendo los cuernos de control de los servos Partes (izquierda); después de seguir las instrucciones (derecha).

¡Alto!

√ Antes del siguiente paso, debes haber terminado las actividades del Capítulo 2: Los Servomotores de tu Boe-Bot.

• Actividad #3: Connecting the Servo Motors • Actividad #4: Calibrando los Servos

Montando los Servos en el Chasis

Lista de Partes:

Ver Figura 3-4. (1) Chasis del Boe-Bot

(parcialmente ensamblado) (2) Continuous Rotation Servos

de Parallax (8) Tornillos de cabeza plana con

ranura, 3/8″ 4-40 (8) Tuercas, 4-40

Instrucciones:

√ Sujeta los servos al chasis usando los tornillos de Estría y las tuercas. Nota que para un desempeño óptimo, debes colocar el frente de cada servo a través de la ventana rectangular desde el interior del chasis en lugar de soltarlos desde el exterior hacia adentro.

√ Usa pedazos de teipe para etiquetar los servos izquierdo (L) y derecho (R).

Horn de control

Tornillo Phillips

Palanca de salida


Figura 3-4 Montando los servos en el chasis Partes (izquierda); ensamblado (derecha).

Montando el Paquete de Baterías

La Figura 3-5 dos juegos de partes distintos. Usa las partes de la izquierda si posees una Board of Education y las de la derecha si posees una HomeWork Board.

Lista de Partes para el Boe-Bot con una Board of Education Rev C:

Ver Figura 3-5 (lado izquierdo). (1) Chasis del Boe-Bot

(parcialmente ensamblado) (2) Tornillos de Estría de

cabeza plana, 3/8″ 4-40 (2) Tuercas, 4-40 (1) Un paquete de baterías con

enchufe de polo positivo central

Lista de Partes para el Boe-Bot con una HomeWork Board:

Ver Figura 3-5 (lado derecho). (1) Chasis del Boe-Bot

(parcialmente ensamblado) (2) Tornillos de Estría de cabeza

plana, 3/8″ 4-40 (2) Tuercas, 4-40 (1) Paquete de baterías con

conexiones estañadas


Figura 3-5 Hardware para montaje del paquete de baterías

Para usar con la Board of Education Para usar con la HomeWork Board

Instrucciones:

√ Usa los tornillos de cabeza plana y las tuercas para sujetar el paquete de baterías en la parte baja del chasis del Boe-Bot como se muestra a la izquierda de la Figura 3-6.

√ Asegúrate de insertar los tornillos a través del paquete de baterías, luego aprieta las tuercas en la parte de arriba del chasis.

√ Como se muestra a la derecha de la Figura 3-6, hala el cable conductor de energía del paquete de baterías a través del orificio donde colocaste el ojal de goma (en el centro del chasis).

√ Hala los cables de los servos a través del mismo orificio. √ Acomoda los cables de los servos y el cable de la fuente de alimentación como

se muestra en la imagen.


Figura 3-6 Paquete de baterías montado Vista inferior (izq.); Vista superior (der.).

Montando las Ruedas

Lista de Partes:

(1) Boe-Bot parcialmente ensamblado (no se muestra en la imagen)

(1) Pin de 1/16″ (1) Bola rodante traser (2) Bandas de goma para usar

como neumáticos (2) Ruedas de plástico

mecanizadas (2) Tornillos que fueron guardados

en el paso de retiro de los servo horns.

Figura 3-7 Hardware de las ruedas

Instrucciones:

El lado izquierdo de la Figura 3-8 muestra cómo se monta la rueda trasera del Boe-Bot en el chasis. La rueda trasera es simplemente una bola de plástico con un orificio en el centro. Un pin metálico la sujeta del chasis y funciona como un eje giratorio para la misma.

√ Alínea el orificio de la rueda trasera con los orificios de la parte de atrás del chasis.


√ Pasa el pin a través de los tres orificios (izquierda del chasis, rueda trasera, derecha del chasis).

√ Dobla los extremos del pin para que no se salga del orificio. El lado derecho de la Figura 3-8 muestra las ruedas del Boe-Bot montadas en los servos.

√ Estira cada banda de goma y colócelas sobre el borde exterior de cada rueda. √ Cada rueda de plástico tiene un orificio que encaja en el eje de salida del servo.

Presiona cada rueda de plástico contra el eje de salida de un servo asegurándote de que cada eje esté alineado y la rueda se pueda hundir en cada uno de los orificios.

√ Usa los tornillos que guardaste cuando retiraste los cuernos de los servos para sujetar las ruedas a los ejes de salida de los servos.

Figura 3-8 Montando las ruedas Rueda trasera (izq.); ruedas de manejo (der.).


Sujetando la Board of Education o HomeWork Board al Chasis

Parts List para el Boe-Bot con una Board of Education:

Ver lado izquierdo de la Figura 3-9. (1) Chasis del Boe-Bot

(parcialmente ensamblado) (4) Tornillos de cabeza plana

con ranura, 1/4″ 4-40 (1) Board of Education with

BASIC Stamp 2

Parts List para el Boe-Bot con un HomeWork Board:

Ver lado derecho de la Figura 3-9. (1) Chasis del Boe-Bot

(parcialmente ensamblado) (4) Tornillos de cabeza plana con

ranura, 1/4″ 4-40 (1) BASIC Stamp HomeWork

Board

Figura 3-9 Chasis del Boe-Bot y plaquetas

Con la Board of Education Rev C Con la HomeWork Board


La Figura 3-10 muestra los puertos de servo reconectados tanto para la Board of Education Rev C (lado izquierdo) como para la HomeWork Board (lado derecho).

√ Reconecta los servos a los cabezales correspondientes. √ Asegúrate de conectar el enchufe etiquetado ‘L’ al puerto P13 y el enchufe

etiquetado ‘R’ al puerto P12.

BlackRed

X4 X5

15 14 13 12Vdd

WhiteRedBlack

WhiteRed

Black

P15P14

P11P10P9P8

P13P12

X3Vdd VssVin


Rev B

Figura 3-10 Puertos de servos reconectados Board of Education Rev C (izq.) HomeWork Board (der.).

En la Board of Education Rev C En la HomeWork Board

La Figura 3-11 muestra el chasis del Boe-Bot con sus respectivas plaquetas sujetas a él.

√ Fija la plaqueta sobre los cuatro espaciadores de tal manera que queden alineados con los cuatro orificios de las esquinas exteriores de la plaqueta.

√ Asegúrate de que el protoboard blanco está más cerca de las ruedas de manejo y no de la rueda trasera.

√ Sujeta la plaqueta a los espaciadores usando los tornillos de cabeza plana.

P13 - Blanco Vbp - Rojo Vss - Negro Vbp - Rojo P12 - Blanco

Cable negro

Banda blanca


Figura 3-11 Plaquetas sujetas al chasis del Boe-Bot

Con la Board of Education Rev C Con la HomeWork Board La Figura 3-12 muestra Boe-Bots ensamblados, el izquierdo construido con una Board of Education Rev C y el derecho construido con una HomeWork Board.

√ Desde la parte de abajo del chasis, a través de orificio con el ojal de goma, hala cualquier cable (de servo o batería) que sea demasiado largo.

√ Mete la parte sobrante de los cables entre los servos y el chasis.

Figura 3-12 Boe-Bots ensamblados

Con la Board of Education Rev C Con la HomeWork Board


ACTIVIDAD #2: PROBANDO LOS SERVOS NUEVAMENTE En esta actividad, verificarás que las conexiones eléctricas entre tu plaqueta y los servos funcionan apropiadamente. La Figura 3-13 muestra el frente, la parte trasera, izquierda y derecha de tu Boe-Bot. Necesitamos asegurarnos de que el servo de la derecha gira cuando recibe los pulsos de P12 y que el servo de la izquierda gira cuando recibe pulsos de P13.

Izquierda

Parte

trasera

Derecha

Parte posterior

Figura 3-13 La parte izquierda, derecha, posterior y trasera de tu Boe-Bot

Verificando la Rueda Derecha

El siguiente programa de ejemplo verificará el servo conectado a la rueda derecha, mostrado en la Figura 3-14. El programa hará que la rueda gire conreloj durante 3 segundos, luego se detenga por un segundo, y luego gire contrareloj durante 3 segundos.

Figura 3-14 Verificando la rueda derecha

Counterclockwise 3 segundos

Detenida 1 segundo

Clockwise 3 segundos


Programa de ejemplo: RightServoTest.bs2

√ Coloca el Boe-Bot sobre su extremo de tal manera que las ruedas queden suspendidas en el aire.

√ Pon las baterías en el paquete de baterías. √ Si tienes una Board of Education Rev C, coloca el interruptor de 3 posiciones en

la posición 2. √ Si tienes una BASIC Stamp HomeWork Board, conecta la batería de 9 V al clip

de batería. √ Introduce, guarda y ejecuta el programa RightServoTest.bs2. √ Verifica que la rueda derecha gira conreloj durante tres segundos, se detiene por

un segundo, luego gira contrareloj por tres segundos. √ Si la rueda/servo no se comporta como se esperaba, ve la sección . Está

inmediatamente después del programa RightServoTest.bs2. √ Si la rueda/servo sí se comporta como se esperaba, entonces avanza a la sección

Tu Turno, donde verificarás la rueda izquierda. ' Robotica con el Boe-Bot - RightServoTest.bs2 ' Servo derecho rota conreloj por tres segunds, se detiene 1 segundo, ' y luego se mueve contrareloj por tres segundos. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FOR counter = 1 TO 122 ' Conreloj por poco menos de 3 s. PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 1 TO 40 ' Para 1 s. PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 1 TO 122 ' Contrareloj 3 s. PULSOUT 12, 850 PAUSE 20 NEXT END


Reparación de Servos: He aquí una lista de los síntomas más comunes y de cómo repararlos.

El servo no se mueve. √ Si estás utilizando una Board of Education Rev C, asegúrate de que el interruptor

de 3 posiciones se encuentra en la posición 2. Puedes volver a ejecutar el programa presionando y soltando el botón Reset.

√ Si estás utilizando una BASIC Stamp HomeWork Board, asegúrate de que el paquete de baterías tiene baterías.

√ Revisa otra vez las conexiones de tu servo usando la Figura 3-10 de la página 102 como referencia. Si estás usando una HomeWork Board, también deberías volver a ver la Figura 2-18 de la página 65.

√ Revisa y asegúrate de que introdujiste el programa correctamente. El servo derecho no funciona, pero el izquierdo sí.

Esto significa que los servos están intercambiados. El servo que está conectado a P12 debería estar conectado a P13 y el servo que está conectado a P13 debería estar conectado a P12.

√ Desconecta la energía. √ Desenchufa los dos servos. √ Conecta el servo que estaba conectado a P12 a P13. √ Conecta el otro servo (que estaba conectado a P13) a P12. √ Reconecta la energía. √ Vuelve a ejecutar el programa RightServoTest.bs2.

La rueda no se detiene por completo; se torna más lenta. Esto puede significar que el servo no está completamente centrado. Puedes ajustar con frecuencia el programa para que el servo no se mueva. Puedes hacerlo modificando el comando PULSOUT 12, 750.

√ Si la rueda se vuelve más lenta contrareloj, usa un valor un poco menor que 750. √ Si está girando conreloj, usa un valor un poco mayor que 750. √ Si puedes encontrar un valor entre 740 y 760 con el que el servo se detenga por

completo, asegúrate de usarlo en donde encuentres el comando PULSOUT 12, 750.

La rueda no se detiene por un segundo entre el cambio de direcciones. Puede que la rueda gire rápidamente por tres segundos en una dirección y por cuatro en la otra. También puede que gire rápidamente por tres segundos, luego un poco más lento por un segundo, luego rápidamente otra vez por tres segundos. O, puede que gire rápidamente en una sola dirección por siete segundos. Sin importar el caso, eso significa que el potenciómetro está desajustado.

√ Retira las ruedas, desmonta los servos servos y repite el ejercicio en el Capítulo 2, la Actividad #4: Calibrando los Servos.


Tu Turno – Verificando la Rueda Izquierda

Ahora, es momento de ejecutar la misma verificación para la rueda izquierda como lo muestra la Figura 3-15. Esto involucra modificar el programa RightServoTest.bs2 de tal manera que los comandos PULSOUT se manden al servo conectado a P13 en lugar de al servo conectado a P12. Lo único que debes hacer es cambiar los tres comandos PULSOUT para que digan PULSOUT 13 en lugar de PULSOUT 12.

Figura 3-15 Verificando la rueda izquierda

√ Guarda el programa RightServoTest.bs2 como LeftServoTest.bs2. √ Cambia los tres comandos PULSOUT para que digan PULSOUT 13 en lugar de

PULSOUT 12. √ Guarda y ejecuta el programa. √ Verifica que la rueda izquierda gire conreloj durante tres segundos, se detenga

por un segundo, luego gire contrareloj por tres segundos. √ Si la rueda/servo no se comporta como se esperaba, ve la sección Reparación de

Servos en la página 106. √ Si la rueda/servo sí se comporta como se esperaba, entonces tu Boe-Bot está

funcionando adecuadamente y estás listo para pasar a la siguiente actividad.

ACTIVIDAD #3: CIRCUITO Y PROGRAMA INDICADOR START/RESET Llamamos bajón al momento cuando el suministro de voltaje llega a un nivel inferior del necesario para que un dispositivo funcione correctamente. El BASIC Stamp se protege de un bajón manteniendo a tu procesador y los chips de memoria de los programas en estado inactivo hasta que el suministro de voltaje vuelva a sus niveles normales. Un voltaje inferior a 5.2 V en Vin ocasiona un voltaje inferior a 4.3 V en la salida del regulador de voltaje interno del BASIC Stamp. Un circuito llamado detector de bajón en el BASIC

Counterclockwise 3 segundos

Detenida 1 segundo

Clockwise 3 segundos


Stamp está siempre alerta en caso de un bajón. Cuando ocurre un bajón, el detector de bajón deshabilita el procesador y la memoria de programas del BASIC Stamp. Cuando el suministro de voltaje vuelve por encima de 5.2 V, el BASIC Stamp vuelve a funcionar, pero no en el mismo lugar del programa. En lugar de eso, arranca desde el principio el programa. De hecho, esto es lo que sucede cuando desconectas y vuelves a conectar la energía, y también cuando presionas y sueltas el botón Reset de tu plaqueta. Cuando las baterías del Boe-Bot se estén descargando, un bajón puede causar que un programa se reinicie en un lugar donde no esperabas. Esto puede ocasionar comportamientos erráticos del Boe-Bot. En algunos casos, el Boe-Bot seguirá el curso que se programó para navegar y de repente parecerá perdido e irá en una dirección inesperada. Si la causa de esto es la descarga de las baterías, puede tratarse de que el programa del Boe-Bot regreso al inicio y comenzó desde cero. En otros casos, puede que el Boe-Bot comience a girar de un lado para otro confusamente porque cada vez que los servos comienzan a girar, sobrecargan las baterías las cuales ya están muy descargadas como para hacerlos girar normalmente. Por una fracción de segundo el programa intenta que los servos giren, pero en seguida se reinicia una y otra vez. Estas situaciones hacen de un indicador start/reset, un dispositivo de diagnóstico extremadamente útil, así como también, una buena herramienta para el robot. Una manera de indicar cuándo ocurre un reset, es incluir una señal inconfundible al principio de todos los programas del Boe-Bot. La señal ocurre cada vez que se conecta la energía, pero también ocurre cada vez que un bajón provoca un reset. Una señal efectiva para resets es una bocina que emita un tono cada vez que un programa del BASIC Stamp se ejecute desde el principio o haga reset.

Instrucciones especiales para la BASIC Stamp HomeWork Board

A pesar de que el indicador de reset te dirá cuando la batería de 9 V que alimenta a la BASIC Stamp se está descargando, no te dirá cuándo el suministro del servo (el paquete de baterías) se está descargando.

Siempre puedes saber cuándo el paquete de baterías se está descargando porque los servos se moverán gradualmente más despacio durante una operación normal. Cuando observes este síntoma, reemplaza las baterías descargadas con nuevas baterías alcalinas de 1.5 V.

Este ejercicio introducirá un dispositivo llamado bocina piezoeléctrica (piezobocina, en inglés) que puedes usar para emitir tonos. Esta puede emitir diferentes tonos dependiendo


de la frecuencia de señales altas/bajas que reciba del BASIC Stamp. El símbolo esquemático y el dibujo de parte de la bocina piezoeléctrica se muestra en la Figura 3-16. Esta bocina emitirá sonidos cuando el BASIC Stamp haga reset en esta actividad así como en el resto de las actividades de este texto.

Figura 3-16 Bocina piezoeléctrica

¿Qué es frecuencia? Es la medida de cuán a menudo ocurre algo en un período de tiempo determinado.

¿Qué es un elemento piezoeléctrico y cómo puede emitir sonidos? Es un cristal que cambia levemente de forma cuando se le aplica voltaje. Aplicar voltajes altos y bajos a un cristal piezoeléctrico con un ritmo de velocidad, causa que el cristal piezoeléctrico cambie rápidamente de forma. El resultado es vibración. La vibración de los objetos provoca que el aire alrededor de ellos también vibre. Es esto lo que nuestros oídos detectan como sonidos y tonos. Cada ritmo o vibración tiene un tono distinto. Por ejemplo, si tocas la cuerda de una guitarra, tendra una frecuencia de vibración y escucharás un tono particular. Si tocas otra cuerda, esta tendrá una frecuencia de vibración distinta y producirá un tono diferente.

Nota: Los elementos piezoeléctricos tienen diversos usos. Por ejemplo, cuando se les aplica fuerza, pueden crear voltaje. Algunos elementos piezoeléctricos tienen una frecuencia a la que vibran naturalmente. Estos pueden ser usados para crear voltajes a frecuencias que funcionen como el oscilador de un reloj para varias computadoras y microcontroladores.

Partes Requeridas (1) Boe-Bot ensamblado y verificado (1) Piezobocina (misc.) Cables para puente eléctricos

Si tu bocina piezoeléctrica tiene una etiqueta que dice “Retire el sello después de lavarlo” simplemente retirelo y proceda. ¡Tu bocina piezoeléctrica no necesita ser lavado!

Construyendo el Circuito Indicador de Start/Reset La Figura 3-17 muestra el diagrama de un circuito de alarma con la bocina piezoeléctrica para la Board of Education y la BASIC Stamp HomeWork Board. La Figura 3-18 muestra un diagrama de conexión para cada una de las plaquetas.


¡Desconecta siempre la energía antes de construir o modificar circuitos!

√ Si posees una Board of Education Rev C, coloca el interruptor de tres posiciones en la posición 0.

√ Si posees una BASIC Stamp HomeWork Board, desconecta la batería de 9 V del clip de batería y retira la una batería del paquete de baterías.

√ Construya el circuito de la Figura 3-17 y la Figura 3-18.

P4

Vss

Figura 3-17 Circuito del indicador de Start/Reset de programas


P15P14P13P12P11P10P9P8P7P6P5

P3P2P1P0

P4

X2

X3Vdd VssVin

Board of Education © 2000-2003Rev C

Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P4

P10P9P8P7P6P5

P3P2P1P0

X2

X3Vdd VssVin

Rev B(916) 624-8333www.parallax.comwww.stampsinclass.com

To Servos

+

HomeWork Board

Figura 3-18 Diagramas de conexión para el circuito del indicador de Start/Reset Programa Board of Education (izq.) y HomeWork Board (der.).

Los circuitos de la bocina piezoeléctrica y de los servo permanecerán conectados a la plaqueta por el resto de las actividades de este texto.

Todos los diagramas de circuitos de ahora en adelante mostrarán circuitos que deben ser añadidos a los circuitos de servos y del piezobocina ya existentes.

Todos los diagramas de conexión mostrarán los circuitos de los dibujos esquemáticos que le preceden, así como también las conexiones con los circuitos de servos y de la bocina piezoeléctrica.

Programando el Indicador Start/Reset El siguiente programa de ejemplo verificará la bocina piezoeléctrica. El programa usa el comando FREQOUT para enviar señales altas/bajas perfectamente sincronizadas a la bocina. He aquí la sintáxis del comando FREQOUT:

FREQOUT Pin, Duration, Freq1 ,Freq2


He aquí un ejemplo del comando FREQOUT usado en el próximo programa de ejemplo.

FREQOUT 4, 2000, 3000 El argumento Pin es 4, lo cual significa que las señales altas/bajas se enviarán al pin I/O P4. El argumento Duration, el que determina la duración de la señal alta/baja, es 2000, lo que equivale a 2000 ms ó 2 segundos. El argumento Freq1 es la frecuencia de las señales altas/bajas. En este ejemplo, las señales altas/bajas producirán un tono de 3000 hertz, o 3 kHz.

La frecuencia se puede medir en hertz (Hz). El hertz es una medida de frecuencia para indicar cuantas veces ocurre un evento por seguno. Un hertz equivale simplemente una vez por segundo y se abrevia 1 Hz. Un kilohertz equivale a mil veces por segundo y se abrevia 1 kHz.

FREQOUT sintetiza tonos digitalmente. El comando FREQOUT aplica tonos altos/bajos de duraciones variadas para hacer que la vibración de la bocina piezoeléctrica se parezca a vibraciones naturales de cuerdas musicales.

Programa de ejemplo: StartResetIndicator.bs2

Este programa de ejemplo emite un bip al principio del programa, luego ejecuta un programa que envía mensajes DEBUG cada medio segundo. Estos mensajes continuarán indefinidamente porque están anidados entre DO y LOOP. Si se interrumpe la fuente de alimentación de la BASIC Stamp mientras el programa está en el proceso DO…LOOP, el programa volverá al inicio nuevamente. Cuando comience de nuevo, volverá a emitir el bip. Ahora puedes simular un bajón presionando y soltando el botón Reset o desconectando y conectando el suministro de baterías de tu plaqueta.

√ Reconecta la energía de tu plaqueta. √ Introduce, guarda y ejecuta el programa StartResetIndicator.bs2. √ Verifica que el piezobocina emitió un tono claramente audible durante dos

segundos antes de que el mensaje “Waiting for reset…” comenzara a aparecer en el Debug Terminal.

√ Si no escuchaste un tono, revisa si el cableado o el código presenta errores. Repite hasta que obtengas un tono audible de tu bocina.

√ Si llegaste a escuchar un tono, intenta simular la condición de bajón presionando y soltando el botón Reset de la plaqueta. Verifica que la bocina piezoeléctrica produce un tono claramente audible después de cada acción de reset.


√ También intenta desconectando y reconectando la fuente de suministro de baterías y verifica que el resultado también es el tono de adverencia de reset.

' Robotica con el Boe-Bot - StartResetIndicator.bs2 ' Prueba el circuito de la bocina piezoelectrica. ' $STAMP BS2 ' Directiva del Stamp ' $PBASIC 2.5 ' Directiva de PBASIC DEBUG CLS, "Beep!!!" ' Mensaje mientras bocina suena FREQOUT 4, 2000, 3000 ' Senal de start/reset DO ' DO...LOOP DEBUG CR, "Waiting for reset…" ' Muestra mensaje PAUSE 500 ' cada 0.5 segundos LOOP ' hasta que haya un reset.

Funcionamiento del Programa StartResetIndicator.bs2 El programa StartResetIndicator.bs2 comienza desplegando el mensaje “Beep!!!” Luego de imprimir el mensaje, el comando FREQOUT reproduce un tono de 3 kHz en el speaker piezoeléctrico durante 2 s. Debido a que estas instrucciones son ejecutados tan rápidamente por el BASIC Stamp, debería parecer que el mensaje se despliega al mismo tiempo en que la bocina piezoeléctrica comienza a emitir el tono. Cuando el tono termina, el programa entra en un bucle DO…LOOP, mostrando el mismo mensaje “Waiting for reset…” una y otra vez. Cada vez que se presione el botón reset de la Board of Education, o se desconecta y reconecta la energía, el programa volverá a iniciarse con el mensaje "Beep!!!" y el tono de 3 kHz.

Tu Turno - Añadiendo el Programa StartResetIndicator.bs2 a un Programa Diferente Las líneas del código en el programa del indicador de batería se utilizarán al principio de cada programa de ejemplo de ahora en adelante. Puedes considerarlo como parte de la “rutina de inicialización” o “boot routine” para cada progrma del Boe-Bot.

Una rutina de inicialización está compuesta por todos los comandos necesarios para hacer que un dispositivo o programa arranque. Generalmente incluye establacer ciertas variables, valores, bips y, para dispositivos más complejos, autoverificación y calibración.


√ Abre el programa HelloOnceEverySecond.bs2. √ Copia el comando FREQOUT command del programa StartResetIndicator.bs2 en

el programa HelloOnceEverySecond.bs2 arriba de la sección DO…LOOP. √ Ejecuta el programa modificado y verifica que responde con un tono de

advertencia cada vez que se hace reset a la BASIC Stamp (presionando y soltando el botón Reset en la plaqueta o desconectando y conectando el suministro de la batería).

ACTIVIDAD #4: PROBANDO EL CONTROL DE VELOCIDAD CON EL DEBUG TERMINAL En esta actividad, harás un gráfico de la velocidad vs. el ancho del pulso. Algo que puede hacer que este proceso avance mucho más rápido es el “Transmit windowpane” del Debug Terminal , que se muestra en la Figura 3-19. Puedes utilizar el Transmit windowpane (panel-ventana para transmisión, en inglés) para enviar mensajes al BASIC Stamp. Enviando mensajes al BASIC Stamp indicándole que ancho de pulso debe enviar al servo, puedes verificar la velocidad del servo ante cada ancho de pulso.

Figura 3-19 Windowpanes del Debug Terminal

Ancho de pulso es una manera común de describir cuánto dura el pulso. La razón por la que se llama "ancho" se debe a que la duración del pulso está relacionada con su anchura en un diagrama de medición del tiempo. Los pulsos que duran más tiempo son más largos en el diagrama y los pulsos que duran menos tiempo son más cortos.

Transmit Windowpane

Receive Windowpane


Usando el comando DEBUGIN

A estas alturas, probablemente ya estás familiarizado con el comando DEBUG y cómo puede usarse para enviar mensajes desde el BASIC Stamp al Debug Terminal. El lugar donde se ven los mensajes se llama “Receive windowpane” (panel-ventana para recepción, en inglés) porque es el lugar donde son mostrados los mensajes que son recibidos desde el BASIC Stamp. El Debug Terminal también tiene un Transmit windowpane, que te permite enviar información a tu BASIC Stamp cuando un programa se está ejecutando. Puedes usar el comando DEBUGIN para hacer que el BASIC Stamp reciba lo que escribes en el Transmit windowpane y lo almacene en una o más variables. El comando DEBUGIN coloca el valor que escribes en el Transmit windowpane dentro de una variable. En el siguiente programa de ejemplo, una variable de palabra pulseWidth se utilizará para almacenar valores que recibe el comando DEBUGIN.

pulseWidth VAR Word Ahora, el comando DEBUGIN puede ser utilizado para capturar un valor decimal que ingreses en el Transmit windowpane del Debug Terminal y almacenarlo en pulseWidth:

DEBUGIN DEC pulseWidth Entonces puedes programar el BASIC Stamp para que use este valor. Aquí está siendo usado en el argumento Duration del comando PULSOUT:

PULSOUT 12, pulseWidth

Programa de ejemplo: TestServoSpeed.bs2

Este programa te permite establacer el argumento Duration del comando PULSOUT introduciéndolo en el Transmit windowpane de la Debug Terminal.

√ Continúa esta actividad con el Boe-Bot sobre su punta de tal manera que las ruedas no toquen el piso.

√ Introduce, guarda y ejecuta el programa TestServoSpeed.bs2. √ Coloca el cursor sobre el Transmit windowpane del Debug Terminal, y haz clic

para activar el cursor en esa ventana para escribir. √ Escribe 650 y luego presiona la tecla Enter. √ Verifica que el servo gira a toda velocidad conreloj durante seis segundos.


Cuando el servo deje de girar, el programa te pedirá que introduzcas otro valor.

√ Escribe 850 y luego presiona la tecla Enter. √ Verifica que el servo gira a toda velocidad contrareloj.

Trata de medir la velicidad rotacional de la rueda RPM (revoluciones por minuto) para un rango de anchos de pulso de entre 650 y 850. He aquí cómo:

√ Coloca una marca en la rueda para ver qué tanto gira en 6 segundos. √ Usa el Debug Terminal para probar qué tanto gira con los siguientes anchos de

pulso: 650, 660, 670, 680, 690, 700, 700, 710, 720, 730, 740, 750, 760, 770, 780, 790, 800, 810, 820, 830, 840, 850

√ Para cada ancho de pulso, multiplica el número de vueltas por 10 para obtener las RPM. Por ejemplo, si la rueda realizó 3.65 vueltas completas, estaba girando a 36.5 RPM.

√ Explica en tus propias palabras cómo se puede usar el ancho de pulso para controlar la velocidad del Continuous Rotation servo.

' Robotica con el Boe-Bot - TestServoSpeed.bs2 ' Ingresa el ancho de pulso, luego cuenta las revoluciones de la rueda ' La rueda se movera por 6 segundos ' Multiplica por 10 para obtener las RPM. '$STAMP BS2 '$PBASIC 2.5 counter VAR Word pulseWidth VAR Word pulseWidthComp VAR Word FREQOUT 4, 2000, 3000 ' Senal de start/reset del programa. DO DEBUG "Enter pulse width: " ' Muestra mensaje para ingresar ' ancho de pulso DEBUGIN DEC pulseWidth pulseWidthComp = 1500 – pulseWidth ' Calcula el complemento del pulso ' usado para la otra rueda


FOR counter = 1 TO 244 PULSOUT 12, pulseWidth ' Envia el pulso a P12 PULSOUT 13, pulseWidthComp ' Envia el complemento a P13 PAUSE 20 NEXT LOOP

Funcionamiento del Programa TestServoSpeed.bs2

Se declaran tres variables, counter para el bucle FOR…NEXT, pulseWidth para los comandos DEBUGIN y PULSOUT, y pulseWidthComp que almacena el valor en un segundo comando PULSOUT.

counter VAR Word pulseWidth VAR Word pulseWidthComp VAR Word

El comando FREQOUT se usa para señalar que el programa comenzó. FREQOUT 4,2000,3000

El resto del programa está anidado en un DO…LOOP, así que se ejecutará una y otra vez. El operador del Debug Terminal (ese eres tú) debe introducir un ancho de pulso. El comando DEBUGIN almacena este valor en la variable pulseWidth.

DEBUG "Enter pulse width: " DEBUGIN DEC pulseWidth

Para que la medición sea precisa, se deben enviar dos comandos PULSOUT. Haciendo que uno de los comandos PULSOUT sea igualmente inferior a 750 como el otro es superior a 750, la suma de los dos argumentos Duration del comando PULSOUT será siempre 1500. Esto asegura que los dos comandos PULSOUT combinados tarden la misma cantidad de tiempo. Esto resulta en que independientemente del valor Duration del comando PULSOUT, el bucle FOR…NEXT tardará el mismo tiempo en ejecutarse. Esto hará que las mediciones en RPM que harás en la sección Tu Turno sean más precisas. El siguiente comando toma el ancho de pulso que introduciste y calcula un ancho de pulso que sumado al anterior de como total 1500. Si introduces un ancho de pulso de 650, pulseWidthComp será 850. Si introduces un ancho de pulso de 850, pulseWidthComp


será 650. Si introduces un ancho de pulso de 700, pulseWidthComp será 800. Intenta otros ejemplos. Todos sumarán 1500.

pulseWidthComp = 1500 - pulseWidth

Un bucle FOR…NEXT que se ejecute durante 6 seconds envía pulsos al servo derecho (P12). El valor pulseWidthComp se envía al servo izquierdo (P13), haciendo que gire en la dirección opuesta.

FOR counter = 1 TO 244 PULSOUT 12, pulseWidth PULSOUT 13, pulseWidthComp PAUSE 20 NEXT

Tu Turno – Tema avanzado: Graficando Ancho de Pulso vs. Velocidad Rotacional

La Figura 3-20 muestra un ejemplo de una curva de transferencia para un Continuous Rotation Servo. El eje horizontal muestra el ancho de pulso en ms y el eje vertical muestra la velocidad rotacional en RPM. En este gráfico, dirección conreloj es negativa y en sentido contrario, positiva. La curva de transferencia de este servo en particular oscila entre las -48 RPM y las 48 RPM y el ancho de pulso oscila entre los1.3 ms y los 1.7 ms.

Rotational Velocity vs. Pulse Width for Servo

-60

-40

-20

0

20

40

60

1.300 1.350 1.400 1.450 1.500 1.550 1.600 1.650 1.700

Pulse Width, ms

Rot

atio

nal V

eloc

ity, R

PM

Right Servo

Figura 3-20 Ejemplo de curva de transferencia para el servo de Parallax


Puedes usar la Tabla 3-1 para registrar las data de tu propia curva de transferencia. Recuerda que el programa de ejemplo controla la rueda derecha con los valores que introduces. La rueda izquierda gira en la dirección opuesta.

Tabla 3-1: Ancho de pulso y RPM para el servo de Parallax

Ancho de pulso (ms)

Velocidad rotacional (RPM)

Ancho de pulso (ms)


Ancho de pulso (ms)


Ancho de pulso (ms)


1.300 1.400 1.500 1.600 1.310 1.410 1.510 1.610 1.320 1.420 1.520 1.620 1.330 1.430 1.530 1.630 1.340 1.440 1.540 1.640 1.350 1.450 1.550 1.650 1.360 1.460 1.560 1.660 1.370 1.470 1.570 1.670 1.380 1.480 1.580 1.680 1.390 1.490 1.590 1.690

1.700 Recuerda que el argumento Duration del comando PULSOUT está indicado en unidades de 2 µs. PULSOUT 12, 650 manda pulsos que duran 1.3 ms a P12. PULSOUT 12, 655 manda pulsos que duran 1.31 ms, PULSOUT 12, 660 manda pulsos que duran 1.32 ms, y así sucesivamente.

sm3.1s0013.0

s000002.0650s2650Duration

==

×=×= μ

sm31.1s00131.0


==

×=×= μ

sm32.1s00132.0


==

×=×= μ

√ Marca la rueda derecha para tener un punto de referencia para contar las

revoluciones. √ Ejecuta el programa TestServoSpeed.bs2. √ Haz clic en el Transmit windowpane de la Debug Terminal. √ Introduce el valor 650.


√ Cuenta cuántas vueltas da la rueda. Dado que el servo gira durante 6 segundos, puedes multiplicar este valor por 10 to para obtener las revoluciones por minuto (RPM).

√ Multiplica este valor por 10 e introduce el resultado en la Tabla 3-1 al lado de la entrada 1.3 ms.

√ Introduce el valor 655. √ Cuenta cuantas vueltas da la rueda. √ Multiplica este valor por 10 e introduce este resultado en la Tabla 3-1 al lado de

la entrada 1.31 ms. √ Sigue aumentando los valores de 5 en 5 (0.01 ms) hasta que llegues a 850 (1.7

ms). √ Usa una hoja de cálculo, calculadora o papel cuadriculado para graficar las data. √ Repite este proceso para el otro servo.

Puedes repetir esta medición para el otro servo. Tendrás que modificar los comandos PULSOUT para que los pulsos con una duración de pulseWidth sean enviados a P13 y los pulsos con duración de pulseWidthComp sean enviados a P12.


RESUMEN Este capítulo cubrió cómo ensamblar y verificar el Boe-Bot. Esto incluyó ensamblaje mecánico, tal como conectar varias partes móviles al chasis del Boe-Bot. También incluyó ensamblaje de circuitos, conectando los servos y la bocina piezoeléctrica. Las verificaciones incluyeron probar los servos de nuevo, después de haber sido desconectados para construir el Boe-Bot. Se introdujo el concepto de bajón, al igual que las consecuencias de dicha condición a un programa ejecutado por el BASIC Stamp. Un bajón causa que el BASIC Stamp se reinicie y comience a ejecutar el programa desde el principio. Se añadió una bocina piezoeléctrica para señalar el comienzo de un programa. Si la bocina piezoeléctrica suena en medio de un programa en ejecución, cuando no se supone que deba hacerlo, puede que indique un bajón. Por su parte, los bajones pueden estar indicando que las baterías se están descargando. Para lograr que la bocina piezoeléctrica emita un tono para señalar un reset, se introdujo el comando FREQOUT. Este comando es parte de una rutina de inicialización que se usará al principio de todos los programas del Boe-Bot. Hasta este capítulo, el Debug Terminal se ha usado para mostrar mensajes enviados a la computadora por el BASIC Stamp. Estos mensajes se mostraban en el Receive windowpane. El Debug Terminal también tiene un Transmit windowpane que puedes usar para enviar valores al BASIC Stamp. El BASIC Stamp puede capturar estos valores ejecutando el comando DEBUGIN, el cual recibe un valor enviado por el Transmit windowpane del Debug Terminal y lo almacena en una variable. El valor puede ser usado por el programa PBASIC. Esta técnica se usó para establacer el ancho de pulso para controlar y verificar la velocidad y dirección del servo. También se usó como ayuda para la recolección de data para trazar la curva de transferencia de un Continuous Rotation Servo.

Preguntas 1. ¿Cuáles son algunos síntomas de un bajón en el Boe-Bot? 2. ¿Cómo se puede usar un piezobocina para detectar un bajón? 3. ¿Qué es un reset? 4. ¿Qué es una rutina de inicialización? 5. ¿Cuáles son tres (o más) posibles errores que pueden ocurrir cuando se

desconectan y reconectan los servos? 6. ¿Qué comando tienes que usar para cambiar el programa RightServoTest.bs2

para probar la rueda izquierda en lugar de la derecha?


Ejercicios 1. Escribe un comando FREQOUT que emita un tono que suene diferente al tono de

detección de reset para que marque el final de un programa. 2. Escribe un comando FREQOUT que emita un tono (diferente a los de inicio y

final) que marque que un paso intermedio en un programa se ha completado. Prueba un valor con 100 ms de duración y una frecuencia de 4 kHz.

Proyectos 1. Modifica el programa RightServoTest.bs2 para que emita un tono que marque

que la prueba se completó. 2. Modifica el programa TestServoSpeed.bs2 para que puedas usar DEBUGIN para

introducir el ancho de pulso para los servos izquierdo y derecho así como el número de pulsos que se enviaran en el bucle FOR…NEXT loop. Usa este programa para controlar los movimientos de tu Boe-Bot a través del Transmit windowpane del Debug Terminal.


Soluciones Q1. Los síntomas incluyen comportamiento errático como ir en direcciónes

inesperadas o hacer movimientos confusos. Q2. Un comando FREQOUT al principio de todos los programas del Boe-Bot ocasiona

que la bocina piezoeléctrica emita un tono. Por lo tanto, este tono sonará cada vez que ocurra un reset accidental debido a un bajón.

Q3. Un reset consiste en una interrupción de la energía y en el programa del BASIC Stamp, el cual comienza nuevamente desde el principio.

Q4. Una rutina de inicialización consiste en líneas de código que son usadas al principio del programa. Estas líneas de código se ejecutan cada vez que el programa comienza desde el principio.

Q5. 1. Las líneas de los servos P12 y P13 están intercambiadas. 2. Uno o ambos servos están conectados al contrario, de manera que el código de colores blanco-rojo-negro está de manera incorrecta. 3. El interruptor de energía no está en la posición 2. 4. La batería de 9 V o las baterías AA no están puestas. 5. El potenciómetro de centrado de servos no está ajustado.

Q6. Los comandos PULSOUT se deben cambiar para que se lea PULSOUT 13 en vez de PULSOUT 12.

E1. La clave es modificar el comando FREQOUT usado para el programa

StartResetIndicator.bs2, es decir, FREQOUT, 4, 2000, 3000. Por ejemplo: FREQOUT, 4, 500, 3500 funcionaría.

E2. FREQOUT 4, 100, 4000

P1. La clave para solucionar este programa es añadir la línea del Ejercicio 1 arriba del comando END en el programa RightServoTest.bs2.

' Robotica con el Boe-Bot - Ch03Prj01_TestCompleteTone.bs2 ' Servo derecho se mueve conreloj tres segundos, se detiene por 1 ' segundo, luego se mueve contrareloj tres segundos. Un tono senaliza ' que la prueba ha finalizado. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word


FREQOUT 4, 2000, 3000 ' Senal comienzo de programa. FOR counter = 1 TO 122 ' Conreloj poco menos de 3 segundos. PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 1 TO 40 ' Para 1 segundo. PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 1 TO 122 ' Contrareloj 3 segundos. PULSOUT 12, 850 PAUSE 20 NEXT FREQOUT 4, 500, 3500 ' Senalizacion de final de programa END

P2. Para resolver este problema, el programa TestServoSpeed.bs2 debe ser

expandido para recibir data: ancho de pulso del servo izquierdo, ancho de pulso del servo derecho y número de pulsos. Luego, un bucle FOR…NEXT con dos comandos PULSOUT para los servos deben ser añadidos para que los sevomotores se muevan. Aún más, todas las variables deben declararse al principio del programa. Un ejemplo de solución es el siguiente programa.

' Robotica con el Boe-Bot - Ch03Prj02_DebuginMotion.bs2 ' Ingresa el ancho de pulso del servo y la duracion para ambas ruedas a ' traves del Debug Terminal. '$STAMP BS2 '$PBASIC 2.5 ltPulseWidth VAR Word ' Ancho de pulso servo izq rtPulseWidth VAR Word ' Ancho de pulso servo der pulseCount VAR Byte ' Numero de pulsos para el servo counter VAR Word ' Contador de bucle DO DEBUG "Enter left servo pulse width: " ' Ingresa valores al Debug DEBUGIN DEC ltPulseWidth ' Terminal DEBUG "Enter right servo pulse width: " DEBUGIN DEC rtPulseWidth DEBUG "Enter number of pulses: "


DEBUGIN DEC pulseCount FOR counter = 1 TO pulseCount ' Numero de pulsos especifico PULSOUT 13, ltPulseWidth ' Mocion servo izq PULSOUT 12, rtPulseWidth ' Mocion servo der PAUSE 20 NEXT LOOP

Nota: Este proyecto se verifica mejor con las ruedas del Boe-Bot suspendidas.

Capítulo 4: Navegación del Boe-Bot · Page 127

Capítulo 4: Navegación del Boe-Bot El Boe-Bot puede ser programado para realizar una variedad de maniobras. Las maniobras y técnicas de programación introducidas en este capítulo serán usadas nuevamente en capítulos posteriores. La única diferencia es que en este capítulo, el Boe-Bot realizará las maniobras a ciegas. En capítulos posteriores, el Boe-Bot realizará maniobras similares en respuesta a condiciones detectadas con sus sensores. Este capítulo también introduce formas para entonar y calibrar la navegación del Boe-Bot. Entre ellas están técnicas de enderezar la línea recta del Boe-Bot, giros más precisos y cálculo de distancias.

Actividad Resumen

1 Programa el Boe-Bot para realizar las actividades básicas: adelante, atrás, rota a la izquierda, rota a la derecha y giros sobre sí mismo.

2 Entona las maniobras de la Actividad 1 para que sean más precisas. 3 Usa las matemáticas para calcular el número de pulsos que se deben enviar

para hacer que el Boe-Bot recorra una distancia predeterminada. 4 En lugar de programar al Boe-Bot para que arranque y frene abruptamente,

escribe programas para que el Boe-Bot comience o termine una maniobra acelerando o desacelerando gradualmente.

5 Escribe subrutinas para realizar las maniobras básicas de tal manera que cada subrutina pueda ser utilizada una y otra vez en un programa.

6 Registra maniobras complicadas en la memoria de programa sin usar del módulo BASIC Stamp y escribe programas que reproducen estas maniobras.

ACTIVIDAD #1: MANIOBRAS BASICAS CON EL BOE-BOT La Figura 4-1 muestra el frente, la parte trasera, izquierda y derecha de tu Boe-Bot. Cuando el Boe-Bot avanza, en la imagen, debe rodar hacia la derecha de la página. El retroceso debe ser hacia la parte izquierda. Un giro hacia la izquierda debe hacer que el Boe-Bot de vuelta hacia la parte de arriba de la página y un giro a la derecha debería dejarlo viendo hacia la parte de abajo de la página.


Figura 4-1 Tu Boe-Bot y las direcciones de manejo

Avanzando

He aquí algo curioso: para hacer que el Boe-Bot avance, La rueda izquierda del Boe-Bot debe girar contrareloj, pero su rueda derecha debe hacerlo conreloj. Si todavía no has comprendido esto, observa la Figura 4-2 y ve si puedes convencerte de que es cierto. Observada desde la izquierda, la rueda tiene que girar contrareloj para que el Boe-Bot avance. Observada desde la derecha, la otra rueda debe girar conreloj para que el Boe-Bot avance.

Figura 4-2 Rotación de las ruedas para movimiento de avance

Lado izquierdo Lado derecho Recuerda del Capítulo 2 que el argumento Duration del comando PULSOUT controla la velocidad y la dirección del giro del servo. Los argumentos StartValue y EndValue de un bucle FOR…NEXT controlan el número de pulsos que se envían. Dado que cada pulso

Adelante

Counterclockwise

Adelante

Clockwise

Adelante Retroceso

Giro a la izq

Giro a la der


toma la misma cantidad de tiempo, el argumento EndValue también controla la cantidad de tiempo durante la cual el servo funciona. He aquí un programa de ejemplo que hará que el Boe-Bot ruede hacia adelante durante unos tres segundos.

Programa de ejemplo: BoeBotForwardThreeSeconds.bs2

√ Asegúrate de que la energía esté conectada a la BASIC Stamp y los servos. √ Introduce, guarda y ejecuta el programa BoeBotForwardThreeSeconds.bs2.

' Robotica con el Boe-Bot - BoeBotForwardThreeSeconds.bs2 ' Hace que el Boe-Bot avance por 3 segundos. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. FOR counter = 1 TO 122 ' Mueve servos por 3 segundos. PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT END

Funcionamiento del Programa BoeBotForwardThreeSeconds.bs2

Desde el capítulo 2, ya tienes bastante experiencia con elementos de este programa: declaración de una variable, un bucle FOR…NEXT, comandos PULSOUT con argumentos Pin y Duration, y comandos PAUSE. He aquí un repaso de lo que hace cada uno y cómo se relaciona con los movimientos del servo. Primero se declara una variable a ser usada en el bucle FOR...NEXT.

counter VAR Word

Deberías reconocer este comando; genera un tono para señalar el comienzo del programa. Se usará en todos los programas que ejecuten los servos.

FREQOUT 4, 2000, 3000 ' Senal comienzo del programa.


Este bucle FOR…NEXT envía 122 grupos de pulsos a los servos, uno a P13 y uno a P12, haciendo pausas de 20 ms después de cada grupo y luego volviendo al principio del bucle.


PULSOUT 13, 850 produce que el servo izquierdo gire contrareloj mientras que PULSOUT 12, 650 produce que el servo derecho gire conreloj. Por lo tanto, ambas ruedas estarán girando hacia el extremo posterior del Boe-Bot, produciendo un movimiento de avance. El bucle FOR…NEXT tarda unos 3 segundos para ejecutarse 122 veces, por lo que el Boe-Bot avanzará durante unos 3 segundos.

Tu Turno – Ajustando la distancia y la velocidad

√ Cambiando el argumento EndValue del bucle FOR…NEXT de 122 a 61, puedes hacer que el Boe-Bot avance durante la mitad del tiempo. Así, el Boe-Bot avanzará la mitad de la distancia.

√ Guarda el programa BoeBotForwardThreeSeconds.bs2 con un nuevo nombre. √ Cambia el EndValue del bucle FOR...NEXT de 122 a 61. √ Ejecuta el programa y verifica que avanzó la mitad de la distancia en la mitad del

tiempo. √ Intenta estos pasos nuevamente, pero esta vez, cambia el EndValue del bucle

FOR…NEXT a 244. Los argumentos Duration del comando PULSOUT, con valored respectivos 650 y 850, provocaron que los servos giraran a una velocidad cercana a su máxima velocidad. Acercando los argumentos Duration del comando PULSOUT al valor 750, el cual indica a los servos que no se muevan, te permite reducir la velocidad de tu Boe-Bot.

√ Modifica tu programa con los comandos PULSOUT: PULSOUT 13, 780 PULSOUT 12, 720

√ Ejecuta el programa y verifica que tu Boe-Bot se mueve más lentamente.


Retrocediendo, girando y rotando sobre sí mismo

Lo único que necesitas hacer para obtener los otros movimientos de tu Boe-Bot es tomar diferentes combinaciones de los argumentos Duration del comando PULSOUT. Por ejemplo, estos dos comandos PULSOUT pueden ser usados para hacer que tu Boe-Bot retroceda:

PULSOUT 13, 650 PULSOUT 12, 850

Estos dos comandos harán que tu Boe-Bot realice un giro hacia la izquierda (contrareloj si lo miras desde arriba):


Estos dos comandos harán que tu Boe-Bot realice un giro a la derecha (conreloj si lo miras desde arriba):


Puedes combinar todos estos comandos en un solo programa que hará que el Boe-Bot avance, gire a la izquierda, luego a la derecha y finalmente retroceda.

Programa de ejemplo: ForwardLeftRightBackward.bs2

√ Introduce, guarda y ejecuta ForwardLeftRightBackward.bs2.

CONSEJO – Para escribir este programa rápidamente, usa el menú de herramientas de edición del BASIC Stamp Editor (copiar y pegar) para hacer cuatro copias del bucle FOR…NEXT. Luego, ajusta sólo los valores del PULSOUT Duration y el EndValues del bucle FOR…NEXT.

' Robotica con el Boe-Bot - ForwardLeftRightBackward.bs2 ' Mueve hacia adelante, izq., der., y atras para ensayar y entonar. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FREQOUT 4, 2000, 3000 ' Senal comienzo del programa.


FOR counter = 1 TO 64 ' Adelante PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 FOR counter = 1 TO 24 ' Rota izq. – aprox. 1/4 de vuelta PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 FOR counter = 1 TO 24 ' Rota der. – aprox. 1/4 de vuelta PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT PAUSE 200 FOR counter = 1 TO 64 ' Atras PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT END

Tu Turno – Pivoteando

Puedes hacer que el Boe-Bot rote por medio de un pivoteo alrededor de una rueda. El truco está en hacer que una de las ruedas permanezca quieta mientras la otra gira. Por ejemplo, si mantienes la rueda izquierda quieta mientras la derecha gira conreloj (hacia adelante), el Boe-Bot rotará sobre sí mismo hacia la izquierda.



Si quieres que rote sobre sí mismo hacia adelante y la derecha, simplemente detienes la rueda derecha y haces que la rueda izquierda gire contrareloj (hacia adelante).


Estos son los comandos PULSOUT para que rote sobre sí mismo hacia atrás y a la derecha. PULSOUT 13, 650 PULSOUT 12, 750

Finalmente, estos son los comandos PULSOUT para que rote sobré sí mismo hacia atrás y a la izquierda.


√ Guarda el programa ForwardLeftRightBackward.bs2 como PivotTests.bs2. √ Substituye los comandos PULSOUT que acabas de ver por las rutinas avance,

izquierda, derecha y retroceso. √ Ajusta el tiempo de ejecución para cada maniobra cambiando cada EndValue del

bucle FOR…NEXT a 30. √ Asegúrate de cambiar el comentario al lado de cada bucle FOR…NEXT para que

refleje las nuevas acciones. √ Ejecuta el programa y verifica que cada uno de los movimientos de giro sobre sí

mismo funcionan.

ACTIVIDAD #2: ENTONANDO LAS MANIOBRAS BASICAS Imagina escribir un programa que le indica al Boe-Bot que avance a toda velocidad durante 15 segundos. ¿Qué pasa si el Boe-Bot se desvía un poco hacia la derecha o la izquierda durante este trayecto cuando se supone que debía avanzar en línea recta? No es necesario desarmar el Boe-Bot y volver a ajustar los servos con el destornillador para arreglar esto. Simplemente puedes ajustar levemente el programa para que las ruedas del Boe-Bot se desplacen a la misma velocidad. Mientras la solución que involucra el uso del destornillador se denomina “ajuste de hardware”, la solución a través de la revisión del programa se denomina “ajuste de software”.

Enderezando el Camino del BOE-BOT

El primer paso es examinar el trayecto de tu Boe-Bot durante suficiente tiempo para averiguar si la desviación es hacia la izquierda o la derecha cuando debería ir en línea recta. Diez segundos de avance deberían ser suficientes. Esto se puede lograr con una


simple modificación del programa BoeBotForwardThreeSeconds.bs2 de la actividad previa.

Programa de ejemplo: BoeBotForwardTenSeconds.bs2

√ Abre el BoeBotForwardThreeSeconds.bs2. √ Cámbiale el nombre y guárdalo como BoeBotForwardTenSeconds.bs2. √ Cambia el EndValue del FOR counter de 122 a 407, para que quede así:

' Robotica con el Boe-Bot - BoeBotForwardTenSeconds.bs2 ' Hace que el Boe-Bot ruede hacia adelante por 10 segundos. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. FOR counter = 1 TO 407 ' Numero de pulsos – tiempo de ' corrida. PULSOUT 13, 850 ' Servo izq., velocidad max CNR. PULSOUT 12, 650 ' Servo der., velocidad max CTR. PAUSE 20 NEXT END

√ Ejecuta el programa y observa cuidadosamente para ver si tu Boe-Bot se desvía

hacia la derecha o la izquierda mientras avanza durante diez segundos.

Tu Turno – Ajustando la Velocidad del Servo para Enderezar el Recorrido del Boe-Bot

Si tu Boe-Bot avanza perfectamente derecho, prueba este ejemplo de todas maneras. Si sigues las instrucciones, debería ajustar tu Boe-Bot para que se desvíe ligeramente hacia la derecha.

Digamos que el Boe-Bot gira levemente hacia la izquierda. Existen dos maneras de ver este problema: la rueda izquierda está girando lentamente o la derecha, rápidamente. Dado que el Boe-Bot ya está avanzando a toda velocidad, aumentar la velocidad de la


rueda izquierda no resulta práctico, pero desacelerar la derecha debería ayudar a resolver el problema. Recuerda que el límite de velocidad del servo está determinado por el argumento Duration del comando PULSOUT. Mientras más cercano sea el valor de Duration a 750, más lento girará el servo. Esto significa que deberías cambiar el valor 650 en el comando PULSOUT 12,650 a algo más cercano a 750. Si el Boe-Bot se encuentra sólo un poco fuera de curso, tal vez PULSOUT 12,663 solucione el problema. Si los servos están muy desfasados, tal vez podría usarse PULSOUT 12,690. Probablemente te tome varios intentos encontrar el valor adecuado. Digamos que el primer intento es PULSOUT 12,663, pero resulta que no es suficiente porque el Boe-Bot todavía se desvía un poco hacia la izqierda. Entonces intentas PULSOUT 12,670. Tal vez esto lo sobrecorrija y resulta que PULSOUT 12,665 es la solución. Esto es lo que se llama un proceso iterativo, es decir un proceso que requiere múltiples intentos y refinamientos para llegar al valor adecuado.

Si tu Boe-Bot se desvía hacia la derecha en vez de la izquierda, significa que tienes que desacelerar la rueda izquierda reduciendo el Duration de 850 en el comando PULSOUT 13,850. Nuevamente, mientras más cercano es el valor a 750, más lento será el movimiento del servo.

√ Modifica el programa BoeBotForwardTenSeconds.bs2 para que indique al Boe-

Bot avanzar en línea recta. √ Usa teipe o un marcador para etiquetar cada servo con los mejores valores

PULSOUT. √ Si tu Boe-Bot no necesita ajustes para avanzar en línea recta, intenta estas

modificaciones para ver los resultados. Debería provocar que el Boe-Bot se desplace describiendo una curva en lugar de una línea recta.

Puede que te des cuenta de que ocurre una situación completamente distinta cuando programas tu Boe-Bot para que se desplace en retroceso.

√ Modifica el programa BoeBotForwardTenSeconds.bs2 para que indique al Boe-Bot que se desplace en retroceso durante diez segundos.

√ Repita la verificación para la trayectoria en línea recta.


√ Repite los pasos para corregir el argumento Duration del comando PULSOUT para enderezar el recorrido en retroceso del Boe-Bot.

Entonando los Giros

Los ajustes de software también pueden usarse para que el Boe-Bot gire en un ángulo deseado, por ejemplo 90°. El tiempo que el Boe-Bot rota sobre sí mismo determina cuánto gira. Dado que el bucle FOR…NEXT controla el tiempo, puedes ajustar el argumento EndValue del bucle FOR…NEXT para acercarte bastante al ángulo de giro que deseas. He aquí una rutina de giro a la izquierda del programa ForwardLeftRightBackward.bs2.

FOR counter = 1 TO 24 ' Rota izq. – aprox. 1/4 de vuelta PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT

Digamos que el Boe-Bot rota un poco más de 90° (1/4 de una circunferencia completa). Intenta FOR counter = 1 TO 23, o tal vez, FOR counter = 1 TO 22. Si no rota lo suficiente, aumenta el tiempo de giro incrementando el valor EndValue del bucle FOR…NEXT al valor que se necesite para completar el cuarto de giro. Si llegas a un valor que se pasa ligeramente de 90° y otro que no llega al ángulo deseado por muy poco, intenta eligiendo el valor que se pase ligeramente, y luego desacelere levemento los servos. En el caso de rotación a la izquierda, ambos argumentos Duration del comando PULSOUT deberían cambiarse de 650 a un valor más cercano a 750. Como con los ejercicios en línea recta, éste también va a ser un proceso iterativo.

Tu Turno – Giro de 90°

√ Modifica el programa ForwardLeftRightBackward.bs2 para que realice giros precisos 90° .

√ Actualiza el programa ForwardLeftRightBackward.bs2 con los valores PULSOUT que determinaste para trayectos de avance y retroceso en línea recta.

√ Actualiza la etiqueta en cada servo con la notación acerca del valor EndValue apropiado para un giro de 90°.


Las alfombras pueden producir errores de navegación. SI estás usando tu Boe-Bot sobre una alfombra, ¡No esperes resultados perfectos! Una alfombra es como el green en un campo de golf – las fibras de la alfombra pueden afectar la forma en que tu Boe-Bot se desplaza, especialmente en distancias largas. Para maniobras más precisas, usa una superficie más lisa.

ACTIVIDAD #3: CALCULANDO DISTANCIAS En muchos concursos de robótica una navegación más precisa es meritoria de un mejor puntaje. Un tipo de concurso de robótica popular es llamado dead reckoning (cálculo a ojo, o, navegación a estima, en inglés). El propósito de este concurso es hacer que tu robot vaya a una o más localidades y luego regrese exactamente al lugar de donde comenzó. Probablemente recuerdas haberle preguntado a tus padres, una y otra vez, en la vía hacia un lugar de vacaciones o a casa de un familiar, la siguiente pregunta:

“¿Ya llegamos?” Tal vez, después de ser mayor y haber aprendido a dividir en la escuela, comenzaste a leer las señales en la carretera para ver qué tan lejos estaba la ciudad de destino. Luego, veías el velocímetro del carro. Dividiendo la distancia por la velocidad podías obtener un buen estimado del tiempo que tardarían en llegar. Seguramente no estabas pensando en estos términos, pero esta es la ecuación que estabas utilizando.

speeddistancetime =


Ejemplo – Tiempo para distancias en millas

Si estás a 140 millas de tu destino y viajas a 70 millas por hora, te va a tomar 2 horas llegar.

hours2miles70hour1miles140

miles/hour 70miles 140time

=

×=

=

Ejemplo – Tiempo para el sistema métrico decimal

Si estás a 200 kilómetros de tu destino y viajas a 100 kilómetros por hora, te va a tomar 2 horas llegar.

hours2km100

hour1km200

/hourkilometers 100kilometers 200time

=

×=

=

Puedes hacer el mismo ejercicio con el Boe-Bot, sólo que tienes control sobre la distancia a la que se encuentra de su destino. He aquí la ecuación que vas a utilizar:

Bot-BoedelvelocidadBot-Boe del distancia

=servodecorridadetiempo

Tendrás que verificar la velocidad de tu Boe-Bot. La forma más fácil de hacerlo es colocar el Boe-Bot al lado de una regla y hacer que avance durante un segundo. Midiendo cuán lejos avanzó tu Boe-Bot, sabrás su velocidad. Si tu regla está marcada en pulgadas tu respuesta estará dada en pulgadas por segundo (in/s), si está marcada con centímetros tu respuesta estará dada en centímetros por segundo (cm/s).

√ Introduce, guarda y ejecuta el programa ForwardOneSecond.bs2. √ Coloca tu Boe-Bot al lado de una regla como se muestra en la Figura 4-3. √ Asegúrate de alinear el punto donde la rueda toca el piso con el 0 de la regla.


Figura 4-3: Midiendo el recorrido del Boe-Bot


Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC


P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2© 2000-2003

Vdd


X2

X3Vdd VssVin

Rev C

1 2 3 4 5 61 2 3 4 5 6 7 8 9 10 11 12 13 14 15

inch

cm

7 8 9 1016 17 18 19 20 21 22 23 24 25

Measured Distance

√ Presiona el botón Reset en tu plaqueta para volver a ejecutar el programa. √ Mide cuán lejos avanzó tu Boe-Bot e indica la distancia hasta el sitio donde la

rueda está haciendo contacto con el piso:__________________ in / cm.

Programa de ejemplo: ForwardOneSecond.bs2 ' Robotica con el Boe-Bot - ForwardOneSecond.bs2 ' Mueve el Boe-Bot hacia adelante pro un segundo. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. FOR counter = 1 TO 41 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT END


También puedes pensar en la distancia que acabas de marcar como la velocidad de tu Boe-Bot, en unidades por segundo. Digamos que tu Boe-Bot avanzó 9 in (23 cm). Ya que esta prueba demoró un segundo, significa que tu Boe-Bot avanza a una velocidad alrededor de 9 in/s (23 cm/s). Ahora, puedes calcular cuántos segundos necesita tu Boe-Bot para avanzar una distancia determinada.

Pulgadas y centímetros por segundo – La abreviatura para pulgadas en inglés es in., la abreviatura para centímetros es cm. De manera análoga, pulgadas por segundo se abrevia in/s y centímetros se abrevia cm/s. Ambas son medidas que indican velocidad, las cuales son apropiadas para el Boe-Bot. Hay 2.54 cm en 1 in. Puedes convertir de pulgadas a centímetros multiplicándo el número de pulgadas por 2.54. Puedes convertir los centímetros en pulgadas dividiendo el número de centímetros por 2.54.

Ejemplo – tiempo para 20 in

A 9 in/s, tu Boe-Bot tiene que avanzar durante 2.22 s para avanzar 20 in.

s22.2in 9s1in 20

in/s 9in 20time

=

×=

=

Ejemplo – tiempo para 51 cm

A 23 cm/s, tu Boe-Bot tiene que avanzar durante 2.22 s para avanzar 51 cm.

s22.2cm 23s1cm 15

cm/s 23cm 51time

=

×=

=

En el Capítulo 2, Actividad #6, aprendimos que la ejecución de dos comandos PULSOUT y uno PAUSE, en un bucle FOR…NEXT, tarda 24.6 ms (0.024 s). El recíproco de este valor equivale al número de pulsos por segundo que el bucle trasmite a cada servo. El recíproco de un número es el resultado obtenido al invertir numerador y denominador de una fracción. Otra forma de obtener un recíproco es dividir uno entre un número o una fracción. En otras palabras, 1 ÷ 0.024 s/pulso = 40.65 pulsos/s. Dado que conoces la cantidad de tiempo durante la que quieres que tu Boe-Bot avance (2.22 s) y el número de impulsos que el BASIC Stamp manda a los servos cada segundo (40.65 pulsos/s), puedes usar estos valores para calcular cuántos pulsos se deben mandar a los servos. Este es el número que debes usar en tu argumento EndValue del bucle FOR…NEXT.


pulses90pulses...24.90

spulses65.40s22.2ulsesp

≈=

×=

Los cálculos en este ejemplo requirieron dos pasos. Primero, calcula cuánto tiempo deben desplazarse los servos para que el Boe-Bot avance una cierta distancia, luego calcula cuántos pulsos necesitas para que los servos se desplacen durante ese periodo de tiempo. Dado que sabes que tienes que multiplicar por 40.65 para convertir tiempo de desplazamiento, en pulsos; puedes reducir la operación a un sólo paso.

spulses65.40

speedBotBoecetandisBotBoeulsesp ×

−−

=

Ejemplo – tiempo para 20 in

A 9 in/s, tu Boe-Bot tiene que avanzar durante 2.22 s para avanzar 20 in.


pulses65.40920s1pulses65.40

in 9 s1in 20

spulses65.40

in/s 9in 20ulsesp

≈=

×÷=

××=

×=

Ejemplo – tiempo para 51 cm

A 23 cm/s, tu Boe-Bot tiene que avanzar durante 2.22 s para avanzar 51 cm.


pulses65.402351s1pulses65.40

cm23 s1cm15

spulses65.40

cm/s 23cm 51ulsesp

≈=

×÷=

××=

×=

Tu Turno – La Distancia de tu Boe-Bot

Ahora, es momento de intentar esto con distancias que tú elijas.

√ Si todavía no lo has hecho, usa una regla y el programa ForwardOneSecond.bs2 para determinar la velocidad de tu Boe-Bot en in/s o cm/s.

√ Decide cuán lejos quieres que tu Boe-Bot avance. √ Usa la ecuación de pulsos para calcular cuántos pulsos deben ser enviados a los

servos del Boe-Bot:

spulses65.40

speedBotBoecetandisBotBoeulsesp ×

−−

=


√ Modifica el programa BoeBotForwardOneSecond.bs2 para que envíe el número de pulsos que determinaste para recorrer tu distancia.

√ Ejecuta el programa y verifica que tan cerca estuviste.

Esta técnica tiene margen de error. La actividad que acabas de terminar no toma en cuenta el hecho de que hace falta un cierto número de pulsos para lograr que el Boe-Bot llegue a su velocidad máxima. Tampoco tomó en cuenta la distancia que pueda recorrer el Boe-Bot antes de frenar por completo. Las velocidades del servo también serán más bajas a medida que las baterías pierden su carga.

Puedes reducir el margen de error de las distancias de tu Boe-Bot con dispositivos llamados encoders (codificadores de giro, en inglés), que cuentan el número de orificios de las ruedas dell Boe-Bot a medida que van pasando. Hardware, documentación y programas ejemplo de estos dispositivos se pueden encontrar en la página Robotics Accessories del sitio www.parallax.com.

ACTIVIDAD #4: MANIOBRAS – ACELERACION GRADUAL Ramping (gradualmente, o, en rampa, en inglés) es una forma de acelerar o desacelerar gradualmente la velocidad de los servos en lugar de arrancar o frenar abruptamente. Esta técnica puede aumentar la vida de las baterías y servos de tu Boe-Bot.

Programando para Aceleración Gradual

La clave para una aceleración gradual es usar variables en conjunto con el argumento Duration del comando PULSOUT. La Figura 4-4 muestra un bucle FOR…NEXT que puede aumentar gradualmente la velocidad del Boe-Bot desde 0 hasta la velocidad máxima hacia adelante. Cada vez que el bucle FOR…NEXT se repite, la variable pulseCount aumenta en 1. La primera vez en el bucle, pulseCount es 1, así que equivale a usar los comandos PULSOUT 13, 751 y PULSOUT 12, 749. La segunda vez en el bucle, el valor de pulseCount es 2, así que equivale a usar los comandos PULSOUT 13, 752 y PULSOUT 12, 748. Mientras el valor de la variable pulseCount aumenta, también lo hace la velocidad de los servos. Cuando el bucle se encuentre en su centésima iteración, la variable pulseCount es 100, así que quivale a usar los comandos PULSOUT 13, 850 y PULSOUT 12, 650, lo cual representa la máxima velocidad hacia adelante del Boe-Bot.


pulseCount VAR Word FOR pulseCount = 1 TO 100 PULSOUT 13, 750 + pulseCount PULSOUT 12, 750 - pulseCount PAUSE 20 NEXT

Figura 4-4 Ejemplo de aceleración gradual

Recuerda del Capítulo 2, Actividad #5, que los bucles FOR…NEXT también pueden contar en forma decreciente. Puede usar esto para ramp la velocidad en forma decreciente usando FOR pulseCount = 100 TO 1. He aquí un programa de ejemplo que usa bucles FOR…NEXT para ramp hasta la velocidad máxima y luego ramp hasta frenar.

Programa de ejemplo: StartAndStopWithRamping.bs2

√ Introduce, guarda y ejecuta el programa StartAndStopWithRamping.bs2. √ Verifica que el Boe-Bot acelera gradualmente hasta alcanzar la velocidad

máxima, se mantiene así por un rato y luego desacelera gradualmente hasta frenar por completo.

' -----[ Titulo ]------------------------------------------------------------- ' Robotica con el Boe-Bot - StartAndStopWithRamping.bs2 ' Acelera gradualmente, avanza, desacelera gradualmente. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" pulseCount VAR Word ' Contador para bucle FOR...NEXT ' -----[ Initializacion ]---------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Main Routine ]------------------------------------------------------- ' Ramp up forward. FOR pulseCount = 1 TO 100 ' Bucle acelera gradualmente 100 pulsos. PULSOUT 13, 750 + pulseCount ' Pulso = 1.5 ms + pulseCount. PULSOUT 12, 750 - pulseCount ' Pulso = 1.5 ms – pulseCount. PAUSE 20 ' Pausa por 20 ms.

1, 2, 3, …100


NEXT ' Avanza por 75 pulsos. FOR pulseCount = 1 TO 75 ' Bucle manda 75 pulsos de avance. PULSOUT 13, 850 ' Pulso de 1.7 ms a servo izq. PULSOUT 12, 650 ' Pulso de 1.3 ms a servo der. PAUSE 20 ' Pausa por 20 ms. NEXT ' Desacelera gradualmente avanzando hasta dentenerse completamente. FOR pulseCount = 1 TO 100 ' Bucle desacelera gradualmente 100 pulsos. PULSOUT 13, 750 + pulseCount ' Pulso = 1.5 ms + pulseCount. PULSOUT 12, 750 - pulseCount ' Pulso = 1.5 ms - pulseCount. PAUSE 20 ' Pausa por 20 ms. NEXT END ' Se detiene hasta un reset.

Tu Turno

También puedes crear rutinas para combinar aceleración gradual ascendente o descendente con otras maniobras. He aquí un ejemplo sobre cómo acelerar gradualmente hasta la velocidad máxima retrocediendo en vez de avanzando. La única diferencia entre esta rutina y la rutina original de avance es que el valor de pulseCount en el comando PULSOUT 13 es restado a 750, en vez de ser sumado como antes. De manera análoga, en el comando PULSOUT 12 se suma a 750 el valor de pulseCount, el cual antes era restado.

' Acelera gradualmente hasta vel. maxima iendo hacia atras FOR pulseCount = 1 TO 100 PULSOUT 13, 750 - pulseCount PULSOUT 12, 750 + pulseCount PAUSE 20 NEXT

También puedes crear una rutina para realizar gradualmente un giro, sumando el valor de pulseCount a 750 en los dos comandos PULSOUT. Restando pulseCount a 750 en los dos comandos PULSOUT, puedes realizar un giro gradual en la otra dirección. He aquí un


ejemplo de un cuarto de giro con rotación gradual. Los servos no tienen la oportunidad de llegar a la velocidad máxima antes de tener que desacelerar otra vez.

' Gradualmente acelera rotando hacia la derecha. FOR pulseCount = 0 TO 30 PULSOUT 13, 750 + pulseCount PULSOUT 12, 750 + pulseCount PAUSE 20 NEXT ' Gradualmente desacelera rotando hacia la derecha. FOR pulseCount = 30 TO 0 PULSOUT 13, 750 + pulseCount PULSOUT 12, 750 + pulseCount PAUSE 20 NEXT

√ Abre el programa ForwardLeftRightBackward.bs2 de la Actividad #1 y guárdalo como ForwardLeftRightBackwardRamping.bs2.

√ Modifica el nuevo programa para que el Boe-Bot acelere gradualmente para comenzar y terminar cada maniobra. Consejo: podrías utilizar los fragmentos de código anteriores y fragmentos similares del programa StartAndStopWithRamping.bs2.

ACTIVIDAD #5: SIMPLIFICANDO LA NAVEGACION CON SUBRUTINAS En el siguiente capítulo, tu Boe-Bot tendrá que realizar maniobras para evadir obstáculos. Uno de los ingredientes clave para evadir obstáculos es ejecutar las maniobras preprogramadas. Una forma de ejecutar maniobras preprogramadas es con subrutinas. Esta actividad introduce subrutinas y también dos enfoques diferentes hacia la creación de maniobras reusables con subrutinas.

Dentro de la Subrutina

Una subrutina de PBASIC tiene dos partes. La primera es la llamada a la Subrutina. Esto consiste en el comando en el programa que le dice que salte a la parte reusable del código, y que luego vuelva cuando haya terminado. La otra parte es la subrutina como


tal. La subrutina comienza con una etiqueta que sirve como su nombre y termina con un comando RETURN. Los comandos entre la etiqueta y el comando RETURN componen el bloque de código que hace el trabajo que quieres que realice la subrutina. La Figura 4-5 muestra un fragmento de un programa de PBASIC que contiene una llamada a subrutina y una subrutina. La llamada a subrutina consiste en el comando GOSUB My_Subroutine. La subrutina en sí, es todo lo que aparece desde la etiqueta My_Subroutine: hasta el comando RETURN. He aquí cómo trabaja. Cuando el programa llega al comando GOSUB My_Subroutine, busca la etiqueta My_Subroutine:. Como se muestra en la flecha (1), el programa salta de la etiqueta My_Subroutine: y comienza a ejecutar comandos. El programa empieza a bajar línea por línea desde la etiqueta, por lo que obtendrás el mensaje “Command in subroutine” en tu Debug Terminal. PAUSE 1000 ocasiona una pausa de un segundo. Entonces, cuando el programa llega al comando RETURN, la flecha (2) muestra como vuelve a saltar al comando inmediatamente después del comando GOSUB. En este caso, es un comando DEBUG el cual despliega el mensaje “After subroutine”.

DO DEBUG "Before subroutine",CR PAUSE 1000 GOSUB My_Subroutine DEBUG "After subroutine", CR PAUSE 1000 LOOP My_Subroutine: DEBUG "Command in subroutine", CR PAUSE 1000 RETURN

Figura 4-5 Subrutinas básicas

Programa de ejemplo – OneSubroutine.bs2

√ Introduce, guarda y ejecuta el programa OneSubroutine.bs2 ' Robotica con el Boe-Bot - OneSubroutine.bs2 ' Este programa demuestra una llamada a subrutina simple. ' $STAMP BS2 ' $PBASIC 2.5

1

2


DEBUG "Before subroutine",CR PAUSE 1000 GOSUB My_Subroutine DEBUG "After subroutine", CR END My_Subroutine: DEBUG "Command in subroutine", CR PAUSE 1000 RETURN

√ Observa tu Debug Terminal y presiona el botón Reset varias veces. Deberías

recibir el mismo grupo de tres mensajes en el mismo orden cada vez. He aquí un programa de ejemplo que tiene dos subrutinas. Una subrutina produce un tono alto mientras que el otro produce un tono bajo. Los comandos entre DO y LOOP llaman cada una de las subrutinas en su turno correspondiente. Prueba este programa y observa su efecto.

Programa de ejemplo – TwoSubroutines.bs2

√ Introduce, guarda y ejecuta el programa TwoSubroutines.bs2 ' Robotica con el Boe-Bot - TwoSubroutines.bs2 ' Este programa demuestra que una subrutina es un bloque de comandos ' reusables. ' $STAMP BS2 ' $PBASIC 2.5 DO GOSUB High_Pitch ' Llamada a la subrutina High_Pitch DEBUG "Back in main", CR ' Muestra este mensaje al regresar PAUSE 1000 GOSUB Low_Pitch ' LLamada a la subrutina Low_Pitch DEBUG "Back in main again", CR ' Muestra este mensaje al regresar otra vez PAUSE 1000 DEBUG "Repeat...",CR,CR LOOP High_Pitch: ' Etiqueta de la subrutina DEBUG "High pitch", CR ' Bloque de FREQOUT 4, 2000, 3500 ' codigo de la subrutina RETURN


Low_Pitch: ' Etiqueta de la subrutina DEBUG "Low pitch", CR ' Bloque de FREQOUT 4, 2000, 2000 ' codigo de la subrutina RETURN

Intentemos las rutinas de navegación adelante, izquierda, derecha y atrás dentro de las subrutinas. He aquí un ejemplo:

Programa de ejemplo – MovementsWithSubroutines.bs2

√ Introduce, guarda y ejecuta el programa MovementsWithSubroutines.bs2. Consejo: puedes utilizar el menú Edit del BASIC Stamp Editor para copiar y pegar bloques de código de un programa a otro.

' Robotica con el Boe-Bot - MovementsWithSubroutines.bs2 ' Convierte los movimientos de avance, izquierda, derecha, retroceso, a ' subrutinas reusables. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. GOSUB Forward GOSUB Left GOSUB Right GOSUB Backward END Forward: FOR counter = 1 TO 64 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT PAUSE 200 RETURN Left: FOR counter = 1 TO 24 PULSOUT 13, 650 PULSOUT 12, 650


PAUSE 20 NEXT PAUSE 200 RETURN Right: FOR counter = 1 TO 24 PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT PAUSE 200 RETURN Backward: FOR counter = 1 TO 64 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

Deberías reconocer el patrón de movimientos que realiza el Boe-Bot; es el mismo realizado por el programa ForwardLeftRightBackward.bs2. Por supuesto, existen varias formas de estructurar un programa que tenga como resultado los mismos movimientos. A continuación se presenta un tercer enfoque.

Programa de ejemplo – MovementsWithVariablesAndOneSubroutine.bs2

He aquí otro programa de ejemplo que le indica al Boe-Bot que realice las mismas maniobras, pero sólo utiliza una subrutina y algunas variables. Seguramente ya habrás notado a estas alturas que cada maniobra del Boe-Bot ha sido lograda con bloques de código similares. Compara estos dos fragmentos:

' Adelante max. velocidad FOR counter = 1 TO 64 PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT

' Desaceleracion gradual desde maxima ' velocidad en retroceso FOR pulseCount = 100 TO 1 PULSOUT 13, 750 - pulseCount PULSOUT 12, 750 + pulseCount PAUSE 20 NEXT


Lo que causa que estos dos bloques de códigos ejecuten maniobras diferentes son los cambios en los argumentos StartValue y EndValue del comando FOR, y los argumentos Duration del comando PULSOUT. Estos argumentos pueden ser variables y estas variables pueden ser cambiadas repetidamente durante la ejecución del programa para generar diferentes maniobras. En lugar de usar subrutinas separadas, con argumentos Duration del comando PULSOUT específicos para cada maniobra, el siguiente programa usa la misma subrutina una y otra vez. La clave para realizar diversas maniobras es establacer las variables con los valores correctos para las maniobras que quieres obtener antes de llamar la subrutina.

√ Introduce, guarda y ejecuta el programa MovementWithVariablesAndOneSubroutine.bs2.

' Robotica con el Boe-Bot - MovementWithVariablesAndOneSubroutine.bs2 ' Rutina de navegacion que acepta parametros. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" counter VAR Word pulseLeft VAR Word pulseRight VAR Word pulseCount VAR Byte FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' Adelante pulseLeft = 850: pulseRight = 650: pulseCount = 64: GOSUB Navigate ' Vuelta a la izquierda pulseLeft = 650: pulseRight = 650: pulseCount = 24: GOSUB Navigate ' Vuelta a la derecha pulseLeft = 850: pulseRight = 850: pulseCount = 24: GOSUB Navigate ' Retrocede pulseLeft = 650: pulseRight = 850: pulseCount = 64: GOSUB Navigate END Navigate:


FOR counter = 1 TO pulseCount PULSOUT 13, pulseLeft PULSOUT 12, pulseRight PAUSE 20 NEXT PAUSE 200 RETURN

¿Tu Boe-Bot realizó la secuencia ya conocida de adelante-izquierda-derecha-atrás? Este programa puede ser difícil de leer al principio, porque las instrucciones están ordenadas de una forma diferente. En lugar de tener cada declaración de variables y cada comando GOSUB en líneas diferentes, están agrupadas en la misma línea y separadas por dos puntos (:). Aquí, los dos puntos funcionan como un caracter de retorno para separar cada instrucción de PBASIC. Usar los dos puntos de esta manera le permite a todos los valores nuevos de las variables para una determinada maniobra, ser almacenados juntos en una misma línea como una llamada de subrutina.

Tu Turno

He aquí tu concurso "dead reckoning" mencionado anteriormente.

√ Modifica el programa MovementWithVariablesAndOneSubroutine.bs2 para hacer que tu Boe-Bot se desplace en un cuadrado, avanzando de frente en los dos primeros lados y de retroceso en los otros dos. Consejo: necesitarás usar tu propio argumento EndValue del comando PULSOUT, el cual determinaste en la Actividad #2, página 136.

ACTIVIDAD #6: TOPICO AVANZADO – CONSTRUYENDO MANIOBRAS COMPLEJAS EN EEPROM Cuando descargas el programa PBASIC a tu BASIC Stamp, el BASIC Stamp Editor convierte tu programa en valores numéricos llamados tokens. Estos tokens son lo que la BASIC Stamp usa como instrucciones para ejecutar el programa. Son almacenados en uno de los dos chips pequeños en la parte de arriba de tu BASIC Stamp, el que está marcado "24LC16B.” Este chip es un tipo especial de memoria de computadora llamado EEPROM, que son las siglas de electrically erasable programmable read only memory (memoria programable de sólo lectura eléctricamente borrable, en inglés). La EEPROM del BASIC Stamp puede almacenar 2048 bytes (2 kB) de información. Lo que no se usa para almacenamiento de programas (lo cual comienza desde la dirección de memoria 2047 hacia la dirección 0) puede ser usado para almacenamiento de datos (lo cual comienza desde la dirección de memoria 0 hasta la dirección 2047).


Si las data que almacena en el EEPROM choca con tu programa, el programa PBASIC no se ejecutará adecuadamente.

La memoria EEPROM es diferente al almacenamiento de variable RAM (memoria de acceso aleatorio, en inglés) en varios aspectos:

• La EEPROM necesita más tiempo para almacenar un valor, a veces hasta varios milisegundos.

• La EEPROM puede aceptar un número finito de ciclos de escritura, alrededor de 10 millones de escrituras. La RAM tiene capacidades de lectura/escritura ilimitadas.

• La primera función de la EEPROM es almacenar programas; las data pueden ser almacenadas en el espacio sobrante.

Puedes ver los contenidos de la EEPROM del BASIC Stamp en el BASIC Stamp Editor haciendo clic en Run y seleccionando Memory Map. La Figura 4-6 muestra el mapa de memoria para el programa MovementsWithSubroutines.bs2. Observa el mapa condensado de la EEPROM a la izquierda de la figura. El área sombreada en el cuadro pequeño en la parte de abajo muestra el espacio de la EEPROM que ocupa el programa MovementsWithSubroutines.bs2.

Las imágenes del mapa de memoria mostradas en esta actividad fueron tomadas del BASIC Stamp Editor v2.1. Si estás usando una versión anterior del BASIC Stamp Editor, tu mapa de memoria incluirá la misma información, pero tendrá un formato distinto.


Figura 4-6 Mapa de memoria del BASIC Stamp

Mientras estamos aquí, observa también que la variable counter que declaramos tamaño Word se puede ver en el Register 0 (Registro 0, en inglés) del mapa de RAM. Este programa puede haber parecido largo cuando lo estabas escribiendo, pero sólo ocupa 136 de los 2048 bytes disponibles de la memoria de programa. En estos momentos hay suficiente espacio para una larga lista de instrucciones. Como un caracter ocupa un byte de memoria, hay espacio para 1912 instrucciones de un caracter de tamaño para indicar la dirección del Boe-Bot.

Navegación con la EEPROM

Hasta este momento hemos probado tres enfoques de programación diferentes para hacer que tu Boe-Bot se desplace hacia adelante, gire a la izquierda, la derecha y retroceda. Cada técnica tiene sus méritos, pero todo sería muy engorroso si quisieras que tu Boe-Bot ejecutara grupos de maniobras más largos y complejos. El siguiente programa de ejemplo usará el bloque de códigos en subrutinas que ya has usado en varias oportunidades para cada maniobra básica. A cada maniobra se le asigna un código de una letra como referencia. En la EEPROM se pueden almacenar largas listas de estas letras código y luego leerlas y decodificarlas durante la ejecución del programa. Esto evita el tedio de repetir largas listas de subrutinas o tener que cambiar las variables antes de usar cada comando GOSUB.


Este enfoque de programación requiere algunas nuevas instrucciones de PBASIC instructions: la directiva DATA , y los comandos READ y SELECT...CASE...ENDSELECT. Veamos cada una antes de probar el programa de ejemplo. Cada una de las maniobras básicas tiene un código de una sóla letra asignado que corresponderá a tu subrutina: F para Forward (adelante, en inglés), B para Backward (retroceso, en inglés), L para Left_Turn (giro izq., en inglés) y R para Right_Turn (giro der., en inglés). Movimientos complejos del Boe-Bot pueden programarse rápidamente haciendo una secuencia de estas letras códigos. La última letra en la secuencia es una Q, que significa “quit” (abandonar, en inglés) cuando los movimientos terminen. La lista se guarda en la EEPROM durante la descarga del programa con la directiva DATA, lo cual queda como esto:

DATA "FLFFRBLBBQ"

Cada letra es almacenada en un byte de la EEPROM, empezando en la dirección de memoria 0 (a menos que le indiquemos que comience en alguna otra dirección de memoria). El comando READ puede ser utilizado para obtener esta lista desde la EEPROM mientras el programa se ejecuta. Estos valores pueden ser leídos desde dentro de un DO…LOOP como el siguiente:

DO UNTIL (instruction = "Q") READ address, instruction address = address + 1 ' Aca se ingresa el codigo PBASIC, omitido por ahora. LOOP

La variable address es la posición de cada byte en la EEPROM que está almacenando una letra código. La variable instruction almacenará el valor de ese byte, es decir, nuestra letra código. Observa que cada vez que comienza el bucle, el valor de la variable address se incrementa en uno. Esto permitirá que cada letra sea leída desde bytes consecutivos en la EEPROM, empezando desde la dirección de memoria 0.

El comando DO…LOOP tiene condiciones opcionales que son útiles para distintas circunstancias. DO UNTIL (condition)...LOOP permite que el bucle se repita hasta que ocurra una cierta condición. DO WHILE (condition)...LOOP permite que un bucle se repita sólamente mientras exista una cierta condición. Nuestro ejemplo utilizará DO…LOOP UNTIL (condition). En este caso, esto hace que DO…LOOP se repita hasta que se lea el caracter “Q” desde la EEPROM.


Una declaración SELECT...CASE...ENDSELECT puede usarse para elegir una variable y evaluarla caso por caso, y además, ejecutar bloques de códigos de acuero a cada caso. He aquí el bloque de código que verá el valor de cada letra, almacenado en la variable instruction, y que luego llamará a la subrutina para cada instancia o caso de una letra determinada.

SELECT instruction CASE "F": GOSUB Forward CASE "B": GOSUB Backward CASE "R": GOSUB Right_Turn CASE "L": GOSUB Left_Turn ENDSELECT

Aquí están todos los conceptos juntos en un solo programa.

Programa de ejemplo: EepromNavigation.bs2

√ Lee cuidadosamente el código de instrucciones y los comentarios en el programa EepromNavigation.bs2 para entender lo que hace cada parte del programa.

√ Introduce, guarda y ejecuta el programa EepromNavigation.bs2. ' Robotica con el Boe-Bot - EepromNavigation.bs2 ' Navega usando los caracteres almacenados en la EEPROM. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]---------------------------------------------------------- pulseCount VAR Word ' Almacena numero de pulsos. address VAR Byte ' Almacena direccion de EEPROM. instruction VAR Byte ' Almacena instruccion de EEPROM. ' -----[ Data EEPROM ]-------------------------------------------------------- ' Address: 0123456789 ' Estas tres lineas-comentario ' |||||||||| ' muestran las direcciones de ' cada datum en la EEPROM. DATA "FLFFRBLBBQ" ' Instrucciones de navegacion. ' -----[ Inicializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal comienzo del programa.


' -----[ Rutina Principal ]--------------------------------------------------- DO UNTIL (instruction = "Q") READ address, instruction ' Data en direccion de memoria address de ' la variable instruction. address = address + 1 ' Suma 1 a address para lectura siguiente. SELECT instruction ' Llama una subrutina distinta CASE "F": GOSUB Forward ' para cada caracter posible CASE "B": GOSUB Backward ' que puede ser recogido de la CASE "L": GOSUB Left_Turn ' EEPROM. CASE "R": GOSUB Right_Turn ENDSELECT LOOP END ' Detiene ejecucion hasta que ocurra reset ' -----[ Subrutina - Forward ]------------------------------------------------ Forward: ' Subrutina de avance. FOR pulseCount = 1 TO 64 ' Envia 64 pulsos para avanzar. PULSOUT 13, 850 ' Pulso de 1.7 ms para servo izq. PULSOUT 12, 650 ' Pulso de 1.3 ms para servo der. PAUSE 20 ' Pausa por 20 ms. NEXT RETURN ' Retorna al bucle Rutina Principal ' -----[ Subrutina – Backward ]----------------------------------------------- Backward: ' Subrutina de retroceso. FOR pulseCount = 1 TO 64 ' Envia 64 pulsos para retroceder. PULSOUT 13, 650 ' Pulso de 1.3 ms para servo izq. PULSOUT 12, 850 ' Pulso de 1.7 ms para servo der. PAUSE 20 ' Pausa por 20 ms. NEXT RETURN ' Retorna al bucle Rutina Principal ' -----[ Subrutina - Left_Turn ]---------------------------------------------- Left_Turn: ' Subrutina de giro izq. FOR pulseCount = 1 TO 24 ' Envia 24 pulsos rotacion izq. PULSOUT 13, 650 ' Pulso de 1.3 ms para servo izq. PULSOUT 12, 650 ' Pulso de 1.3 ms para servo der. PAUSE 20 ' Pausa por 20 ms. NEXT RETURN ' Retorna al bucle Rutina Principal ' -----[ Subrutina – Right_Turn ]---------------------------------------------


Right_Turn: ' Subrutina de giro der. FOR pulseCount = 1 TO 24 ' Envia 24 pulsos rotacion der. PULSOUT 13, 850 ' Pulso de 1.7 ms para servo izq. PULSOUT 12, 850 ' Pulso de 1.7 ms para servo der. PAUSE 20 ' Pausa por 20 ms. NEXT RETURN ' Retorna al bucle Rutina Principal

¿Tu Boe-Bot se desplazó en un rectángulo, avanzando de frente los dos primeros lados y luego de retroceso los otros dos? Si se vio más como un trapezoide, quizá quieras ajustar los argumentos EndValue del bucle FOR...NEXT en las subrutinas de giro para hacer precisos los giros de 90 grados.

Tu Turno

√ Con el programa EepromNavigation.bs2 activo en el BASIC Stamp Editor, haz clic en Run y selecciona Memory Map.

Tus instrucciones almacenadas aparecerán resaltadas en azul al principio del mapa detallado de la EEPROM como se muestra en la Figura 4-7. Los números mostrados son códigos hexadecimales de ASCII (American Standard Code for Information Interchange) que corresponden a los caracateres que introduciste en tu declaración DATA.

Figura 4-7 Mapa de memoria con instrucciones almacenadas visibles en el mapa de la EEPROM

√ Haz clic en la casilla Display ASCII cerca de la esquina inferior izquierda de la

ventana de Memory Map.


Ahora la dirección de tus instrucciones aparecerán en un formato más familiar mostrado en la Figura 4-8. En lugar de los códigos ASCII, aparecen con el caracter con que los registraste usando la directiva DATA .

Figura 4-8 Acercamiento del mapa detallado de la EEPROM después de marcar la casilla “Display ASCII”

Este programa almacenó un total de 10 caracteres en la EEPROM. Estos 10 caracteres fueron localizados por la variable address del comando READ. La variable address se declaró como un byte, así que puede localizar 256 direcciones de memoria, muchas más de las 10 que necesitamos. Si la variable address se vuelve a declarar, ahora con tamaño Word, teóricamente podría acceder a 65535 direcciones de memoria, muchas más de las que hay disponibles. Recuerda que si tu programa se hace más largo, el número de direcciones disponibles en la EEPROM para almacenar data se hace más pequeño. Puedes modificar la secuencia de data existente para que sea un nuevo grupo de direcciones. También puede añadir declaraciones DATA adicionales. Las data son almacenadas secuencialmente, para que el primer caracter de la segunda secuencia de data sea almacenado inmediatamente después del último caracter de la primera secuencia de data.

√ Prueba cambiar, añadir y borrar caracteres en la directiva DATA, y vuelve a ejecutar el programa. Recuerda que el último caracater en la directiva DATA debería ser siempre “Q.”

√ Modifica la directiva DATA para hacer que tu Boe-Bot realice la secuencia de movimientos conocidos adelante-izquierda-derecha-atrás.

√ Prueba añadir una segunda directiva DATA. Recuerda quitar la “Q” del final de la primera directiva DATA y añádela al final de la segunda. De no hacerlo, el programa ejecutará nada más los comandos de la primera directiva DATA.


Programa de ejemplo – EepromNavigationWithWordValues.bs2

El siguiente programa de ejemplo parece complicado al principio, pero es una manera muy eficiente de diseñar programas para direcciones de movimiento habituales del Boe-Bot. Este programa de ejemplo usa el almacenamiento de data de la EEPROM, pero no usa subrutinas. En su lugar, se usa un solo bloque de código, con variables en lugar de los argumentos EndValue del bucle FOR...NEXT y Duration. del comando PULSOUT. Por defecto, la directiva DATA almacena byets de información en la EEPROM. Para almacenar ítems de data de tamaño Word puedes añadir el modificador Word a la directiva DATA, antes de cada ítem de data de tu secuencia. Cada ítem de data de tamaño Word, usará dos bytes del almacenamiento en la EEPROM; así que se podrá acceder las data a través de cada otra dirección de memoria (es decir, cada dos direcciones de memoria). Cuando se usa más de una directiva DATA, es recomendable asignar una etiqueta a cada una. De esta manera, tus comandos READ pueden referirse a la etiqueta para buscar los ítems de data sin tener que decifrar en cual dirección de la EEPROM comienza cada secuencia de ítems de data. Observa este fragmento de código:

' addressOffset 0 2 4 6 8 Pulses_Count DATA Word 64, Word 24, Word 24, Word 64, Word 0 Pulses_Left DATA Word 850, Word 650, Word 850, Word 650 Pulses_Right DATA Word 650, Word 650, Word 850, Word 850

Cada una de las declaraciones DATA comienza con su propia etiqueta. El modificador Word va delante de cada íitem de data y los ítems están separados por comas. Estas tres secuencias de data se almacenarán en la EEPROM una tras otra. No debemos hacer cálculos para deducir el número de la dirección de un ítem de data específico, porque las etiquetas y la variable addressOffset lo harán automáticamente. El comando READ usa cada etiqueta para determinar la dirección en la EEPROM donde la secuencia comienza y luego suma el valor a la variable addressOffset para saber cuántos números de direcciones debe pasar para encontrar DataItem. que corresponde. El ítem DataItem encontrado en la dirección de memoria Address resultante será almacenada en el argumento Variable del comando READ. Observa que el modificador Word también está antes de la variable que almacena el valor traído de la EEPROM.

DO READ Pulses_Count + addressOffset, Word pulseCount READ Pulses_Left + addressOffset, Word pulseLeft READ Pulses_Right + addressOffset, Word pulseRight


addressOffset = addressOffset + 2 ' Bloque de codigo PBASIC omitido. LOOP UNTIL (pulseCount = 0)

La primera vez que pasa por el bucle, addressOffset = 0. El primer comando READ traerá un valor de 64 desde la primera dirección de memoria de la etiqueta Pulses_Count y lo coloca en la variable pulseCount. El segundo comando READ trae un valor de 850 desde la primera dirección de memoria especificada por la etiqueta Pulses_Left y la coloca en la variable pulseLeft. El tercer comando READ trae un valor de 650 desde la primera dirección de memoria especificada por la etiqueta Pulses_Right y la coloca en la variable pulseRight. Observa que estos son los tres valores de la columna “0” del fragmento de código de la página 159. Cuando el valor de esas variables es colocado en el siguiente bloque de código, esto:

FOR counter = 1 TO pulseCount PULSOUT 13, pulseLeft PULSOUT 12, pulseRight PAUSE 20 NEXT

se transforma en


¿Reconoces la maniobra básica generada por este bloque de código?

√ Mira el fragmento de código en la página 159 e imagina cómo se verá el bloque de código FOR…NEXT después de la segunda, tercera y cuarta vez que pase por el bucle.

√ Mira la declaración LOOP UNTIL (pulseCount = 0) en el siguiente programa. El operador <> significa "no-igual a". ¿Qué pasará la quinta vez que se repita el bucle?

√ Introduce, guarda y ejecuta el programa EepromNavigationWithWordValues.bs2.

' Robotica con el Boe-Bot - EepromNavigationWithWordValues.bs2 ' Almacena listas de valores de tamano Word que dictan. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]----------------------------------------------------------


counter VAR Word pulseCount VAR Word ' Almacena numero de pulsos. addressOffset VAR Byte ' Almacena valor de compensado. instruction VAR Byte ' Almacena instruccion de EEPROM. pulseRight VAR Word ' Almacena anchos de pulso de servo. pulseLeft VAR Word ' -----[ Data EEPROM ]-------------------------------------------------------- ' addressOffset 0 2 4 6 8 Pulses_Count DATA Word 64, Word 24, Word 24, Word 64, Word 0 Pulses_Left DATA Word 850, Word 650, Word 850, Word 650 Pulses_Right DATA Word 650, Word 650, Word 850, Word 850 ' -----[ Inicializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Rutina Principal ]--------------------------------------------------- DO READ Pulses_Count + addressOffset, Word pulseCount READ Pulses_Left + addressOffset, Word pulseLeft READ Pulses_Right + addressOffset, Word pulseRight addressOffset = addressOffset + 2 FOR counter = 1 TO pulseCount PULSOUT 13, pulseLeft PULSOUT 12, pulseRight PAUSE 20 NEXT LOOP UNTIL (pulseCount = 0) END ' Detiene ejecucion hasta que ocurra reset

¿Tu Boe-Bot realizó los movimientos adelante-izquierda-derecha-atrás? ¿Está aburridísimo con esto? ¿Quieres ver a tu Boe-Bot realizar algo más o coordinar tu propia rutina?

Tu Turno – Haciendo tus Propias Rutinas de Navegación

√ Guarda el programa EepromNavigationWithWordValues.bs2. bajo un nuevo nombre.

√ Reemplaza las directivas DATA con las que están a continuación.


√ Ejecuta los programas modificados y observa lo que hace tu Boe-Bot. Pulses_Count DATA Word 60, Word 80, Word 100, Word 110, Word 110, Word 100, Word 80, Word 60, Word 0 Pulses_Left DATA Word 850, Word 800, Word 785, Word 760, Word 750, Word 740, Word 715, Word 700, Word 650, Word 750 Pulses_Right DATA Word 650, Word 700, Word 715, Word 740, Word 750, Word 760, Word 785, Word 800, Word 850, Word 750

√ Haz una tabla con tres filas, una para cada directiva DATA y una columna para cada maniobra que quieras que el Boe-Bot realice, además de una para el ítem Word 0 en la fila Pulses_Count.

√ Usa la tabla para planear los movimientos de tu Boe-Bot, rellenando los argumentos EndValue del bucle FOR...NEXT y Duration del comando PULSOUT, los cuales necesitarás para el bloque de código de cada maniobra.

√ Modifica tu programa con las directivas DATA de tu nueva tabla. √ Introduce, guarda y ejecuta el programa tu programa personalizado. ¿El Boe-Bot

hizo lo que tú querías que hiciera? Sigue trabajando en ello hasta que la respuesta sea afirmativa.


RESUMEN En este capítulo se introducieron las maniobras básicas del Boe-Bot: adelante, atrás, girar a la derecha y la izquierda, y girar sobre sí mismo. El tipo de maniobra está determinado por los argumentos Duration del comando PULSOUT. Cuán lejos sigue la maniobra, está determiando por los argumentos StartValue y EndValue del bucle FOR…NEXT. El capítulo 2 incluyó ajustes de hardware, es decir, centrar físicamente los servos del Boe-Bot con un destornillador. Este capítulo se enfoca hacia la entonación a través de la manipulación del software. Específicamente, se compensó una diferencia de velocidad entre los dos servos cuambiando los argumentos Duration del comando PULSOUT para el servo más rápido. Esto cambia el trayecto del Boe-Bot de una línea curva a una recta si los servos no están perfectamente calibrados. Para entonar los giros para que el Boe-Bot gire en el ángulo deseado, los argumentos StartValue y EndValue del bucle FOR…NEXT pueden ajustarse. Se puede lograr programar el Boe-Bot para que recorra una distancia predefinida midiendo la distancia que recorre en un segundo, con la ayuda de una regla. Usando esta distancia y el número de pulsos por cada segundo durante el tiempo del recorrido, puedes calcular el número requerido para cubrir la distancia deseada. Se introdujo la aceleración gradual (ramping) como una manera de acelerar y desacelerar gradualmente. Es mejor para los servos, por lo que recomendamos que uses tus propias rutinas de aceleración gradual en lugar de arranques y frenadas abruptas como se muestra en los programas de ejemplo. La aceleración gradual se logra tomando la misma variable que se usa en el argumento Counter de un bucle FOR…NEXT y sumándolo o restándolo a 750 en el argumento Duration del comando PULSOUT. Se introducieron subrutinas como una manera de realizar maniobras preprogramadas reusables en un programa de PBASIC. En lugar de escribir un nuevo bucle FOR…NEXT para cada maniobra, se puede ejecutar una subrutina que contenga el bucle FOR…NEXT si se necesita, con el comando GOSUB. Una subrutina comienza con una etiqueta y termina con el comando RETURN. Una subrutina es llamada desde el programa principal con el comando GOSUB. Cuando una subrutina finaliza y encuentra el comando RETURN, el próximo comando que se ejecutará es el que sigue inmediatemente después del comando GOSUB.


La EEPROM del BASIC Stamp almacena el programa que ejecuta, pero puedes aprovechar cualquier porción sin usar del programa para almacenar valores. Esta es una muy buena opción para personalizar rutinas de navegación. La directiva DATA pede almacenar valores en la EEPROM. El tamaño por defecto es Byte, pero añadiendo el modificador Word te permite alamacenar valores de hasta 65535 en el equivalente a dos bytes de espacio de la EEPROM. Puedes leer los valores de la EEPROM usando el comando READ. Si vas a traer una variable de tamaño Word, asegúrate de colocar el modificador Word delante de la variable que va a recibir el valor, el cual es buscaddo por la directiva READ. SELECT…CASE fue introducido como una forma de evaluar una variable caso por caso y ejecutando un bloque de código diferente dependiendo de cada caso. Las condiciones opcionales de DO…LOOP son útiles en ciertas ciscunstancias; DO UNTIL(Condición)...LOOP and DO...LOOP UNTIL (Condición) se mostraron como formas de ejecutar DO…LOOP hasta que se detectara una situación particular.

Preguntas 1. ¿En qué dirección debe girar la rueda izquierda para que el Boe-Bot avance

hacia adelante? ¿Y la rueda derecha? 2. Cuando el Boe-Bot gira sobre sí mismo hacia la izquierda ¿Qué están haciendo

las ruedas derecha e izquierda? ¿Qué comandos de PBASIC necesitas para que el Boe-Bot ruede sobre sí mismo hacia la izquierda?

3. Si tu Boe-Bot se desvía levemente hacia la izquierda cuando estás ejecutando el programa para que avance en línea recta ¿Cómo lo corriges? ¿Qué comandos necesitas ajustar y que clase de ajustes se deben hacer?

4. Si tu Boe-Bot avanza a 11 in/s, ¿Cuántos pulsos necesitará para avanzar 36 pulgadas?

5. ¿Cuál es la relación entre el argumento Counter del bucle FOR…NEXT y el argumento Duration del comando PULSOUT que hace posible la aceleración gradual?

6. ¿Qué directiva puedes usar para pre almacenar los valores en la EEPROM del BASIC Stamp antes de ejecutar un programa?

7. ¿Qué comando puedes usar para buscar un valor almacenado en la EEPROM y copiarlo en la variable?

8. ¿Qué bloque de código puedes usar para seleccionar una variable particular y evaluarla caso por caso, y además ejecutar un bloque de código diferente para cada caso?

9. ¿Cuáles son las diferentes condiciones que se pueden usar con DO…LOOP?


Ejercicios 1. Escribe una rutina que haga que el Boe-Bot retroceda durante 350 pulsos. 2. Digamos que probaste tus servos y descubriste que necesitan 48 pulsos para girar

180° a la derecha. Con esta información, escribe rutinas que hagan que el Boe-Bot realice giros de 30, 45 y 60 grados.

3. Escribe una rutina que haga que el Boe-Bot avance en línea recta, luego acelere/desacelere gradualmente para comenzar y culminar un giro sobre sí mismo y luego coninúe su avance rectilíneo.

Proyectos 1. Es momento de llenar la columna 3 de la Tabla 2-1: Combinaciones de PULSOUT

Duration en la página 82. Para hacer esto, modifica los argumentos Duration del comando PULSOUT en el programa BoeBotForwardThreeSeconds.bs2 usando cada par de valores de la columna 1. Registra el comportamiento resultante de tu Boe-Bot, correspondiente a cada pareja, en la columna 3. Una vez completada, esta tabla servirá como guía de referencia cuando diseñes tus propias maniobras personalizadas para tu Boe-Bot.

2. La Figura 4-9 muestra dos trayectos simples con obstáculos. Escribe un programa que haga que tu Boe-Bot navegue a lo largo de cada figura. Asume que las distancias en línea recta (incluyendo el diámetro del círculo) equivalen a 1 yd o 1 m.

Figura 4-9 Trayecto simple con obstáculos


Soluciones Q1. Rueda izquierda contrareloj, rueda derecha conreloj. Q2. La rueda derecha está girando conreloj (hacia adelante), y la izquierda no se

mueve. PULSOUT 13, 750 PULSOUT 12, 650

Q3. Puedes desacelerar la rueda derecha para corregir la desviación hacia la izquierda. El comando PULSOUT para la rueda derecha necesita ser ajustado. PULSOUT 12, 650

Ajusta 650 a algo más cercano a 750 para desacelerar la rueda. PULSOUT 12, 663

Q4. Con los datos: Velocidad del Boe-Bot = 11 in/s Distancia que recorre el Boe-Bot = 36 in/s pulsos = (distancia del Boe-Bot / velocidad del Boe-Bot) * (40.65 pulsos / s) = (36 / 11 ) * (40.65) = 133.04 = 133 Deberías necesitar 133 pulsos para recorrer 36 pulgadas.

Q5. La variable pulseCount del bucle FOR…NEXT puede ser usada como un compensador (de suma o resta) para 750 (la posición central) en el argumento Duration.

FOR pulseCount = 1 to 100 PULSOUT 13, 750 + pulseCount PULSOUT 12, 750 – pulseCount PAUSE 20 NEXT

Q6. La directiva DATA. Q7. El comando READ. Q8. SELECT...CASE...ENDSELECT. Q9. UNTIL y WHILE.

E1. FOR counter = 1 to 350 ' Retroceso

PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT

E2. FOR counter = 1 to 8 ' Rota der. 30 grados


PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT FOR counter = 1 to 12 ' Rota der. 45 grados PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT FOR counter = 1 to 16 ' Rota der. 60 grados PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT

E3. FOR counter = 1 to 100 ' Avance PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT FOR counter = 0 TO 30 ' Vuelta pivot con acel. PULSOUT 13, 750 + counter ' gradual PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 30 TO 0 ' Desacel. gradual PULSOUT 13, 750 + counter PULSOUT 12, 750 PAUSE 20 NEXT FOR counter = 1 to 100 ' Avance PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT


P1. P13 P12 Descripción Comportamiento 850 650 Velocidad máxima

P13 CCW, P12 CW Avance

650 850 Velocidad máxima P13 CW, P12 CCW

Retroceso

850 850 Velocidad máxima P13 CCW, P12 CCW

Rotación der.

650 650 Velocidad máxima P13 CW, P12 CW

Rotación izq.

750 850 P13 Detenido P12 CCW Velocidad máx

Pivot hacia atrás izq.

650 750 P13 CW Velocidad máx P12 Detenido

Pivot hacia atrás der.

750 750 P13 Detenido P12 Detenido

Detenido

760 740 P13 CCW Lento P12 CW Lento

Avance lento

770 730 P13 CCW Med P12 CW Med

Avance mediano

850 700 P13 CCW Velocidad máx P12 CW Mediana

Desvío hacia der.

800 650 P13 CCW Mediana P12 CW Velocidad máx

Desvío hacia izq.

P2. El círculo se puede completar desviando continuamente hacia la derecha. Ensayo y error, una vara de una yarda o un metro puede ayudarte a encontrar el valor PULSOUT adecuado. Para un círculo con un diámetro de una yarda:

' Robotica con el Boe-Bot - Capítulo 4 - Circle.bs2 ' Boe-Bot navega un circulo de 1 yarda de diámetro. '$STAMP BS2 '$PBASIC 2.5 DEBUG "Program running!" pulseCount VAR Word ' Contador de pulsos para los servos FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Rutina Principal ]-------------------------------------------- Main: DO PULSOUT 13, 850 ' Desvío derecha PULSOUT 12, 716 PAUSE 20 LOOP

Para completar el triángulo, primero calcula el número de pulsos necesarios para recorrer una yarda o un metro en línea recta, como en la Pregunta 4. Luego


entona las distancias para que estén coordinadas con la superficie de tu Boe-Bot. Para un patrón en forma de triángulo, el Boe-Bot debe recorrer 1 metro/yarda hacia adelante, luego hacer un giro de 120 grados. Esto se debe repetir tres veces, una para cada lado del triángulo. Puede que tengas que ajustar el EndValue en pulseCount usado en la subrutina Right_Rotate120 para obtener un giro preciso. ' Robotica con el Boe-Bot - Capítulo 4 - Triangle.bs2 ' Boe-Bot navega un trayecto con forma de triangulo con lados de 1 ' yarda. ' Avanza, luego gira 120 grados. Repite tres veces. '$STAMP BS2 '$PBASIC 2.5 DEBUG "Program running!" counter VAR Nib ' Un triangulo tiene 3 lados pulseCount VAR Word ' Contador de pulsos para los servos FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. Main: FOR counter = 1 TO 3 ' Repetir 3 veces para triangulo GOSUB Forward GOSUB Right_Rotate120 NEXT END Forward: FOR pulseCount = 1 TO 163 ' Avance 1 yarda PULSOUT 13, 850 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Right_Rotate120: FOR pulseCount = 1 TO 21 ' Rotacion der. 120 grados PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

Capítulo 5: Navegación Táctil con Bigotes · Page 171

Capítulo 5: Navegación Táctil con Bigotes Varios tipos de maquinarias robóticas dependen de una variedad de interruptores táctiles. Por ejemplo, un interruptor táctil puede detectar cuando un brazo robótico se ha topado con un objeto. El robot puede ser programado para recoger el objeto y colocarlo en otro sitio. Las fábricas utilizan interruptores táctiles para contar objetos en la línea de producción y también para alinear objetos durante el proceso industrial. En todas estas instancias, los interruptores proporcionan entradas que dictaminan alguna otra forma de salida programada. Las entradas son monitoreadas electrónicamente por el producto, sea un robot, o una calculadora, o una línea de producción. Basado en el estado del interruptor, el brazo robótico agarra un objeto, o la calculadora muestra actualizaciones, o la línea de producción de la fábrica reacciona con motores o servos para guíar sus productos. En este capítulo, construirás interruptores táctiles, llamados interruptores de bigote (o simplemente bigotes en este texto), en tu Boe-Bot y los verificarás. Luego, programarás al Boe-Bot para que monitoree el estado de estos interruptores y decida qué hacer cuando encuentre algún obstáculo. El resultado final será una navegación autónoma por contacto.

NAVEGACIÓN TÁCTIL Los bigotes reciben este nombre porque son interruptores que se asemejan precisamente a un bigote, aunque algunas personas sostienen que se parecen más a una antena. En todo caso, estos bigotes se muestran montados en un Boe-Bot en la Figura 5-1. Los bigotes le dan al Boe-Bot la capacidad de percibir el mundo que le rodea a través del tacto, tal como una antena para una hormiga o los bigotes en un gato. Las actividades de este capítulo usan los bigotes solos, pero también pueden usarse en combinación con otros sensores los cuales aprenderás a usar en capítulos posteriores para incrementar la funcionalidad de tu Boe-Bot.


Figura 5-1 Boe-Bot con bigotes

ACTIVIDAD #1: CONSTRUYENDO Y PROBANDO LOS BIGOTES Antes de seguir con los programas que hacen que tu Boe-Bot navegue basado en lo que puede tocar, es esencial construir y verificar los bigotes. Esta actividad te guiará a través del proceso de construcción y verificación de los bigotes.

Circuito y Ensambleje de los Bigotes

√ Toma el hardware de los bigotes como se muestra en la Figura 5-2. √ Desconecta la energía de tu plaqueta y tus servos.


Lista de partes:

(2) Cables de bigote (2) Tornillos de Estría 7/8″ de

cabeza plana 4-40 (2) Separador circular de ½″ (2) Arandela de nylon –

tamaño #4 (2) Cabezales de 3-pines

m/m (2) Resistores de 220 Ω (rojo-rojo-marrón) (2) Resistores de 10 kΩ (marrón-negro-naranja)

Figura 5-2 Hardware para los Bigotes

Construyendo los Bigotes

√ Retira los dos tornillos que sujetan tu plaqueta a los separadores frontales. √ Observa la Figura 5-3 mientras sigues el resto de las instrucciones. √ Ensarta una arandela de nylon y luego un separador circular de ½″ en cada uno

de los tornillos de 7/8″. √ Sujeta los tornillos a través de los orificios en tu plaqueta, a los separadores que

están debajo, pero no los aprietes completamente todavía. √ Coloca los extremos con forma de gancho de los bigotes alrededor de los

tornillos, uno sobre la arandela y otro por debajo de la arandela, posicionándolos de tal manera que se crucen sin tocarse.

√ Apreta los tornillos a los separadores.


Board of Education / HomeWork Board

Figura 5-3 Montando los Bigotes

El próximo paso es añadir el circuito de los bigotes mostrado en la Figura 5-4 a la bocina piezoeléctrica y los circuitos de servo que construiste y verificase en el Capítulo 2 y en el Capítulo 3.

√ Si posees una Board of Education, construye el circuito de los bigotes mostrado en la Figura 5-4 usando el diagrama de conexión de la Figura 5-5 de la página 175 como referencia.

√ Si posees una HomeWork Board, construye el circuito de los bigotes mostrado en la Figura 5-4 usando el diagrama de conexión de la Figura 5-6 de la página 176 como referencia.

√ Asegúrate de ajustar cada bigote para que esté cerca del cabezal de 3 pines en la protoboard, pero sin tocarlo. Se recomienda un punto de partida de 1/8″ (3 mm).

P7

P5

Vss Vss

Vdd Vdd

Right Whisker

LeftWhisker

10 kΩ10 kΩ

220 Ω

220 Ω

Figura 5-4 Diagrama Esquemático de los Bigotes


Figura 5-5: Diagrama de Conexión de los Bigotes para la Board of Education

P15P14P13P12P11P10P9P8

P6

P3P2P1P0

P7

P5P4

X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

Left Whisker

Right Whisker

+

Utiliza los resistores de 220 Ω (código de colores rojo-rojo-marrón) para conectar P5 y P7 a sus cabezales de 3 pines correspondientes. Utiliza los resistores de 10 kΩ (código de colores marrón-negro-naranja) para conectar Vdd a cada cabezal de 3 pines.


Figura 5-6: Diagrama de Conexión de los Bigotes para la HomeWork Board

P15P14

P11

P13P12

P7

P5P4

P10P9P8

P6

P3P2P1P0

X2

X3Vdd VssVin


To Servos

Left Whisker

Right Whisker

+

HomeWork Board

Utiliza los resistores de 220 Ω (código de colores rojo-rojo-marrón) para conectar P5 y P7 a sus cabezales de 3 pines correspondientes. Utiliza los resistores de 10 kΩ (código de colores marrón-negro-naranja) para conectar Vdd a cada cabezal de 3 pines.

Bigote Izq.

Bigote Der.

Hacia los servos


Verificando los Bigotes

Vuelve a observar el dibujo esquemático de los bigotes (Figura 5-7). Cada bigote consiste tanto en la extensión mecánica como en la conexión eléctrica a tierra de un interruptor simple (single-throw), regularmente abierto, de un solo polo (single-pole). La razón para que los bigotes estén conectados a tierra (Vss) es que los todos orificios enchapados en el borde exterior de la plaqueta están conectados a Vss. Esto es así en la Board of Education y la BASIC Stamp HomeWork Board. Los standoffs y los tornillos de metal proveen la conexión eléctrica para cada bigote.

P7

P5

Vss Vss

Vdd Vdd

Right Whisker

LeftWhisker

10 kΩ10 kΩ

220 Ω

220 Ω

Figura 5-7 Diagrama Esquemático de los Bigotes – Una Segunda Vista

La BASIC Stamp puede ser programada para detectar cuando un bigote es presionado. Los pines I/O conectados a cada circuito de interruptor monitorean el voltaje del resistor de subida (pull-up resistor) de 10 kΩ. La Figura 5-8 ilustra su funcionamiento. Cuando un bigote no se encuentra presionado, el voltaje del pin I/O conectado a ese bigote es de 5 V. Cuando un bigote es presionado, la línea I/O hace contacto a tierra (Vss), por lo que la línea I/O lee 0 V. Todos los pines I/O funcionan por defecto como entradas cada vez que un programa de PBASIC comienza. Esto significa que los pines I/O conectados a los bigotes funcionarán como entradas automáticamente. Como entrada, un pin I/O conectado a un circuito de bigote ocasionará que tu registro de entrada almacene un 1 si el voltaje es de 5 V (bigote no presionado) o un 0 si el voltaje es 0 V (bigote presionado). El Debug Terminal puede usarse para mostrar estos valores.

Bigote Izq.

Bigote Der.


¿Cómo haces para que el BASIC Stamp te diga si está leyendo 1 ó 0? Porque el circuito está conectado a P7, este valor 1 ó 0 aparecerá en una variable llamada IN7. IN7 es conocida como un registro de entrada. Las variables de registros de entrada vienen con el software por lo que no es necesario declararlas al comienzo de tu programa. Puedes ver el valor que esta variable guarda usando el comando DEBUG BIN1 IN7. El BIN1 es un formateador que le dice al Debug Terminal que muestre un dígito binario (un 1 ó un 0).

Figura 5-8 Detectando Contactos Eléctricos

Programa de Ejemplo: TestWhiskers.bs2

Este próximo programa de ejemplo está diseñado para probar los bigotes y asegurar que funcionan apropiadamente. Mostrando los dígitos binarios guardados en los registros de entrada P7 y P5 (IN7 e IN5), el programa te mostrará si el BASIC Stamp detecta algún contacto con los bigotes. Cuando el valor guardado en un registro de entrada determinado es 1, el bigote no está presionado. Cuando es 0, el bigote se encuentra presionado.

√ Reconecta la alimentación a tu plaqueta y servos. √ Escribe, guarda y ejecuta TestWhiskers.bs2. √ Este programa hace uso del Debug Terminal, así que deja conectado el cable

serial al BASIC Stamp mientras el programa se está ejecutando.

Bigote presionado


' Robotica con el Boe-Bot - TestWhiskers.bs2 ' Muestra lo que perciben los pines I/O conectados a los bigotes. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "WHISKER STATES", CR, ' Tabla Estado de Bigotes "Left Right", CR, ' Derecho Izquierdo "------ ------" DO DEBUG CRSRXY, 0, 3, "P5 = ", BIN1 IN5, " P7 = ", BIN1 IN7 PAUSE 50 LOOP

√ Observa el valor mostrado en el Debug Terminal; debería mostrar que ambos P7

y P1son iguales a 1. √ Revisa la Figura 5-5 en la página 175 (o la Figura 5-6 en la página 176) para que

sepas cuál es el “bigote izquierdo” y cuál es el “bigote derecho.” √ Presiona el bigote derecho hasta su cabezal de tres-pin, y observa los valores

mostrados en el Debug Terminal. Ahora deberías ver: P5 = 1 P7 = 0

√ Presiona el bigote izquierdo hasta su cabezal de tres-pin, y observa que el valor mostrados en el Debug Terminal otra vez. Esta vez deberías ver: P5 = 0 P7 = 1

√ Presiona ambos bigotes contra ambos cabezales de tres-pin. Ahora deberías ver: P5 = 0 P7 = 0

√ Si ambos bigotes pasan todas estas pruebas, estás listo para sequier adelante; en caso contrario, revisa tu programa y los circuitos en busca de errores.

Qué es CRSRXY?

Es un formateador que te permite arreglar de manera conveniente la información que tu programa manda al Debug Terminal. El formato CRSRXY 0, 3, en el comando

DEBUG CRSRXY, 0, 3, "P5 = ", BIN1 IN5, " P7 = ", BIN1 IN7

coloca el cursor en la columna 0, fila 3 en el Termnal de Depuración. Esto hace que se muestre debajo del encabezado de la tabla “Estados de Bigotes”. Cada paso por el bucle, los nuevos valores reemplazan los viejos valores porque el cursor siempre regresa al mismo lugar.


ACTIVIDAD #2: VERIFICANDO LOS BIGOTES EN EL CAMPO Asume que puede ser necesario que verifiques los bigotes un rato más tarde lejos de la computadora. Como el Debug Terminal no estará disponible, ¿qué puedes hacer? Una solución puede ser programar el BASIC Stamp para que envíe una señal de salida que corresponda a la señal de entrada que está recibiendo. Esto puede hacese con un par de circuitos LEDs y un programa que prenda y apague los LEDs de acuerdo a las entradas de los bigotes.

Lista de Partes:

(2) Resistores - 220 Ω (rojo-rojo-marrón) (2) LEDs – Rojo

Construyendo el Circuito de Prueba de Bigotes con LEDs

√ Desconecta la fuente de alimentación de tu plaqueta y servos. √ Si tienes una Board of Education, agrega el circuito mostrado en la Figura 5-9

con la ayuda del diagrama de conexión en la Figura 5-10 (página 181). √ Si tienes una HomeWork Board, agrega el circuito mostrado en la Figura 5-9 con

la ayuda del diagrama de cabledo en la Figura 5-11 (página 182).

P1

P10

Vss Vss

LEDLED

220 Ω

220 Ω

Figura 5-9 Daigrama de Verificación de Bigote con LED Agrega este circuito LED.

Recuerda que un LED es una válvula de corriente en un sólo sentido. Si está conectado alrevés, no dejará pasar corriente, por lo que no emitirá luz. Para que el LED emita luz cuando el BASIC Stamp mande una señal alta, el ánodo del LED debe estar conectado al resistor de 220 Ω, y su cátodo debe estar conectado a Vss. Observa la Figura 5-10 o la Figura 5-11.


Figura 5-10: Diagrama de conexión de Bigotes más LED para la Board of Education

P15P14P13P12P11P10

P7

P5P4

P1

P9P8

P6

P3P2

P0X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

Left Whisker

Right Whisker

+

This lead is the anode.

This lead is the anode. Esta pata es el ánodo

Esta pata es el ánodo

Parte plana en el cobertor plástico indica cátodo

Bigote Izq.

Bigote Der.

Hacia los Servos


Figura 5-11: Diagrama de Conexión de Bigotes más LED para la HomeWork Board

P15P14

P11

P13P12

P10

P7

P5P4

P1

P9P8

P6

P3P2

P0X2

X3Vdd VssVin


To Servos

Left Whisker

Right Whisker

+

HomeWork Board

Programando el Circuito de Prueba de Bigotes con LEDs

√ Reconecta la fuente de alimentación a tu plaqueta. √ Guarda TestWhiskers.bs2 como TestWhiskersWithLeds.bs2. √ Inserta estos dos sentencias IF...THEN entre los comandos PAUSE 50 y LOOP.

IF (IN7 = 0) THEN HIGH 1 ELSE LOW 1 ENDIF

Parte plana en el cobertor plástico indica cátodo

El ánodo se conecta al 220 Ω resistor.

El ánodo se conecta al 220 Ω resistor.

Hacia los Servos

Bigote Izq.

Bigote Der.


IF (IN5 = 0) THEN HIGH 10 ELSE LOW 10 ENDIF

Estas son llamadas sentencias IF…THEN, y ellas serán introducidas más detalladamente en la próxima actividad. Estas sentencias son usadas para tomar decisiones en PBASIC. La primera de las dos sentencias IF…THEN hace que P1 sea alto, lo cual prende el LED cuando el bigote conectado a P7 es presionado (IN7 = 0). La porción ELSE de la sentencia hace que P1 sea bajo, lo cual apaga el LED cuando el bigote no se encuentra presionado. La segunda sentencia IF…THEN hace lo mismo para el bigote conectado a P5 y el LED conectado a P10.

√ Ejecuta TestWhiskersWithLeds.bs2. √ Verifica el programa presionando gentilmente los bigotes. Los LEDs rojos

deberían iluminarse cuando cada bigote hace contacto con su cabezal de tres-pins.

ACTIVIDAD #3: NAVEGACION CON BIGOTES En la Actividad #1, el BASIC Stamp fue programado para detectar si alguno de los bigotes había sido presionado. En esta actividad, el BASIC Stamp será programado para aprovechar esta información y guiar al Boe-Bot. Cuando el Boe-Bot esté rodando y se presione un bigote, significará que el Boe-Bot ha chocado contra algo. Un programa de navegación necesita tomar esta entrada, decidir qué significa, y llamar al conjunto de maniobras que harán que el Boe-Bot retroceda del obstáculo, de la vuelta, y vaya en una dirección distinta.

Programando el Boe-Bot para Navegar Basado en las Entradas de los Bigotes

Este próximo programa hace que el Boe-Bot avance hasta que encuentre un obstáculo. En este caso, el Boe-Bot sabe cuando encuentra un obstáculo chocando uno o ambos de sus bigotes contra él. Tan pronto como el obstáculo es detectado por los bigotes, las rutinas de navegación y subrutinas desarrolladas en el capítulo 4 harán que el Boe-Bot retroceda y se voltee. Entonces, el Boe-Bot continúa su moción hacia adelante hasta chocar con otro obstáculo.


Para hacer eso, el Boe-Bot necesita ser programado para tomar decisiones. PBSIC tiene el comando llamado sentencia IF…THEN que toma decisiones. La sintaxis para la sentencia IF…THEN es: IF (condition) THEN…ELSEIF (condition)…ELSE…ENDIF Los “…” significan que puedes poner un bloque de código (uno o más comandos) entre las palabras clave. El próximo programa de ejemplo toma decisiones basado en las decisiones de las entradas de los bigotes, y luego llama las subrutinas para hacer qye el Boe-Bot haga una acción. Las subrutinas son similares a las que desarrollaste en el Capítulo 4: Navegación del Boe-Bot. Aquí está el uso de IF…THEN.

IF (IN5 = 0) AND (IN7 = 0) THEN GOSUB Back_Up ' Ambos bigotes detectan el obstáculo, GOSUB Turn_Left ' Retrocede y has vuelta en U (izq. ' dos veces) GOSUB Turn_Left ELSEIF (IN5 = 0) THEN ' Bigote izq. hace contacto GOSUB Back_Up ' Retrocede y voltea a la der. GOSUB Turn_Right ELSEIF (IN7 = 0) THEN ' Bigote der. hace contacto GOSUB Back_Up ' Retrocede y voltea a la izq. GOSUB Turn_Left ELSE ' Ambos bigotes 1, no hay contacto GOSUB Forward_Pulse ' Aplica un pulso hacia adelante ENDIF ' chequea nuevamente

Programa de Ejemplo: RoamingWithWhiskers.bs2

Este programa demuestra una manera de evaluar las entradas de los bigotes y decidiendo cuales subrutinas de navegación deben ser llamadas usando IF…THEN.

√ Reconecta la fuente de alimentación a tu plaqueta y servos. √ Introduce, guarda, y ejecuta RoamingWithWhiskers.bs2. √ Trata de dejar que el Boe-Bot corra libremente. Cuando haga contacto con

obstáculos en su camino, debería retroceder, dar vuelta, y luego correr libremente en una nueva dirección.

' -----[ Title ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - RoamingWithWhiskers.bs2 ' Boe-Bot usa los bigotes para detectar obstaculos y navegar en torno a ellos.


' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]---------------------------------------------------------- pulseCount VAR Byte ' Contador del bucle FOR...NEXT ' -----[ Initialization ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Main Routine ]------------------------------------------------------- DO IF (IN5 = 0) AND (IN7 = 0) THEN GOSUB Back_Up ' Ambos bigotes detectan el obstáculo, GOSUB Turn_Left ' Retrocede y has vuelta en U (izq. GOSUB Turn_Left ' dos veces) ELSEIF (IN5 = 0) THEN ' Bigote izq. hace contacto GOSUB Back_Up ' Retrocede y voltea a la der. GOSUB Turn_Right ELSEIF (IN7 = 0) THEN ' Bigote der. hace contacto GOSUB Back_Up ' Retrocede y voltea a la izq. GOSUB Turn_Left ELSE ' Ambos bigotes 1, no hay contacto GOSUB Forward_Pulse ' Aplica un pulso hacia adelante ENDIF ' chequea nuevamente LOOP ' -----[ Subrutinas ]--------------------------------------------------------- Forward_Pulse: ' Envia un solo pulso de avance PULSOUT 13,850 PULSOUT 12,650 PAUSE 20 RETURN Turn_Left: ' Vuelta izq., aprox. 90-grados. FOR pulseCount = 0 TO 20 PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Vuelta der., aprox. 90-grados. PULSOUT 13, 850 PULSOUT 12, 850


PAUSE 20 NEXT RETURN Back_Up: ' Retrocede. FOR pulseCount = 0 TO 40 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

Funcionamiento de Corriendo con Bigotes

Las sentencias IF...THEN en la sección de la Rutina Principal primero chequean los bigotes para saber si hay un estado de atención. Si ambos bigotes son presionados (IN5 = 0 e IN7 = 0), una vuelta en U es ejecutada llamando a la subrutina Back_Up y seguidamente llamando la subrutina Turn_Left dos veces seguidas. Si solo el bigote izquierdo es presionado (IN5 = 0), entonces el programa llama a la subrutina Back_Up y seguidamente llama a la subrutina Turn_Right. Si el bigote derecho es presionado (IN7 = 0), la subrutina Back_Up es llamada, y seguidamente la subrutina Turn_Left. La única combinación posible que no ha sido cubierta es si ninguno de los dos bigotes es presionado (IN5 = 1 and IN7 = 1). El comando ELSE llama en este caso a la subrutina Forward_Pulse.

IF (IN5 = 0) AND (IN7 = 0) THEN GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN7 = 0) THEN GOSUB Back_Up GOSUB Turn_Left ELSE GOSUB Forward_Pulse ENDIF

Las subrutinas Turn_Left, Turn_Right, y Back_Up deberían verse bastante familiares, pero la subrutina Forward_Pulse tiene un truco. Sólo envía un pulso, y luego retorna. Esto es realmente importante, porque significa que el Boe-Bot puede chequear sus


bigotes entre cada pulso hacia adelante. Eso significa que el Boe-Bot chequea por obstáculos aproximadamente 40 veces por segundo mientras viaja hacia adelante.

Forward_Pulse: PULSOUT 12,650 PULSOUT 13,850 PAUSE 20 RETURN

Ya que cada pulso hacia adelante hace que el Boe-Bot ruede medio centímetro, es realmente una buena idea mandar un sólo pulso, y luego regresar y chequear los bigotes cada vez. Ya que la sentencia IF…THEN está dentro de un DO…LOOP, cada vez que el programa retorna de un Forward_Pulse, llega a LOOP, lo cual envía al programa de regreso a DO. ¿Qué pasa entonces? La sentencia IF…THEN chequea los bigotes una vez más.

Tu Turno

Los argumentos EndValue del bucle FOR...NEXT en las rutinas Back_Right y Back_Left pueden ser ajustados para más o menos vuelta, y la rutina Back_Up puede tener su EndValue ajustado para retroceder menos en espacios más apretados.

√ Experimenta con los arguntos EndValue del bucle FOR...NEXT en las rutinas de navegación en RoamingWithWhiskers.bs2.

También puedes modificar tus sentencias IF…THEN para hacer que los indicadores LED de la actividad previa transmitan la maniobra en la que el Boe-Bot se encuentra añadiendo comandos HIGH y LOW para controlar los circuitos LED. Aquí está un ejemplo.

IF (IN5 = 0) AND (IN7 = 0) THEN HIGH 10 HIGH 1 GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN HIGH 10 GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN7 = 0) THEN HIGH 1


GOSUB Back_Up GOSUB Turn_Left ELSE LOW 10 LOW 1 GOSUB Forward_Pulse ENDIF

√ Modifica la sentencia IF…THEN en RoamingWithWhiskers.bs2 para hacer que el

Boe-Bot Boe-Bot transmita su maniobra usando los indicadores LED.

ACTIVIDAD #4: INTELIGENCIA ARTIFICIAL Y DECIDIENDO CUANDO ESTAS ATASCADO Puedes notar que el Boe-Bot se atasca en las esquinas. Cuando el Boe-Bot entra a una esquina, su bigote toca la pared en la izquierda por lo que voltea a la derecha. Cuando el Boe-Bot se mueve hacia adelante nuevamente, su bigote derecho choca con la pared en la derecha así que da vuelta a la izquierda. Cuando voltea choca con la pared izquierda nuevamente, y con la pared derecha nuevamente, y así sucesivamente, hasta que alguien lo rescata de su lío.

Programando para Escapar de las Esquinas

RoamingWithWhiskers.bs2 puede ser modificado para detectar este problema y hacer algo al respecto. El truco es contar el número de veces que bigotes alternos hacen contacto. Una cosa importante de este truco es que el programa tiene que recordar en qué estado estaba cada bigote durante el contacto previo. Tiene que comparar eso con el estado de los bigotes durante el contacto actual. Si son opuestos, entonces suma uno al contador. Si el contador pasa de un umbral que tú (el programador) has determinado, entonces, es hora de dar una vuelta en U y reiniciar el contador de bigotes alternos. Este próximo programa también depende del hecho que puedes “encadenar” o “anidar” sentencias IF…THEN. En otras palabras, el programa chequea por una condición, y si esa condición es verdadera, chequea otra condición dentro de la primera condición. Aquí está un ejemplo con pseudo código demostrando su utilización.

IF condition1 THEN Commands for condition1 IF condition2 THEN Commands for both condition2 and condition1 ELSE


Commands for condition1 but not condition2 ENDIF ELSE Commands for not condition1 ENDIF

Hay un ejemplo de sentencias IF…THEN anidadas en la rutina que detecta los contactos de bigotes alternos en el próximo programa.

Programa de Ejemplo: EscapingCorners.bs2

Este programa causará que tu Boe-Bot ejecute una vuelta en U en la cuarta o quinta esquina alterna, dependiendo de cuál bigote fue presionado primero.

√ Introduce, guarda, y ejecuta EscapingCorners.bs2. √ Verifica este programa presionando bigotes alternos mientras el Boe-Bot corre

libremente. Dependiendo de cual Bigote fue presionado primero, el Boe-Bot debería ejecutar su maniobra de vuelta en U después de la cuarta o quinta vez consecutiva que los bigotes son presionados.

' -----[ Titulo ]------------------------------------------------------------- ' Robotica con el Boe-Bot - EscapingCorners.bs2 ' Boe-Bot navega fuera de las esquinas detectando el contacto alterno de los ' bigotes ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]---------------------------------------------------------- pulseCount VAR Byte ' Contador de bucle FOR...NEXT counter VAR Nib ' Cuenta contactos alternos. old7 VAR Bit ' Guarda IN7 previo. old5 VAR Bit ' Guarda IN5 previo. ' -----[ Initializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. counter = 1 ' Comienza contador alterno. old7 = 0 ' Inventa valores previos. old5 = 1 ' -----[ Rutina Principal ]---------------------------------------------------


DO ' --- Detecta Esquinas Alternas Consecutivas -------------------------------- ' Ve la seccion "Funcionamiento de EscapingCorners.bs2" que sigue al programa IF (IN7 <> IN5) THEN ' Uno u otro es presionado. IF (old7 <> IN7) AND (old5 <> IN5) THEN ' Diferente del previo. counter = counter + 1 ' Contador alterno + 1. old7 = IN7 ' Guarda este contacto de bigote old5 = IN5 ' para proxima comparacion. IF (counter > 4) THEN ' Si la cuenta de contacto counter = 1 ' alterno = 4, reinicia counter GOSUB Back_Up ' y ejecuta una vuelta en U. GOSUB Turn_Left GOSUB Turn_Left ENDIF ' ENDIF counter > 4. ELSE ' ELSE (old7=IN7) o (old5=IN5), counter = 1 ' no alternante, reinicia counter ENDIF ' ENDIF (old7<>IN7) y ' (old5<>IN5). ENDIF ' ENDIF (IN7<>IN5). ' --- Misma rutina de navigacion de RoamingWithWhiskers.bs2 ----------------- IF (IN5 = 0) AND (IN7 = 0) THEN GOSUB Back_Up ' Ambos bigotes detectan el obstáculo, GOSUB Turn_Left ' Retrocede y has vuelta en U (izq. GOSUB Turn_Left ' dos veces) ELSEIF (IN5 = 0) THEN ' Bigote izq. hace contacto GOSUB Back_Up ' Retrocede y voltea a la der. GOSUB Turn_Right ELSEIF (IN7 = 0) THEN ' Bigote der. hace contacto GOSUB Back_Up ' Retrocede y voltea a la izq. GOSUB Turn_Left ELSE ' Ambos bigotes 1, no hay contacto GOSUB Forward_Pulse ' Aplica un pulso hacia adelante ENDIF ' chequea nuevamente LOOP ' -----[ Subrutinas ]--------------------------------------------------------- Forward_Pulse: ' Envia un solo pulso de avance PULSOUT 13,850 PULSOUT 12,650 PAUSE 20 RETURN Turn_Left: ' Vuelta izq., aprox. 90-grados. FOR pulseCount = 0 TO 20 PULSOUT 13, 650 PULSOUT 12, 650


PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Vuelta der., aprox. 90-grados. PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT RETURN Back_Up: ' Retrocede. FOR pulseCount = 0 TO 40 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

Funcionamiento del Programa EscapingCorners.bs2

Ya que este programa es una versión modificada de RoamingWithWhiskers.bs2, sólo las nuevas características relacionadas con la detección y el escape de las esquinas son discutidas aquí. Tres variables extras son creadas para detectar una esquina. La variable tamaño nibble counter puede guardar un valor entre 0 y 15. Ya que nuestro valor objetivo para detectar una esquina es 4, el tamaño de la variable es razonable. Recuerda que una variable tamaño bit puede guardar un sólo bit, un 1 o un 0. Las próximas dos variables (old7 y old5) son ambas variables tamaño bit. Estas son también de tamaño adecuado para la operación ya que son usadas para guardar valores previos de IN7 e IN5, los cuales son también de tamaño bit.

counter VAR Nib old7 VAR Bit old5 VAR Bit

Estas variables tienen que ser inicializadas (dados los valores iniciales). Para hacer el programa más facil de leer, counter es inicializado como 1, y cuando llega a 4 debido al hecho que el Boe-Bot se encuentra atascado en una esquina, es reiniciado a 1. Las variables old7 y old5 tienen que ser establecidas para que parezca que uno de los dos bigotes fue presionado algún tiempo atrás antes de que el programa comenzara. Esto


tiene que hacerse porque la rutina para detectar esquinas consecutivas siempre compara un patrón alternante, (IN5 = 1 e IN7 = 0) ó (IN5 = 0 e IN7 = 1). De igual forma, old5 y old7 tienen que ser diferentes entre sí.

counter = 1 old7 = 0 old5 = 1

Ahora llegamos a la sección Detectar Esquinas Alternantes Consecutivas. La primera cosa que queremos chequear es si uno de los bigotes es presionado. Una manera de hacer esto es preguntar “¿es IN7 diferente de IN5?” En PBASIC, podemos usar el operador no-igual a <> en una sentencia IF:

IF (IN7 <> IN5) THEN Si ciertamente uno de los bigotes está presionado, la próxima cosa es chequear si es el patrón exactamente opuesto de la vez anterior. En otras palabras, ¿es (old7 <> IN7) y es (old5 <> IN5)? De ser cierto, entonces, es hora de sumar uno al contador que sigue los contactos alternos de los bigotes. Además es tiempo de recordar que el patrón actual de bigote haciendo que old7 sea igual al actual IN7 y old5 sea igual al actual IN5.

IF (old7 <> IN7) AND (old5 <> IN5) THEN counter = counter + 1 old7 = IN7 old5 = IN5

Si resulta que esta es la cuarta vez consecutiva que hay contacto con uno de los bigotes, entonces es hora de reiniciar el contador a 1 y ejecutar la vuelta en U.

IF (counter > 4) THEN counter = 1 GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left

Este ENDIF finaliza el bloque de código que es ejecutado si counter > 4.

ENDIF


Esta sentencia ELSE está conectada a la sentencia IF (old7 <> IN7) AND (old5 <> IN5) THEN. La sentencia ELSE cubre lo que sucede si la sentencia IF no es válida. En otras palabras, no se ha presionado un bigote alterno, así que se reinicia el contador porque el Boe-Bot no está atascado en una esquina.

ELSE counter = 1

Esta sentencia ENDIF finaliza el proceso de toma de decisión para la sentencia IF (old7 <> IN7) AND (old5 <> IN5) THEN.

ENDIF ENDIF

El remanente del programa es similar al anterior.

Tu Turno

Una de las sentencias IF...THEN en EscapingCorners.bs2 chequea si counter ha llegado a 4.

√ Trata incrementando el valor a 5 y 6 y observa el efecto. √ Trata también reduciendo el valor y observa si tiene algún efecto cuando corre

libremente.


RESUMEN En este capítulo, en vez de navegar con una lista pre-programada, el Boe-Bot fue programado para navegar basado en entradas de sus sensores. Las entradas de sus sensores en este capítulo fueron bigotes, los cuales sirvieron como interruptores de contacto normalmente abiertos. Cuando están conectados adecuadamente, estos interruptores pueden mostrar un voltaje (5 V) en el punto de contacto del interruptor cuando están abiertos, y un voltaje distinto (0 V) cuando están cerrados. Los registros de los pines de I/O del BASIC Stamp guardan “1” si detectan Vdd (5 V) y “0,” si detectan Vss (0 V). El BASIC Stamp fue programado para probar los sensores de bigote y mostrar los resultados de la verificación usando dos tipos distintos de medios, el Debug Terminal y LEDs. Programas en PBASIC fueron desarrollados para hacer que el BASIC Stamp chequeara los bigotes entre cada pulso del servo. Basado en los estados de los bigotes, las sentencias IF…THEN en la sección de la Rutina Principal del programa, llamaron a subrutinas de navegación similares a las desarrolladas en el capítulo anterior para guiar al Boe-Bot evadiendo los obstáculos. Como un ejemplo de inteligencia artificial, una rutina adicional fue desarrollada para permitir que el Boe-Bot determinase cuando se quedaba atascado en una esquina. Esta rutina requirió que los estados previos de los bigotes fueran guardados, comparados con los estados actuales de los bigotes, y contando el numero de veces en que objetos alternantes fueron detectados. Este capítulo introdujo la navegación del Boe-Bot basada en sensores. Los próximos tres capítulos se concentrarán en usar diferentes tipos de sensores para darle visión al Boe-Bot. Tanto el palpe como la visión abren muchas oportunidades para que el Boe-Bot navegue en ambientes de mayor complejidad.

Preguntas 1. ¿Qué tipo de conección eléctrica es un bigote? 2. ¿Cuando un bigote es presionado, que voltaje ocurre en el pin I/O que lo

monitorea? ¿Qué valor binario ocurrirá en el registro de entrada? ¿Si el pin I/O P8 es usado para monitorear el pin de entrada, qué valor tiene IN8 cuando el bigote es presionado, y que valor tiene cuando el bigote no es presionado?

3. ¿Si IN7 = 1, que significa? ¿Qué significa si IN7 = 0? ¿Y qué hay de IN5 = 1 e IN5 = 0?


4. ¿Qué comando es usasdo para saltar a diferentes subrutinas dependiendo del valor de una variable? ¿Qué comando es utilizado para decidir a cuál subrutina saltar? ¿En qué se basan estas decisiones?

5. ¿Cuál es el propósito de tener sentecias IF…THEN anidadas?

Ejercicios 1. Escribe un comando DEBUG para TestWhiskers.bs2 que actualice el estado de

cada bigote en una nueva línea. Ajusta el comando PAUSE para que sea 250 en vez de 50.

2. Usando RoamingWithWhiskers.bs2 como referencia, escribe una subrutina llamada Turn_Away que llame a la subrutina Back_Up una vez y a la subrutina Turn_Left dos veces. Escribe las modificaciones que vas a tener que hacerle a la sección de la Rutina Principal del programa RoamingWithWhiskers.bs2.

Proyectos 1. Modifica el programa RoamingWithWhiskers.bs2 de modo que el Boe-Bot haga

un bip de 4 kHz que dure 100 ms antes de ejecutar la maniobra evasiva. Haz que haga bip dos veces si ambos bigotes detectan un contacto durante el mismo muestreo (o ciclo).

2. Modifica el programa RoamingWithWhiskers.bs2 de modo que el Boe-Bot navegue libremente en un círculo de 1 yarda (o metro) de diámetro. Cuando toques uni de los bigotes, causará que el Boe-Bot navegue en un círculo más apretado (de menor diámetro). Cuando toques el otro bigote, causará que el Boe-Bot navegue en un círculo de mayor diámetro.


Soluciones Q1. Un interruptor táctil. Q2. Cero (0) voltios, resultando en un cero Binario (0) en el registro de entrada.

IN8 = 0 cuando el bigote es presionado. IN8 = 1 cuando el bigote no está presionado.

Q3. IN7 = 1 significa que el bigote derecho no está presionado. IN7 = 0 significa que el bigote derecho es presionado. IN5 = 1 significa que el bigote izquierdo no está presionado. IN5 = 0 significa que el bigote izquiero es presionado.

Q4. El comando GOSUB realiza el salto. El comando IF...THEN es usado para decidir a cuál rutina saltar. Esa decisión es basada en condiciones, las cuales son sentencias lógicas que son evaluadas como verdadero o falso.

Q5. El programa puede chequear por una condición, y si esa condición es verdadera, puede chequear otra condición dentro de la primera condición.

E1. La clave para resolver este problema es usar un segundo comando CRSRXY que

hará que el estado del segundo bigote se muestre en el lugar apropiado en la pantalla. Para alinearlo con los encabezados, el texto debe comenzar en la columna 9 de la fila 3. ' Robotica con el Boe-Bot - TestWhiskers_UpdateEaOnNewLine.bs2 ' Actualiza el estado de cada bigote en una nueva linea. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "WHISKER STATES", CR, "Left Right", CR, "------ ------" DO DEBUG CRSRXY, 0, 3, "P5 = ", BIN1 IN5 ' Muestra en Columna 0,Fila 3 DEBUG CRSRXY, 9, 3, "P7 = ", BIN1 IN7 ' Muestra in Columna 9,Fila 3 PAUSE 250 ' Cambio de 50 a 250 LOOP

E2. Turn_Away:

GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left RETURN


Para modificar la Rutina Main, reemplaza los tres comandos GOSUB bajo la primera condición IF con esta sola línea: GOSUB Turn_Away

P1. La clave para resolver este problema es escribir una sentencia que haga bip con los parámetros requeridos:

FREQOUT 4, 100, 4000 ' Bip de 4kHz por 100ms Esta sentencia debe ser agregada a la Rutina Principal en los lugares apropiados, como se muestra abajo. El resto del programa se mantiene igual. ' -----[ Rutina Principal ]------------------------------------ DO IF (IN5 = 0) AND (IN7 = 0) THEN ' Ambos bigotes detectan FREQOUT 4, 100, 4000 ' Bip de 4 kHz por 100 ms FREQOUT 4, 100, 4000 ' Repite dos veces GOSUB Back_Up ' Retrocede y da vuelta en U GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN ' Bigote izq. hace contacto FREQOUT 4, 100, 4000 ' Bip de 4 kHz por 100 ms GOSUB Back_Up ' Retrocede y gira der. GOSUB Turn_Right ELSEIF (IN7 = 0) THEN ' Bigote der. hace contacto FREQOUT 4, 100, 4000 ' Bip de 4 kHz por 100 ms GOSUB Back_Up ' Retrocede y gira izq. GOSUB Turn_Left ELSE ' Ambos bigotes 1, no GOSUB Forward_Pulse ' hay contacto ENDIF ' Pulso de avance y LOOP ' chequea nuevamente

P2. Encontramos en los Proyectos del Capítulo 4 que un círculo de 1 yarda puede ser logrado con PULSOUT 13, 850 y PULSOUT 12, 716. Usando estos valores como el círculo de 1y, el radio puede ser ajustado a través de leves incrementos o disminuciones del ancho de pulso desde un valor inicial de 716. Cada vez que un bigote es presionado el programa sumará o restará un poco del ancho de pulso de la rueda derecha.


En la solución de abajo, un indicador con bip audible fue añadido. Esto actúa como una retroalimentación para verificar que el bigote fue presionado. Esto es completamente opcional.

' Robotica con el Boe-Bot - CirclingWithWhiskerInput.bs2 ' Mueve en un circulo de 1 yarda, incrementa/disminuye el radio en ' respuesta al activamiento de los bigotes, uno incrementa y el otro ' disminuye. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables/Inicializacion ]------------------------------------ pulseWidth VAR Word ' Senal enviada al servo toneFreq VAR Word ' Frecuencia del tono (bip) pulseWidth = 716 ' Encontrado en Cap 4 para ' circulo de 1y toneFreq = 4000 ' Tono inicial es 4 kHz ' -----[ Rutina Principal ]-------------------------------------------- DO PULSOUT 13, 850 ' Pulso de servos en trayecto circular PULSOUT 12, pulseWidth ' 12 mas lento que 13 para curvear PAUSE 20 IF (IN5 = 0) THEN ' Bigote izq. hace el circulo IF (pulseWidth <= 845) THEN ' pequeno, hasta el max pulso pulseWidth = pulseWidth + 5 ' del servo, pulseWidth 850. toneFreq = toneFreq + 100 FREQOUT 4, 100, toneFreq ' Toca el tono como indicacion ENDIF ELSEIF (IN7 = 0) THEN ' Bigote der. hace el circulo IF (pulseWidth >= 655) THEN ' grande, hasta el min pulso pulseWidth = pulseWidth - 5 ' del servo, pulseWidth 650. toneFreq = toneFreq - 100 FREQOUT 4, 100, toneFreq ' Toca el tono como indicacion ENDIF ENDIF LOOP

Capítulo 6: Navegación Sensible a la Luz con Fotoresitores · Page 199

Capítulo 6: Navegación Sensitiva a Luz con Fotoresistores La luz tiene muchas aplicaciones en robótica y control industrial. Algunos ejemplos son, la percepción del borde de un rollow de tela en la industria textil, la determinación de cuándo activar las luces en la calle durante distintas épocas del año, cuándo tomar una foto, o cuándo regar con agua una cosecha de plantas. Existen muchos sensores de luz diferentes con funciones únicas. El sensor de luz en tu kit del Boe-Bot está diseñado para detectar luz visible, y puede ser usado para hacer que tu Boe-Bot detecte variaciones en la intesidad de la luz. Con esta abilidad, tu Boe-Bot puede ser programado para reconocer áreas con perímetros claros u obscuros, así como también, podrá reportar la luminosidad global y el nivel de obscuridad que observe, además podrá seguir fuentes de luz, tales como el rayo de luz de una linterna y puertas que permitan el paso de luz a un cuarto obscuro.

INTRODUCIENDO EL FOTORESISTOR Los resistores con los que has trabajado en capítulos previos tenían valores fijos, tales como 220 Ω y 10 kΩ. Por otro lado, el fotoresistor , es un resistor dependiente de luz (LDR, por sus siglas en inglés). Lo cual quiere decir, que su valor de resistencia depende en la luminosidad en el ambiente que es reflejada sobre su superficie detectora de luz. La Figura 6-1 muestra el símbolo esquemático y el dibujo de parte del fotoresistor que usarás para hacer que el Boe-Bot sea capaz de detectar variaciones en la intensidad de la luz.

Figura 6-1 Fotoresistor Símbolo Esquemático y Dibujo de parte

Light detecting surface


Un fotoresistor es un resistor dependiente de luz (LDR, por sus siglas en inglés) que tiene una sensitividad espectral similar a la del ojo humano. En otras palabras, el tipo de luz que tu ojo detecta es el mismo tipo de luz que afecta la resistencia del fotoresistor. El elemento activo de estos fotoresistores está hecho de Sulfuro de Cadmio (CdS). La luz entra en la capa de semiconductor que se encuentra sobre el substrato de cerámica y que se encarga de producir conductores libres. Una resistencia eléctrica definida es producidad de manera inversamente proporcional a la intensidad de la iluminación (o luminosidad). En otras palabras, la obscuridad causa mayor resistencia, y brillo causa menor resistencia.

Luminosidad es un nombre científico para la medida de luz incidente . Una manera de entender luz incidente es pensar acerca de una linterna iluminando la pared. El rayo de luz enfocado que observas iluminando la pared es la luz incidente. La unidad de medida de luminosidad es comunmente llamado "foot-candle" (en inglés) en el sistema Británico de medida, o también como "lux" en es sistema métrico. Mientras estemos usando fotoresistores no nos preocuparemos de los niveles de lux, solo de que la luminosidad sea mayor o menor en ciertas direcciones. El Boe-Bot puede ser programado para usar la intensidad relativa de la luz para tomar decisiones de navegación.

ACTIVIDAD #1: CONSTRUYENDO Y PROBANDO CIRCUITOS DE FOTORESISTORES En esta actividad, construirás y verificarás un circuito sensible a la luz con fotoresistores. Tu circuito perceptor de nivel de luz será capaz de detectar la diferencia entre sombra y no-sombra. Los comandos PBASIC para determinar si una sombra recubre el fotoresistor será muy similar a los usados para determinar si un bigote había sido presionado o no.

Lista de Partes:

(2) Fotoresistores - CdS (2) Resistores – 2 kΩ (rojo-negro-rojo) (2) Resistores – 220 Ω (rojo-rojo-marrón) (4) Cables de conexión (2) Resistores – 470 Ω (amarillo-violeta-marrón) (2) Resistores – 1 kΩ (marrón-negro-rojo) (2) Resistores – 4.7 kΩ (amarillo-violeta-rojo) (2) Resistores – 10 kΩ (marrón-negro-naranja)

Construyendo los Ojos Fotosensitivos Figura 6-2 muestra el dibujo esquemático y Figura 6-3 muestra el diagrama de conexión para los circuitos de fotoresistores que vas a usar para esta y las próximas dos actividades.


√ Desconecta la energía de tu plaqueta y servos. √ Construye el circuito mostrado en Figura 6-2, usando la Figura 6-3 como

referencia. Vdd

Vss

220 ΩP6

2 kΩ

Vdd

Vss

220 ΩP3

2 kΩ

Figura 6-2 Schematic – First Light Detection Circuit

P15P14P13P12P11P10P9P8P7

P5

P2P1P0

P6

P4P3

X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P6

P4P3

P10P9P8P7

P5

P2P1P0

X2

X3Vdd VssVin


To Servos

+

HomeWork Board

Figura 6-3 Diagrama de Conexión para el Primer Circuito de Detección de Luz Board of Education (izq.) y HomeWork Board (der.).


Funcionamiento del Circuito Fotoresistivo Un pin I/O en el BASIC Stamp puede funcionar como una entrada o una salida. Como una salida, el pind I/O puede enviar una señal alta (5 V) o baja (0 V). Hasta ahora, señales altas y bajas han sido usadas para prender y apagar los circuitos LED, controlar los servos, y enviar tonos a la bocina. Un pin I/O del BASIC Stamp I/O también puede funcionar como una entrada. De esta forma, el pin I/O no ejerce nigún voltaje al circuito al cual está conectado. Al contrario, escucha silenciosamente sin afectar el circuito. En el capítulo previo, estos registros de entrada guardaron valores que indicaban si un bigote era presionado o no. Por ejemplo, el registro de entrada IN7 guardaba un 1 cuando percibía 5 V (bigote no presionado), o un 0 cuando percibía 0 V (bigote presionado). Un pin de I/O establecido como pin de entrada no necesita tener 5 V ejercidos sobre él para hacer que su registro de entrada almacene 1. Cualquier valor por encima de 1.4 V hará que el registro de entrada de un pin de I/O almacene un 1. De igual forma, el pin no necesita 0 V para hacer que su registro de entrada almacene un 0. Cualquier voltaje por debajo de 1.4 V hará que el registro de entrada del pin de I/O almacene un 0.

Los pines de I/O del BASIC Stamp son entradas por defecto. Cuando un programa del BASIC Stamp comienza, todos los pines de I/O comienzan como entradas. Cuando usas los comandos como HIGH, LOW, PULSOUT o FREQOUT, los pines de I/O son cambiados de entradas a salidas de modo que el BASIC Stamp pueda mandas las señales altas o bajas.

Cuando un pin de I/O del BASIC Stamp es una entrada, el circuito se comporta como si no estuvieran presente ni el pin de I/O ni el resistor de 220 Ω. La Figura 6-4 muestra el circuito equivalente. La resistencia del fotoresistor es mostrada con la letra R. Podría ser unos pocos Ω si la luz es muy brillante, o en la vecindad de 50 kΩ en obscuridad total. En un cuarto bien iluminado con ajustes de luces fluorescentes en el techo, la resistencia podría ser tan pequeña como 1 kΩ (exposición completa a la luz) o tan grande como 25 kΩ (sombra recubiendo la mayor parte del objeto). Mientras la resistencia del fotoresistor cambia con la exposición a la luz, también lo hace el voltaje en Vo; mientras R aumenta, Vo disminuye y mientras R disminuye, Vo aumenta. Vo es lo que el pin del BASIC Stamp I/O está detectando cuando funciona como una entrada. Si este circuito es conectado a IN6, cuando el voltaje en Vo es mayor a 1.4 V, IN6 almacenará un 1. Si Vo cae por debajo de 1.4 V, IN6 almacenará un 0.


Vdd

Vss

2 kΩ

Vo

R

Figura 6-4 Dibujo Esquemático – Circuito Divisor de Voltaje

Cuando los resistores están conectados extremo con extremo como lo muestra la figura Figura 6-4 están conectados en serie, y pueden ser llamados resistores en serie .

Cuando dos resistores se encuentran conectados en serie para establecere un voltaje Vo, el circuito es llamado divisor de voltaje. En este circuito, el valor de Vo puede rondar entre Vdd y Vss. El vlaor exacto de Vo es determinado por la relación entre R y 2 kΩ. Cuando R sea mayor a 2 kΩ, Vo estará más cerca de Vss. Cuando R sea más pequeño que 2 kΩ, Vo estará más cerca a Vdd. Cuando R sea igual a 2 kΩ, Vo será 2.5 V. Si mides uno de los valores (R o Vo), puedes calcular el otro valor usando uno de estas dos ecuaciones.

R00020002V5Vo

+ΩΩ

×=

Ω−⎟⎠⎞

⎜⎝⎛ Ω

×= 2000Vo

2000V5R

1.4 V es llamado el voltaje umbral del pin I/O del BASIC Stamp, también es conocido como el umbral lógico del pin I/O. Cuando el voltaje percibido por un pin de I/O está por encima de ese umbral, el registro de entrada del pin I/O almacenará un 1. Si es menor a ese valor, el registro de entrada del pin I/O almacenará un 0.

Detectando Sombras Cubrir con una sombra al fotoresistor produce un valor de resistencia (R) mayor, lo cual hace que Vo sea menor. Los resistores de 2 kΩ fueron escogidos para hacer que el valor de Vo fuera un poco mayour al voltaje umbral del pin I/O del BASIC Stamp (1.4 V) en un cuarto bien alumbrado. Cuando cubres con una sombra sonre él con tu mano, debería de enviar Vo por debajo del umbral de 1.4 V.


En un cuarto bien iluminado, tanto IN6 como IN3 almacenarán el valor 1. Si cubres con una sombra el fotoresistor divisor conectado a P6, entonces almacenará un 0. De igual manera, si cubres con una sombra el fotoresistor divisor conectado a P3, causará que IN3 almacene un 0.

Example Program: TestPhotoresistorsDividers.bs2

Este programa de ejemplo es TestWhiskers.bs2 adaptado a los fotoresistores divisores. En vez de monitorear P5 y P7 como hicimos con los bigotes, ahora monitoreamos P3 y P6, los cuales están conectados a los circuitos de fotoresistores divisores. Este programa debería mostrar un valor de 1 en ambos lados dentro de un cuarto bien iluminado. Cuando cubres con una sombra uno o ambos fotoresistores, los valores correspondientes deberían cambiar a 0.

√ Reconecta la energía a tu plaqueta. √ Introduce, guarda, y ejecuta TestPhotoresistorDividers.bs2. √ Verifica que sin sombra, tanto IN6 como IN3 almacenan el valor 1. √ Verifica que cuando usas tu mano para cubrir con una sombra cada uno de los

fotoresistores puedes originar un cambio en el registro de entrada de 1 a 0. √ Si estás teniendo dificultades, bien sea haciendo que el registro de entrada

cambie a 0 cuando causas una sombra, o si los registro de entrada son 0 independientemente si originas una sombra o no, consulta el recuadro Resolución de Problemas del Fotoresistor Divisor luego del listado del programa. Continúa trabajando en ello hasta que la sombra originada por tu mano haga que el estado cambie de 1 a 0 con regularidad.

' Robotica con el Boe-Bot - TestPhotoresistorDividers.bs2 ' Muestra lo que perciben los pines de I/O conectados al circuito de ' fotoresistores divisores de voltaje. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "PHOTORESISTOR STATES", CR, "Left Right", CR, "------- --------" DO DEBUG CRSRXY, 0, 3, "P6 = ", BIN1 IN6, " P3 = ", BIN1 IN3 PAUSE 100 LOOP


Resolución de Problemas para el divisor de voltaje con fotoresistor

Cosas en general para verificar:

√ Chequea tus conexiones y programa por errores. √ Asegúrate que cada componente está firmemente conectado en su enchufe. √ Chequea el código de colores de tus resistores. Los resistores que se conectan

entre Vss y los fotoresistores deberían ser de 2 kΩ (rojo-negro-rojo). Los resistores conectando P6 y P3 a los fotoresistores deberían ser de 220 Ω (rojo-rojo-marrón).

Si ninguno de lo registros IN3 o IN6 mostró 0 independientemente de si los cubriste o no con una sombra:

√ Si el cuarto tiene poca iluminación, considera traer unas lámparas extra. Alternativamente, puedes reemplazar los resitores de 2 kΩ con unos de 4.7 kΩ (Amarillo Violeta Rojo). Esto hará que tu divisor tenga mejor desempeño en condiciones de luz baja. Para condiciones de luz realmente bajas, hasta puedes usar resistores de 10 kΩ (marrón-negro- naranja).

Si ninguno de los registros IN3 o IN6 mostró 1 independientemente de si los cubriste o no con una sombra:

√ Si el cuarto está muy iluminado, y te ves forzado a poner tu mano en forma de copa sobre la superficie recolectora de luz del fotoresistor para hacer que 1 cambie a 0, puede que necesites subsituir por un valor menor, el resistor de 2 kΩ. Trata con un resistor de 1 kΩ (marrón-negro-rojo), o inclusive con uno de 470 Ω (amarillo-violeta-marrón) si te encuentras en un área al aire libre.

Tu Turno – Experimentando con Distintos Divisores de Voltaje Dependiendo de las condiciones de luz en tu área, colocar resitores en serie más grande o pequeños a 2 kΩ puede mejorar el desempeño de tus detectores de sombra.

√ Recuerda desconectar la energía de tu plaqueta durante cada modificación de algún circuito.

√ Trata de reemplazar los resistores de 2 kΩ (rojo-negro-rojo) con cada uno de los valores de los otros resistores que has recolectado: 470 Ω, 1 kΩ, 4.7 kΩ, y 10 kΩ.

√ Prueba cada combinación de divisor de voltaje con TestPhotoresistorDividers.bs2 y determina cuáles resistores funcionan mejor bajo tus condiciones de iluminación. La mejor combinación es una que no sea super sensitiva, pero que no requiera tampoco que coloques tu mano como un domo encima del fotoresistor.

√ Usa la combinación de resistor que creas más conveniente durante las próximas dos actividades.


ACTIVITY #2: NAVEGACIÓN LIBRE Y EVASIÓN DE OBJETOS TIPO SOMBRA Ya que los fotoresistores divisores se comportan de manera similar a los bigotes, vale la pena examinar lo que implica la adaptación de RoamingWithWhiskers.bs2 para que funcione con los fotoresistores divisores.

Adaptando RoamingWithWhiskers.bs2 para los Fotoresistores Divisores

Lo único que en realidad necesitas hacer es ajustar las sentencias IF…THEN de manera que monitoreen IN6 e IN3, en vez de IN7 e IN5. La Figura 6-5 demuestra como hacer estos cambios.

Figura 6-5: Modifica RoamingWithWhiskers.bs2 para Usar con Fotoresistores Divisores ' De RoamingWithWhiskers.bs2 IF (IN5 = 0) AND (IN7 = 0) THEN GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN5 = 0) THEN GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN7 = 0) THEN GOSUB Back_Up GOSUB Turn_Left ELSE GOSUB Forward_Pulse ENDIF

' Modificado para ' RoamingWithPhotoresistor ' Dividers.bs2 IF (IN6 = 0) AND (IN3 = 0) THEN GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN6 = 0) THEN GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN3 = 0) THEN GOSUB Back_Up GOSUB Turn_Left ELSE GOSUB Forward_Pulse ENDIF

Example Program – RoamingWithPhotoresistorDividers.bs2

√ Abre el programa RoamingWithWhiskers.bs2 de la página 184, y guárdalo como RoamingWithPhotoresistorDividers.bs2.

√ Haz las modificaciones mostradas en la Figura 6-5. √ Reconecta la energía a tu plaqueta y servos. √ Ejecuta y verifica el programa.


Creando sombras sobre ambos fotoresistores puede ser difícil. Cuando el Boe-Bot avanza, revisa los fotoresistores aproximadamente 40 veces/segundo. Tu tendrás que moverte rápidamente pra crear una sombra sobre ambos fotoresistores entre los pulsos. Ayuda que muevas tu mano rápidamente de una pose sin nada de sombra a una con sombra completa para activar ambos fotoresistores al mismo tiempo. Alternativamente, puedes dejar que tu mano cubra con una sombra ambos fotoresistores mientras ejecuta una maniobra. Cuando retorne de la maniobra y chequee los fotoresistores nuevamente, debería reconocer que ambos fotoresistores están cubiertos por una sombra.

√ Verifica que el Boe-Bot esquiva las sombras usando tu mano para crear sombras

sobre los fotoresistores. Trata primero sin ninguna sombra, luego con una sombra sobre el fotoresistor divisor derecho (circuito conectado a P3), una sombra sobre el fotoresistor divisor izquierdo (circuito conectado a P7), y una sombra sobre ambos fotoresistores divisores.

√ Actualiza los comentarios tales como el título y las descripciones de las reacciones para reflejar el cambio de contactos con los bigotes a comportamiento del circuito del fotoresistor. Debería parecerse al siguiente programa cuando hayas terminado.

' -----[ Titulo ]------------------------------------------------------------- ' Robotica con el Boe-Bot - RoamingWithPhotoresistorDividers.bs2 ' El Boe-Bot detecta sombras con circuito de fotoresistor divisor de voltahe y ' gira alejandose de ellas. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]---------------------------------------------------------- pulseCount VAR Byte ' Contador de bucle FOR...NEXT ' -----[ Inicializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal de start/restart ' -----[ Rutina Principal ]--------------------------------------------------- DO IF (IN6 = 0) AND (IN3 = 0) THEN ' Ambos fotoresistores detectan GOSUB Back_Up ' sombra, retrocede y vuelta en U GOSUB Turn_Left ' (izquierda dos veces). GOSUB Turn_Left ELSEIF (IN6 = 0) THEN ' Fotoresistor izq. detecta GOSUB Back_Up ' sombra, retrocede y gira der.


GOSUB Turn_Right ELSEIF (IN3 = 0) THEN ' Fotoresistor der. detecta GOSUB Back_Up ' sombra, retrocede y gira izq. GOSUB Turn_Left ELSE ' Ningun fotoresistor detecta GOSUB Forward_Pulse ' sombra, avanza. ENDIF LOOP ' -----[ Subrutinas ]--------------------------------------------------------- Forward_Pulse: ' Envia un solo pulso de avance PULSOUT 12,650 PULSOUT 13,850 PAUSE 20 RETURN Turn_Left: ' Giro izq, aprox. 90-grados FOR pulseCount = 0 TO 20 PULSOUT 12, 650 PULSOUT 13, 650 PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Giro der, aprox. 90-grados PULSOUT 12, 850 PULSOUT 13, 850 PAUSE 20 NEXT RETURN Back_Up: ' Retrocede. FOR pulseCount = 0 TO 40 PULSOUT 12, 850 PULSOUT 13, 650 PAUSE 20 NEXT RETURN

Tu Turno – Mejorando el desempeño

Puedes mejorar el desempeño de tu Boe-Bot comentando algunas de las llamadas a subrutinas que fueron diseñadas para ayudar al Boe-Bot a retroceder de los obstáculos y luego girar para evadirlos. La Figura 6-6 muestra un ejemplo donde dos llamadas a la subrutina Turn_Left son comentadas dentro de la sentencia IF…THEN, cuando la condición sea que ambos fotoresistores detecten una sombra. Entonces, cuando


solamente uno de los fotoresistores detecte sombras, las llamadas a subrutina Back_Up son comentadas de manera que el Boe-Bot solo gire en respuesta a una sombra.

Figura 6-6: Modifica RoamingWithPhotoresistorDividers.bs2 ' Extracto del programa ' RoamingWithPhotoresistor ' Dividers.bs2 IF (IN6 = 0) AND (IN3 = 0) THEN GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (IN6 = 0) THEN GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN3 = 0) THEN GOSUB Back_Up GOSUB Turn_Left ELSE GOSUB Forward_Pulse ENDIF

' Extracto modificado del programa ' RoamingWithPhotoresistor ' Dividers.bs2 IF (IN6 = 0) AND (IN3 = 0) THEN GOSUB Back_Up ' GOSUB Turn_Left ' GOSUB Turn_Left ELSEIF (IN6 = 0) THEN ' GOSUB Back_Up GOSUB Turn_Right ELSEIF (IN3 = 0) THEN ' GOSUB Back_Up GOSUB Turn_Left ELSE GOSUB Forward_Pulse ENDIF

√ Modifica RoamingWithPhotoresistorDividers.bs2 como lo muestra la parte

derecha de la Figura 6-6. √ Ejecuta el programa y compara el desempeño.

ACTIVIDAD #3: UN BOE-BOT CONTROLADO POR SOMBRAS MAS RESPONSIVO Al eliminar los bucles FOR…NEXT en las subrutinas navegación, puedes hacer que tu Boe-Bot sea significativente más responsivo. Esto no era realmente posible con los bigotes, porque el Boe-Bot tenía que retroceder antes de girar ya que había hecho contacto físico con el obstáculo. Cuando estás usando sombras para guiar el Boe-Bot, él puede chequear entre cada pulso, para determinar si la sombra todavía es detectada independientemente de si se está moviendo hacia adelante o si está ejecutando una maniobra.

Un Control Simple con Sombras para el Boe-Bot

Una forma interesante de control remoto es hacer que el Boe-Bot se quede quieto en la luz normal, y luego siga una sombra que hagas sobre los fotoresistores. Es una manera amigable al usuario para guiar la moción del Boe-Bot.


Programa de Ejemplo – ShadowGuidedBoeBot.bs2

Cuando ejecutes este próximo programa, el Boe-Bot debería quedarse quieto mientras que ninguna sombra cubra sus fotoresistores divisores. Cuando cubras ambos fotoresistores con una sombra, el Boe-Bot debería avanzar. Si cubres con una sombra uno de los fotoresistores, el Boe-Bot debería girar en la dirección de el fotoresistor que perciba la sombra.

√ Introduce, guarda, y ejecuta ShadowGuidedBoeBot.bs2. √ Usa tu mano para crear sombras sobre los fotoresistores divisores. √ Estudia este programa detalladamente y asegúrate de entender cómo funciona.

Es muy corto, pero a la vez muy poderoso. ' Robotica con el Boe-Bot - ShadowGuidedBoeBot.bs2 ' Boe-Bot detecta sombras creadas por tu mano y trata de seguirlas. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" FREQOUT 4, 2000, 3000 ' Senal de Start/restart DO IF (IN6 = 0) AND (IN3 = 0) THEN ' Ambos detectan sombras, avanza PULSOUT 13, 850 PULSOUT 12, 650 ELSEIF (IN6 = 0) THEN ' Izq. detecta sombra, PULSOUT 13, 750 ' gira (pivotea) izq. PULSOUT 12, 650 ELSEIF (IN3 = 0) THEN ' Der. detecta sombra, PULSOUT 13, 850 ' gira (pivotea) der. PULSOUT 12, 750 ELSE PULSOUT 13, 750 ' No hay sombra, queda quieto PULSOUT 12, 750 ENDIF PAUSE 20 ' Pausa entre pulsos. LOOP

Funcionamiento del Programa ShadowGuidedBoeBot.bs2

La sentencia IF…THEN en DO…LOOP busca una de cuatro combinaciones de sombra posibles: ambos, izq., der., ninguno. Dependiendo de cuál condición es detectada, los


comandos PULSOUT envían pulsos para una de las siguientes maniobras: avance, pivoteo a la der., pivoteo a la izq., or quedarse quieto. Independientemente de la condición, uno de los cuatro conjuntos de pulsos será enviado en cada iteración de DO…LOOP. Luego de una sentencia IF…THEN, es importante recordar incluir el comando PAUSE 20 para asegurar el tiempo de señal baja entre cada par de pulsos hacia los servos.

Tu Turno – Condensando el Programa

Este programa no necesita la condición ELSE o los dos comandos PULSOUT que le siguen. Si no envías pulsos, el Boe-Bot se quedará quieto, de igual forma que si le envías pulsos usando 750 para el argumento Duration del comando PULSOUT.

√ Prueba borrar (o comentar) este bloque de código. ELSE PULSOUT 13, 750 PULSOUT 12, 750

√ Ejecuta el programa modificado. √ ¿Puedes detectar alguna diferencia en el comportamiento del Boe-Bot?

ACTIVIDAD #4: OBTENIENDO MAS INFORMACION DE TUS FOTORESISTORES La única información que el BASIC Stamp fue capaz de recolectar de los circuitos de fotoresistores divisores, fue si el nivel de luz estaba por encima o por debajo de un umbral. Esta actividad introduce un circuito diferente que el BASIC Stamp puede monitorear, y obtener suficiente información para determinar niveles relativos de iluminación. El valor que el BASIC Stamp obtiene del circuito variará entre números pequeños, indicando luz intensa, hasta números grandes, indicando poca luz. Esto implica que no tendrás que reemplazar a mano los resistores en serie basado en los niveles de luz. En su lugar, podrás ajustar tu programa para buscar diferentes rangos de valores.

Introduciendo el Capacitor

Un capacitor es un dispositivo que alamacena carga, y es un bloque fundamental para la construcción de muchos circuitos. La capacidad de almacenamiento de carga del capacitor es medida en faradios (F). Un faradio es un valor bastante grande por lo que no es práctico para ser usado con el Boe-Bot. Los capacitores que usarás en esta actividad almacenan fracciones de millonésimas de faradio. Una millonésima de faradio se llama


microfaradio, y se abrevia μF. El capacitor que usarás en este ejercicio alamacena exactamente una centésima de una millonésima de faradio. Es decir, 0.01 μF.

Medidas de capacitancia comunes:

• Microfaradios: (millonésimas de un Faradio), abreviado como μF 1 μF = 1×10-6 F

• Nanofaradios: (billonésimas de un Faradio), abreviado como nF 1 nF = 1×10-9 F

• Picofaradioss: (trillonésimas de un Faradio), abreviado como pF 1 pF = 1×10-12 F

El 103 en la carcasa del capacitor de 0.01 μF es una medida de picofaradios (pF). 103 es 10, con tres ceros añadidos, lo cual equivale a 10,000. He aquí la manera de relacionar 103 con 0.01 μF.

10,000 equivale a 10 × 103.

(10 × 103) × (1 × 10-12) F = 10 × 10-9 F

lo cual equivale a 0.01 × 10-6 F

lo cual, a su vez, equivale a 0.01 μF.

La Figura 6-7 muestra el símbolo esquemático para un capacitor de 0.01 μF junto con el dibujo de la parte en el kit de partes de tu Boe-Bot. El 103 del capacitor indica su valor.

Lista de Partes:

(2) Fotoresistores - CDS (2) Capacitores – 0.01 μF (103) (2) Resistores - 220 Ω (rojo-rojo-marrón) (2) Cables de conexión

0.01 µF103

Figura 6-7 Capacitor Símbolo esquemático y Dibujo de parte

También puede haver capacitores de 0.1 μF marcados con 104 en tu kit. No los uses en estas actividades.

√ Asegúrate que hayas selecionado los capacitores de 0.01 µF (marcados 103) para esta actividad.

Los capacitores de 0.1 μF pueden ser usados en áreas con bastante iluminación, pero interfieren con el desempeño del Boe-Bot en áreas cubiertas, con pocas fuentes de iluminación.


Reconstruyendo los Ojos Fotosensitivos El circuito que el BASIC Stamp puede usar para determinar los niveles de luz es llamado cicuito resistor/capacitor (RC). La Figura 6-8 muestra los dibujos esquemáticos del circuito RC de detección de luz del Boe-Bot y la Figura 6-9 muestra ejemplos de los diagramas de conexión para la Board of Education y la HomeWork Board.

√ Desconecta la energía de tu plaqueta y servos. √ Construye el circuito RC mostrado en la Figura 6-8 usando Figura 6-9 como

referencia.

Vss

220 ΩP6

0.01 µF

Vss

220 ΩP3

0.01 µF

Figura 6-8 Dibujo esquemático – Dos circuitos RC con Fotoresistores Para medir resistencia que varía con luminosidad.


P15P14P13P12P11P10P9P8P7

P5

P2P1P0

P6

P4P3

X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P6

P4P3

P10P9P8P7

P5

P2P1P0

X2

X3Vdd VssVin


To Servos

+

HomeWork Board

Figura 6-9 Diagramas de Conexión para los Circuitos con Fotoresistores Board of Education (izq.) y HomeWork Board (der.).

Acerca del Tiempo de Decaimiento RC y del Circuito Fotoresistor Piensa que un capacitor, como el encontrado en circuito mostrado en la Figura 6-10, es como una batería recargable pequeña. Cuando P6 envía la señal alta , esencialmente carga esta batería-capacitor aplicándole 5 V. Luego de unos cuantos ms, el capacitor se carga hasta casi 5 V. Si el programa del BASIC Stamp program cambia entonces el pin de I/O para que escuche silenciosamente, el capacitor pierde su carga a través del fotoresistor. Mientras el capacitor pierde su carga a través del fotoresistor, su voltaje decae, disminuyendo a medida que pierda la carga. El tiempo que le toma a IN6 en percibir que el voltaje está oir debajo de 1.4 V depende de cuán fuerte el fotoresistor “resista” el flujo de corriente eléctrica proveniente del capacitor. Si el fotoresistor tiene un valor de resistencia grande debido a condiciones de luz baja, el capacitor tarda mas en descargarse. Si el fotoresistor tiene un valor de resistancia pequeño debido a condiciones de luz alta, no resistirá la corriente muy fuertemente, por lo que el capacitor se descargará rápidamente.

Hacia los Servos

Hacia los Servos


Vss

220 ΩP6

0.01 µF

Figura 6-10 Circuito RC Conectado a un Pin de I/O

Conectado en paralelo

El fotoresistor y capacitor mostrados en la Figura 6-10 se encuentran conectados en paralelo. Para que dos componentes estén conectados en paralelo, cada uno de sus extremos debe estar conecado a un terminal común (tambieén llamados nodos ). Tanto el fotoresistor como el capacitor tienen un terminal (o pata) conectado a Vss. También tienen un extremo conectado al mismo terminal del resitor de 220 Ω.

Midiendo el Tiempo de Decaimiento RC con el BASIC Stamp El BASIC Stamp puede ser programado para cargar el capacitor y luego medir el tiempo que le toma al voltaje almacenado en decaer a 1.4 V. Es tiempo de decaimiento puede ser usado para indicar la resistencia del fotoresistor. La resistencia a su vez indica cuan brillante es la luz detectada por el fotoresistor. Esta medida requiere una combinación de comandos HIGH y PAUSE junto con un nuevo comando llamado RCTIME. El comando RCTIME está diseñado para medir el tiempo de decaimiento RC en un circuito como el que muestra la Figura 6-10. He aquí la sintaxis del comando RCTIME:

RCTIME Pin, State, Duration

El argumento Pin es el número del pin de I/O que quieres medir. Por ejemplo, si quieres medir P6, el argumento Pin debería ser 6/ El argumento State puede ser 1 ó 0. Debería ser 1 si el voltaje a través del capacitor comienza por encima de 1.4 V y decae. Debería ser 0 si el voltaje a través del capacitor comienza por debajo y de 1.4 V y crece. Para el circuito en la Figura 6-10, el voltaje a través del capacitor comenzará cerca de 5 V y decaerá a 1.4 V, así que el argumento State debería ser 1. El argumento Duration tiene que ser una variable que guarde la medida del tiempo, la cual está en unidades de 2 μs. En este próximo programa de ejemplo, mediremos el tiempo de decaimiento RC en el circuito con fotoresistor, que se encuentra conectado a P6, el cual es el fotoresistor en la izquierda del Boe-Bot.


Para medir el decaimiento RC, la primera cosa que debes hacer es asegurarte que hayas declarado una variable que guarde la medida de tiempo:

timeLeft VAR Word Estas próximas tres líneas de código cargan el capacitor, miden el tiempo de decaimiento RC, y luego almacenan ese valor en la variable timeLeft.

HIGH 6 PAUSE 3 RCTIME 6,1,timeLeft

Para obtener la medida, el código implementa estos tres pasos:

1. Comienza a cargar el capacitor conectando el circuito a 5 V (usando el comando HIGH).

2. Usa el comando PAUSE para darle suficiente tiempo al comando HIGH para cargar el capacitor en el circuito RC.

3. Ejecuta el comando RCTIME, lo cual establece al pin de I/O como entrada, mide el tiempo de decaimiento (desde casi 5 V a 1.4 V), y lo almacena en la variable timeLeft.

Example Program: TestP6Photoresistor.bs2

√ Reconecta la energía a tu plaqueta. √ Introduce, guarda, y ejecuta TestP6Photoresistor.bs2. √ Cubre con una sombra al fotoresistor conectado a P6 y verifica que el tiempo

medido aumenta a medida que el ambiente se hace más obscuro. √ Apunta la superficie recolectora de luz del fotoresistor directamente hacia una

lámpara en el techo, o alúmbrala directamente con una linterna. El tiempo medido debería de disminuir bastante. Luego, debería de aumentar mientras gradualmente alejas el fotoresistor de la fuente de luz. Debería de aumentar mucho más inclusive, si con tu mano haces una sombra que lo cubra o si apagas las luces.

' Robotica con el Boe-Bot - TestP6Photoresistor.bs2 ' Verifica el circuito con fotoresistor conectado a P6 en el Boe-Bot ' y mmuestra el tiempo de decaimiento. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC.


timeLeft VAR Word DO HIGH 6 PAUSE 2 RCTIME 6,1,timeLeft DEBUG HOME, "timeLeft = ", DEC5 timeLeft PAUSE 100 LOOP

Tu Turno √ Guarda TestP6Photoresistor.bs2 como TestP3Photoresistor.bs2. √ Modifica el programa para que realice la medida de tiempo de decaimiento en el

fotoresistor dereche, el que está conectado a P3. √ Repite las pruebas con sombra y luz con el circuito RC conectado a P3 y verifica

su desempeño. Necesitarás modificar los argumentos Pin para ambos comandos HIGH y RCTIME, cambiándolos de 6 a 3.

ACTIVIDAD #5: BOE-BOT SEGUIDOR DE RAYO DE LUZ DE LINTERNA En esta actividad, verificarás y entonarás los sensores de luz de tu Boe-Bot, de manera que reconozcan la diferencia etre luz de ambiente y un rayo de luz de linterna enfocado. De allí, harás que el Boe-Bot siga el rayo de luz de una linterna que se encuentre apuntado a la superficie frontal del Boe-Bot.

Partes Extra

(1) Linterna

Ajuste de Sensores para Percibir el Rayo de Luz de una Linterna Esta actividad funciona mejor si la superficie recolectora de luz de los fotoresistores está apuntada hacia adelante a puntos separados en el piso a una distancia de 2 in (5.1 cm) en frente del Boe-Bot.

√ Apunta las superficies recolectoras de luz de tus fotoresistores a la superficie en frente del Boe-Bot como lo muestra la Figura 6-11.


Figura 6-11: Orientación del Fotoresistor

P15P14P13P12P11P10P9P8P7

P5

P2P1P0

P6

P4P3

X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

Verificando la Respuesta del Sensor al Rayo de Luz de una Linterna

Antes de que puedas programar el Boe-Bot para dar vuelta hacia un rayo de luz de una linterna, tienes que saber la diferencia entre las medidas de luz con y sin el rayo de luz de linterna iluminando el trayecto del Boe-Bot.

Programa del Ejemplo: TestBothPhotoresistors.bs2

√ Introduce, guarda, y ejecuta TestBothPhotoresistors.bs2. √ Coloca el Boe-Bot en la superficie donde va a seguir el rayo de luz de linterna.

Asegúrate que está conectado al cable serial y que las medidas están siendo mostradas en el Debug Terminal.

√ Guarda ambos valores de las medidas de tiempo en la primera fila de la Tabla 6-1.


√ Prende tu linterna, y enfoca tu rayo de luz en frente del Boe-Bot. √ Los tiempos medidos deberán ser ahora, significativamente más bajos que antes.

Guarda estos nuevos valores de ambas medidas de tiempo en la segunda fila de la Tabla 6-1.

Tabla 6-1: Medidas de Tiempo RC con y sin el Rayo de Luz de Linterna

Valores de Duración timeLeft timeRight Descripción

Medidas de tiempo sin rayo de luz de linterna (luz de ambiente).

Medidas de tiempo con el rayo de luz de linterna enfocado en frente del Bo-Bot.

' Robotica con el Boe-Bot - TestBothPhotoresistors.bs2 ' Prueba de los circuitos RC con fotoresistores. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. timeLeft VAR Word ' Declaraciones de variables. timeRight VAR Word DEBUG "PHOTORESISTOR VALUES", CR, ' Inicializacion. "timeLeft timeRight", CR, "-------- ---------" DO ' Rutina principal. HIGH 6 ' Medida de RC time izq. PAUSE 3 RCTIME 6,1,timeLeft HIGH 3 ' Medida de RC time der. PAUSE 3 RCTIME 3,1,timeRight DEBUG CRSRXY, 0, 3, ' Mostrar medidas. DEC5 timeLeft, " ", DEC5 timeRight PAUSE 100 LOOP


Tu Turno

√ Trata de apuntar el Boe-Bot en direcciones distintas y repetir tus medidas. √ Para mejores resultados, puedes promediar tus medidas con la linterna prendida

y apagada respectivamente y reemplazar los valores en la Tabla 6-1 con tus valores promedio.

Siguiendo el Rayo de Luz de una Linterna Has estado usando declaraciones de variables hasta ahora. Por ejemplo, counter VAR Nib le da el nombre counter a una localidad particular en la memoria RAM del BASIC Stamp. Luego de que declaras la variable, cada vez que usas counter en un programa PBASIC, dicho programa usa el valor guardado en esa localidad particular en la memoria RAM del BASIC Stamp. Puedes también declarar constantes. En otras palabras, si tuenes un número que planeas usar tu programa, dale un nombre útil. En vez de la directiva VAR, usa la directiva CON. Aquí se muestran varias directivas CON del próximo programa de ejemplo:

LeftAmbient CON 108 RightAmbient CON 114 LeftBright CON 20 RightBright CON 22 Ahora, cada vez que en el programa aparezca el nombre LeftAmbient, el BASIC Stamp usará el número 108. Cada vez que RightAmbient sea usado, el BASIC Stamp usará el valor 114. De igual manera, cada vez que aparezca LeftBright, en realidad es el valor 20, y RightBright es 22. Substituirás tus valores específicos que anotaste en la Tabla 6-1 antes de ejecutar el programa. Las constantes también pueden ser usadas para calcular otras constantes. He aquí un ejemplo en el que dos constantes llamadas LeftThreshold y RightThreshold son calculadas usando las cuatro constantes discutidas anteriormente. Las constantes LeftThreshold y RightThreshold son usadas en el programa para determinar si el rayo de luz de la linterna ha sido detectado. ' Promedio Factor de Escala LeftThreshold CON LeftBright + LeftAmbient / 2 * 5 / 8 RightThreshold CON RightBright + RightAmbient / 2 * 5 / 8


Los cálculos matemáticos hechos con estas constantes consisten en un promedio seguido de una re-escala. El cálculo del promedio para LeftThreshold es LeftBright + LeftAmbient / 2. Ese resultado es multiplicado por 5 y dividido por 8. Esto significa que LeftThreshold es una constante cuyo valor es 5/8 del promedio de LeftBright y LeftAmbient.

Las expresiones matemáticas en PBASIC son ejecutadas de izquierda a derecha. Primero, LeftBright es sumado a LeftAmbient. Este valor es dividido por 2. Luego, el resultado es multiplicado por 5 y dividido por 8.

Intentemos: LeftBright + LeftAmbient = 20 + 108 = 128.

128 / 2 = 64.

64 * 5 = 320

320 / 8 = 40

Puedes usar paréntesis para forzar que un cálculo que esté más a la derecha en una línea de código en PBASIC sea ejecutada primero. Por ejemplo, puedes reescribir esta línea de código en PBASIC:

pulseRight = 2 - distanceRight * 35 + 750

de esta manera:

pulseRight = 35 * (2 – distanceRight) + 750

En esta expresión, 35 es multiplicado por el resultado de (2 – distanceRight), entonces el producto es sumado a 750.

Programa de Ejemplo: FlashlightControlledBoeBot.bs2

√ Introduce FlashlightControlledBoeBot.bs2 al BASIC Stamp Editor. √ Substituye tu medida timeLeft con el valor sin rayo de luz de linterna (de la

Tabla 6-1), en lugar del valor 108 en la directiva LeftAmbient CON. √ Substituye tu medida timeRight con el valor sin rayo de luz de linterna, en

lugar del valor 114 en la directiva RightAmbient CON. √ Substituye tu medida timeLeft con el valor obtenido cuando el rayo de luz de la

linterna estaba enfocado, en lugar del valor 20 en la directiva LeftBright CON. √ Substituye tu medida timeRight con el valor obtenido cuando el rayo de luz de

la linterna estaba enfocado, en lugar del valor 22 en la directiva RightBright CON.


√ Reconecta la energía a tu plaqueta y servos. √ Guarda y luego ejecuta FlashlightControlledBoeBot.bs2. √ Experimenta y descubre cómo hay que apuntar la luz para avanzar, dar vuelta a

la izquierda, y dar vuelta a la derecha. √ Usa la linterna para guiar a tu Boe-Bot a través de varios cursos con obstáculos.

' -----[ Titulo ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - FlashlightControlledBoeBot.bs2 ' El Boe-Bot sigue el rayo de luz de linterna enfocado en su frente. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Constantes ]--------------------------------------------------------- ' REEMPLAZA ESTOS VALORES CON LOS VALORES QUE DETERMINASTE E INTRODUCISTE EN ' LA TABLA 6.1. LeftAmbient CON 108 RightAmbient CON 114 LeftBright CON 20 RightBright CON 22 ' Promedio Factor de Escala LeftThreshold CON LeftBright + LeftAmbient / 2 * 5 / 8 RightThreshold CON RightBright + RightAmbient / 2 * 5 / 8 ' -----[ Variables ]---------------------------------------------------------- ' Declara las variables para alamacenar los tiempos RC medidos ' por los fotoresistores izq- y der. timeLeft VAR Word timeRight VAR Word ' -----[ Inicializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ Rutina Principal ]---------------------------------------------------- DO GOSUB Test_Photoresistors


GOSUB Navigate LOOP ' -----[ Subrutina - Test_Photoresistors ]------------------------------------- Test_Photoresistors: HIGH 6 ' Medida de tiempo RC izq. PAUSE 3 RCTIME 6,1,timeLeft HIGH 3 ' Medida de tiempo RC der. PAUSE 3 RCTIME 3,1,timeRight RETURN ' -----[ Subrutina - Navigate ]----------------------------------------------- Navigate: IF (timeLeft < LeftThreshold) AND (timeRight < RightThreshold) THEN PULSOUT 13, 850 ' Ambos detectan rayo de luz, PULSOUT 12, 650 ' max. Velocidad de avance. ELSEIF (timeLeft < LeftThreshold) THEN ' Izq. detecta rayo de luz, PULSOUT 13, 700 ' pivotea hacia la izq. PULSOUT 12, 700 ELSEIF (timeRight < RightThreshold) THEN ' Der. detecta rayo de luz, PULSOUT 13, 800 ' pivotea hacia la der. PULSOUT 12, 800 ELSE PULSOUT 13, 750 ' Ninguno detecta rayo de luz, PULSOUT 12, 750 ' queda quieto. ENDIF PAUSE 20 ' Pausa entre pulsos. RETURN

Funcionamiento del Programa FlashlightControlledBoeBot.bs2

Estas son las cuatro declaraciones de constantes que usaste con tus valores de la Tabla 6-1.

LeftAmbient CON 108 RightAmbient CON 114 LeftBright CON 20 RightBright CON 22


Ahora que las cuatro constantes han sido declaradas, las próximas dos líneas promedian y re-escalan los valores para determinar los valores de umbral el programa. Estos valores de umbral pueden ser comparados con los valores de las medidas actuales de timeLeft y timeRight para determinar si los fotoresistores están percibiendo luz de ambiento o el rayo de luz enfocado.

' Promeadio Factor de Escala LeftThreshold CON LeftBright + LeftAmbient / 2 * 5 / 8 RightThreshold CON RightBright + RightAmbient / 2 * 5 / 8

Estas variables son utilizadas para almacenar los valores de las medidas de RCTIME.

timeLeft VAR Word timeRight VAR Word

Este es el indicador de reset que ha sido usado en la mayoría de nuestros programas en este texto.

FREQOUT 4, 2000, 3000

La sección de la Rutina Principal contiene solamente dos llamadas a subrutinas. Todo el trabajo en el programa ocurre en estas dos subrutinas. Test_Photoresistors toma las medidas de RCTIME de ambos circuitos RC con fotoresistores, y la subrutina Navigate toma las decisiones y envía los pulsos a los servos.

DO GOSUB Test_Photoresistors GOSUB Navigate LOOP

Esta es la subrutina que realiza las medidas RCTIME en ambos circuitos RC con fotoresistores. La medida para el circuito izq. es almacenada en la variable timeLeft, y la medida para el circuito der. Es almacenada en la variable timeRight.

Test_Photoresistors: HIGH 6 PAUSE 3 RCTIME 6,1,timeLeft


HIGH 3 PAUSE 3 RCTIME 3,1,timeRight RETURN

La subrutina Navigate usa una sentencia IF…THEN para comparar la variable timeLeft con la constante LeftThreshold y la variable timeRight con la constante RightThreshold. Recuerda que cuando la medida de RCTIME es pequeña, significa que luz intensa ha sido detectada, y cuano es grande, significa que la luz detectada no es tan intensa. Así que, cuando una de las variables que almacena una medida de RCTIME, es más pequeña que la constante de umbral, significa que el rayo de luz de la linterna ha sido detectado. De lo contrario, significa que el rayo no ha sido detectado. Dependiendo de cuál condición detecte la subrutina (ambos, izq., der., o ninguno), los pulsos de navegación apropiados son enviados a los servos, seguido de un comando PAUSE antes de que el comando RETURN salga de la subrutina.

Navigate: IF(timeLeft<LeftThreshold)AND(timeRight<RightThreshold) THEN PULSOUT 13, 850 PULSOUT 12, 650 ELSEIF (timeLeft < LeftThreshold) THEN PULSOUT 13, 700 PULSOUT 12, 700 ELSEIF (timeRight < RightThreshold) THEN PULSOUT 13, 800 PULSOUT 12, 800 ELSE PULSOUT 13, 750 PULSOUT 12, 750 ENDIF PAUSE 20 RETURN

Tu Turno – Ajustando el Desempeño y Modificando el Comportamiento

Puedes ajustar el desempeño del programa ajustando el factor de escala en esta declaración de constates:


' Promedio Factor de Escala LeftThreshold CON LeftBright + LeftAmbient / 2 * 5 / 8 RightThreshold CON RightBright + RightAmbient / 2 * 5 / 8

Si cambias el factor de escala de 5/8 a 1/2, harás que el Boe-Bot sea menos sensible a la luz de la linterna, lo cual puede (o no) mejorar el control del Boe-Bot con la linterna.

√ Prueba diferentes factores de escala, tales como 1/4, 1/2, 1/3, 2/3, y 3/4 y toma notas acerca de las diferencias en cuanto a cómo respondió el Boe-Bot ante el rayo de luz de la linterna.

Modificando la sentencia IF…THEN en el programa de ejemplo, puedes cambiar el comportamiento del Boe-Bot en el Programa de Ejemplo, puedes cambiar el comportamiento del Boe-Bot para que trate de deshacerse de la luz que ilumine sus ojos.

√ Modifica la sentencia IF…THEN para que el Boe-Bot retroceda cuando detecte el rayo de luz de la linterna con ambos circuitos de fotoresistores y de vuelta si detecta el rayo de luz de la linterna con sólo uno de sus circuitos con fotoresistores.

ACTIVIDAD #6: NAVEGANDO LIBREMENTE HACIA LA LUZ El programa de ejemplo en esta actividad puede ser usado para guiar al Boe-Bot a salir de un cuarto obscuro hacia una puerta o entrada que está dejando entrar luz más brillante. También permite mayor control sobre la navegación libre del Boe-Bot creando sombras con tu mano que cubran los fotoresistores.

Reajustando los Fotoresistores

Esta actividad funciona mejor si las superficies recolectoras de luz de los fotoresistores están apuntando hacia arriba y afuera.

√ Apunta las superficies recolectoras de luz de tus fotoresistores hacia arriba y afuera como lo muestra la Figura 6-12.


Figura 6-12: Orientación del Fotoresistor

P15P14P13P12P11P10P9P8P7

P5

P2P1P0

P6

P4P3

X2

X3Vdd VssVin

+

Programando Comportamiento para Navegación Libre hacia la Luz

La clave para la navegación libre hacia fuentes de luz más brillantes es avanzar en línea recta cuando la diferencia entre las medidas de los fotoresistores son pequeñas, y dar vuelta hacia el fotoresistor con la menor medida cuando haya una diferencia grande entre las dos medidas. De hecho, esto significa que el Boe-Bot dará vuelta hacia luz brillante. Inicialmente esto parece como una tarea sencilla de programación; razonando con un comando IF…THEN como en el ejemplo que ves abajo debería funcionar. El problema está en que no funciona, esto se debe a que el Boe-Bot se queda atascado dando vuelta a la izquierda y luego a la derecha nuevamente porque la variación de las variables timeLeft y timeRight son muy grandes. Cada vez que el Boe-Bot gira un poco, las variables timeRight y timeLeft cambian tanto que el Boe-Bot trata de corregir y voltear nuevamente. Nunca logra incorporar los pulsos de avance.

IF (timeLeft > timeRight) THEN ' Gira der. PULSOUT 13, 850 PULSOUT 12, 850 ELSEIF (timeRight > timeLeft) THEN ' Gira izq. PULSOUT 13, 650 PULSOUT 12, 650 ELSE ' Avanza.


PULSOUT 13, 850 PULSOUT 12, 650 ENDIF

He aquí otro bloque de código que funciona un poco mejor. Este bloque de código repara el problema de inestabilidad de giro de una lado para otro bajo ciertas condiciones. La variable timeLeft ahora tiene que ser mayor que timeRight por un margen de 15 antes que el Boe-Bot aplique un pulso izquierdo. De igual manera timeRight tiene que ser mayor que timeLeft por 15 antes de que el Boe-Bot ajuste hacia la izquierda. Esto le da al Boe-Bot la oportunidad de aplicar suficientes pulsos de avance antes de corregir su trayectoria con un giro, pero solo a ciertos niveles de luminosidad.

IF (timeLeft > timeRight + 15) THEN ' Gira der. PULSOUT 13, 850 PULSOUT 12, 850 ELSEIF (timeRight > timeLeft + 15) THEN ' Gira izq. PULSOUT 13, 650 PULSOUT 12, 650 ELSE ' Avanza. PULSOUT 13, 850 PULSOUT 12, 650 ENDIF

El problema con el bloque de código arriba es que funciona solamente en condiciones de luminosidad medianamente obscuras. Si lo llevas a un área muy obscura, el Boe-Bot comienza a oscilar de un lado para otro nuevamente, y nunca aplica los pulsos de avance. Si lo llevas a un área más alumbrada, entonces el Boe-Bot sólo avanza, y nunca hace ajustes hacia la izquierda o hacia la derecha. ¿Por qué sucede esto? He aquí la respuesta: Cuando el Boe-Bot está en un área del cuarto obscura, la medida de de cada fotoresistor será grande. Para que el Boe-Bot decida girar hacia la fuente de luz, la diferencia entre las dos medidas tiene que ser grande. Cuando el Boe-Bot está en un área más ilumindad, la medida de cada fotoresistor será pequeña. Para que el Boe-Bot decida girar, la diferencia entre las medidas de los fotoresistores también tiene que ser mucho más pequeña que lo que fue en la parte más obscura del cuarto. Lo que podemos hacer parar que esta diferencia responda a las condiciones de luminosidad, es hacerla una variable que sea una fracción del averaje de timeRight y timeLeft. De esa manera, siempre será el valor correcto, independientemente de si la luminosidad es alta o baja.

average = timeRight + timeLeft / 2


difference = average / 6

Ahora, la variable difference puede ser usada en esta sentencia IF…THEN, y será un valor grande cuando la luminosidad sea baja, y un valor pequeño cuando la luminosidad sea alta.

IF (timeLeft > timeRight + difference) THEN ' Gira der. PULSOUT 13, 850 PULSOUT 12, 850 ELSEIF (timeRight > timeLeft + difference) THEN ' Gira izq. PULSOUT 13, 650 PULSOUT 12, 650 ELSE ' Avanza. PULSOUT 13, 850 PULSOUT 12, 650 ENDIF

Programa de Ejemplo– RoamingTowardTheLight.bs2

En contraste con RoamingWithPhotoresistorDividers.bs2 en la página 207, este programa será muy responsivo a la sombra generada por tu mano sobre el fotoresistor, independientemente de las condiciones de iluminación (altas o bajas) del área. Este programa no necesita cambiar los resistores dependiendo de las condiciones de iluminación. En su lugar, toma en consideración las condiciones de iluminación y ajusta la sensitividad en el software usando las variables average y difference.

Para que este programa funcione bien, tus fotoresistores deben responder de manera similar a condiciones semejantes de iluminación. Si los circuitos RC están severamente disparejos, tus medidas de Tabla 6-1 serán muy distintas bajo las mismas condiciones de iluminación. Puedes corregisr estas mediciones disparejas usando las técnicas discutidas en el Apéndice F: Balanceando Fotoresistores.

Este programa mide el averaje total de timeLeft y timeRight y los usa para establecer la variable difference entre las medidas timeLeft y timeRight que son necesarias para justificar el envío de un pulso.

√ Introduce, guarda, y ejecuta RoamingTowardTheLight.bs2 √ Llévalo a varias áreas, déjalo navegar libremente, y verifica que puedes cambiar

su curso al cubrir uno de sus cicuitors RC con fotoresistores, con una sombra generada por tu mano independientemente de las condiciones de iluminación.


√ También trata de colocar tu Boe-Bot en un cuarto que esté pobremente iluminado, pero que tenga una entrada de luz por una puerta de un cuarto adyacente brillante o de un pasillo. Observa si el Boe-Bot puede satisfactoriamente salir por la puerta.

' -----[ Titulo ]------------------------------------------------------------- ' Robotica con el Boe-Bot - RoamingTowardTheLight.bs2 ' Boe-Bot navega libremente, y da vuelta alejandose de la obscuridad en busca ' de areas bien iluminadas. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]---------------------------------------------------------- ' Declara variables para almacenar tiempos RC medidos de los fotoresitores ' izqquierdo y derecho. timeLeft VAR Word timeRight VAR Word average VAR Word difference VAR Word ' -----[ Inicializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ Rutina Principal ]--------------------------------------------------- DO GOSUB Test_Fotoresistors ' Para fotoresistores disparejos, consulta Apendice F, quita el comentario ' para usar la proxima linea. ' timeLeft = (timeLeft */351)+7 ' Reemplaza 351 y 7 con tus propios valores. GOSUB Average_And_Difference GOSUB Navigate LOOP ' -----[ Subrutina - Test_Photoresistors ]------------------------------------ Test_Photoresistors: HIGH 6 ' Medida de tiempo RC izq. PAUSE 3 RCTIME 6,1,timeLeft HIGH 3 ' Medida de tiempo RC der.


PAUSE 3 RCTIME 3,1,timeRight RETURN ' -----[ Subrutina – Averaje y Diferencia ]--------------------------------- Average_And_Difference: average = timeRight + timeLeft / 2 difference = average / 6 RETURN ' -----[ Subrutina - Navegacion ]--------------------------------------------- Navigate: ' Sombra significativamente mayor en detector izq., gira der. IF (timeLeft > timeRight + difference) THEN PULSOUT 13, 850 PULSOUT 12, 850 ' Sombra significativamente mayor en detector der., gira izq. ELSEIF (timeRight > timeLeft + difference) THEN PULSOUT 13, 650 PULSOUT 12, 650 ' Sombras en la misma vecindad de valores de intensidad en ambos detectores. ELSE PULSOUT 13, 850 PULSOUT 12, 650 ENDIF PAUSE 10 RETURN

¿Por qué PAUSE 10 en vez de PAUSE 20? Porque la subrutina Test_Photoresistors tiene dos comandos PAUSE que añaden 6 ms más el tiempo extra que toma la ejecución de los comandos RCTIME. Ambos factores suman tiempo entre los pulsos enviados a los servos, así que el comando PAUSE en la subrutina Navigate debe ser reducido. Luego de un poco de ensayo y error, el comando PAUSE 10 pareció dar los mejores resultados para los servos bajo el rango más amplio de niveles de luminosidad.

Tu Turno – Adjustando la Sensibilidad a las Diferencias en Iluminación

Ahora, la variable difference es la variable average dividida por 6. Puedes dividir average por un valor menor si quieres hacer al Boe-Bot menos sensible a las diferencias


en iluminación o dividir por un valor mayor si quieres hacer que el Boe-Bot sea más sensible a las diferencias de iluminación.

√ En vez del valor 6, prueba dividir la variable average por los valores 3, 4, 5, 7, y 9.

√ Ejecuta el programa y verifica la abilidad del Boe-Bot’s para salir de un cuarto obscuro con cada valor en el denominador.

√ Decide cuál de ellos es el valor óptimo.

Average_And_Difference: average = timeRight + timeLeft / 2 difference = average / 6 RETURN

También puedes cambiar el valor del denominador a una constante como:

Denominator CON 6 Entonces, en tu subrutina Average_And_Difference, puedes reemplazar 6 (o el valor óptimo que hayas determinado) con la constante Denominator de esta manera:

Average_And_Difference: average = timeRight + timeLeft / 2 difference = average / Denominator RETURN

√ Haz los cambios que acaban de ser discutidos, y verifica que el programa todavía

funciona correctamente. También puedes eliminar el uso de una variable en este programa. Nota que la única vez que la variable average es usada es para alamacenar temporalmente el valor del averaje, luego es dividida por la constante Denominator y almacenada en la variable difference. La variable difference es usada luego, pero la variable average no. Una manera de resolver este problema es simplemente usando la variable difference en lugar de la variable average. Funcionará bien, y no tendrás que usar la variable average. He aquí como se miraría esta subrutina:


Average_And_Difference: difference = timeRight + timeLeft / 2 difference = difference / Denominator RETURN

Inclusivve, existe una mejor manera.

√ Deja la rutina Average_And_Difference así:

Average_And_Difference: average = timeRight + timeLeft / 2 difference = average / Denominator RETURN

√ Luego, haz el siguiente cambio en las declaraciones de variable:

Figura 6-13: Modifica RoamingTowardTheLight.bs2 para Alamacenar en RAM ' Codigo original average VAR Word difference VAR Word

' Codigo modificado para almacenar ' en RAM average VAR Word difference VAR average

En realidad no necesitamos la variable average, pero el programa tiene más sentido a alguien quien quiere entenderlo, si usamos el término average en la primera línea y el término difference en la segunda línea. He aquí como crear un alias llamado difference para la variable average.

difference VAR average Ahora, tanto average como difference se refierem a la misma variable en RAM de tamaño Word en RAM.

√ Verifica tu programa modificado y asegúrate que funcione apropiadamente.


RESUMEN Este capítulo estuvo enfocado en medir diferencias de iluminación y programando al Boe-Bot para actuar de acuerdo a esas diferencias. Un par de fotoresistores de Sulfuro de Cadmio (CdS) fueron usados para medir las diferencias de luz visible. Los fotoresistores de CdS fueron conectados primero a resistores para forma divisores de voltaje, y el BASIC Stamp monitoreó el voltaje en la conexión entre el fotoresistor y el resistor fijo. Cuando este voltaje caía por debajo o aumentaba por encima de 1.4 V, el registro de entrada oara el pin de I/O conectado al circuito, almacenaba un 0 ó 1. El Boe-Bot fue programado para tomar decisiones usando estos valores binarios de una manera similar a los bigotes. La técnica de fotoresistor divisor funciona siempre y cuando los resistores adecuados sean escogidos, y también el nivel de luminosidad no varíe. Sin embargo, una manera más versátil de detectar los valores de luminosidad con el BASIC Stamp es usando los fotoresistores CdS en un circuito RC, cargando el capacitor, y luego midiendo el tiempo de caída. RC significa resistor capacitor, y el capacitor fue introducido en este capítulo junto con un circuito que hizo posible que el BASIC Stamp midiera el tiempo de decaimiento RC. Esto se hizo sencillamente con el BASIC Stamp usando el comando RCTIME, el cuál está diseñado específicamente para medir el tiempo de decaimiento RC y los tiempos de crecimiento (o incremento). Las constantes fueron introducida como una manera de substituir nombres con sentido en vez de números en un programa de PBASIC. Ajuste (escala) y promedio (averaje) también fueron introducidos. Ajuste fue usado para establecer un valor umbral para indicar si el rayo de luz de la linterna había sido detectado. También fue usado para determinar el valor del averaje de los niveles de luminosidad en el área, basándose en las medidas de tiempo de los dos fotoresistores. Esto fue usado para crear un umbral que automáticamente se ajustaba a las condiciones generales de luminosidad, eliminando la necesidad de cambiar los resistores con los cambios de iluminación.

Observa el Boe-Bot en Acción en el sitio www.parallax.com!

Puedes observar al Boe-Bot resolviendo los Proyectos 1 y 2 del Capítulo 6 junto com otros clips de video robóticos, en la galería de video “Robo Video Gallery” (en inglés) bajo el menú “Robotics Menu” (en inglés) en el sitio www.parallax.com.


Preguntas 1. ¿Cómo responde la resistencia de un fotoresistor a luz brillante y obscuridad?

¿Qué sucede cuando los niveles de luminosidad están entre brillante y obscuro? 2. ¿Un pin de I/O tiene algún efecto en un circuito cuando está establecido como

entrada (input)? ¿Qué causa que el registro de entrada del pin de I/O almacene un 1 ó 0 cuando está establecido como entrada (input)?

3. ¿Qué quiere decir voltaje umbral? ¿Cuál es el voltaje umbral de un pin de I/O en el BASIC Stamp?

4. Refiriéndote a la Figura 6-4 en la página 203, ¿qué causa que Vo crezca por encima o caiga por debajo del voltaje umbral? ¿Qué hay con respecto al circuito que causa que Vo cambie de valor?

5. ¿Cómo difiere el programa ShadowGuidedBoeBot.bs2 del programa RoamingWithPhotoresistorDividers.bs2? ¿Cómo afecta esto al desempeño del Boe-Bot?

6. ¿Qué es una declaración de constante? ¿Qúe es lo que hace? ¿Cómo podrías usar una en tu programa?

7. ¿Cómo son evaluadas las expresiones matemáticas en PBASIC? 8. ¿En cuáles dos ejemplos de este capítulo se usó PBASIC para calcular un

promedio? ¿Cuáles son las diferencias entre ellos? ¿Cómo se asemejan?

Ejercicios 1. Calcula Vo para la Figura 6-4 en la página 203 si R es 10 kΩ. Repite para R =

30 kΩ. 2. Si Vo en la Figura 6-4 en la página 203 es 1.4 V, ¿cuál es el valor de R? Repite

para Vo = 1 V y Vo = 3 V. 3. Asume que tienes tres valores varibales: firstValue, secondValue, y

thirdValue. Escribe un comando que tome el promedio de estos tres valores en una variable llamada myAverage. Escribe un comando que guarde 7/8 del valor del averaje en una variable llamada myScaledAverage. Escribe las declaraciones de variable necesarias para hacer que tu comando pueda ser ejecutado en un programa, primero con myAverage y myScaledAverage como variables separadas, y luego con una de ellas siendo un alias de la otra.

Proyectos 1. Con los fotoresistores de tu Boe-Bot mirando hacia abajo y al frente de él,

desarrolla un programa que haga que tu Boe-Bot reconozca la diferencia entre negro y blanco. Encuentra una superficie extensa blanca, y coloca hojas de papel


negro sobre ella. Escribe un programa que haga que el Boe-Bot esquive las hojas de papel negro. Pista: Asegúrate de verificar y enteder lo que el Boe-Bot observa cuadno está enfocado en una hoja negra de papel y lo que observa cuando está enfocado en un fondo blanco. Usa los programas de ejemplo de las últimas tres actividades en este capítulo. El circuito RC de tiempo de decaimiento y los programas asociados, serán de mucha más ayuda para hacer que el programa funcione que las técnicas de fotoresistor divisor. También, asegúrate de que es curso con obstáculos se encuentra en un área con una iluminación uniforme. Luz brillante del sol entrando por las ventanas, y sombras originadas por espectadores, pueden hacer que la demostración no sea exitosa.

2. Si tienes éxito con el proyecto 1, experimenta restringiendo al Boe-Bot para que sólo pueda navegar libremente en un espacio delimitado por hojas de papel negro.


Soluciones Q1. La resistencia es pequeña, unos pocos ohms, si la luz es brillante. La resistencia

es grande, aproximadamente 50 kΩ, en obscuridad. Para niveles de luz entre brillante y obscuro, la resistencia estará entre valores de luz brillante y obscuridad.

Q2. No. El pin de I/O sólo escucha silenciosamente sin ningún efecto sobre el circuito. El valor del voltaje aplicado causa que el registro de entrada cambie lo que almacena. Si el voltaje es menor a 1.4 voltios almacena un 0. De lo contrario, guarda un 1.

Q3. El voltaje umbral es un valor que por encima de él se considera como 1 lógico, y por debajo se considera como 0 lógico. El voltaje umbral del módulo BASIC Stamp modules es de 1.4 voltios.

Q4. El valor de Vo es determinado por la relación entre los resitores. Vo cambia su valor porque el resistor, R, cambia de valor. R es un fotoresistor que cambia su valor dependiendo del nivel de iluminación que recae sobre él.

Q5. El chequea los sensores entre cada pulso, en vez de tener maniobras fijas de muchos pulsos. Esto hace que el Boe-Bot sea muy responsivo.

Q6. Una declaración de constante le dice al compilador el valor de tu constante. Por ejemplo, MaxTemp CON 212 es una declaración de una constante . Una declaración de una constante le da un nombre significativo a un número o valor usado en un programa. Para usar una constante, escribe su nombre en cualquier parte del programa donde de su valor es necesario.

Q7. Las expresiones son evaluadas de izquierda a derecha. Esto es diferente a evaluaciones algebráicas normales, donde la multiplicación y división son evaluadas antes de la suma y la resta.

Q8. En el programa FlashLightControlledBoeBot.bs2, los promedios fueron usados para calcular los umbrales de luminosidad. En el programa RoamingTowardTheLight.bs2, un promedio de las medidas izquierda y derecha fue calculado. Los dos programas difieren en que el primero es calculado estáticamente en una declaración constante, mientras que el segundo es calculado dinámicamente mientras el programa es ejecutado. Se asemejan debido a que ambos suman dos valores y dividen por 2.


E1. a) R = 10 kOhm

Vo = 5V * (2000 / (2000 + R)) = 5 * (2000 / (2000 + 10000) = 5 * (2000 / (12000) = 5 * ( 2 / 12 ) = 5 * ( 1 / 6 ) = 5 * 0.17 = 0.83 Volts Si R = 10 kOhm, Vo = 0.83 V

b) R = 30 kOhm Vo = 5V * (2000 / (2000 + R)) = 5 * (2000 / (2000 + 30000) = 5 * (2000 / (32000) = 5 * ( 2 / 32 ) = 5 8 ( 1 / 16 ) = 5 * 0.06 = 0.31 Volts

Si R = 30 kOhm, Vo = 0.31 V

E2. a) Vo = 1.4 V

R = (5 * (2000/Vo)) – 2000 = (5 * (2000/1.4)) – 2000 = (5 * 1428.57) – 2000 = 7142.86 – 2000 = 5142.86 = 5143 Ohm Cuando Vo = 1.4V, R = 5143 Ω

b) Vo = 1.0 V R = (5 * (2000/1)) – 2000 = (5 * 2000) – 2000 = (10000) – 2000 = 8000 = 8 kOhm Cuando Vo = 1.4V, R = 8 kΩ

c) Vo = 3.0 V R = (5 * (2000/3.0)) – 2000 = (5 * 666.67) – 2000 = 3333.33 – 2000 = 1333.33 = 1333 Ohm Cuando Vo = 1.4V, R = 1333 Ω

E3. El promedio de estos tres valores en una variable llamada myAverage, almacenando 7/8 en myScaledAvereage:

myAverage = firstValue + secondValue + thirdValue / 3 myScaledAverage = myAverage * 7 / 8

Declaraciones como variables separadas:

myAverage VAR Word myScaledAverage VAR Word

Declaraciones usando alias:

myAverage VAR Word myScaledAverage VAR myAverage


P1. El primer paso es usar el programa "TestBothPhotoresistors.bs2" y determinar

los valores para la superficie blanca y el papel negro. Similarmente al programa "FlashlightControlledBoeBot.bs2", estos valores pueden ser codificados como constantes. Luego, las sentencias IF…THEN pueden ser usadas para determinar si los valores están por encima o por debajo del promedio de las lecturas. (Para el Boe-Bot del autor, no fue necesario ningún ajuste). He aquí un programa solución que hace que el Boe-Bot reconozca la diferencia entre superficies negras y blancas.

' -----[ Titulo ]--------------------------------------------------------- ' Robotica con el Boe-Bot - TestBlackWhiteLogic.bs2 ' Calcula si el Boe-Bot esta sobre superficie negra o blanca y lo muestra. ' $STAMP BS2 ' Directiva del Stamp ' $PBASIC 2.5 ' Directiva de PBASIC. ' -----[ Constantes ]----------------------------------------------------- LeftWhite CON 16 RightWhite CON 33 LeftBlack CON 26 RightBlack CON 45 LeftAvg CON LeftWhite + LeftBlack / 2 RightAvg CON RightWhite + RightBlack / 2 ' -----[ Variables ]------------------------------------------------------ timeLeft VAR Word ' Medida fotoresistor izq. timeRight VAR Word ' Medida fotoresistor der. ' -----[ Rutina Principal ]----------------------------------------------- DO GOSUB Test_Photoresistors IF (timeLeft > LeftAvg) THEN DEBUG CRSRXY, 0, 0, "Left Negro " ELSE DEBUG CRSRXY, 0, 0, "Left White " ENDIF IF (timeRight > RightAvg) THEN DEBUG CRSRXY, 13, 0, "Right Negro", CR ELSE DEBUG CRSRXY, 13, 0, "Right White", CR ENDIF LOOP ' -----[ Subrutina - Test_Photoresistors ]--------------------------------


Test_Photoresistors: HIGH 6 ' Medida tiempo RC izq. PAUSE 3 RCTIME 6,1,timeLeft HIGH 3 ' Medida tiempo RC der. PAUSE 3 RCTIME 3,1,timeRight RETURN

Para desarrollar un programa que haga que el Boe-Bot esquive las hojas de papel negro, los pasos de navegación y decisión requeridos son muy similares a los usados en los programas "FlashlightControlledBoeBot.bs2" y "RoamingTowardTheLight.bs2". Una solución de ejemplo se muestra a continuación:

' -----[ Titulo ]------------------------------------------------------ ' Robotica con el Boe-Bot - AvoidBlackSpots.bs2 ' Boe-Bot esquiva piezas de papel negras. ' $STAMP BS2 ' Directiva del Stamp ' $PBASIC 2.5 ' Directiva de PBASIC. ' -----[ Constantes ]-------------------------------------------------- LeftWhite CON 16 RightWhite CON 33 LeftBlack CON 26 RightBlack CON 45 LeftAvg CON LeftWhite + LeftBlack / 2 RightAvg CON RightWhite + RightBlack / 2 ' -----[ Variables ]--------------------------------------------------- timeLeft VAR Word ' Medidad fotoresistor izq. timeRight VAR Word ' Medidad fotoresistor der. ' -----[ Inicializacion ]---------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ Rutina Principal ]-------------------------------------------- DO GOSUB Test_Photoresistors GOSUB Navigate LOOP ' -----[ Subrutinas ]-------------------------------------------------- Test_Photoresistors: HIGH 6 ' Medida de tiempo RC izq. PAUSE 3 RCTIME 6,1,timeLeft


HIGH 3 ' Medida de tiempo RC der. PAUSE 3 RCTIME 3,1,timeRight RETURN Navigate: ' Ambos detectan papel negro, retrocede y emite sonido IF (timeLeft > LeftAvg) AND (timeRight > RightAvg) THEN PULSOUT 13, 650 PULSOUT 12, 850 FREQOUT 4, 20, 4400 ' Hace Bip en vez de pausa ' Izq. detecta papel negro, gira hacia la der., emite sonido ELSEIF (timeLeft > LeftAvg) THEN PULSOUT 13, 850 PULSOUT 12, 850 FREQOUT 4, 20, 2200 ' Der. detecta papel negro, gira hacia la izq., emite sonido ELSEIF (timeRight > RightAvg) THEN PULSOUT 13, 650 PULSOUT 12, 650 FREQOUT 4, 20, 3300 ' Ninguno detecta papel negro, avanza enviando un solo pulso ELSE PULSOUT 13,850 PULSOUT 12,650 PAUSE 20 ENDIF RETURN

Pistas: Asegúrate de probar y entender lo que el Boe-Bot observa cuando está enfocado en una hoja de papel negro y lo que observa cuando está enfocado en un fondo blanco. Usa los programas de ejemplo de las últimas tres actividades en este capítulo. El circuito RC de tiempo de decaimiento y los programas asociados, serán de mucha más ayuda para hacer que el programa funcione que las técnicas de fotoresistor divisor. También, asegúrate de que es curso con obstáculos se encuentra en un área con una iluminación uniforme. Luz brillante del sol entrando por las ventanas, y sombras originadas por espectadores, pueden hacer que la demostración no sea exitosa.

P2. El programa solución "AvoidBlackSpots.bs2", arriba, funciona muy bien para mantener al Boe-Bot confinado en un espacio delimitado por hojas negras. Un clip de video del Boe-Bot haciendo esto puede ser visto en el sitio www.parallax.com. Bajo el menú “Robotics menu”, busca la galería de videos “Robo Video Gallery”.

Capítulo 7: Navegando con Luces Delanteras Infrarrojas · Page 243

Capítulo 7: Navegando con Luces Delanteras Infrarrojas Los productos más populares actualmente parecen tener una cosa en común: comunicación inalámbrica (wireless). Organizadores personales mandan data a las computadoras de escritorio a través de rayos, así como en el caso de los controles remotos que nos dejan surfear por los canales. Muchos controles remotos y PDA’s usan señales en el rango infrarojo de frecuencia para comunicar, dicho rango se encuentra más abajo del espectro de luz visible. Con unas cuantas partes de poco costo y ampliamente disponibles, el BASIC Stamp puede también recibir señales de luz infraroja.

USANDO LUCES DELANTERAS INFRARROJAS PARA VER LA VIA Detectar objetos sin los bigotes no requiere nada tan sofisticado como visión de máquina (Machine Vision). Algunos robots usan RADAR o SONAR (a veces conocidos como SODAR cuando usan aire en vez de agua). Un sistema incluso más simple es usar luz infrarroja para iluminar el camino del robot y determinar cuando la luz es reflejada de un objeto. Gracias a la proliferación de controles remotos infrarrojos (IR), emisores y detectores IR están abiertamente disponibles y son poco costosos.

Infrarrojo: Infra quiere decir por debajo, así que Infra-rojo es luz (o radiación elctromagnética) que tiene una frecuencia más baja, o una longitud de onda más larga que la luz roja. La Tabla 7-1 muestra las longitudes de onda para colores comunes junto con el espectro infrarrojo. Nuestro LED IR y detector funcionan a 980 nm (nanómetros) lo cual es considerado cercano a infrarrojo. Los lentes de visión-nocturna y los sensores de temperatura IR usan longitudes de ondas de lejano a infrarrojo, es decir, entre 2000-10,000 nm, dependiendo de la aplicación. La Tabla 7-1 muestra las longitudes de ondas para colores comunes a lo largo del espectro ifrarrojo.

Tabla 7-1: Colores y Longitudes de Onda Aproximadas

Color Longitud de Onda Color Longitud de

Onda Violeta 400 Rojo 780

Azul 470 Infrarrojo Cercano 800-1000

Verde 565 Infrarrojo 1000-2000

Amarillo 590 Infrarrojo Lejano 2000-10,000

Naranja 630


Luces Delanteras Infrarrojas

El sistema de detección de objetos con luz infrarroja que construiremos en el Boe-Bot se asemeja a las luces delanteras de un carro de varias maneras. Cuando las luces delanteras de un carro reflejan de un obstáculo, tus ojos detectan dicho obstáculo y tu cerebro los procesa y hace que tu cuerpo conduzca el carro de manera apropiada. El Boe-Bot usa LEDs infrarrojos para las luces delanteras como lo muestra la Figura 7-1. Ellos emiten luz infrarroja, y en algunos casos, la luz infrarroja refleja de un objeto y rebota de regreso en la dirección del Boe-Bot. Los ojos del Boe-Bot son los detectores infrarrojos. Los detectores infrarrojos envían señales indicando si han detectado o no la luz infrarroja reflejado de algún objeto. El cerebro del Boe-Bot, el BASIC Stamp, toma decisiones y opera los servomotores, basado en esta entrada de sensor.

Figura 7-1 Detección de Objeto con Luces Delanteras IR

Los detectores IR tienen filtros ópticos ya incorporados que dejan entrar muy poca luz, con la excepción del rango infrarrojo (de 980 nm) que queremos detectar con su fotodiodo interno perceptor. El detector infrarojo también tiene un filtro electrónico que sólo deja pasar señales alrededor de 38.5 kHz. En otras palabras el detector solamente está buscando por infrarrojo que está prendiéndose y apagándose 38,500 veces por segundo. Esto previene interferencia IR de fuentes comunes como luz del sol y luz interna. La luz del Sol hace interferencia (0 Hz), y la luz interna tiende a prenderse y apagarse de 100 a 120 Hz, dependiendo de la fuente de alimentación principal y la región. Ya que 120 Hz está por fuera de la banda de frecuencia de paso para el filtro electrónico a 38.5 kHz, es completamente ignorda por los detectores IR.


Algunas luces fluorescenetes generan señales que pueden ser detectadas con los detectores IR. Estas luces pueden causar problemas con las luces delanteras infrarrojas de tu Boe-Bot. Una de las cosas que harás en este capítulo es desarrollar un “husmeador” de frecuencias de interferencia que puedes usar para probar las luces fluorescentes alrededor de las pistas de tu Boe-Bot.

ACTIVIDAD #1: CONSTRUYENDO Y PROBANDO LOS PARES IR En esta actividad, construirás y probarás los pares infrarrojos transmisor/detector.

Lista de Partes:

(2) Detectores Infrarrojos (2) LEDs IR (cubierta

transparente) (2) LED IR ensambles

cobertores (2) Resistores - 220 Ω (rojo-rojo-marrón) (2) Resistores – 1 kΩ (marrón-negro-rojo)

123

123

+

-Flattened edge

Longer lead

+-

Figura 7-2 Nuevas Partes Usadas en este Capítulo detector IR (arriba) IR LED (medio) Ensamblaje decobertores del LED IR (abajo)

Construyendo las Luces Delanteras IR

√ Inserta los LED infrarrojos en los cobertores como lo indica la Figura 7-3. √ Asegúrate que el LED quede asegurado en la parte más grande del cobertor. √ Asegura la parte más pequeña del cobertor sobre la cubierta plástica del LED y

sobre la parte más grande del ensamble.

Pata larga

Borde liso


+-

IR LED will snap in.

Figura 7-3 Asegurando el LED IR en el Ensamble

Un par IR (LED y detector IR) es montado en cada esquina de la protoboard. La Figura 7-4 muestra las luces delanteras IR en un dibujo esquemático y la Figura 7-5 muestra el circuito como un diagrama de conexión.

√ Desconecta la fuente de alimentación de tu plaqueta y servos. √ Construye el circuito mostrado en el dibujo esquemático en la Figura 7-4, usando

el diagrama de conexión para tu plaqueta en la Figura 7-5 como una referencia para la colocación de partes.

Figura 7-4 Pares IR Izquierdo y Derecho

Par IR Izquierdo Par IR Derecho

Vdd

Vss

P9

P8

IRLED

Vss

1 k Ω

220 Ω

Vdd

Vss

P0

P2

IRLED

Vss

1 kΩ

220 Ω

El LED queda asegurado


Observa los ánodos y cátodos de tu LED IR!

Recuerda que la pata del ánodo es más larga por convención en un LED IR, pero también recuerda que necesitas chequear la cubierta plástica del LED para asegurarte. La pata del cátodo es la que está cerca del borde liso de la cubierta. En la Figura 7-5, el ánodo de cada LED IR está conectado a un resistor de 1 kΩ. La pata del cátodo se enchufa en la misma fila de la protoboard que el pin central del detector IR, y esa fila se conecta a Vss con un cable de conexión.

P15P14P13P12P11P10

P7P6P5

P3

P1

P9P8

P4

P2

P0X2

X3Vdd VssVin


Vdd

BlackRed

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P9P8

P4

P2

P0

P10

P7P6P5

P3

P1

X2

X3Vdd VssVin


To Servos

+

HomeWork Board

Figura 7-5 Diagramas de Conexión para Circuitos Emisor y Receptor Infrarrojos Board of Education (izquierda) y HomeWork Board (derecha).

Probando los Pares IR Usando el Truco FREQOUT

El comando FREQOUT fue diseñado principalmente para sintetizar tonos de audio. El rango actual del comando FREQOUT es de 32768 Hz. Un fenómeno interesante de tonos digitalmente sintetizados es que ellos contienen señales llamadas armónicas. Una armónica es una tono de frecuencia más alto que está mezaclado con el tono que quieres oír. Estos tonos están fuera de la habilidad humana de detectar sonido, la cual tiende a ser entre 20 Hz to 20 kHz. Las armónicaas generadas por el comando FREQOUT comienzan a 32769 Hz e incrementan. Tú puedes controlar directamente estas armónicas usando los argumentos Freq1 por encima de 32768. En esta actividad, usarás el comando FREQOUT 8, 1, 38500 para enviar una armónica de 38.5 kHz que dure 1 ms a P8. El circuito LED infrarrojo conectado a P8 difusionará esta armónica. Si la luz

anode leads

anode leads Patas de

Anodos

Patas de Anodos

Hacia los servos Hacia los servos


infrarroja es reflejada de regreso al Boe-Bot por un objeto en su trayecto, el detector infrarrojo enviará una señal al BASIC Stamp para dejarle saber que la luz infrarroja reflejada fue detectada.

Comando FREQOUT – Harmónicas Fundamentales

La frecuencia fundamental es el valor del argumento Freq1 cuando es igual o menor a 32768. Por ejemplo, cuando usas el comando FREQOUT 4, 2000, 3000, la frecuencia fundamental es 3000 Hz. Ese es el sonido buscado, pero también hay un sonido armónico que lo acompaña. Esta armónica es a una frecuencia mucho más alta que el oído humano no puede detectar, en la vecindad de 62.5 kHz. Aquí está cómo calcular la frecuencia armónica dada una frecuencia fundamental y viceversa.

Cada vez que usas el comando FREQOUT para enviar un tono en este rango, contiene también ese tono (armónica) escondido. La ecuación para la armónica es:

frecuencia armónica = 65536 – Freq1, Freq1 <= 32678

Cada vez que usas el comando FREQOUT con un argumento Freq1 por encima de 32768 para enviar una armónica, contiene un tono fundamental. La ecuación para la frecuencia fundamental es:

frecuencia fundamental = 65536 – Freq1, Freq1 > 32768

La clave para hacer funcionar cada par LED/detector IR es enviar 1 ms de armónica FREQOUT a 38.5 kHz, y luego, inmediatamente guardar la salida del detector IR en una variable. Aquí está un ejemplo que envía la señal de 38.5 kHz a un LED IR conectado a P8, y luego guarda la salida del detector IR, el cual está conectado a P9, en una variable tamaño bit llamada irDetectLeft.

FREQOUT 8, 1, 38500 irDetectLeft = IN9

La salida del estado del detector IR cuando no ve ninguna señal IR, es alta. Cuando el detector IR ve la armónica de 38500 Hz reflejada por un objeto, su salida es baja. La salida del detector IR sólo se mantiene baja por una fracción de milisegundo luego de que el comando FREQOUT termina de enviar la armónica, así que es esencial guardar la salida del detector IR en una variable inmediatamente después de enviar el comando FREQOUT. El valor guardado por la variable puede entonces ser mostrado en el Debug Terminal o usado para decisiones de navegación por el Boe-Bot.


Programa de Ejemplo: TestLeftIrPair.bs2

√ Reconecta la fuente de alimentación a tu plaqueta. √ Introduce, guarda, y ejecuta TestLeftIrPair.bs2.

' Robotica con el Boe-Bot - TestLeftIrPair.bs2 ' Prueba circuitos IR de deteccion de objetos, LED IR conectado a P8 y ' detectores conectados a P9. ' $STAMP BS2 ' $PBASIC 2.5 irDetectLeft VAR Bit DO FREQOUT 8, 1, 38500 irDetectLeft = IN9 DEBUG HOME, "irDetectLeft = ", BIN1 irDetectLeft PAUSE 100 LOOP

√ Deja el Boe-Bot conectado al cable serial, porque vas a usar el Debug Terminal

para probar tu dispositivo IR. √ Coloca un objeto, como tu mano o una hoja de papel a una pulgada del par IR

izquierdo, como lo muestra la Figura 7-1 en la página 244. √ Verifica que cuando colocas un objeto en frente del par IR el Debug Terminal

muestra un 0, y cuando quitas el objeto del frente del par IR, muestra un 1. √ Si el Debug Terminal muestra los valores anticipados para objeto no detectado

(1) y objeto detectado (0), avanza a la sección Tu Turno que sigue al programa de ejemplo.

√ Si el Debug Terminal no muestra los valores corectos, trata de seguir los pasos en la sección de Resolución de Problemas.


Resolución de Problemas

Si el Debug Terminal no muestra los valores corretos, revisa el circuito y el programa en busc de algún error.

Si siempre estás obteniendo 0, hasta cuando no hay ningún objeto al frente del Boe-Bot, puede haber un objeto cercano reflejando la luz infrarroja. La superficie de la mesa en frente del Boe-Bot es una culpable típica. Mueve el Boe-Bot para que los LED y detectores IR no puedan ser reflejados por ningún objeto cercano.

Si mides 1 la mayor parte del tiempo cuando no hay ningún objeto en frente del Boe-Bot, pero aparece por un breve instante, y ocasionalmente, un 0, puede ser que tengas interferencia dde una luz fluorescente cercana. Apaga cualquier fuente de luz fluorescente cercana y repite tus pruebas.

Tu Turno

√ Guarda TestLeftIrPair.bs2 como TestRightIrPair.bs2. √ Cambia la sentencia DEBUG, el título y los comentarios para referirse al par IR

derecho. √ Cambia el nombre de la variable de irDetectLeft a irDetectRight.

Necesitarás hacer esto cuatro veces en el Programa. √ Cambia el argumento Pin del comando FREQOUT de 8 a 2. √ Cambia el registro de entrada monitoreado por la variable irDetectRight de

IN9 a IN0. √ Repite los pasos de prueba en esta actividad para el par IR derecho, con el

circuito LED IR conectado a P2 y el detector conectado a P0.

ACTIVIDAD #2: PRUEBA DE CAMPO PARA DETECCION DE OBJETO E INTERFERENCIA INFRARROJA En esta actividad, construirás y probarás indicadores LEDs que te dirán si un objeto es detectado sin la ayuda del Debug Terminal. Esto es útil si no estás cerca de una PC o Laptop, y si necesitas resolver algún problema con tus circuitos de detector IR. También escribirás un programa para “husmear” alguna interferencia infrarroja proveniente de las luces fluorescentes. Algunas luces fluorescentes envían señales que se asemejan a las enviadas por tus LEDs infrarojos. El dispositivo dentro de la luz fluorescente que controla el voltaje de la lámpara es llamdo “ballast” (en inglés). Algunos de estos dispositivos operan en el mismo rango de frecuencia de tu detector IR, 38.5 kHz, lo cual causa que la lámpara emita una señal a esta frecuencia. Cuando integras la detección de objetos con IR a la navegación, esta interferencia puede hacer que el Boe-Bot ¡se comporte alocadamente!


Reconstruyendo los Circuitos Indicadores con LED

Estos son los mismos circuitos indicadores que usaste con los bigotes.

Lista de Partes:

(2) LEDs Rojos (2) Resistores – 220 Ω (rojo-rojo-marrón)

√ Desconecta la fuente de alimentación de tu plaqueta y servos. √ Construye el circuito mostrado en la Figura 7-6 usando la Figura 7-7 como

referencia.

P10

Vss

220 Ω

RedLED

P1

Vss

220 Ω

RedLED

Figura 7-6 Indicadores LEDs Izquierdo y Derecho

IR Par Izquierdo IR Par Derecho

Figura 7-7 Diagrama de Conexión para Indicadores LED Rojos con Circuito IR de Detección de Objetos Board of Education (izq.) y HomeWork Board (der.).

P15 P14 P13 P12 P11 P10 P9 P8

P4 P2 P1 P0

P7 P6 P5 P3

X2

X3 Vdd VssVin

Board of Education © 2000-2003 Rev C

Vdd

NegroRojo

X4 X5

15 14 13 12

To Servos

+

P15P14

P11

P13P12

P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3Vdd VssVin


To Servos

+

HomeWork Board

Anode leads

Anode leads


Probando el Sistema

Existen unos cuantos componentes envueltos en este sistema, lo que incrementa la posibilidad de un error de conexión. Por ello es importante tener un programa de verificación que te muestre lo que los detectores infrarojos estás percibiendo. Puedes usar este programa para verificar que todos los circuitos están funcionando antes de desconectar al Boe-Bot de su cable serial para probar con otros objetos.

Programa de Ejemplo – TestIrPairsAndIndicators.bs2

√ Reconecta la fuente de alimentación a tu plaqueta. √ Introduce, guarda, y ejecuta TestIrPairsAndIndicators.bs2. √ Verifica que la bocina emite un tono claro y audible mientras el Debug Terminal

muestra “Testing piezobocina…”. √ Usa el Debug Terminal para verificar que el BASIC Stamp todavía recibe un

cero de cada detector IR cuando un objeto es colocado en su frente. √ Verifica que el LED próximo a cada detector emite luz cuando el detector

detecta un objeto. Si uno o ambos LEDs parecen no funcionar, chequea tus conexiones y tu programa.

' Robotica con el Boe-Bot - TestIrPairsAndIndicators.bs2 ' Verifica Circuitos IR de Deteccion de objetos. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. ' -----[ Variables ]---------------------------------------------------------- irDetectLeft VAR Bit irDetectRight VAR Bit ' -----[ Inicializacion ]----------------------------------------------------- DEBUG "Testing piezobocina..." FREQOUT 4, 2000, 3000 DEBUG CLS, "IR DETECTORS", CR, "Left Right", CR, "----- -----" ' -----[ Rutina Principal ]--------------------------------------------------- DO FREQOUT 8, 1, 38500


irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 IF (irDetectLeft = 0) THEN HIGH 10 ELSE LOW 10 ENDIF IF (irDetectRight = 0) THEN HIGH 1 ELSE LOW 1 ENDIF DEBUG CRSRXY, 2, 3, BIN1 irDetectLeft, CRSRXY, 9, 3, BIN1 irDetectRight PAUSE 100 LOOP

Tu Turno – Pruebas Remotas y Pruebas de Rango

Puedes usar ahora tus detectores LED para probar los detectores IR de tu Boe-Bot con objetos que de otra manera no podrían estar en el rango de alcance del cable serial de la computadora.

√ Desconecta tu Boe-Bot del cable serial, y colócalo al frente de una variedad de objetos y prueba el rango de los detectores IR.

√ Prueba el rango de detección de objetos de coloración distinta. ¿Qué color es detectado al rango más lejano? ¿Qué color es detectado al rango más cercano?

Husmeando Interferencia IR

Si te has dado cuenta que tu Boe-Bot te deja saber que detectó algo a pesar de que nada estaba en su rango, puede significar que alguna luz cercana está generando cierta luz IR a una frecuencia cercana a 38.5 kHz. Si tratas de hacer que el Boe-Bot participe en un concurso o haga una demostración bajo estas condiciones de iluminación, puede ser que tus sistemas infrarrojos terminen desempeñándose de una manera pobre. La última cosa que alguien quisiera, es ver que tu robot no se comporta como debe durante una demostración pública, así que asegúrate de revisar previamente con un “husmeador” de interferencia IR cualquier área de demostración posible.


El concepto tras este programa es simple, no transmite ninguna señal IR a través de los LEDs IR, sólo monitorea a ver si alguna señal IR es detectada. Si una señal IR es detectada, suena una alarma a través de la bocina piezoeléctrica.

Puedes usar un control remoto de mano de casi cualquier aparato electrónico para generar interferencia IR. TVs, VCRs, reproductores CD/DVD, y proyectores usan los mismos detectores IR que tienes en tu Boe-Bot. Similarmente, los controles que usas para manejar estos dispositivos usan el mismo tipo de LED IR que está en tu Boe-Bot para transmitir mensajes al detector IR en tu TV, VCR, reproductor CD/DVD, etc.

Programa de Ejemplo – IrInterferenceSniffer.bs2

√ Introduce, guarda, y ejecuta IrInterferenceSniffer.bs2. √ Prueba para asegurarte que el Boe-Bot emite la alarma cuando detecta

interferencia infrarroja. Puedes hacer esto con un Boe-Bot separado ejecutando TestIrPairsAndIndicators.bs2. Si no tienes un segundo Boe-Bot, sólo usa un control remoto de mano para TV, VCR, reproductor CD/DVD, o proyector. Simplemente apunta el control remoto al Boe-Bot y presiona un botón. Si el Boe-Bot responde sonando la alarma, sabes que tu husmeador de IR funciona.

' Robotics with the Boe-Bot – IrInterferenceSniffer.bs2 ' Prueba luces fluorescentes, conroles remotos infrarrojos, y otras fuentes ' de interferencia IR de frecuencia 38.5 kHz IR. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. counter VAR Nib DEBUG "IR interference not detected, yet...", CR DO IF (IN0 = 0) OR (IN9 = 0) THEN DEBUG "IR Interference detected!!!", CR FOR counter = 1 TO 5 HIGH 1 HIGH 10 FREQOUT 4, 50, 4000 LOW 1 LOW 10 PAUSE 20 NEXT ENDIF LOOP


Tu Turno – Probando para Luces Fluorescentes que Interfieran

√ Desconecta tu Boe-Bot de su cable serial, y apúntalo hacia cualquier luz fluorescente cerca de donde planeas operar. Especialmente si obtienes alarmas frecuentes, apaga las luces fluorescentes antes de tratar de usar la detección IR de objetos bajo ellas.

Siempre usa este IrInterferenceSniffer.bs2 para asegurarte que cualquier área donde estás usando al Boe-Bot está libre de interferencia infrarroja.

ACTIVIDAD #3: AJUSTES DEL RANGO DE DETECCION INFRARROJA Puede que hayas visto que luces más brillantes de un carro (o una linterna más brillante) pueden ser usadas para ver objetos más lejos cuando está obscuro. Haciendo que los IR LED del Boe-Bot sean más brillantes, también puede incrementar su rango de detección. Resistiendo menos la corriente eléctrica, un resistor más pequeño permite mayor flujo de corriente a través de un LED. En esta actividad, examinarás el efecto de distintos valores de resistencia tanto con los LEDs rojos como los infrarrojos.

Lista de Partes:

Vas a necesitar unas partes extra para esta actividad. (2) Resistores – 470 Ω (amarillo-violeta-marrón) (2) Resistores – 220 Ω (rojo-rojo-marrón) (2) Resistores – 2 kΩ (rojo-negro-rojo) (2) Resistores – 4.7 kΩ (amarillo-violeta-rojo)

Resistencia en Series y Brillo del LED

Primero, usemos uno de los LEDs rojos para “ver” la diferencia que un resistor hace en el brillo de un LED. Todo lo que necesitamos para probar el LED es un programa que envíe una señal alta al LED.

Programa de Ejemplo – P1LedHigh.bs2

√ Introduce, guarda, y ejecuta P1LedHigh.bs2. √ Ejecuta el programa y verifica que el LED conectado en el circuito a P1 emite

luz.


' Robotica con el Boe-Bot - P1LedHigh.bs2 ' Haz que P1 sea alto para probar la luminosidad de LED con cada resistor de ' valor: 220 ohm , 470 ohm, 1 k ohm. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" HIGH 1 STOP

El comando STOP es usado aquí en vez de END, ya que END pondría al BASIC Stamp en modo de alimentación baja.

Tu Turno – Probando el Brillo de los LEDs

Recuerda desconectar la fuente de alimentación antes de cambiar un circuito. Recuerda también que el mismo programa correrá nuevamente cuando reconectes la fuente de alimentación, así que puedes retomar justo donde terminaste con cada prueba.

√ Observa cuán brillante está el LED en el circuito conectado a P1 con el resistor

de 220 Ω. √ Reemplaza el resistor de 220 Ω conectado a P1 y al cátodo del LED derecho con

un resistor de 470 Ω. √ Observa cuán brillante esta el LED. √ Repite para un resistor de 2 kΩ. √ Repite una vez más con un resistor de 4.7 kΩ. √ Reemplaza el resistor de 4.7 kΩ con el resistor de 220 Ω antes de continuar con

la próxima porción de esta actividad. √ Explica en tus propias palabras la relación entre el brillo de LED y la resistencia

en serie.

Resistencia en Serie y Rango de Detección IR

Sabemos que menor resistencia en serie hace que un LED brille más. Una hipótesis razonable sería que LEDs IR más brillantes permiten detectar obstáculos más lejanos.

√ Abre y ejecuta TestIrPairsAndIndicators.bs2 (de la página 252). √ Verifica que ambos detectores funcionan adecuadamente.


Tu Turno – Probando el Rango de LED IR

√ Con una regla, mide la distancia más larga que pueda ser detectada con el LED IR colocando una hoja de papel en frente de él, usando los resistores de 1 kΩ , y guarda tus data en la Tabla 7-2.

√ Reemplaza los resistores de 1 kΩ que conectan a P2 y P8 a los ánodos de los IR LEDs con resistores de 4.7 kΩ.

√ Determina la distancia más larga a la cual la misma hoja de papel es detectada y guarda tu data.

√ Repite con resistores de 2 kΩ. √ Repite con resistores de 470 Ω. √ Repite con resistores de 220 Ω.

Tabla 7-2: Distancia de Detección de Distancia vs. Resistencia

Resistencia (Ω) en Serie con LED IR

Máxima Distancia de Detección. Encierra una en círculo: ( in / cm )

4700 2000 1000 470 220

√ Antes de proseguir con la próxima actividad, regresa tus pares IR a su

configuración original (con resistores de 1 kΩ en serie con cada LED IR). √ Además, antes de proseguir, asegúrate de verificar este último cambio con

TestIrPairsAndIndicators.bs2 para verificar que ambos pares LED/detector IR funcionan adecuadamente.

ACTIVIDAD #4: DETECCION Y EVASION DE OBJETOS Un aspecto interesante acerca de los detectores IR es que sus salidas son semejantes a los bigotes. Cuando ningún obstáculo es detectado, la salida es alta; cuando algún objeto es detectado su salida es baja. En esta actividad, RoamingWithWhiskers.bs2 de la página 184 es modificado para que funcione con detectores IR.


Convirtiendo el Programa de Bigotes para Detección/Evasión de Objetos con IR

Este próximo programa de ejemplo comenzó como RoamingWithWhiskers.bs2. Aparte de ajustar el nombre y la descripción, dos variables de tamaño bit fueron añadidas para guardar los estados de los detector IRes.

irDetectLeft VAR Bit irDetectRight VAR Bit

Una rutina fue agregada también para leer los pares IR. FREQOUT 8, 1, 38500 irDetectLeft = IN9

Las sentencias IF…THEN fueron modificadas para que observen las variables que guardan las detecciones de los pares IR en vez de las entradas de los bigotes.

IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN GOSUB Back_Up GOSUB Turn_Left GOSUB Turn_Left ELSEIF (irDetectLeft = 0) THEN GOSUB Back_Up GOSUB Turn_Right ELSEIF (irDetectRight = 0) THEN GOSUB Back_Up GOSUB Turn_Left ELSE GOSUB Forward_Pulse ENDIF

Programa de Ejemplo – RoamingWithIr.bs2

√ Abre RoamingWithWhiskers.bs2 √ Modifícalo de tal manera que sea igual al programa abajo. √ Reconecta la fuente de alimentación a tu plaqueta y servos. √ Guárdalo y ejecútalo. √ Verifica que, aparte del hecho que no hay ningún contacto requerido, se

comporta como RoamingWithWhiskers.bs2.


' -----[ Titulo ]------------------------------------------------------------- ' Robotica con el Boe-Bot - RoamingWithIr.bs2 ' Adapta RoamingWithWhiskers.bs2 para uso con pares IR. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Variables ]---------------------------------------------------------- irDetectLeft VAR Bit irDetectRight VAR Bit pulseCount VAR Byte ' -----[ Inicializacion ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Rutina Principal ]--------------------------------------------------- DO FREQOUT 8, 1, 38500 ' Store IR detection values in irDetectLeft = IN9 ' bit variables. FREQOUT 2, 1, 38500 irDetectRight = IN0 IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN GOSUB Back_Up ' Both IR pairs detect obstacle GOSUB Turn_Left ' Back up & U-turn (left twice) GOSUB Turn_Left ELSEIF (irDetectLeft = 0) THEN ' Left IR pair detects GOSUB Back_Up ' Back up & turn right GOSUB Turn_Right ELSEIF (irDetectRight = 0) THEN ' Right IR pair detects GOSUB Back_Up ' Back up & turn left GOSUB Turn_Left ELSE ' Both IR pairs 1, no detects GOSUB Forward_Pulse ' Apply a forward pulse ENDIF ' and check again LOOP ' -----[ Subroutines ]-------------------------------------------------------- Forward_Pulse: ' Send a single forward pulse. PULSOUT 13,850 PULSOUT 12,650 PAUSE 20 RETURN


Turn_Left: ' Left turn, about 90-degrees. FOR pulseCount = 0 TO 20 PULSOUT 13, 650 PULSOUT 12, 650 PAUSE 20 NEXT RETURN Turn_Right: FOR pulseCount = 0 TO 20 ' Right turn, about 90-degrees. PULSOUT 13, 850 PULSOUT 12, 850 PAUSE 20 NEXT RETURN Back_Up: ' Back up. FOR pulseCount = 0 TO 40 PULSOUT 13, 650 PULSOUT 12, 850 PAUSE 20 NEXT RETURN

Tu Turno

√ Modifica RoamingWithIr.bs2 para que los pares IR sean chequeados en una subrutina.

ACTIVIDAD #5: NAVEGACION IR CON ALTO DESEMPEÑO El estilo de maniobras pre-programadas que fueron en la actividad previa estaban bien para bigotes, pero son innecesariamente lentos para su uso con IR LEDs y detectores. Puedes mejorar bastante el desempeño de tu Boe-Bot al correr libremente chequeando por obstáculos antes de enviar cada grupo de pulsos a los servos. El programa puede usar las entradas de los sensores para seleccionar la mejor maniobra para cada momento de navegción. De esa manera, el Boe-Bot nunca voltea más allá de lo que necesita, y puede limpiamente encontrar la vía alrededor de los obstáculos y navegar satisfactoriamente a través de pistas más complejas.

Muestreando Entre Cada Pulso para Evitar Colisiones El gran detalle de detectar obstáculos antes de chocar contra el es que le da al Boe-Bot cierto espacio para navigar a su alrededor. El Boe-Bot puede aplicar un pulso para dar vuelta lejos de un objeto, chequear nuevamente y si el objeto sigue allí, aplicar otro pulso


para evadirlo. El Boe-Bot puede mantenerse aplicando pulsos y chequeando, hasta que maniobre hasta donde no se encuentre el obstáculo. Entonces, puede continuar con sus pulsos de avance. Luego de experimentar con este proximo programa de ejemplo, seguramente coincidirás en que es una mejor manera de correr libremente con el Boe-Bot.

Programa de Ejemplo – FastIrRoaming.bs2

√ Introduce, guarda, y ejecuta FastIrRoaming.bs2. ' Robotica con el Boe-Bot - FastIrRoaming.bs2 ' Higher performance IR object detection assisted navigation ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" irDetectLeft VAR Bit ' Variable Declarations irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. DO ' Main Routine FREQOUT 8, 1, 38500 ' Check IR Detectors irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 ' Decide how to navigate. IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 850 ELSEIF (irDetectLeft = 0) THEN pulseLeft = 850 pulseRight = 850 ELSEIF (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 650 ELSE pulseLeft = 850 pulseRight = 650 ENDIF PULSOUT 13,pulseLeft ' Apply the pulse. PULSOUT 12,pulseRight PAUSE 15 LOOP ' Repeat main routine


Funcionamiento del Programa FastIrRoaming.bs2

Este programa toma una ruta distinta al aplicar los pulsos. Aparte de las dos bits que se usan para guardar las salidas del detector IR, usa dos variables tamaño Word para establecer las duraciones de los pulsos enviados por el comando PULSOUT.

irDetectLeft VAR Bit irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word

Dentro del DO…LOOP, los comandos FREQOUT son utilizados para enviar una señal IR de 38.5 kHz IR a cada IR LED. Inmediatamente después el destello de IR es enviado por 1 ms, una variable tamaño bit guarda el estado de la salida del detector IR. Esto es necesario, porque si esperas por un poco más de tiempo que lo que le toma al comando en ejecutar, el detector IR retornará al estado de no detectado (estado 1), independientemente de si había o no había detectado un objeto.

FREQOUT 8, 1, 38500 irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0

En las sentencias IF…THEN, en vez de enviar pulsos o llamar rutinas de navegación, este proma establece los valores de las variables que serán usados en los argumentos Duration de los comandos PULSOUT.

IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 850 ELSEIF (irDetectLeft = 0) THEN pulseLeft = 850 pulseRight = 850 ELSEIF (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 650 ELSE pulseLeft = 850 pulseRight = 650 ENDIF


Antes de que se repita el DO…LOOP, la última cosa por hacer es enviar pulsos a los servos. Observa que el comando PAUSE no sigue siendo 20. En vez, es 15 ya que aproximadamente se toman 5 ms en chequear los IR LEDs.

PULSOUT 13,pulseLeft ' Apply the pulse. PULSOUT 12,pulseRight PAUSE 15

Tu Turno

√ Guarda FastIrRoaming.bs2 como FastIrRoamingYourTurn.bs2. √ Usa los LEDs para transmitir que el Boe-Bot ha detectado un objeto. √ Trata de modificar los valores que establecidos para pulseLeft y pulseRight para

que el Boe-Bot haga todo a media velocidad.

ACTIVIDAD #6: EL DETECTOR DE CAIDA Hasta ahora, el Boe-Bot ha sido programado principalmente para tomar maniobras evasivas cuando un objeto es detectado. Existen también aplicaciones donde el Boe-Bot debe tomar acciones evasivas incluso cuando un objeto no es detectado. Por ejemplo, si el Boe-Bot está corriendo libremente sobre una mesa, sus detector IRes pueden estar viendo hacia abajo a la superficie de la mesa como lo muestra la Figura 7-8. El programa debería continuar avanzando mientras ambos detector IRes puedan “ver” la superficie de la mesa. En otras palabras, el Boe-Bot puede continuar avanzando siempre y cuando la mesa sobre la que está navegando sea detectada.

√ Desconecta la fuente de alimentación de tu plaqueta y servos. √ Apunta tus pares IR hacia abajo y hacia afuera como lo muestra la Figura 7-8.


Figura 7-8 IR Pares Dirigidos Hacia Abajo Para Chequear por una Caída

Vista Superior Vista Lateral

Recommended Materials:

(1) Rollo de teipe eléctrico negro de vinil – ¾″ (19 mm) de ancho. (1) Lámina blanca para póster – 22 x 28 in (56 x 71 cm).

Simulación de Caída con Teipe Eléctrico

Una lámina blanca para póster con un borde hecho de teipe eléctrico es una manera útil de simular la caída presente en el borde de una mesa, sin peligro para tu Boe-Bot.

√ Construye una pista similar a la que se muestra en la Figura 7-9 usando teipe negro. Usa al menos tres tiras de teipe eléctrico de borde a borde, sin nigún tipo de espacios blancos entre las tiras.

√ Reemplaza tus resistores de 1 kΩ con resistores de 2 kΩ (rojo-negro-rojo) para conectar P2 a sus IR LED y P8 a sus IR LED. Nosotros queremos que el Boe-Bot sea corto de vista para esta actividad.

√ Reconecta la fuente de alimentación a tu plaqueta. √ Ejecuta el programa IrInterferenceSniffer.bs2 (página 254) para asegurarte que

las luces fluorescentes cercanas no van a interferir con los detector IRes de tu Boe-Bot.

√ Usa el programa TestIrPairsAndIndicators.bs2 (página 252) para asegurarte de que el Boe-Bot detecta la lámina de póster y no detecta el teipe eléctrico.

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3 Vdd VssVin

Board of Education

© 2000-2003 Rev C

Vdd

NegroRojo

X4 X5

15 14 13 12

To Servos

+


Si el Boe-Bot todavía "ve" el teipe eléctrico muy brillante, aquí hay unos cuantos remedios:

√ Trata ajustando los detector IRes y los LEDs hacia abajos a varios ángulos. √ Trata con una marca diferente de teipe eléctrico de vinil. √ Trata reemplazando los resistores de 2 kΩ con resistores de 4.7 kΩ (amarillo-violeta-

rojo) para hacer que el Boe-Bot sea más corto de vista. √ Ajusta el comando FREQOUT con distintos argumentos Freq1. Aquí están algunos

argumentos que harán que el Boe-Bot sea más corto de vista: 38250, 39500, 40500

Si estás usando antiguos IR LEDs, el Boe-Bot puede estar teniendo dificultades siendo muy corto de vista. Aquí están algunos remedios que aumentarán la sensibilidad del Boe-Bot a objetos haciéndolo menos corto de vista:

√ Trata con 1 kΩ (marrón-negro-rojo) ó 470 Ω (amarillo-violeta-marrón) o inclusive resistores de 220 Ω (rojo-rojo-marrón) en serie con los IR LEDs en vez de 2 kΩ.

22” (56 cm)

22” (

56 c

m)

Figura 7-9 Borde con Teipe Eléctrico Simula Borde de Mesa


Si intentas con una mesa luego de tener éxito con la pista de teipe eléctrico:

√ Recuerda seguir los mismos pasos que seguiste antes de dejar que el Boe-Bot navegara sobre la pista con teipe eléctrico!

Asegúrate que seas el asistente de tu Boe-Bot. Está prevenido apenas tu Boe-Bot corra libremente por la mesa:

√ Siempre está listo para recoger tu Boe-Bot desde arriba cuando se acerque al borde de la mesa sobre la que esté navegando. Si el Boe-Bot intenta manejar fuera del borde de la mesa agárralo antes de que se lance. De otra manera, tu Boe-Bot puede que se convierta en un No-Bot!

√ Tu Boe-Bot puede detectarte si estás en su campo de visión. Su programa actual no tiene ninguna manera de diferenciarte a tí de la mesa bajo él, así que puede intentar continuar avanzando fuera del borde de la mesa. Así que mantente fuera del campo de visión del detector mientras asistes a tu Boe-Bot.

Programando para Detección de Caída

En su mayoría, programando a tu Boe-Bot para navegar alrededor de la superficie de una mesa sin caer del borde es cuestión de ajustar las sentencias IF...THEN del programa FastIrNavigation.bs2. El ajuste principal es que los servos deberían ser dirigidos para hacer que el Boe-Bot ruede hacia adelante cuando irDetectLeft y irDetectRight son 0, indicando que un objeto (la superficie de la mesa) ha sido detectado. El Boe-Bot también tiene que dar vuelta alejándose de un detector que no ha detectado un obstáculo. Por ejemplo, si irDetectLeft es 1, el Boe-Bot más vale que voltee a la derecha. Una segunda característica de un programa para voltear de las caídas es distancia ajustable. Puede ser que quieras que tu Boe-Bot solamente tome un pulso hacia adelante entre chequeos de los detectores, pero tan pronto como una caída sea detectada, puede ser que quieras hacer que tu Boe-Bot tome varios pulsos para voltear antes de chequear los detectores nuevamente. Sólo porque tú estás enviando múltiples pulsos en una maniobra evasiva, no quiere decir que tienes que regresar a la navegación al estilo de los bigotes. En vez, puedes agregar una variable pulseCount que puedas usar para establecer el número de pulsos a ser enviados para completar la maniobra. El comando PULSOUT puede ser colocado dentro de un bucle FOR…NEXT que ejecuta los pulsos de acuerdo a FOR 1 TO pulseCount pulses. Para un pulso hacia adelante, pulseCount puede ser 1, para diez pulsos hacia la izquierda, pulseCount puede ser establecido a 10, y así sucesivamente.


Programa de Ejemplo – AvoidTableEdge.bs2

√ Abre FastIrNavigation.bs2 y guárdalo como AvoidTableEdge.bs2. √ Modifica el programa para que sea exacto en comparación con el programa de

ejemplo. Esto incluye agregar variables, modificar las sentencias IF…THEN, y anidar los comandos PULSOUT dentro del bucle FOR…NEXT. Ten cuidado de asegurarte que todas los valores de las variables pulseLeft y pulseRight dentro de las sentencias IF…THEN están apropiadamente ajustadas. Sus valores son diferentes de los presentes en FastIrNavigation.bs2 porque las reglas de la pista son distintas.

√ Reconecta la fuente de alimentación a tu plaqueta y servos. √ Verifica el programa en tu pista delimitada por teipo eléctrico. √ Si decides tratar sobre una mesa, recuerda de seguir los consejos discutidos

antes. ' Robotica con el Boe-Bot - AvoidTableEdge.bs2 ' IR detects object edge and navigates to avoid drop-off. ' $STAMP BS2 ' $PBASIC 2.5 DEBUG "Program Running!" irDetectLeft VAR Bit ' Variable declarations. irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word loopCount VAR Byte pulseCount VAR Byte FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. DO ' Main Routine. FREQOUT 8, 1, 38500 ' Check detector IRs. irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 ' Decide navigation. IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseCount = 1 ' Both detected, pulseLeft = 850 ' one pulse forward. pulseRight = 650 ELSEIF (irDetectRight = 1) THEN ' Right not detected, pulseCount = 10 ' 10 pulses left.


pulseLeft = 650 pulseRight = 650 ELSEIF (irDetectLeft = 1) THEN ' Left not detected, pulseCount = 10 ' 10 pulses right. pulseLeft = 850 pulseRight = 850 ELSE ' Neither detected, pulseCount = 15 ' back up and try again. pulseLeft = 650 pulseRight = 850 ENDIF FOR loopCount = 1 TO pulseCount ' Send pulseCount pulses PULSOUT 13,pulseLeft PULSOUT 12,pulseRight PAUSE 20 NEXT LOOP

Funcionamiento del Programa AvoidTableEdge.bs2

Debido a que este programa es una versión modificada de FastIrRoaming.bs2, sólo los cambios al programa son discutidos aquí.

Un bucle FOR…NEXT es agregado al programa para controlar el número de pulsos que son enviados cada vez que se completa la rutina (DO…LOOP) principal. Dos variables son añadidas, loopCount funciona como un índice para un bucle FOR…NEXT y pulseCount es usado como el argumento EndValue.

loopCount VAR Byte pulseCount VAR Byte

Las sentencias IF…THEN ahora tienen el valor de pulseCount establecido así como también los valores de pulseRight y pulseLeft. Si ambos detectores pueden ver la mesa, entonces, toma un pulso precabido hacia adelante.

IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseCount = 1 pulseLeft = 850 pulseRight = 650


De lo contrario, si el detector IR derecho no ve la superficie de la mesa, rota 10 pulsos hacia la izquierda.

ELSEIF (irDetectRight = 1) THEN pulseCount = 10 pulseLeft = 650 pulseRight = 650

De lo contrario, si el detector IR izquierdo no ve la superficie de la mesa, rota 10 pulsos hacia la derecha.

ELSEIF (irDetectLeft = 1) THEN pulseCount = 10 pulseLeft = 850 pulseRight = 850

De lo contrario, si ninguno de los dos detectores puede ver el borde de la mesa, retrocede 15 pulsos y prueba nuevamente, en busca de que alguno de los detectores vea la caída antes que el otro.

ELSE pulseCount = 15 pulseLeft = 650 pulseRight = 850 ENDIF

Ahora que el valor de pulseCount, pulseLeft, y pulseRight están establecidos, este bucle FOR…NEXT envía el número específico de pulsos para la maniobra determinada por las variables pulseLeft y pulseRight.

FOR loopCount = 1 TO pulseCount PULSOUT 13,pulseLeft PULSOUT 12,pulseRight PAUSE 20 NEXT

Tu Turno

Puedes experimentar con establecer diferentes valores para pulseLeft, pulseRight, y pulseCount dentro de la sentencia IF…THEN. Por ejemplo, si el Boe-Bot no da la vuelta completa, puede rastrear el borde de la pista delimitada por teipe eléctrico. Pivotear hacia atrás en vez de rotar en el sitio puede conllevar también a comportamientos interesantes.


√ Modifica AvoidTableEdge.bs2 para que siga el eje de la pista delimitada con teipe eléctrico ajustando los valores pulseCount para que el Boe-Bot no de la vuelta tan alejado del borde.

√ Experimenta con el pivoteo como una manera de hacer que el Boe-Bot corra libremente dentro del perímetro en vez de siguiendo el borde.


RESUMEN Este capítulo cubrió una técnica úniica para la detección de objetos con infrarrojo que usa los IR LED encontrados en controles remotos comunes de casa, y los detectores infrarrojos encontrados en TVs, reproductores de CD/DVD, y otros dispositivos electrónicos controlados con estos controles remotos. Alumbrando con infrarrojo en el camino del Boe-Bot y mirando su reflexión, la detección de objetos es lograda sin detectar fisicamente el objeto. Circuitos LED infrarrojos son usados para enviar una señal de 38.5 kHz con la ayuda de una propiedad del comando FREQOUT llamada armónica, la cual es inherente a las señales sintetizadas digitalmente. Un programa indicador de detección infrarroja fue introducido para pruebas remotas (sin conexión a la PC) de los pares IR LED/Detector. Un programa husmeador de interferencia infrarroja también fue introducido para ayudar a detectar interferencia que puede ser generada por algunas luces fluorescentes. Ya que las señales enviadas por los detector IRes son tan similares a las señales enviadas por los bigotes, RoamingWithWhiskers.bs2 fue adaptado a los detectores infrarrojos. Un programa que chequea los detectores infrarrojos entre cada pulso de servo fue introducido para demostrar mejor desempeño al correr libremente para no chocar con con obstáculos. Este programa fue modificado para evadir el borde de un área delimitada por teipe eléctrico. Debido a que el teipe eléctrico absorbe infrarrojo, enmarcar una hoja amplia de papel de construcción asemeja la caída vista en el borde de una mesa sin el peligro para el Boe-Bot.

Preguntas 1. ¿Cuál es la frecuencia de la harmónica enviada por FREQOUT 2, 1, 38500?

Cuál es el valor de la frecuencia fundamental enviado por ese comando? ¿Cuál es la duración de estas señales? ¿Qué pin I/O tiene que tener el circuito de IR LED conectado para poder transmitir esta señal?

2. ¿Qué comando tiene que seguir inmediatamente al comando FREQOUT para poder determinar precisamente si el objeto ha sido o no detectado?

3. ¿Qué significa que el detector IR envíe una señal baja? ¿Qué significa que el detector envíe una señal alta?

4. ¿Qué socede so cambias el valor de un resistor en serie con un LED rojo? ¿Qué pasa si cambias el valor de un resistor en serie con un LED infrarrojo?


Ejercicios 1. Modifica una línea de código en IrInterferenceSniffer.bs2 para que sólo

monitoree uno de los pares IR LED/detector. 2. Explica la función de pulseCount en AvoidTableEdge.bs2. ¿Cómo se relaciona

esto a tu respuesta al Ejercicio 3?

Proyectos 1. Diseña una aplicación para el Boe-Bot en la que se quede quieto hasta que

muevas tu mano en frente de él, y luego comience a correr libremente. 2. Diseña una aplicación para el Boe-Bot en la que rote en un punto hasta que

detecte un objeto. Tan pronto detecte el objeto, lo asegura y lo persigue. Este es un comportamiento clásico de un SumoBot.

3. Diseña una aplicación para el Boe-Bot que navegue libremente, pero si detecta interferencia infraroja, suena una alarma brevemente, y continúa navegando. Esta alarma debería ser distinta a la alarma que indica batería baja.


Soluciones Q1. 38.5 kHz es la frecuencia de la armónica. Su frecuencia fundamental = 65536 –

38500 = 27036 Hz. Las señales son enviadas por 1 milisegundo, y el IR LED debe ser conectado al Pin I/O 2.

Q2. El comando que guarda la salida del detector en una variable. Por ejeplo irDetectLeft = IN9.

Q3. Una señal baja significa que IR a 38.5 kHz fue detectada, por ende, un objeto fue detectado. Una señal alta significa que IR a 38.5kHz no fue detectada, entonces, ningún objeto.

Q4. Electricamente hablando, para LEDs tanto rojos como infrarrojos, resistores más pequeños causarán que el LED brille más intensamente. Un resistor más grande resulta en LEDs más opacos. En términos de resultados, IR LEDs hacen posible la detección de obstáculos más lejanos.

E1. Cambia la sentencia IF…THEN por:

IF (IN0 = 0) THEN Esto solo monitoreará el detector derecho.

E2. La variable pulseCount permita que el Boe-Bot tenga una distancia de movimiento ajustable dependiendo de la situación.

P1. El programa FastIrRoaming.bs2 puede ser combinado con un bucle DO…UNTIL

para que no nada hasta que detecte un objeto. Una ejemplo de solución es mostrado abajo.

' -----[ Title ]------------------------------------------------------- ' Robotica con el Boe-Bot - MotionActivatedBoeBot.bs2 ' Boe-Bot starts roaming when hand is waved in front of detector IRs. ' $STAMP BS2 ' $PBASIC 2.5 ' -----[ Variables ]--------------------------------------------------- irDetectLeft VAR Bit ' Variable Declarations irDetectRight VAR Bit pulseLeft VAR Word pulseRight VAR Word ' -----[ Initialization ]---------------------------------------------- DEBUG "Program Running!"


FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Main Routine ]------------------------------------------------ Main: ' Loop until something is detected DO GOSUB Check_IRs LOOP UNTIL (irDetectLeft = 0) OR (irDetectRight = 0) ' Now start roaming -- this code from FastIrRoaming.bs2 DO IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 ' Both detect pulseRight = 850 ' Back up ELSEIF (irDetectLeft = 0) THEN ' Left detect pulseLeft = 850 ' Turn right pulseRight = 850 ELSEIF (irDetectRight = 0) THEN ' Right detect pulseLeft = 650 ' Turn left pulseRight = 650 ELSE ' Nothing detected pulseLeft = 850 ' Go forward pulseRight = 650 ENDIF PULSOUT 13, pulseLeft ' Apply the pulse. PULSOUT 12, pulseRight PAUSE 15 GOSUB Check_IRs ' Check IRs again LOOP ' -----[ Subroutines ] ------------------------------------------------ Check_IRs: FREQOUT 8, 1, 38500 ' Check IR Detectors irDetectLeft = IN9 FREQOUT 2, 1, 38500 IrDetectRight = IN0 RETURN

P2. Este comportamiento es de muchas formas opuesto al comportamiento de correr

libremente cubierto en este capítulo. En vez de evadir objetos, el Boe-Bot trata de ir hacia ellos. Por esta razón el código principal puede ser derivado de "FastIrRoaming.bs2", con algo extra añadido para hacer que el Boe-Bot voltee lentamente hasta que el objeto es detectado.


En la situación de abajo, una vez que el Boe-Bot a espieado un objeto, continuará hacia adelante incluso cuando los detectores muestren "ningún objeto" (1) por unos cuantos bucles. Esto se debe a que el Boe-Bot está maniobrando hacia el objeto, algunas veces los detectores muestran "ningún objeto" por unos breves instantes, pero esta no es razón por la cual abandonar la persecusión.

' Robotica con el Boe-Bot - SumoBoeBot.bs2 ' Search for object, lock onto it and push it. ' $STAMP BS2 ' $PBASIC 2.5 irDetectLeft VAR Bit ' Left IR reading irDetectRight VAR Bit ' Right IR reading pulseLeft VAR Word ' pulse values for servos pulseRight VAR Word ' -----[ Initialization ]---------------------------------------------- DEBUG "Program Running!" FREQOUT 4, 2000, 3000 ' Signal start/reset. ' -----[ Main Routine ]------------------------------------------------ Main: ' Spin around slowly until an object is spotted DO PULSOUT 13, 790 ' Rotate slowly PULSOUT 12, 790 PAUSE 15 ' 5 ms for detectors GOSUB Check_IRs ' While looking for object LOOP UNTIL (irDetectLeft = 0) OR (irDetectRight = 0) ' Now figure out exactly where the object is and go toward it DO ' Object in both detectors -- go forward IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 850 ' Forward pulseRight = 650 ' Object on left - go left ELSEIF (irDetectLeft = 0) THEN pulseLeft = 650 ' Left toward object pulseRight = 650 ' Object on right - go right ELSEIF (irDetectRight = 0) THEN


pulseLeft = 850 ' Right toward object pulseRight = 850 ' No object -- go forward anyway, because the detectors will ELSE ' momentarily show pulseLeft = 850 ' "no object" as the pulseRight = 650 ' Boe-Bot is adjusting ENDIF ' its position. PULSOUT 13,pulseLeft ' Apply the pulse. PULSOUT 12,pulseRight PAUSE 15 ' 5 ms for detectors ' Check IRs again in case object is moving GOSUB Check_IRs LOOP ' -----[ Subroutines ] ------------------------------------------------ Check_IRs: FREQOUT 8, 1, 38500 ' Check IR Detectors irDetectLeft = IN9 FREQOUT 2, 1, 38500 IrDetectRight = IN0 RETURN

P3. La clave para resolver este problema es combinar "FastIrRoaming.bs2" con

"IrInterferenceSniffer.bs2" en un mismo programa.

' -----[ Title ]------------------------------------------------------- ' Robotica con el Boe-Bot - RoamAndSniffBoeBot.bs2 ' Boe-Bot roams around and sounds alarm when IR detected. ' $STAMP BS2 ' $PBASIC 2.5 ' -----[ Variables ]--------------------------------------------------- irDetectLeft VAR Bit ' Left IR sensor reading irDetectRight VAR Bit ' Right IR sensor reading pulseLeft VAR Word ' Pulses sent to servos pulseRight VAR Word counter VAR Nib ' Loop counter ' -----[ Initialization ]---------------------------------------------- DEBUG "Program Running!" FREQOUT 4, 2000, 3000 ' Senal comienzo del programa. ' -----[ Main Routine ]------------------------------------------------


Main: DO GOSUB Roam GOSUB Sniff LOOP ' -----[ Subroutines ] ------------------------------------------------ Sniff: ' From IrInterferenceSniffer.bs2 IF (IN0 = 0) OR (IN9 = 0) THEN FOR counter = 1 TO 5 ' Beep 5 times HIGH 1 ' and flash LEDs HIGH 10 FREQOUT 4, 50, 4000 LOW 1 LOW 10 PAUSE 20 NEXT ENDIF RETURN Roam: ' From FastIrRoaming.bs2 FREQOUT 8, 1, 38500 ' Check IR Detectors irDetectLeft = IN9 FREQOUT 2, 1, 38500 irDetectRight = IN0 ' Decide how to navigate. IF (irDetectLeft = 0) AND (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 850 ELSEIF (irDetectLeft = 0) THEN pulseLeft = 850 pulseRight = 850 ELSEIF (irDetectRight = 0) THEN pulseLeft = 650 pulseRight = 650 ELSE pulseLeft = 850 pulseRight = 650 ENDIF PULSOUT 13,pulseLeft ' Apply the pulse. PULSOUT 12,pulseRight PAUSE 15 RETURN

Capítulo 8: Control de Robot con Detección de Distancia · Page 279

Capítulo 8: Control de Robot con Detección de Distancia En el Capítulo 7, usamos los sensores infrarojos para detectar si un objecto está en el camino del Boe-Bot sin tocarlo directamente. ¿No sería agradable saber cuán lejos se encuentra el objeto? Este es la tarea para un sonar, el cual envía un pulso de sonido y guarda el tiempo que toma el eco en regresar. El tiempo que le toma al eco en regresar puede ser usado para determinar la distancia a la que se encuentra el objecto. Existe, de cualquier manera, una manera de lograr la detección de distancia con el mismo circuito que usaste en el capítulo previo. Con tu Boe-Bot capacitado para determinar la distancia de un objecto, se puede programar para seguir un objeto en movimiento sin chocar contra él. El Boe-Bot también puede ser programado para segir pistas negras en un fondo blanco.

DETERMINANDO LA DISTANCIA CON EL MISMO CIRCUITO IR LED/DETECTOR Vas a usar el mismo circuito del capítulo anterior para detectar la distancia.

√ Si el circuito todavía se encuentra construido en tu Boe-Bot, asegúrate que tu IR LED tengan resistores de 1 kΩ en serie.

√ Si ya desarmaste el circuito del capítulo previo, repite los pasos en el Capítulo #7, ActiviDAD #1 en la página 245.

Materiales y Equipo Recomendados:

(1) Regla (1) Hoja de papel

ACTIVIDAD #1: VERIFICANDO EL BARRIDO DE FRECUENCIA La Figura 8-1 muestra un extracto de la hoja de especificaciones de un detector de IR de marca específica (Panasonic PNA4602M). Este extracto es una gráfica que muestra cuán menos sensible es este detector de IR si la señal que recibe se prende y se apaga continuamente a una frecuencia distinta a 38.5 kHz. Por ejemplo, si envías una señal que se prende y apaga a 40 kHz, solo es 50% sensible a como sería a 38.5 kHz. Si el IR es prendido y apagado a 42 kHz, el detector es solamente 20% sensible. Especialmente para


frecuencias que hacen el detector menos sensible, el objecto tiene que estar más cercano para hacer el IR reflejado más brillante para que el detector lo pueda detectar.

Figura 8-1 Sensibilidad del Filtro Depende en la Frecuencia Portadora

Otra manera de pensar al respecto es que la frecuencia más sensible detectará los objectos más lejanos, mientras que las frecuencias menos sensibles sólo pueden detectar objetos cercanos. Esto hace que la detección de la distancia sea simple. Selecciona 5 frecuencias, luego prueba de la más a la menos sensible. Trata con la más sensible primero. Si un objeto es detectado, revisa a ver si la próxima frecuencia más sensible lo detecta. Dependiendo en cuál frecuencia el infrarrojo reflejado no es visible para el detector IR, puedes inferir la distancia.

Barrido de Frecuencia es la técnica que consiste en probar la salida de un circuito usando una variedad de frecuencias de entrada.

Programando el Barrido de Frecuencia para la Detección de Distancia

La Figura 8-2 muestra un ejemplo de como el Boe-Bot puede probar las distancia usando frecuencias. En este ejemplo, el objecto se encuentra en la Zona 3. Eso quiere decir que el objeto puede ser detectado cuando 37500 y 38250 Hz son transmitidos, pero no puede ser detectado con 39500, 40500, y 41500 Hz. Si movieras el objeto a la Zona 2, entonces el objecto podría ser detectado cuando 37500, 38250, y 39500 Hz son transmitidos, pero no cuando 40500 y 41500 Hz son transmitidos.


Figura 8-2: Frecuencias y Zonas del Boe-Bot

Puede que te preguntes por qué el valor de la Zona 4 es 37.5 kHz y no 38.5 kHz. La razón por la que no son los valores que esperarías basado en el % de sensibilidad de la gráfica es porque el comando FREQOUT transmite una señal un poco más potente (harmónica) a 37.5 kHz que a 38.5 kHz. Las frecuencias listadas en la Figura 8-2 son frecuencias que vas a programar para que el BASIC Stamp use para determinar la distancia a un objeto. Estas frecuencias fueron determinadas usando ensayos similares a los que aparecen descritos en el Apénance of an object. These frequencies were determined using tests similar to the ones outlined in Apéndice G: Entonando la Detección de Distancia con IR.

Para verificar el detector IR a cada frecuencia, necesitarás usar FREQOUT para enviar cinco frecuencias distintas y probar a cada frecuencia para descubrir si el detector IR pudo ver el objeto. Los pasos entre cada frecuencia no son tan precisos como para usar el operador STEP del bucle FOR…NEXT. Pudieras usar DATA y READ, pero eso sería un tanto incómodo. Pudieras usar cinco comandos diferentes FREQOUT, pero eso sería una pérdida de espacio de código. En vez de esto, la mejor manera de guardar una lista corta de valores que quieres usar en secuencia es un comando llamado LOOKUP. La sintaxis para el comando LOOKUP es:

LOOKUP Index, [Value0, Value1, …ValueN], Variable

Si el argumento Index es 0, Value0 de la lista dentro de los corchetes será colocado en Variable. Si Index es 1, Value1 de la lista será colocado en Variable. Puede haber hasta 256 valores en la lista, pero para el próximo programa ejemplo, solo necesitaremos 5. Aquí esta cómo será usado:

FOR freqSelect = 0 TO 4

P15 P14 P13 P12 P11 P10 P9 P5 P3 P8 P7 P2 P1 P0 P6 P4

X2

X3 Vdd Vss Vin

Board of Education

© 2000-2003

Vdd Negro Rojo

X4 X5

15 14 13 12

+

Objeto

Zona 5 No hay Detección a ninguna Frecuencia

Zona 437500 Hz

Zona 338250 Hz

Zona 239500 Hz

Zona 140500 Hz

Zona 0 41500 Hz


LOOKUP freqSelect,[37500,38250,39500,40500,41500],irFrequency FREQOUT 8,1, irFrequency irDetect = IN9 ' Commands not shown... NEXT

En la primera pasada por el bucle FOR…NEXT, freqSelect es 0, así que el comando LOOKUP coloca el valor 37500 en la variable irFrequency. Ya que irFrequency contiene 37500 después del comando LOOKUP, el comando FREQOUT envía esa frecuencia al LED IR conectado a P8. Como en el capítulo anterior, el valor de IN9 es entonces guardado en la variable irDetect. En la segunda pasada por el bucle FOR…NEXT, el valor de freqSelect es ahora 1, lo cual significa que el comando LOOKUP coloca 38250 en la variable irFrequency, y el proceso es repetido para esta frecuencia más alta. En la tercera pasada el proceso es repetido nuevamente con 39500, y así sucesivamente. El resultado es notable, especialmente considerando que estás usando partes que fueron diseñadas para un propósito completamente distinto, para establecer comunicación IR entre un control remoto de mano y una televisión.

Programa de Ejemplo – TestLeftFrequencySweep.bs2

TestLeftFrequencySweep.bs2 hace dos cosas. Primero, prueba que el par izquierdo de IR LED/detector (conectado a P8 y P9) para asegurarse que están funcionando apropiadamente para la detección de distancia. Sin embargo, también demuestra cómo el barrido de frecuencia ilustrado Figura 8-2 es logrado. Cuando corres el programa, el Debug Terminal mostrara tu medida de zona. Existen muchos patrones si-no que pueden ser generados; dos están mostrados en la Figura 8-3. Los patrones de prueba variarán dependiendo de las características del filtro dentro del detector. El programa determina en cuál zona se encuentra el objeto detectado contando el número de ocurrencias de “No.” Observa que a pesar de que los dos patrones de prueba del Debug Terminal en la Figura 8-3 son distintos, ambos tienen tres ocurrencias “Si” y dos “No.” Por lo tanto, la “Zona 2” es la ubicación del objeto detectado en ambos ejemplos.


Figura 8-3 Probando los Ejemplos de Detección de Distancia

Ten en cuenta que estas medidas de distancia son relativas y no son necesariamente precisas ni espaciadas uniformemente. Sin embargo, ellas le dan al Boe-Bot un sentido de distancia al objeto suficientemente bueno como para seguir, rastrear, y otras actividades.

√ Introduce, guarda, y ejecuta TestLeftFrequencySweep.bs2. √ Usa una hoja de papel o tarjeta viendo hacia el IR LED/detector para verificar la

detección de distancia. √ Comienza con la hoja bastante cerda del IR LED, quizás a ¼ in (ó 1 cm) de

distancia del IR LED. Tu Zona en el Debug Terminal debería ser o 0 ó 1. √ Gradualmente mueve la hoja de papel alejándola del IR LED y tomando nota de

cada distancia que cause que el valor de la zona aumente.

Las Zonas 1-4 típicamente caen en el rango de 6 a 12 in (de 15 a 30 cm) para estos LEDs encubiertos con un resistor de 1 kΩ. Para los LED antiguos con cubierta de goma viejos las distancias serán menores. Mientras los objetos puedan ser detectados hasta 4 in (10 cm) de distancia, los experimentos en este capítulo funcionarán. Si el rango de detector de distancia es menor que eso, lo cual es muy probable si tienes los IR LEDS antiguos con cubierta de goma, trata de reducir tu resistencia en serie de 1 kΩ a 470 Ω ó 220 Ω.

' -----[ Title ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - TestLeftFrequencySweep.bs2 ' Test detector IR distance responses to frequency sweep. ' $STAMP BS2 ' Directiva del Stamp.


' $PBASIC 2.5 ' Directiva de PBASIC. ' -----[ Variables ]---------------------------------------------------------- freqSelect VAR Nib irFrequency VAR Word irDetect VAR Bit distance VAR Nib ' -----[ Initialization ]----------------------------------------------------- DEBUG CLS, " OBJECT", CR, "FREQUENCY DETECTED", CR, "--------- --------" ' -----[ Main Routine ]------------------------------------------------------- DO distance = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1, irFrequency irDetect = IN9 distance = distance + irDetect DEBUG CRSRXY, 4, (freqSelect + 3), DEC5 irFrequency DEBUG CRSRXY, 11, freqSelect + 3 IF (irDetect = 0) THEN DEBUG "Yes" ELSE DEBUG "No " PAUSE 100 NEXT DEBUG CR, "--------- --------", CR, "Zone ", DEC1 distance LOOP

Tu Turno – Probando el Par Derecho IR LED/Detector

A pesar de que habría que tomar en cuenta la denotación, puedes modificar el programa para probar el IR LED y detector derecho cambiando estas dos líneas

FREQOUT 8,1, irFrequency irDetect = IN9


para que digan

FREQOUT 2,1, irFrequency irDetect = IN0

√ Modifica TestLeftFrequencySweep.bs2 para probar la medición de distancia del par derecho de IR LED/detector.

√ Ejecuta el programa y verifica que este par puede medir una distancia similar.

Mostrando Ambas Distancias

Es útil a veces tener un programa rápido que puedas correr para probar ambos detectores de deistancias del Boe-Bot’s al mismo tiempo. Este programa está organizado en subrutinas, las cuales son prácticas para copiar y pegar en otros programas que requieran detección de distancia.

Programa de Ejemplo – DisplayBothDistances.bs2

√ Introduce, guarda, y ejecuta DisplayBothDistances.bs2. √ Repite el ejercicio de la medida de distancias con una hoja de papel en cada

LED, y luego en ambos LED al mismo tiempo. ' -----[ Title ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - DisplayBothDistances.bs2 ' Test detector IR distance responses of both IR LED/detector pairs to ' frequency sweep. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. ' -----[ Variables ]---------------------------------------------------------- freqSelect VAR Nib irFrequency VAR Word irDetectLeft VAR Bit irDetectRight VAR Bit distanceLeft VAR Nib distanceRight VAR Nib ' -----[ Initialization ]----------------------------------------------------- DEBUG CLS, "IR OBJECT ZONE", CR, "Left Right", CR, "----- -----"


' -----[ Main Routine ]------------------------------------------------------- DO GOSUB Get_Distances GOSUB Display_Distances LOOP ' -----[ Subroutine – Get_Distances ]----------------------------------------- Get_Distances: distanceLeft = 0 distanceRight = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight PAUSE 100 NEXT RETURN ' -----[ Subroutine – Display_Distances ]------------------------------------- Display_Distances: DEBUG CRSRXY,2,3, DEC1 distanceLeft, CRSRXY,9,3, DEC1 distanceRight RETURN

Tu Turno – Más Pruebas de Distancia

√ Trata de medir la distancia de distintos objetos y encuentra si el color y/o la textura hacen alguna diferencia en cuanto a la medida de distancia.


ACTIVIDAD #2: VEHICULO BOE-BOT SOMBRA Para que un Boe-Bot siga a otro, el Boe-Bot que sigue o “vehículo sombra,” tiene que saber cuán lejos adelante está el vehículo líder. Si el vehículo sombra se retrasa, tiene que detectar esto y acelerar. Si el vehículo sombra está muy cerca al vehículo líder, tiene que detectar esto y desacelerar. Si está a la distancia correcta, puede esperar a que la medida indique que está muy lejos o muy cerca nuevamente. La distancia es sólo un tipo de valor por el cual robots y otra maquinaria autamatizada son responbles. Cuando una máquina está diseñada para mantener un valor automáticamente, como distancia, presión, o nivel de fluido, generalmente requiere un sistema de control. Estos sistemas a veces consisten de sensores y válvulas, o sensores y motores, o, en el caso del Boe-Bot, sensores y servos de rotación contínua. Existe también algún tipo de procesador que toma las medidas de los sensores y las convierte en acción(es) mecánica(s). El procesdor tiene que ser programado para tomar decisiones basado en las entradas de los sensores, y luego controlar las salidas mecánicas respectivamente. En el caso del Boe-Bot, el procesador es el BASIC Stamp 2. Control de lazo cerrado es un método común para mantener niveles, y funciona muy bien ayudando a que el Boe-Bot mantenga su distancia a un objeto. Existen muchos ti[os distintos de control de lazo cerrado. Algunos de los más comunes son histéresis, proporcional, integral, y derivativo. Todos estos tipos de control son introducidos en dealle en el texto Process Control (en inglés) de la serie Stamps in Class, listado en el Prefacio. La mayoría de las técnicas pueden ser implementadas con unas pocas líneas de código en PBASIC. De hecho, la mayoría de los lazos de control proporcional mostrados en la Figura 8-4 se reducen a sólo una línea de código PBASIC. Este diagrama es llamado diagrama de bloque, y describe los pasos del proceso de control proporcional que el Boe-Bot utilizará para medir la distancia con su IR LED y detector derecho y ajustar su posición para mantener la distancia con servo derecho.


Figura 8-4 Diagrama de Bloque para Control Proporcional del Servo y Par de IR LED y Detector Derechos

Miremos más de cerca los números en la Figura 8-4 para aprender cómo funciona el control proporcional. Este ejemplo particular es para el IR LED/detector y servo derechos. El punto de control es 2, lo que significa que queremos que el Boe-Bot mantenga una distancia de 2 entre sí y cualquier objeto que detecte. La distancia medida, es 4, la cual es muy lejana. El error es el punto de control menos la distancia medida 2 – 4 = –2. Esto es indicado por los símbolos dentre del círculo a la izquierda. Este círculo es conocido como nodo sumador. Luego, el error alimenta a un bloque operador. Este bloque muestra que el error será multiplicado por un valor llamado constante de proporcionalidad (Kp). El valor de Kp es 35. La salida del bloque muestra el resultado de –2 × 35 = –70, el cual es llamado ajuste de salida. Este ajuste de salida entra a otro nodo sumador, y esta vez es sumado al ancho de pulso central del servo 750. El resultado es un ancho de pulso de 680 que hará que el servo se mueva hacia adelante a aproximadamente ¾ de su velocidad en sentido de las manecillas del reloj. Esto hace que la rueda derecha del Boe-Bot ruede hacia adelante, hacia el objeto. Esta corrección entra al sistema general, el cual consiste en el Boe-Bot, y el objecto, que fue medido a una distancia de 4. En la próxima pasada por el lazo, la distancia medida puede cambiar, pero eso está bien porque independientemente de la distancia medida, este lazo de control calculará el valor que ocasionará que el servo se mueva para corregir cualquier error. La corrección siempre es proporcional al error, el cual es la diferencia entre el punto de control y las distancias medidas. Un lazo de control tiene un grupo de ecuaciones que gobiernan el sistema. El diagrama de bloque en la Figura 8-4 es una manera de describir visualmente este grupo de

Sistema

Error = -2Kp X error

35 X -2

750

Ajuste de salida

-70

Salida Servo derecho 680

Distancia der. medida = 4

-++

+Punto de control distancia derecha = 2

Ancho de Pulso Central


ecuaciones. Aquí están las ecuaciones que pueden ser extraídas de este diagrama de bloque, junto con las soluciones. Error = Punto de Control distancia derecha – Distancia derecha medida = 2 – 4 Ajuste de Salida = error × Kp = –2 × 35 = – 70 Salida Servo derecho = Ajuste de salida + Ancho de pulso central = – 70 + 750 = 680 Haciendo algunas substituciones, las tres ecuaciones arriba pueden ser reducidas a una, la cual te dará el mismo resultado.

Salida Servo derecho = (Punto de Control distancia derecha – Distancia derecha medida) × Kp + Ancho de pulso central

Substituyendo los valores del ejemplo, podemos darnos cuenta que la ecuación funciona: = ((2 – 4) × 35) + 750 = 680 El par IR y servo izquierdos tienen un algoritmo similar mostrado en la Figura 8-5. La diferencia es que Kp es –35 en vez de +35. Asumiendo que el mismo valor del par IR derecho es medido, el ajuste de salida resulta en un ancho de pulso de 820. Aquí est’a la ecuación y los cálculos para este diagrama de bloque:

Salida Servo izq. = (Punto de Control distancia izquierda – Distancia izquierda medida) × Kp + Ancho de pulso central

= ((2 – 4) × –35) + 750 = 820 El resultado de este lazo de control es un ancho de pulso que hace que el servo izquierdo rote a aproximadamente ¾ de su máxima velocidad en el sentido contrario a las manecillas del reloj. Este también es un pulso hacia adelante para la rueda izquierda. La idea de retroalimentación es que la salidad del sistema sea muestreada nuevamente, por el Boe-Bot sombra tomando una nueva medida de distancia. Entonces el lazo de control se repite otra y otra vez... aproximadamente 40 veces por segundo.


Figura 8-5 Diagrama de Bloque para Control Proporcional del Servo y Par de IR LED y Detector Izquierdos

Programando el Vehículo Boe-Bot Sombra Recuerda que la ecuación para la salida del servo derecho era:

Salida Servo derecho = (Punto de Control distancia derecha – Distancia derecha medida) × Kp + Ancho de pulso central

Aquí esta un ejemplo de cómo resolver la misma ecuación en PBASIC. El punto de control de la distancia derecha es 2, la distancia medida es la variable llamada distanceRight que guardará las medidas de la distancia IR, Kp es 35, y el ancho de pulso central es 750:


Sistema

Error = -2Kp X error

-35 X -2

750

Ajuste de salida

+70

Salida Servo izquierdo 820

Distancia izq. medida = 4

- ++

+Punto de control distancia izq. = 2

Ancho de pulso Central


Recuerda que en PBASIC las expresiones matemáticas son ejecutadas de izquierda a derecha. Primero, distanceRight es substraída de 2. El resultado de esta substracción es entonces multiplicado por Kpr, y luego, el producto es sumado al ancho de pulso central.

Puedes usar paréntesis para forzar que un cálculo que esté más a la derecha en una linea de código PBASIC sea realizado primero. Recuerda este ejemplo: tu puedes reescribir esta línea de código PBASIC:


de esta manera:

pulseRight = 35 * (2 – distanceRight) + 750

En esta expresión, 35 es multiplicado por el resultado de (2 – distanceRight), y entonces el productos es sumado a 750.

El servo izquierdo es diferente porque Kp para ese sistema es -35

pulseLeft = 2 - distanceLeft * (-35) + 750

Ya que los valores -35, 35, 2, y 750 tienen sus respectivos nombres, es definitivamente una buena ocasión para el uso de algunas declaraciones de constantes.

Kpl CON -35 Kpr CON 35 SetPoint CON 2 CenterPulse CON 750

Con estas declaraciones de constantes en el programa, puedes usar el nombre Kpl en vez de -35, Kpr en vez de 35, SetPoint en vez de 2, y CenterPulse en vez de 750. Después de estas declaraciones de constantes, los cálculos de control proporcional se ven así:

pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse

Lo conveniente de declarar constantes para estos valores es que puedes cambiarlos en un sólo lugar, al comienzo del programa. Los cambios que hagas al comienzo del programa serán reflejados en todos lados donde estas constantes son usadas. Por ejemplo, cambiando la directiva Kpl CON de -35 a -40, toda instancia de Kpl en todo el programa cambia de -35 a -40. Esto es bastante útil para experimentar y entonar los lazos de control proporcional izquierdo y derecho.


Programa Ejemplo – FollowingBoeBot.bs2

FollowingBoeBot.bs2 repite el recientemente discutido lazo de control proporcional con cada pulso de servo. En otras palabras, antes de cada pulso, la distancia es medida y el la señal de error es determinada. Entonces el error es multiplicado por Kp, y el valor que resulta es sumado/substraído a/de los anchos de pulso que son enviados a los servos izquierdo/derecho.

√ Introduce, guarda, y ejecuta FollowingBoeBot.bs2. √ Apunta el Boe-Bot a una hoja de papel tamaño carta (8 ½ × 11”) sostenida en

frente del mismo como si se tratase de una pared-obstáculo. El Boe-Bot debería mantener una distancia fiha entre sí mismo y la hoja de papel.

√ Trata de rotar un poco la hoja de papel. El Boe-Bot debería de rotar con ella. √ Trata de usar la hoja de papel para guiar al Boe-Bot por sus alrededores. El Boe-

Bot debería seguirla. √ Mueve la hoja de papel muy cerca del Boe-Bot, debería de retroceder, alejándose

del papel. ' -----[ Title ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - FollowingBoeBot.bs2 ' Boe-Bot adjusts its position to keep objects it detects in zone 2. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Constants ]---------------------------------------------------------- Kpl CON -35 Kpr CON 35 SetPoint CON 2 CenterPulse CON 750 ' -----[ Variables ]---------------------------------------------------------- freqSelect VAR Nib irFrequency VAR Word irDetectLeft VAR Bit irDetectRight VAR Bit distanceLeft VAR Nib distanceRight VAR Nib pulseLeft VAR Word pulseRight VAR Word ' -----[ Initialization ]-----------------------------------------------------


FREQOUT 4, 2000, 3000 ' -----[ Main Routine ]------------------------------------------------------- DO GOSUB Get_Ir_Distances ' Calculate proportional output. pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse GOSUB Send_Pulse LOOP ' -----[ Subroutine - Get IR Distances ]-------------------------------------- Get_Ir_Distances: distanceLeft = 0 distanceRight = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight NEXT RETURN ' -----[ Subroutine – Get Pulse ]--------------------------------------------- Send_Pulse: PULSOUT 13,pulseLeft PULSOUT 12,pulseRight PAUSE 5 RETURN

Funcionamiento del Programa FollowingBoeBot.bs2 FollowingBoeBot.bs2 declara cuatro constantes, Kpr, Kpl, SetPoint, y CenterPulse usando la directiva CON. Dondequiera que ves SetPoint, es en realidad el número 2 (una


constante). De igual manera, dondequiera que veas Kpl, es en realidad el número -35. Kpr es en realidad 35, y CenterPulse es 750.

Kpl CON -35 Kpr CON 35 SetPoint CON 2 CenterPulse CON 750

La primera cosa que la rutina principal hace es llamar la subrutina Get_Ir_Distances. Luego que la subrutina Get_Ir_Distances finaliza, distanceLeft y distanceRight contienen cada una un número correspondiente a la zone en la cual un objeto fue detectado para los pares IR izquierdo y derecho.

DO GOSUB Get_Ir_Distances

Las próximas dos líneas de código implementan los cálculos del control proporcional para cada servo.

' Calculate proportional output. pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse

Ahora que los cálculos pulseLeft y pulseRight han finalizado, la subrutina Send_Pulse puede ser llamada.

GOSUB Send_Pulse

La porción LOOP del DO…LOOP envía el programa de regreso al comando que se encuentra inmediatamente después de DO al principio del bucle principal.

LOOP

Tu Turno La Figura 8-6 muestra un Boe-Bot líder seguido por un Boe-Bot sombra. El Boe-Bot líder está ejecutando una versión modificada del programa FastIrRoaming.bs2, y el Boe-Bot sombra está ejecutando FollowingBoeBot.bs2. El control proporcional hace que el vehículo sombra sea un seguidor fiel. Un Boe-Bot líder puede llevar consigo unos 6 ó 7


Boe-Bots sombra. Solo añade los páneles del lado y la parte posterior del Boe-Bot líder al resto de los Boe-Bot sombra en la cadena.

Figura 8-6 Boe-Bot líder (izq.) y Boe-Bot sombra (der.)

√ Si eres parte de una clase, monta los páneles de papel en la cola y a ambos lados

del Boe-Bot líder como se muestra en la Figura 8-6. √ Si no eres parte de una clase (y sólo tienes un Boe-Bot) el vehículo sombra

seguirá un pedazo de papel o tu mano de igual manera que si siguiera un Boe-Bot líder.

√ Reemplaza los resistores de 1 kΩ que conectan P2 y P8 del Boe-Bot líder con los IR LEDs con resistores de 470 Ω ó 220 Ω.

√ Programa el Boe-Bot líder para evadir objeto usando una versión modificada del programa FastIrRoaming.bs2. Abre FastIrRoaming.bs2, y dale el nombre SlowerIrRoamingForLeadBoeBot.bs2.

√ Haz estas modificaicones al programa SlowerIrRoamingForLeadBoeBot.bs2: √ Incrementa todos los argumentos Duration de PULSOUT de su valor

actual 650 a 710. √ Reduce todos los argumentos Duration de PULSOUT de su valor actual

850 a 790. √ El Boe-Bot sombra debería de ejecutar FollowingBoeBot.bs2 sin ninguna

modificación.


√ Con ambos Be-Bots ejecutando sus programas respectivos, coloca el Boe-Bot sombra detrás del Boe-Bot líder. El Boe-Bot sombra debería seguir a una distancia fija, siempre y cuando no sea distraído por otro objeto como una mano o una pared cercana.

Puedes ajustar los puntos de control y constantes de proporcionalidad para cambiar el comportamiento del Boe-Bot sombra. Usa tu mano o una pieza de papel para guiar al Boe-Bot sombra mientras haces estos ejercicios:

√ Trata de ejecutar FollowingBoeBot.bs2 usando valores constantes de Kpr y Kpl, en el rango 15 a 50. Observa la diferencia en cuanto a la responsividad de tu Boe-Bot al seguir un objeto.

√ Trata de hacer ajustes al valor constante SetPoint. Trata con valores de 0 a 4.

ACTIVIDAD #3: SIGUIENDO UNA BANDA La Figura 8-7 muestra un ejemplo de una pista que puedes construir y programar a tu Boe-Bot para que la siga. Cada banda en esta pista contiene tres tiras largas de ¾ in (19 mm) de teipe eléctrico de vinil en una tabla para póster blanca. Ningún papel debería ser visible entre las bandas de teipe eléctrico.

28” (71 cm)

22” (

56 c

m)

w w w . st a mp si nc la ss .c om

R eset

S TAMPS C LAS Sin

B o a rd o f E d uc a t i o n

Pw r

9 V dcB a t t ery

6-9VD C

S outS inAT NV ssP 0P 1P 2P 3P 4P 5P 6P 7

P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X 4 X 5

15 1 4 13 1 2

1

X 1

V ssP 1P 3P 5P 7P 9P 11P 13P 15V in

V ssP 0P 2P 4P 6P 8P 10P 12P 14V dd

U 1

TM

0 1 2

© 2 000 -2 003

V dd

P 15P 14P 13P 12P 11P 10P 9P 8P 7P 6P 5P 4P 3P 2P 1P 0

X 2

X 3V dd V ssV in

P 15P 14P 13P 12P 11P 10P 9P 8

P 4

P 2P 1P 0

P 7P 6P 5

P 3

X 2

X 3V dd V ssV in

R ev C

+


Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC

SoutSinATN

VssP0P1P2P3P4P5P6P7

P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2000-2003

Vdd


X2

X3VddVss Vin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3VddVss Vin

Rev C

+

Start

Finish

Figura 8-7 Pista para seguimiento de banda

Inicio

Final


Construyendo y Probando la Pista

Para navegación exitosa en esta pista, es requerida cierta verificación y ajuste del Boe-Bot.

Materiales Requeridos

(1) Lámina de tabla para póster – Dimensiones aproximadas: 22 X 28 in (56 X 71 cm) (1) Rollo de Teipe Eléctrico Negro de Vinil – ¾” (19 mm) de ancho.

√ Usa tu tabla para póster y teipe eléctrico para construir la pista mostrada en la Figura 8-7.

Probando las bandas

√ Apunta tus pares IR hacia abajo y afuera como muestra la Figura 8-8 (la Figura 7-8 de la página 264 es repetida acá por conveniencia).

Vdd VssVin


X4 X5

+

Figura 8-8 Pares IR Dirigidos Hacia Abajo para Buscar la Banda

Vista Superior Vista Lateral

√ Asegúrate que tu teipe eléctrico esté libre de interferencia generada por luces fluorescentes. Lee Husmeando Interferencia IR en la página 253 ).

√ Reemplaza los resistores de 1 kΩ en serie con los IR LEDs por unos resistores de 2 kΩ para hacer reducir el campo de visión de tu Boe-Bot.

√ Ejecuta DisplayBothDistances.bs2 encontrado en la página 285. Mantén tu Boe-Bot conectado a su cable serial para que puedas observar las distancias mostradas.


√ Comienza colocando tu Boe-Bot de tal manera que se encuentre viendo directamente al fondo blanco de tu tabla para póster como lo muestra la Figura 8-9.

√ Verifica que las medidas de tus zonas indican que un objeto es detectado en una zona bastante cercana. Ambos sensores deberían darte una medida de 1 ó 0.

w w w . st a mps i nc la ss .c om

R eset

STA MPS C LASSi n


Pw r

9 V dcB a t t ery

6-9VD C

S outS inAT N

V ssP 0P 1P 2P 3P 4P 5P 6P 7

P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X 4 X 5

15 1 4 13 1 2

1

X 1



U 1

TM

0 1 2

© 2 000 -2 003

V dd


X 2

X 3V dd V ssV in

P 15P 14P 13P 12P 11P 10P 9P 8

P 4

P 2P 1P 0

P 7P 6P 5

P 3

X 2

X 3V dd V ssV in

R ev C

+

Figura 8-9 Prueba para Número de Zona Bajos – Vista Superior

√ Coloca tu Boe-Bot de tal manera que ambos pares de IR LED/detector estén

enfocados directamente sobre el centro de tu teipe eléctrico (como en la Figura 8-10 y la Figure 8-11).

√ Entonces, ajusta la posición de tu Boe-Bot (acercándolo y alejándolo del teipe) hasta que ambos valores de zona alcancen el nivel 4 ó 5 indicando que un objeto lejano ha sido detectado, o ningún objeto ha sido detectado.

√ Si tienes dificultades en obtener lecturas más altas con tu pista de teipe eléctrico, consulta la sección de Resolución de Problemas de la Pista de Teipe EléctricoIf you are having difficulties getting the higher readings with your electrical tape course, see Resolución de Problemas de la Pista de Teipe Eléctrico en la página 300.



R eset

STA MPS C LASSi n


Pw r

9 V dcB a t t ery

6-9VD C

S outS inAT N

V ssP 0P 1P 2P 3P 4P 5P 6P 7

P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X 4 X 5

15 1 4 13 1 2

1

X 1



U 1

TM

0 1 2

© 2 000 -2 003

V dd


X 2

X 3V dd V ssV in

P 15P 14P 13P 12P 11P 10P 9P 8

P 4

P 2P 1P 0

P 7P 6P 5

P 3

X 2

X 3V dd V ssV in

R ev C

+

Figura 8-10 Prueba para Número de Zona Alto – Vista Superior

Electrical Tape

Figure 8-11 Prueba para Número de Zona Alto – Vista Lateral


Resolución de Problemas de la Pista de Teipe Eléctrico

Si no puedes obtener un valor alto de zona cuando los detectores IR están enfocados sobre el teipe eléctrico, toma una hoja de papel adicional, y has una banda que contenga cuatro tiras en vez de tres. Si los números de zona siguen siendo bajos, asegúrate que estás usando resistores de 2 kΩ (rojo-negro-rojo) en serie con tus IR LEDs. Puedes también probar con un 4.7 kΩ para reducir aún más el campo de visión del Boe-Bot. Si ninguno de éstos métodos funciona, prueba con una marca distinta de teipe negro eléctrico de vinil. Ajustando el IR LED/detector para que esté enfocado más cerca o más lejos de la parte de adelante del Boe-Bot (observa la Figure 8-11) puede ayudar también.

Si estás teniendo problemas con las medidas bajas de zona cuando mides la superficie blanca, trata de apuntar los IR LEDs y detectores más hacia abajo y hacia el frente del Boe-Bot, pero cuidado que no causes reflexiones del chasis. También puedes probar con valores de resistor más bajos como 1 kΩ (marrón-negro-rojo).

Si usas antiguos IR LEDs con cubierta de goma en vez de los de la cubierta de plástico de 2-piezas, puedes estar teniendo dificultades para obtener los números bajos cuando los IR/LED detectores están enfocados sobre el fondo blanco. Estos LEDs puede que necesiten resistores de 470 Ω (amarillo-violeta-marrón) ó 220 Ω (rojo-rojo-marrón) en serie. También, asegúrate que las patas de los IR LEDs no están haciendo contacto entre ellas.

√ Ahora, coloca el Boe-Bot en la pista de manera tal que sus ruedas estén a ambos

lados de la línea negra. Los detectores IR deberían de estar apuntando un poco hacia afuera. Ve el acercamiento en la Figura 8-12. Verifica que la medida de distancia para ambos pares IR son nuevamente 0 ó 1. Si las medidas son más altas, significa que necesitan estar apuntados un poco más hacia afuera, alejados de el borde de la banda.

Cuando mueves tu Boe-Bot en cualquier dirección indicada por una flecha-doble, uno u otro par IR será enfocado sobre el teipe eléctrico. Cuando haces esto, las medidas del par que se encuentra ahora sobre el teipe eléctrico deberían aumentar a 4 ó 5. Ten en cuenta que si mueves al Boe-Bot hacia su izquierda, el detector derecho debería aumentar el valor, y si lo mueves hacia su derecha, el detector izquierdo debería mostrar el valor más alto.

√ Ajusta tus pares IR LED/detector hasta que el Boe-Bot pase esta última prueba. Entonces estarás listo para tratar de seguir la banda.


Vdd VssVin


X4 X5

+


R eset

S TAMPS C LAS Sin


Pw r

9 V dcB a t t ery

6-9VD C


P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X 4 X 5

15 1 4 13 1 2

1

X 1



U 1

TM

0 1 2

© 2 000 -2 003

V dd


X 2

X 3V dd V ssV in

P 15P 14P 13P 12P 11P 10P 9P 8

P 4

P 2P 1P 0

P 7P 6P 5

P 3

X 2

X 3V dd V ssV in

R ev C

+

Figura 8-12 Prueba de Lectura de Banda

Acercamiento sobre los Pares IR

Vista superior del Boe-Bot a ambos lados de la banda

Programando para Seguimiento de Banda

Sólo vas a necesitar hacer unos pequeños ajustes al programa FollowingBoeBot.bs2. en la página 292 para hacer que funcione para seguimiento de banda. Primero, el Boe-Bot debería moverse hacia objetos cercanos al punto de control SetPoint y alejarse de los objetos más alejados de SetPoint. Esto es opuesto al comportamiento del programa original FollowingBoeBot.bs2. Para revertir la dirección en que se mueve el Boe-Bot cuando detecta que el objeto no está a la distancia del punto de control SetPoint, simplemente cambia los signos de las constantes Kpl y Kpr. En otras palabras, cambia Kpl de -35 a 35, y cambia Kpr de 35 a -35. Vas a necesitar experimentar con tu punto de control SetPoint. Los valores de 2 a 4 tienden a funcionar mejor. Este próximo ejemplo usa un punto de control SetPoint de 3.

Programa de Ejemplo: StripeFollowingBoeBot.bs2

√ Abre FollowingBoeBot.bs2 y guárdalo como StripeFollowingBoeBot.bs2. √ Cambia la declaración de SetPoint de SetPoint CON 2 a SetPoint CON 3. √ Cambia Kpl de -35 a 35. √ Cambia Kpr de 35 a -35. √ Ejecuta el programa (mostrado abajo). √ Coloca tu Boe-Bot en la ubicación “Inicio” mostrada en la Figura 8-13. El Boe-

Bot debería esperar allí hasta que coloques tu mano en frente de sus pares IR. Entonces rodará hacia adelante. Cuando pase la banda de inicio, retira tu mano,


y debería de empezar a seguir la banda. Cuando ve la banda de “Final,” debería detenerse y esperar allí.

√ Asumiendo que puedes obtener medidas de distancia de 5 sobre el teipe eléctrico y 0 sobre la tabla para póster, los valores constantes de SetPoint de 2, 3, y 4 deberían funcionar. Trata con valores distintos de SetPoint y toma notas del desempeño de tu Boe-Bot’s en la pista.

28” (71 cm)

22” (

56 c

m)

w w w . st a mp si nc la ss .c om

R eset

S TAMPS C LAS Sin


Pw r

9 V dcB a t t ery

6-9VD C


P 11

P 9P 8

V in

P 10

P 15P 14P 13P 12

V ddR stV ss

Bl ackR ed

X 4 X 5

15 1 4 13 1 2

1

X 1



U 1

TM

0 1 2

© 2 000 -2 003

V dd


X 2

X 3V dd V ssV in

P 15P 14P 13P 12P 11P 10P 9P 8

P 4

P 2P 1P 0

P 7P 6P 5

P 3

X 2

X 3V dd V ssV in

R ev C

+


Reset

STAMPS CLASSin

Board of Education

Pwr

9 VdcBattery

6-9VDC

SoutSinATN

VssP0P1P2P3P4P5P6P7

P11

P9P8

Vin

P10

P15P14P13P12

VddRstVss

BlackRed

X4 X5

15 14 13 12

1

X1



U1

TM

0 1 2

© 2000-2003

Vdd


X2

X3VddVss Vin

P15P14P13P12P11P10P9P8

P4

P2P1P0

P7P6P5

P3

X2

X3VddVss Vin

Rev C

+

Start

Finish

Figura 8-13 Pista de Seguimiento de Banda

' -----[ Title ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - StripeFollowingBoeBot.bs2 ' Boe-Bot adjusts its position to move toward objects that are closer than ' zone 3 and away from objects further than zone 3. Useful for following a ' 2.25 inch wide vinyl electrical tape stripe. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Constants ]---------------------------------------------------------- Kpl CON 35 ' Change from -35 to 35 Kpr CON -35 ' Change from 35 to -35 SetPoint CON 3 ' Change from 2 to 3. CenterPulse CON 750 ' -----[ Variables ]----------------------------------------------------------

Final

Inicio


freqSelect VAR Nib irFrequency VAR Word irDetectLeft VAR Bit irDetectRight VAR Bit distanceLeft VAR Nib distanceRight VAR Nib pulseLeft VAR Word pulseRight VAR Word ' -----[ Initialization ]----------------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ Main Routine ]------------------------------------------------------- DO GOSUB Get_Ir_Distances ' Calculate proportional output. pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse GOSUB Send_Pulse LOOP ' -----[ Subroutine - Get IR Distances ]-------------------------------------- Get_Ir_Distances: distanceLeft = 0 distanceRight = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight NEXT RETURN


' -----[ Subroutine - Get Pulse ]--------------------------------------------- Send_Pulse: PULSOUT 13,pulseLeft PULSOUT 12,pulseRight PAUSE 5 RETURN

Tu Turno – Concurso de Seguimiento de Banda

Puedes convertir esto en un concurso en el que el menor tiempo gane, dado que el Boe-Bot espere fielmente en las bandas de “Inicio” y “Final.” Puedes inventar otros concursos también. Para mejor desempeño, experimenta con distintos valores para SetPoint, Kpl, y Kpr.


RESUMEN El concepto de Barrido de Frecuencia fue introducido como una manera de determinar distancias usando los IR LED y detectores del Boe-Bot. FREQOUT fue usado para enviar señales IR a una frecuencia en el rango de 37.5 kHz (más sensible) a 41.5 kHz (menos sensible). La distancia fue determinada determinando cuáles frecuencias causaban que el detector IR reportara que un objeto fue detectado y cuáles no. Debido a que no todas las frecuencias estaban separadas por el mismo valor, se introdujo el comando LOOKUP como una manera sencilla de usar la secuencia de conteo proveniente de un bucle FOR…NEXT para indicar listas secuenciales de números. Los sistemas de Control fueron introducidos junto con control de lazo cerrado. Control proporcional en un sistema de lazo cerrado es un algoritmo donde el error es multiplicado por una constante de proporcionalidad para determinar la salida del sistema. El error es el resultado de la medida de la salida de sistema subtraída del punto de control. Para el Boe-Bot, tanto la salida del sistema como el punto de control estaban en términos de distancia. El BASIC Stamp fue programado en PBASIC para operar lazos de control para tanto el servo izquierdo como el derecho y los detectores de ditancia. Re-muestreando la distancia y ajustando las salidas de los servos antes de mandar los pulsos a los servos, el lazo de control hizo que el Boe-Bot respondiera a los movimientos de objetos. El Boe-Bot fue capaz de usar control proporcional para rastrear objetos y seguirlos, y tambien usó este tipo de control para seguir una banda de teipe eléctrico negro.

Observa el Boe-Bot en Acción en el sitio web www.parallax.com!

Puedes ver al Boe-Bot resolviendo el Proyecto 2 del Capítulo 8 y otros clips de video Robóticos en la “Robo Video Gallery” bajo el menú “Robotics Menu” en www.parallax.com.

Preguntas 1. ¿Cuál es la sensibilidad relativa del detector IR si usas FREQOUT para enviar una

armónica de kHz? ¿Cuál es la sensibilidad relativa con una armónica de 36 kHz?

2. Considera el pedazo de código abajo. ¿Si la variable index es 4, cuál número será colocado en la variable prime en este comando LOOKUP? ¿Qué valores guardará prime cuando index es 0, 1, 2, y 7?


LOOKUP index, [2, 3, 5, 7, 11, 13, 17, 19], prime

3. ¿En qué orden son evaluadas las expresiones matemáticas en PBASIC? Cómo puedes invalidar este orden?

4. ¿Qué directiva PBSAIC usas para declarar una constante? ¿Cómo puedes darle al número 100 el nombre “BoilingPoint”?

Ejercicios 1. Haz una lista de sensibilidad del detector IR para cada frecuencia en kHz

mostrada en la Figura 8-1. 2. Escribe un segmento de código que haga el barrido de frecuencia para sólo

cuatro frecuencias en vez de cinco. 3. Haz una lista de chequeo para las pruebas qeu debes realizar para asegurarte de

un fiel seguimiento de la banda.

Proyectos P1. Crea intersectiones de distinto tipo usando teipe eléctrico y programa al Boe-Bot

para que navegue a través de ellas. Las intersecciones pueden ser 90° izquierda, 90° derecha, a tres-vías, y a cuatro-vías. Esto requerirá que el Boe-Bot reconozca que es una intersección. Cuando el Boe-Bot ejecute StripeFollowingBoeBot.bs2, el Boe-Bot se quedará inmóvil en las intersecciones. El objetivo es hacer que el Boe-Bot se dé cuenta que no está haciendo nada y salga de su bucle de control proporcional. Pistas: Puedes hacer esto creando dos contadores, uno que se incremente en 1 con cada pasada por el DO…LOOP, y otro que sólo incremente cuando el Boe-Bot proporcione un pulso hacia adelante. Cuando el contador que incrementa con cada pasada por el DO…LOOP llegue a 60, usa IF…THEN para chequear cuantos pulsos hacia adelante fueron aplicados. Si menos de 30 pulsos hacia adelante fueron aplicados, el Boe-Bot está probablemente atascado. Recuerda reiniciar ambos contadores cada vez que el contador de bucle llegue a 60. Después de que el Boe-Bot reconozca que está en una intersección, necesita moverse al borde superior de la intersección, y luego retroceder para determinar si observa teipe eléctrico o fondo blanco a la izquierda y a la derecha, entonces deberá hacer la maniobra de 90° correcta. Usa una maniobra pre-programada para dar vuelta de 90°, sin control proporcional. Para intersecciones a tres-vías y cuatro-vías el Boe-Bot puede dar vuelta a la izquierda o a la derecha.


P2. Proyecto Avanzado- Diseña un concurso de resuloción de laberinto por tí mismo, y luego programa el Boe-Bot para que lo resuelva!


Preguntas Q1. La sensibilidad relativa a 35 kHz es 30%. Para 36 kHz, es 50% Q2. Cuando index = 4, prime = 11

index = 0, prime = 2 index = 1, prime = 3 index = 2, prime = 5 index = 7, prime = 19

Q3. Las expresiones son evaluadas de izquierda a derecha. Para invalidar, usa paréntesis para cambiar el orden.

Q4. Usa la directiva CON. BoilingPoint CON 100

E1. Frecuencia (kHz): 34 35 36 37 38 39 40 41 42 Sensibilidad : 14% 30% 50% 76% 100% 80% 55% 35% 16%

E2. Para resolver este problema, coloca sólo cuatro frecuencias en la lista LOOKUP, y disminuye en uno el índice del bucle FOR…NEXT.

FOR freqSelect = 0 TO 3 LOOKUP freqSelect, [37500, 38750, 39500, 40500], irFrequency FREQOUT 8, 1, irFrequency irDetect = IN9 … commands not shown NEXT

E3. • Husmea interferencia IR con "IrInterferenceSniffer.bs2". • Ejecuta Display BothDistances.bs2. • Medidas blancas deberían ser 0-1 en ambos sensores. • Medidas negras deberían ser 4-5 en ambos sensores. • A ambos lados de la línea, ambos sensores deberían mostrar medir 0-1. • Mueve el Boe-Bot para atrás y adelante sobre la línea, el sensor sobre la línea debería medir 4-5.

P1. En la solución abajo, la subrutina Check_For_Intersection implementa el algoritmo descrito. El servo izquierdo fue escogido arbitrariamente para contar los pulsos hacia adelante. Una variable de tamaño bit llamada isStuck es usada como aviso para hacerle saber al programa Principal si se ha alcanzado una intersección. En la subrutina Navigate_Intersection, el Boe-Bot adelanta pasando la intersección y luego retrocede, chequeando los sensores, usando


DO…LOOP…UNTIL. Entonces hace una vuelta de 90 grados preprogramada en la dirección correcta. Si la intersección es a 3-vías o 4-vías, el Boe-Bot arbitrariamente volteará en la dirección en la que el primer negro fue detectado. Una constante, Turn90Degree, es proveída para entonar la vuelta de 90 grados. Indicadores visuales y audibles están incluídos, lo cual ayuda en la resolución de problemas y entendiendo lo que el Boe-Bot está viendo y decidiendo, así como también añadiendo un poco de personalidad y diversión.

' -----[ Title ]------------------------------------------------------- ' Robotica con el Boe-Bot - IntersectionsBoeBot.bs2 ' Navigate 90 degree left/right, 3-way, and 4-way intersections. ' Based on StripeFollowingBoeBot.bs2 ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. DEBUG "Program Running!" ' -----[ Constants ]--------------------------------------------------- Kpl CON 35 ' Left proportional constant Kpr CON -35 ' Right proportional constant SetPoint CON 3 ' 0-1 is White, 4-5 is Negro CenterPulse CON 750 Turn90Degree CON 30 ' Pulses needed for 90 turn RightLED PIN 1 ' LED Indicators LeftLED PIN 10 ' -----[ Variables ]--------------------------------------------------- freqSelect VAR Nib ' Sweep through 5 frequencies irFrequency VAR Word ' Freq sent to IR emitter irDetectLeft VAR Bit ' Store results from detectors irDetectRight VAR Bit distanceLeft VAR Nib ' Calculate distance zones distanceRight VAR Nib pulseLeft VAR Word ' Servo pulseWidths pulseRight VAR Word numPulses VAR Byte ' Count total pulses fwdPulses VAR Byte ' Count forward pulses counter VAR Byte isStuck VAR Bit ' Boolean variable,is bot stuck? ' -----[ Initialization ]---------------------------------------------- FREQOUT 4, 2000, 3000 ' -----[ Main Routine ]------------------------------------------------


DO GOSUB Get_Ir_Distances ' Read IR sensors GOSUB Update_LEDs ' Indicate white/negro line ' Calculate proportional output and move accordingly. pulseLeft = SetPoint - distanceLeft * Kpl + CenterPulse pulseRight = SetPoint - distanceRight * Kpr + CenterPulse GOSUB Send_Pulse GOSUB Check_For_Intersection ' Are we stuck at intersection? IF (isStuck = 1) THEN GOSUB Make_Noise ' Audible indication GOSUB Navigate_Intersection ' Navigate through it ENDIF LOOP ' -----[ Subroutines ]------------------------------------------------- Navigate_Intersection: ' Go forward until both sensors read white, through the intersection. DO pulseLeft = 850: pulseRight = 650 ' Forward GOSUB Send_Pulse GOSUB Get_Ir_Distances GOSUB Update_LEDs LOOP UNTIL (distanceLeft <=2) AND (distanceRight <=2) GOSUB Stop_Quickly ' Don't coast forward ' Now back up until one detector sees the negro.L & R turn will see ' negro on one detector.3- or 4-way will see both negro, turn toward ' whichever the bot sees first (random). DO pulseLeft = 650: pulseRight = 850 ' Backward GOSUB Send_Pulse GOSUB Get_Ir_Distances GOSUB Update_LEDs LOOP UNTIL (distanceLeft >=4) OR (distanceRight >=4) GOSUB Stop_Quickly ' Don't coast backward ' Make 90 degree turn in direction of the detector which sees negro IF (distanceLeft >=4) THEN ' Left detector reads negro FOR counter = 1 TO Turn90Degree ' Turn 90 degrees left PULSOUT 13, 750 ' without proportional control PULSOUT 12, 650 PAUSE 20 ' so use PAUSE 20 NEXT ELSEIF (distanceRight >=4) THEN ' Right detector reads negro


FOR counter = 1 TO Turn90Degree ' Turn 90 degrees right PULSOUT 13, 850 PULSOUT 12, 750 PAUSE 20 NEXT ENDIF ' That's it. At this point the Boe-Bot should have turned 90 degrees ' to follow the intersection. Continue following the negro line. RETURN Check_For_Intersection: ' Keep track of no. of pulses vs the forward pulses. If there are less ' than 30 forward pulses per total of 60 pulses, robot is likely stuck ' at an intersection. isStuck = 0 ' Initialze Boolean variable numPulses = numPulses + 1 ' Count total pulses sent SELECT numPulses CASE < 60 IF (pulseLeft > CenterPulse) THEN fwdPulses = fwdPulses + 1 ' Count foward pulses ENDIF ' (forward is any pulse > 750) CASE = 60 ' If we have sent 60 pulses IF (fwdPulses < 30) THEN ' how many were forward? isStuck = 1 ' If < 30, robot is stuck ENDIF CASE > 60 numPulses = 0 ' Reset counters back to zero fwdPulses = 0 ' (Could reset in =60 case but ENDSELECT ' it spoils cool Make_Noise) RETURN Make_Noise: ' Makes an increasing tone, proportional to number of forward pulses FOR counter = 1 TO fwdPulses STEP 3 FREQOUT 4, 100, 3800 + (counter * 10) NEXT RETURN Update_LEDs: ' Use LEDs to indicate whether detectors are seeing negro or white. ' White = Off, Negro = On. Negro is a distance reading > or = 4 . IF (distanceLeft >= 4) THEN HIGH LeftLED ELSE LOW LeftLED IF (distanceRight >= 4) THEN HIGH RightLED ELSE LOW RightLED RETURN


Stop_Quickly: ' This stops the wheels so the Boe-Bot does not "coast" forward. PULSOUT 13, 750 PULSOUT 12, 750 PAUSE 20 RETURN Get_Ir_Distances: ' Read both IR pairs and calculate the distance. Negro line gives 4-5 ' reading. White surface give 0-1 reading. distanceLeft = 0 distanceRight = 0 FOR freqSelect = 0 TO 4 LOOKUP freqSelect,[37500,38250,39500,40500,41500], irFrequency FREQOUT 8,1,irFrequency irDetectLeft = IN9 distanceLeft = distanceLeft + irDetectLeft FREQOUT 2,1,irFrequency irDetectRight = IN0 distanceRight = distanceRight + irDetectRight NEXT RETURN Send_Pulse: ' Send a single pulse to the servos in between IR readings. PULSOUT 13,pulseLeft PULSOUT 12,pulseRight PAUSE 5 ' PAUSE reduced due to IR readings RETURN

P2. Si creas un proyecto de laberinto interesante para el Boe-Bot y quieres

compartirlo con otros, puedes registrarte en el Grupo Yahoo! StampsInClass (en inglés), listado en la parte de atrás de la página de título de Robótica con el Boe-Bot. O, puedes mandar un correo electrónico al Equipo Educacional de parallax a la dirección [email protected].

Apéndice A: Resolución de Problemas de Comunicación · Page 313

Apéndice A: Resolución de Problemas de Comunicación entre la PC y el BASIC Stamp Aquí está una lista de cosas para intentar arreglar de manera rápida alguna dificultad que se presente en la comunicación entre el BASIC Stamp Editor y tu BASIC Stamp:

√ Si estás usando la Board of Education Rev C, asegúrate que la el interruptor de alimentación esté colocado en la posición-1.

√ Descarta baterías muertas y funcionamiento incorrecto o inadecuado de las fuentes de alimentación usando una batería nueva de 9 V o cuatro nuevas baterías alcalinas AA de 1.5 V en el paquete de baterías.

√ Asegúrate que el cable serial esté firmemente conectado tanto al puerto COM de la computadora como al conector DB9 en la Board of Education o BASIC Stamp HomeWork Board.

√ Asegúrate que tu cable serial sea normal (straight-through). NO USES UN CABLE NULO DE MODEM. La mayoría de los cables nulos de módem están etiquetados NULL o Null Modem; inspecciona visualmente el cable para ver si encuentras dicha etiqueta.

√ Deshabilita cualquier software de comunicación con una palmtop. Si estás usando un BASIC Stamp y una Board of Education, también chequea lo siguiente:

√ Asegúrate que el BASIC Stamp sea introducido en su enchufe con el lado

correcto hacia arriba como se muestra en la Figura 1-24 en la página 18. √ Si tú estás usando una fuente de alimentción DC que se conecta a la pared, revisa

que esté conectada tanto a la pared como a la Board of Education. Verifica que la luz verde Pwr en la Board of Education emita luz cuando la fuente de alimentación DC está enchufada.

√ Asegúrate que el BASIC Stamp esté firmemente insertado en su enchufe. √ Inspecciona visualmente el módulo BASIC Stamp para asegurarte que ninguno

de sus pines está doblado bajo el módulo en vez de hundidos en su enchufe en la Board of Education.

Si tu ventana de Identificación se ve similar a la Figura A-1, quiere decir que el BASIC Stamp Editor no puede encontrar tu BASIC Stamp en ningún puerto COM. Si tienes este problema trata lo siguiente:


Figura A-1 Ventana de Identificación Ejemplo: el BASIC Stamp 2 no ha sido encontrado en ningún puerto COM.

Si conoces el número de puerto COM, pero no aparece en la ventana de Identificación:

√ Usa el botón Edit Port List para agregar el puerto COM. Cuando regreses a la ventana de Identificación, haz clic en el botón Refresh para encontrar si el BASIC Stamp 2 es detectado ahora.

√ Cierra la ventana de Identificación. √ En el BASIC Stamp Editor, haz clic en Edit y selecciona Preferences. Haz clic en

la pestaña Editor Operation, y establece Default COM Port como AUTO. √ Trata con la prueba Run → Identify nuevamente.

Si no estás seguro a cuál puerto COM está conectado tu BASIC Stamp, o si estás usando un adaptador de puerto USB a serial, puede ser que necesites buscar en tu para encontrar el puerto COM en uso.

√ Haz clic en el botón de Inicio en el escritorio de tu computadora. √ Para ver una lista de puertos COM en uso, haz las selcciones listadas de acuerdo

a tu sistema operativoTo view the list of COM ports in use, make the selections listed next to your operating system :

Windows® 98: Panel de control → Sistema → Hardware → Administrador

de dispositivos → Puertos (COM & LPT1). Windows® 2000: Configuración → Panel de control → Sistema → Hardware

→ Administrador de dispositivos → Puertos (COM & LPT). Windows® XP: Panel de control → Impresoras y otro hardware. en el recuadro Ver también seleccione Sistema. Seleccione Hardware → Administrador de dispositivos →

Puertos Windows® XP Pro: Configuración → Panel de control → Sistema → Hardware

→ Administrador de dispositivos → Puertos (COM & LPT).


√ Si estás usando un puerto serial (no un adaptador USB a serial), toma nota de los puertos COM listados Si uno o más de estos puertos COM no aparecen en la lista de tu BASIC Stamp Editor, toma nota de los números para cada puerto COM que no aparece en la lista ahora.

√ Si estás usando un adaptador “FTDI USB to Serial,” busca el puerto COM que diga FTDI USB to Serial COM…

√ Repite la prueba Run → Identify. √ Haz clic en el botón Edit Ports List y agrega los números de puerto COM faltantes. √ Repite la prueba Run → Identify nuevamente, esta vez, la ventana de

Identificación debería "encontrar" tu BASIC Stamp 2. ¿Todavía no se detecta tu BASIC Stamp?

√ Si tienes más de un puerto COM, trata de conectar tu Board of Education o BASIC Stamp HomeWork Board a un puerto COM diferente y observa si la prueba Run → Identify funciona.

√ Si tienes una segunda computadora, trata en la computadora distinta. Si tienes un mensaje de error “No BASIC Stamp Found” pero la prueba Run → Identify muestra “Yes” en ambas columnas para uno de los puertos COM, puede ser que necesites cambiar los parámetros de tus Búferes FIFO. Esto ocurre ocasionalmente con los usuarios de Microsoft Windows® 98 y XP. Toma nota del puerto COM con los mensajes “Yes” y prueba lo siguiente: Windows® 98:

√ Haz clic en el botón Inicio en tu escritorio. √ Selecciona Configuración→ Panel de control → Sistema → Administrador de dispositivos

→ Puertos (COM & LPT). √ Selecciona el puerto COM que se usó en la prueba Run → Identify. √ Selecciona Propiedades → Configuración de puerto → Opciones avanzadas. √ Desmarca la casilla llamada “Usar búferes FIFO” y haz clic en OK. √ Haz clic en OK cada vez que lo necesites para cerrar cada ventana y vuelve al

BASIC Stamp Editor. √ Intenta descargar el programa una vez más.

Windows® 2000:


√ Haz clic en el botón Inicio en tu escritorio. √ Selecciona Configuración→ Panel de control → Sistema → Hardware → Administrador

de dispositivos → Puertos (COM & LPT). √ Selecciona el puerto COM que se usó en la prueba Run → Identify. √ Selecciona Configuración de puerto → Opciones avanzadas. √ Desmarca la casilla llamada “Usar búferes FIFO” y haz clic en OK. √ Haz clic en OK cada vez que lo necesites para cerrar cada ventana y vuelve al


Windows® XP:

√ Haz clic en el botón Inicio en tu escritorio. √ Selecciona Panel de control → Impresoras y otro hardware. √ En el recuadro Ver también selecciona Sistema. √ Selecciona Hardware → Administrador de dispositivos → Puertos. √ Introduce el número del puerto COM que se usó en la prueba Run → Identify. √ Selecciona Configuración de puerto → Opciones avanzadas. √ Desmarca la casilla llamada “Usar búferes FIFO” y haz clic en OK. √ Haz clic en OK cada vez que lo necesites para cerrar cada ventana y vuelve al


Windows® XP Pro:

√ Haz clic en el botón Inicio en tu escritorio. √ Selecciona Panel de control → Sistema → Hardware → Administrador de dispositivos →

Puertos (COM & LPT). √ Selecciona el número del puerto COM que se usó en la prueba Run → Identify. √ Selecciona Propiedades → Configuración de puerto → Opciones avanzadas. √ Desmarca la casilla llamada “Usar búferes FIFO” y haz clic en OK. √ Haz clic en OK cada vez que lo necesites para cerrar cada ventana y vuelve al


Si ninguna de estas soluciones te funciona, puedes ir al sitio web www.parallax.com y hacer clic en el link de “Support” (en inglés). O, mandar un correo a


[email protected] (en inglés) o llamar al Soporte Técnico (en inglés) de manera gratuita dentro de los EE.UU. al 1-888-99-STAMP. Para ayuda en español únete a la lista de discusión en Yahoo! Parallax en Español. Esta lista de discusión está orientada a usuarios de productos Parallax. Se intercambian ideas y consultas sobre productos como los microcontroladores BASIC Stamp, Javelin Stamp y sensores y aplicaciones que comercializa Parallax. http://espanol.groups.yahoo.com/group/ParallaxenEspanol/

Apéndice B: Componentes y Características del BASIC Stamp · Page 319

Apéndice B: Componentes y Características del BASIC Stamp y la Plaqueta de Soporte El Módulo Microcontrolador BASIC STAMP® 2 La Figura B-1 muestra de cerca el módulo microcontrolador BASIC Stamp® 2 microcontroller module. Sus componentes más importantes y sus funciones están respectivamente denotadas.


Figura B-1: Módulo Microcontrolador BASIC Stamp® 2 Componentes y sus Funciones

La Plaqueta de Soporte Board of Education® Rev C

La plaqueta de soporte Board of Education® Rev C para los módulos microcontroladores de 24-pines BASIC Stamp® es mostrada en la Figura B-2. Sus componentes más importantes y sus funciones entán respectivamente denotadas.

Figura B-2: Plaqueta de Soporte Board of Education® Rev C

Apéndice B: Componentes y Características del BASIC Stamp · Page 321

La Plataforma de Proyecto BASIC Stamp® HomeWork Board™

La plataforma de proyecto BASIC Stamp® HomeWork Board™ es mostrada en la Figura B-3. Sus componentes más importantes y sus funciones están respectivamente denotadas.

Figura B-3: Plataforma de Proyecto BASIC Stamp® HomeWork Board™


La Plaqueta de Soporte Board of Education® Rev B

La plaqueta de soporte Board of Education® Rev B para los módulos microcontroladores de 24-pines BASIC Stamp® es mostrada en la Figura B-2. Sus componentes más importantes y sus funciones entán respectivamente denotadas.

Figure B-4: Plaqueta de Soporte Board of Education® Rev B

Apéndice C: Código de Colores de un Resistor · Page 323

Apéndice C: Código de Colores de un Resistor Resistores como los que estamos usando en esta guía para el estudiante tienen bandas de colores que te indican cuál es el valor de su resistencia. Existe una combinación de colores diferentes para cada valor de resistencia. Por ejemplo, el código de color para el resistor de 470 Ω es amarillo-violeta-marrón. Puede existir una cuarta banda que indica la tolerancia del resitor. La tolerancia es medida en porcentaje, y te indica cuand lejos se puede encontrar del valor real de resistencia del resitor. La cuarta banda puede ser dorada (5%), plateada (10%), o sin ninguna banda (20%). Para las actividades en este libra la tolerancia del resistor no importa, pero su valor sí. Cada barra de color te dice el valor de resistor en correspondencia a un dígito, y estos colores/dígitos aparence listados en la Tabla C-1. La Figura C-1 muestra el uso de cada color con la tabla para determinar el valor del resistor.

Tabla C-1: Código de Color para Valores de

Resistor

Dígito Color

0 Negro 1 Marrón 2 Rojo 3 Naranja 4 Amarillo 5 Verde 6 Azul 7 Violeta 8 Gris 9 Blanco

Figura C-1 Códigos de Colores de Resistor

Primer Dígito

Segundo Dígito

Número de Ceros

Código de Tolerancia


Aquí está un ejemplo que muestra como la Tabla C-1 y la Figura C-1 pueden ser usadas para determinar el valor de un resistor demostrando que amarillo-violeta-marrón es en realidad 470 Ω:

• La primera banda es amarilla, lo que significa que el dígito de más a la izquierda es un 4. La segunda banda es violeta, lo que significa que el próximo dígito es un 7.

• La tercera banda es marrón. Ya que marrón es 1, significa agrega un cero a la derecha de los dos primeros dígitos.

Amarillo-Violeta-Marrón = 4-7-0.

Apéndice D: Reglas para Uso de la Protoboard · Page 325

Apéndice D: Reglas para Uso de la Protoboard Mira tu Plaqueta de Educación o Plaqueta de Tareas. El cuadrado blanco con muchos huecos, o enchufes en ella, es conocido como una protoboard presoldada. Esta protoboard, en combinación con las filas negras de enchufes en dos de sus lados, es conocida como área de prototipos (como se muestra en Figura D-1). Los circuitos de ejemplo en este texto son construidos enchufando los componentes en estos pequeños enchufes. Los componentes están conectados entre sí con los enchufes de la protoboard. Tu suministrarás electricidad a tu circuito proveniente de los terminales de alimentación, que son los enchufes negros en la parte superior denotados Vdd, Vin, y Vss. Los enchufes negros en la izquierda están denotados P0, P1, hasta P15. Estos enchufes te permiten conectar tu circuito a los pins de entrada/salida del BASIC Stamp.


X2

X3Vdd VssVin

Figura D-1 Area de prototipos Terminales de alimentación (enchufes negros en la parte de arriba), acceso a pines I/O (enchufes negros en la parte lateral), y protoboard presoldada (enchufes blancos)

La protoboard tiene 17 filas de enchufes separadas en dos columnas por medio de una hendidura. La hendidura separa cada una de las filas de enchufes en dos filas de a cinco. Cada fila de cinco enchufes está conectada eléctricamente dentro de la protoboard. Puedes usar estas filas de enchufes para conectar componentes como lo determina el diagrama de un circuito. Si insertas dos cables en cualquier par de enchufes en la misma fila de 5 enchufes, entonces se encuentran eléctricamente conectados entre sí. Un diagrama de circuito es un mapa que muestra como conectar los componentes entre sí. Este usa símbolos únicos para representar cada componente. Estos símbolos de


componentes están conectados por medio de líneas para indicar una conexión eléctrica. Cuando dos símbolos en el circuito están conectados por medio de líneas en el diagrama, la línea indica que se ha hecho una conexión eléctrica. Las líneas también pueden ser usadas para conectar componentes a fuentes de alimentación. Vdd, Vin, y Vss tienen sus símbolos respectivos. Vss corresponde al terminal negativo de la fuente de alimentación (batería) de la Plaqueta de Educación o de la Plaqueta de Tareas BASIC Stamp. Vin es el terminal positivo de la fuente de alimentación (batería), y Vdd está regulado a +5 voltios. Examinemos un ejemplo que use un diagrama para conectar las partes mostradas en la Figura D-2. Para cada una de estas partes, el dibujo de la parte es mostrado por encima del símbolo de diagrama respectivo.

Figura D-2 Dibujos de parte y símbolos de diagrama LED(izquierda) y resistor de 470 Ω (derecha)

La Figura D-3 muestra un ejemplo de un diagrama de circuito en la izquierda y en la derecha un dibujo de circuito que puede ser construido usando este diagrama. Toma en cuenta como el diagrama muestra que un lado de la línea zig-zag que denota un resistor está conectada al símbolo de Vdd. En el dibujo, uno de los dos terminales del símbolo del resistor está enchufado en uno de los enchufes marcados Vdd. En el diagrama, el otro terminal del símbolo del resistor está conectado por medio de una línea al terminal + del símbolo del LED. Recuerda, la línea indica que dos partes están eléctricamente conectadas/ En es dibujo, esto se consigue conectando el otro terminal del resistor en la misma fila de 5 enchufes que el terminal + del LED. Esto conecta eléctricamente los dos terminales. El otro terminal del LED está mostrado conectado al símbolo de Vss en el

470 Ω

AmarilloVioleta

Marrón

OroPlataonada

+

LED


diagrana. En el dibujo, el otro terminal del LED está enchufado en uno de los enchufes marcados Vss.


X2

X3Vdd VssVin

Vdd

Vss

LED

470 Ω

+

Figura D-3 Diagrama de ejemplo y Diagrama de conexión Diagrama (izquierda) y diagrama de conexión (derecha)

La Figura D-3 muestra un segundo ejemplo de un diagrama y un diagrama de conexión. Este diagrama muestra P14 conectado a un terminal de un resistor, con el otro terminal conectado al terminal + de un LED, y el terminal – del LED conectado a Vss. El diagrama sólo difiere por una conexión. El terminal del resistor que antes estaba conectado a Vdd está ahora conetado al pin I/O 14 del BASIC Stamp. El diagrama podría verse más distinto que como está, principalmente porque el resistor se muestra dibujado horizontalmente en vez de verticalmente. Pero en término de conexiones, solo difiere en una, P14 en vez de Vdd. El diagrama de conexión muestra como esta diferencia es manejada con el terminal del resistor que antes estaba conectado en Vdd, ahora conectado en P14.


P14

Vss

LED470 Ω

P15

P13P12P11P10P9P8P7P6P5P4P3P2P1P0

P14

X2

X3Vdd VssVin

+

Figura D-4 Diagrama de ejemplo y Diagrama de conexión Diagrama (izquierda) y diagrama de conexión (derecha)

Aquí esta un ejemplo más complejo que requiere dos partes adicionales, un fotoresistor y un capacitor. Los símbolos esquemáticos y dibujos de partes para estos dos componentes aparecen en la Figura D-4.

0.01 µF

Figura D-4 Dibujos de Partes y Símbolos Esquemáticos Fotoresistor (arriba) y capacitor no polarizado (abajo)

Ya que este dibujo esquemático en la Figura D-5 requiere un resistor de 220 Ω, el primer paso es consultar el Apéndice C: Código de Colores de un Resistor para determinar el código de color para un resistor de 220 Ω. El código de color es Rojo, Rojo, Marrón. Este resistor está conectado a P6 en el dibujo esquemático, el cual corresponde a la pata


del resistor conectada en el enchufe denotado P6 en el área de prototipo (Figure D-6). En el dibujo esquemático, la otra pata del resistor está conectada a no uno, sino dos terminales de otros componentes. Un terminal del fotoresistor y uno del capacitor comparten esta conexión. En la protoboard, la otra pata del resistor está conectada en una de las filas de 5 enchufes. Esta fila también tiene patas del capacitor y fotoresistor conectadas a Vss. En el dibujo esquemático, los otros terminales del fotoresistor y capacitor están conectados a Vss. Aquí está un truco para estar pendiente al construir circuitos en una protoboard. Puedes usar un cable para conectar una fila entera en la protoboard a otra fila, o incluso a pines I/O o terminales de alimentación como Vdd o Vss. En este caso, un cable fue usado para conectar Vss a una fila en la protoboard. Entonces, las patas para el capacitor y fotoresistor fueron enchufadas en la misma fila, completando el circuito.

Vss

220 ΩP6

0.1 µF

Figura D-5 Dibujo esquemático de Resistor, Fotoresistor, y Capacitor


P15P14P13P12P11P10P9P8P7

P5P4P3P2P1P0

P6

X2

X3Vdd VssVin

Figure D-6 Diagrama de conexión de Resistor, Fotoresistor, y Capacitor

Ten en cuenta que los diagramas de cableado presentados aquí como soluciones a los dibujos esquemáticos no son las UNICAS soluciones para dichos dibujos. Por ejemplo, la Figura D-7 muestra otra solución para el dibujo esquemático recientemente discutido. Sigue las conexiones y convéncete que de hecho satisface el dibujo esquemático.

P15P14P13P12P11P10P9P8P7

P5P4P3P2P1P0

P6

X2

X3Vdd VssVin

Figura D-7 Diagrama de conexión de Resistor, Fotoresistor, y Capacitor Observa la localización alternativa de las partes.

Apéndice E: Lista de Partes del Boe-Bot · Page 331

Apéndice E: Lista de Partes del Boe-Bot Para completar las actividades en este texto, vas a necesitar un Boe-Bot completo y los componentes necesarios para construir los circuitos de ejemplo. Hay varias opciones para ordernar estos ítems de Parallax, los cuales están descritos en las páginas siguientes. Toda la información en este apéndice era vigente al momento de la impresión en inglés. Parallax puede hacer substituciones de partes a su discresión, basado en necesidad o para actualizar la calidad de sus productos. Para la información más actualizada y descargas gratis acerca de tu Boe-Bot y Robótica con el Boe-Bot Guía para el Estudiante, revisa periódicamente las páginas individuales de los productos en el sitio www.parallax.com.

Boe-Bot Robot Kit (también conocido como Boe-Bot Full Kit) Además de una PC con un puerto serial y unas herramientas comunes del hogar, el Boe-Bot Robot Kit contiene todas las partes y la documentación (en inglés) necesaria para completer los experimentos en este texto.

Tabla E-1: Boe-Bot Robot (Full) Kit (#28132) Partes y cantidades sujetos a cabio sin previo aviso

Código de Stock Parallax

Descripción Cantidad

BS2-IC Módulo microcontrolador BASIC Stamp 2 1 27000 CD Parallax con software y documentación (en inglés) 1 28124 Robotics with the Boe-Bot Parts Kit 1 28125 Robotics with the Boe-Bot Student Guide 1 28150 Board of Education Rev C 1 700-00064 Destornillador Parallax 1 800-00003 Cable serial 1

Todos estos ítems también pueden ser ordenados por separado, usando los números de parte individuales. Puedes contactar al equipo de ventas Parallax Sales Team de manera gratuita dentro de EE.UU. al número 1-888-512-1024 u ordenar en línea en el sitio www.parallax.com. Para preguntas técnicas o asistencia llama al equipo de soporte técnico Technical Support Team al 1-888-99-STAMP.


Kit de Partes Robótica con el BOE-BOT Si ya tienes una Board of Education y BASIC Stamp, puedes comprar el paquete Robotics with the Boe-Bot Parts kit, con o sin el texto impreso Robotics with the Boe-Bot Student Guide.

Table E-2: Robotics with the Boe-Bot Parts & Text, #28154 Robotics with the Boe-Bot Parts only, #28124

Partes y cantidades sujetas a cambio sin previo aviso



150-01020 Resistor de 1 kΩ 2 150-01030 Resistor de 10 kΩ 2 150-02020 Resistor de 2 kΩ 2 150-02210 Resistor de 220 Ω 8 150-04710 Resistor de 470 Ω 4 150-04720 Resistor de 4.7 kΩ 2 200-01031 Capacitor de 0.01 μF 2 200-01040 Capacitor de 0.1 μF 2 350-00003 LED IR 2 350-00006 LED Rojo 2 350-00009 Fotoresistores (EG&G Vactec VT935G group B) 2 350-00014 Recibidor IR (Panasonic PNA4602M or equivalent) 2 350-90000 Base para LED IR 2 350-00001 Cobertor de luz para LED IR 2 451-00303 Cabezal de 3-pines 2 700-00056 Cable de bigote 2 700-00015 Arandela de nylon tamaño #4 de tornillo 2 710-00007 Tornillo cabeza-plana 7/8” 4-40, estría 2 713-00007 ½” Espaciador, aluminio, #4 redondo 2 800-00016 Cable para conexiones (bolsa de 10) 2 900-00001 Bocina piezoeléctrica 1 28133 Paquete de Hardware para el Boe-Bot 1

Apéndice E: Lista de Partes del Boe-Bot · Page 333

Construyendo un Boe-Bot con una HomeWork Board

Si ya tienes una BASIC Stamp HomeWork Board que desees usar con un Boe-Bot, necesitarás el paquete Robotics with the Boe-Bot Parts kit y estos ítems adicionales: (2) Cabezales de 3-pines macho/macho, #451-00303 (1) Paquete de Patería de plomo y estaño, #753-00001

Paquete de Hardware para el Boe-Bot Todos las partes de hardware del Boe-Bot pueden ser compradas individualmente, como se encuentran en nuestra tienda en-línea Robot Component Shop si requieres de alguna parte para reemplazo. Por favor nota que el Hardware Pack no es vendido como una unidad separada del Boe-Bot Robot (Full) Kit o el Boe-Bot Parts Kit.

Table E-3: Boe-Bot Hardware Pack (#28133) Partes y cantidades sujetas a cambio sin previo aviso



700-00002 Tornillos de máquina 4-40 x 3/8”, estría 8 700-00003 Tuerca Hex, 4-40 zinc platificada 10 700-00009 Bola de rueda posterior 1 700-00016 Tornillos de máquina 4-40 x 3/8” de cabeza plana, estría 2 700-00022 Chasis de aluminio Boe-Bot 1 700-00023 Pin largo de metal 1/16" x 1.5” 1 700-00025 Gromilla de goma 13/32" 2 700-00028 Tornillo de máquina 4-40 x 1/ 4”, estría 8 700-00038 Sostenedor de batería con cable y conector de barril 1 700-00060 Base, aluminio enroscado, redonda 4-40 4 721-00001 Rueda de plástico Parallax 2 721-00002 Caucho de goma 4 900-00008 Servo de Rotación Contínua Parallax 2

Kits de la Board of Education Casi todos los títulos en el currículo Stamps in Class utilizan hardware distinto y paquetes de componente que dependen del BASIC Stamp y la Board of Education como núcleo.


La Board of Education puede ser comprada por separado o en su propio kit, como lo enlista la Tabla E-4 abajo.

Table E-4: Board of Education – Full Kit (#28102) Partes y cantidades sujetas a cambio sin previo aviso



28150 Board of Education Rev C 1 800-00016 Cables para conexión – paquete de 10 1 BS2-IC Módulo micrcontrolador BASIC Stamp 2 1 750-00008 Fuente de alimentación de 300 mA 9 VDC 1 800-00003 Cable serial 1

Apéndice F: Balanceando Fotoresistores · Página 335

Apéndice F: Balanceando Fotoresistores En este apéndice, verificarás que los fotoresistores respondan similarmente a los mismos niveles de incidencia de luz. Si las medidas que reportan son distintas para niveles de incidencia de luz similares, puedes modificar tus programas para ajustar a escala los valores reportados por tus fotoresistores. Los valores serán entonces, similares para los mismos niveles de incidencia de luz, lo cual puede ayudar a que tu Boe-Bot reconozca diferentes niveles de luminosidad con mayor rigurosidad. Esta técnica puede en sí asistir al Boe-Bot en salir de localidades obscuras, inclusive con circuitos de fotoresistores disparejos.

Circuitos RC con fotoresistores pueden reportar diferentes valores para el mismo nivel de luminosidad por muchas razones . El valor nominal de los capacitores es de 0.01 μF, pero el valor actual de los mismos puede variar bastante. Muchos capacitores comunes de cerámica son clasificados con una tolerancia de +80/-20%, lo que significa que el valor actual puede ser hasta 80% mayor o 20% menor que 0.01 μF. Esto conlleva a que tus medidas del tiempo de decaimiento podría ser también 80% mayor y 20% menor. Los fortoresistores mismos también pueden comportarse de manera distinta si provienen de diferentes paquetes de manufactura o si han sido deteriorados o si su superficie recolectora de luz ha sido astillada.

Verificando Circuitos Fotoresistivos Semejantes Este próximo ejemplo muestra el tiempo de decaimiento de ambos fotoresistores en el Debug Terminal. Facilita la verificación de las diferencias entre las dos medidas para niveles de luminosidad similares.

Para mejores resultados, elimina fuentes de luz solar directa: En general, condiciones de luz uniformes mejoran el desempeño del Boe-Bot’ con los fotoresistores. Cierra las persianas para eliminat las fuentes de luz solar directa. Cuartos con fuentes de luz distribuida, tales como luces fluorescentes o lámparas de techo funcionan bien.

Example Program: TestPhotoresistors.bs2

√ Escribe, guarda, y ejecuta TestPhotoresistors.bs2. √ Haz una sombra sobre los fotoresistores del Boe-Bot con una hoja blanca de

papel. Encuentra un nivel de sombra que proporcione medidas entre 20 y 100. √ Apunta los valores de ambas medidas de tiempo en la primera fila de la Tabla F-

1.


√ Coloca tu mano a manera de cúpula sobre los fotoresistores, asegurándote que estés proporcionando sombras similares sobre ambos. Para mejores resultados, las medidas deberán encontrarse en el rango de 200 a 400.

√ Apunta los valores de ambas medidas de tiempo en la segunda fila de la Tabla F-1.

Tabla F-1: Mediciones del Tiempo-RC en Luz Baja y de Ambiente


Fotoresistores en luz uniforme de ambiente Fotoresistores en luz uniforme baja

' Robotica con el Boe-Bot - TestPhotoresistors.bs2 ' Test Boe-Bot fotoresistor circuits. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. timeLeft VAR Word ' Variable declarations. timeRight VAR Word DEBUG "PHOTORESISTOR VALUES", CR, ' Initialization. "timeLeft timeRight", CR, "-------- ---------" DO ' Main routine. HIGH 6 ' Left RC time measurement. PAUSE 3 RCTIME 6,1,timeLeft HIGH 3 ' Right RC time measurement. PAUSE 3 RCTIME 3,1,timeRight DEBUG CRSRXY, 0, 3, ' Display measurements. DEC5 timeLeft, " ", DEC5 timeRight PAUSE 200 LOOP


Calibrando con el Uso de una Aproximación Linear Frecuentemente el fotoresistor es considerado un dispositivo no-linear. En otras palabras, si retorna un valor a una intensidad, no quiere decir que el valor retornado será cinco veces mayor cuando la intesidad de luz sea cinco veces más luminosa. La matemática es más complicada y requiere el uso de logaritmos. De cualquier manera, en casos en que las medidas están restringidas a un rango de valores de la habilidad de detección de los sensores un tanto estrecho, el sensor puede ser considerado como un dispositivo linear. Puedes tomar un par de medidas, y luego determinar cómo el dispositivo reaccionará si otras medidas en su rango pueden ser graficadas en una línea recta. Esta técnica se llama aproximación linear. Otra cosa que puedes hacer con dispositivos lineares es asumir que las diferencias entre las dos líneas también pueden ser graficadas como una línea. De hecho, si tienes un dispositivo linear que tiene mediciones mayores que otros para luz baja y de ambiente, puedes usar una aproximación linear para hacer que los sensores retornen aproxumadamente los mismos valores para los mismos niveles de iluminación. Por cada medida de un sensor, (llamaremos x a éste), puedes multiplicar por una factor de escala (m), y sumar una constante (b) para obtener un valor en el mismo rango que otro sensor reportaría (y).

bmxy += Aquí está un ejemplo de cómo hacer que los valores m y b del sensor izquierdo correspondan a los del derecho. Primero, asigna X1 y X2 a los valores del fotoresistor izquierdo y Y1 y Y2 a los valores del fotoresistor derecho. (Tabla F-1) muestra algunos ejemplos de valores no correspondientes de los fotoresistores. Tus valores serán distintos.

Tabla F-1: Mediciones del Tiempo-RC en Luz Baja y de Ambiente


X1 = 36 Y1 = 56 Fotoresistores en luz uniforme de ambiente X2 = 152 Y2 = 215 Fotoresistores en luz uniforme baja

Ahora, resuelve para m y b usando dos ecuaciones y dos incógnitas. Uno de los procedimientos más simples es escribir dos ecuaciones y = mx + b, una en términos de X1


y Y1 y la otra en términos de X2 y Y2. Entonces, sustrae una de la otra para eliminar b. Luego, resuelve para m.

)xx()yy(m

)xx(m)yy(

)bmxy(bmxy

12

12

1212

11

22

−−

=

−=−−−−−−−−−−−−−−

+=−+=

Una vez que hayas resuelto para m, puedes incorporar m en cualquiera de las dos ecuaciones y = mx + con las que empezaste para obtener b.

22

22

mxybbmxy

−=+=

Así que las dos ecuaciones para resolver para m y b resultan ser:

)xx()yy(m

12

12

−−

= y 22 mxyb −=

Incorporemos nuestros valores de ensayo de la Tabla F-1 en las ecuaciones para ver cuál es el factor de escala (m) y la constante de compensación (b) para el fotoresistor izquierdo. Primero, calcula m:

37.1116159m

)36152()56215(m

)xx()yy(m

12

12

==

−−

=

−−

=

Luego usa m, y2, y x2 para calcular b:


7b76.6b

)15237.1(215b

≈=

×−=

Ahora, sabemos cómo corregir la variable timeLeft de manera que reporte sus valores similares a los de la variable timeRight en un rango estrechho de niveles de luz:

7timeLeft37.1timeLeft7x37.1y

bmxy

)adjusted( +×=+=

+=

Una Ecuación Linear en PBASIC En la mayoría de los lenguajes de programación para PCs, esta ecuación podría ser implementada como es. El BASIC Stamp es un procesador miniatura en comparación con el de una PC. Por ello, toma un paso extra para multiplicar por un valor fraccional. Tienes que usar el operador /* (llamado operador “star-slash”). Para la ecuación timeLeft, el código PBASIC para ajustar la variable timeLeft puede ser escrito así:

timeLeft = (timeLeft */ 351) + 7 El valor ajustado de timeLeft luego de que esta línea de código es ejecutada, es 1.37 por el valor anterior de timeLeft, más 7.

Por qué 1.37 se convirtió en 351? La manera en que el operador */ trabaja es multiplicando tu valor fraccional por 256, y colocándolo a la derecha del operador */. Ya que 1.37 X 256 = 350.72 ≈ 351, el valor 351 es colocado a la derecha del operador */.

Puedes encontrar más información acerca del operador */ en el Editor del BASIC Stamp Editor haciendo click en Help y seleccionando Index. Escribe */ en el espacio denotado “Type in keyword to find”. Puedes también buscar */ en la sección operadores Binarios en el BASIC Stamp Manual.

Tu Turno – Balancea tus Fotoresistores con m y b

√ En la Tabla F-1, denota la primera aparición timeLeft como X1 y la segunda aparición de timeLeft como X2.

√ Marca la primera aparición de timeRight como Y1 y la segunda aparición timeRight como Y2.

√ Usa estas ecuaciones y tus valores X1, X2, Y1, y Y2 para resolver para m y b.


√

)xx()yy(m

12

12

−−

= y 22 mxyb −=

√ Calcula los valores de m, usarás el operador */ al multiplicar m por 256. √ Sustituye tu valor de m y b en esta línea de código en BalancePhtoresistors.bs2:

timeLeft = (timeLeft */ 351) + 7

√ Introduce, guarda, y ejecuta tu versión ajustada de BalancePhotoresistors.bs2. √ Expone ambos fotoresistores al mismo nivel de luz. √ Verifica que los valores “after” sean similares y corrijan las diferencias en los

valores “before.” √ Elige un nivel de luz distinto y nuevamente, expón ambos fotoresistor a él. √ Verifica los valores “after” por similitud. √ Cuando hayas determinado tus valores de m y b, puedes modificar

RoamingTowardTheLight.bs2 quitando los comentarios de la ecuación entre GOSUB Test_Photoresistors y GOSUB Average_And_Difference. Tu valor de m reemplazará 351 y tu valor de b reemplazará 7.

' Robotica con el Boe-Bot - BalancePhotoresistors.bs2 ' Test adjustments to Boe-Bot fotoresistor circuits. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC. timeLeft VAR Word ' Variable declarations. timeRight VAR Word DEBUG "PHOTORESISTOR VALUES", CR, ' Initialization. "timeLeft timeRight", CR, "-------- ---------" DO ' Main routine. HIGH 6 ' Left RC time measurement. PAUSE 3 RCTIME 6,1,timeLeft HIGH 3 ' Right RC time measurement. PAUSE 3 RCTIME 3,1,timeRight


DEBUG CRSRXY, 0, 3, ' Display measurements. DEC5 timeLeft, " ", DEC5 timeRight, " Before" timeLeft = (timeLeft */ 351) + 7 DEBUG CRSRXY, 0, 5, ' Display measurements. DEC5 timeLeft, " ", DEC5 timeRight, " After" PAUSE 200 LOOP

Apéndice G: Afinando la Detección de Distancia con IR· Page 343

Apéndice G: Entonando la Detección de Distancia con IR

Encontrando los Valores Adecuados del barrido de Frecuencia Entonar la detección de distancia de tu Boe-Bot requiere determinar cuál frecuencia es la más rigurosa para cada par de IR por cada zona.

Nota: Este apéndice resalta un método para determinar las mejores frecuencias para determinar las distancias dadas usando hojas de cálculo. Esta actividad toma tiempo y paciencia, y sólo es recomendada si tu medición de distancia está considerablemente fuera de calibración. Requiere la recolección de la data correspondiente a barridas de frecuencia y el uso de las mismas para determinar los valores más rigurosos para las distancias particulares.

√ Apunta ambos IR IR LEDs y detectores hacia adelante en línea recta. √ Coloca el Boe-Bot en frente de una pared con una hoja de papel como el blanco

de los IR. √ Coloca el Boe-Bot de manera que sus IR LEDs estén a 2.5 cm de distancia del

blanco de papel. Asegúrate de que el frente del Boe-Bot esté viendo hacia el blanco de papel. Ambos IR LEDs y detectores deberían ser apuntados directamente hacia el papel.

Programa de Entonación de IR FrequencySweep.bs2 realiza una barrida de frecuencia en el detector de IR y muestra la data en pantalla. A pesar de que las técnicas son similares a otros programas, éste tiene una característica única. El BASIC Stamp está programado para esperar que presiones la tecla Enter.

√ Entra y ejecuta FrequencySweep.bs2, pero no desconectes el Boe-Bot del cable serial.

' -----[ Title ]-------------------------------------------------------------- ' Robotica con el Boe-Bot - FrequencySweep.bs2 ' Test IR LED/detector response to frequency sweep. ' $STAMP BS2 ' Directiva del Stamp. ' $PBASIC 2.5 ' Directiva de PBASIC.


' -----[ Variables ]---------------------------------------------------------- crsrPosRow VAR Byte irFrequency VAR Word irDetect VAR Bit distance VAR Nib dummy VAR crsrPosRow ' -----[ Initialization ]----------------------------------------------------- DEBUG CLS, "Click transmit windowpane,", CR, "then press enter to begin", CR, "frequency sweep...", CR, CR, " OBJECT", CR, "FREQUENCY DETECTED", CR, "--------- --------", CR ' -----[ Main Routine ]------------------------------------------------------- DO DEBUGIN dummy crsrPosRow = 6 FOR irFrequency = 30500 TO 46500 STEP 1000 crsrPosRow = crsrPosRow + 1 FREQOUT 8,1, irFrequency irDetect = IN9 DEBUG CRSRXY, 4, crsrPosRow, DEC5 irFrequency DEBUG CRSRXY, 11, crsrPosRow IF (irDetect = 0) THEN DEBUG "Yes" ELSE DEBUG "No " PAUSE 100 NEXT LOOP

√ Haz click en la parte superior de los dos páneles mostrados en la Figura G-1. √ Presiona la tecla Enter. La data de respuesta a la frecuencia aparecerá como lo

muestra la figura.


Figura G-1 Depuración de la data de Frequencia

El BASIC Stamp ha sido programado para hacer que el Debug Terminal muestre “Yes” si un objecto ha sido detectado y “No” si el objecto no ha sido detectado. La Figura G-1


muestra que la región de buena respuesta de señal para el sensor izquierdo es entre 36500 y 42500.

√ Modifica el bucle FOR...NEXT en el Listado de Programa FrequencySweep.bs2 de manera que los incrementos sean de 250 y también incluya un límite superior e inferior para ambos detectores. Basado en la data del ejemplo mostrado en la Figura G-1, los valores de start, end, y step para el bucle FOR...NEXT serían modificados de la siguiente manera:

FOR irFrequency = 36500 to 42500 STEP 250

√ Ejecuta de nuevo tu FrequencySweep.bs2 modificado, y presiona Enter otra vez. √ Apunta la data del lado izquierdo y derecho en hojas de cálculo distintas. √ Presiona la tecla Enter nuevamente y apunta el próximo set de valores. √ Repite este proceso tres veces más. Al finalizar, tendrás cinco sets de valores por

cada sensor en hojas de cálculo distintas para esta frecuencia particular. √ Retrocede el Boe-Bot 2.5 cm. Ahora los detectores de IR estarán a 5 cm del

blanco de papel. √ Apunta cinco sets de data con esta distancia. √ Mantente retrociendo el Boe-Bot 2.5 cm a la vez y apuntando los cinco valores

del barrido de frecuencia entre cada ajuste de distancia. √ Cuando el Boe-Bot haya sido retrocedido 20 cm, el barrido de frecuencia

mostrará la mayoría, sino todas las regiones como “No.” Cuando el barrido de frecuencia sea todo “No,” significa que ningún objecto ha sido detectado en ninguna de las frequencias del barrido.

Por medio de un escrutinio cuidadoso de las hojas de cálculo y del proceso de eliminación, podrás determinar la frecuencia óptima para cada par de IR por cada zona. Modificando el proceso para un total de ocho zonas puede ser realizado sin ninguna reestructuración de las rutinas de navegación del Boe-Bot. Si modificaras para 15 zonas, esto exigiría 30 comandos FREQOUT de un milisegundo. Esto no cabrá debidamente entre los pulsos del servo. Una solución sería tomar a 15 medidas cada otro pulso. A continuación se discute cómo determinar las mejores frecuencias para el sensor izquierdo. Ten presente que tendrás que repetir este proceso para el sensor derecho. Este ejemplo asume que estás buscando seis zonas (de cero a cinco).


√ Comienza examinando los valores de data tomados cuando el Boe-Bot estaba más apartado del blanco de papel. Probablemente no habrá ningún set de data en el que todas las medidas correspondan a un “Yes” en una sola frecuencia. Revisa los próximos valores de data que se encuentran avanzando 2.5 cm en la dirección del blanco de papel. Probablemente, verás un set the cuatro o cinco valores “Yes” para una sola frecuencia. Apunta esta frequencia como una medida rigurosa para la línea divisoria entre Zona 0 y Zona 1.

√ En cada una de las cinco distancias restantes, encuentra una frequencia para la cual los valores de la salida comienzan a ser estables.

Por ejemplo, a 15 cm, tres frequencias distintas puedes mostrar medidas “Yes.” Si miras atrás a la marca de 17.5 cm, dos de estas frequencias eran estables, pero la otra no. Toma la frequencia que no era estable a los 17.5 cm, pero sí a los 15 cm como tu frequencia más rigurosa para esta distancia. Ahora, este ejemplo ha determinado que las frequencias que pueden ser usadas para separar Zonas 5 y 4 y Zonas 4 y 3. Repite este proceso para las divisiones de zona restantes.

√ lectura a una frecuencia particular. Nota esta frequencia como una medida rigurosa para la línea divisoria entre Zona 0 y Zona 1.

√ En cada una de las cinco distancias restantes, encuentra una frequencia para la cual los valores del output comienzan a ser estables.

Por ejemplo, a 15 cm, tres frequencias distintas puedes mostrar medidas “Sí.” Si miras atrás a la marca de 17.5 cm, dos de estas frequencias eran estables, pero la otra no. Toma la frequencia que no era estable a los 17.5 cm, pero sí a los 15 cm como tu frequencia más rigurosa para esta distancia. Ahora, este ejemplo ha determinado que las frequencias que pueden ser usadas para separar Zonas 5 y 4 y Zonas 4 y 3. Repite este proceso para las divisiones de zona restantes.

Tu Turno √ Si conseguiste con éxito ajustar con precisión las 5 medidas y el tiempo lo

permite, prueba incrementar la resolución a ocho medidas. Guarda tu data para ambos métodos.

Apéndice H: Concursos de Navegación para el Boe-Bot· Page 349

Apéndice H: Concursos de Navegación para el Boe-Bot Si estás planificando una competencia para robots autónomos, estas reglas han sido provistas cortesía de la sociedad robótica de Seattle (Seattle Robotics Society).

CONCURSO #1: EJERCICIO DE PISO PARA EL ROBOT

Propósito El concurso ejercicio de piso tiene como propósito darle la oportunidad a los creadores de los robots de demostrar las habilidades de sus robots u otras contrapciones técnicas.

Reglas Las reglas para esta competencia son bastante simples. Un área de 10-pies-por-10-pies es identificada, preferiblemente con algún tipo de borde físico. Cada concursante contará con un máximo de 5 minutos en esta área para demostrar lo que su robot puede hacer. El concursante dueño del robot podrá relatar cada habilidad y característica del robot. Como siempre, no será permitido cualquier robot que ocasione algún tipo de daños al área o represente un peligro para el público. Los robots no necesitan ser autónomos, pero es recomendado que sí lo sean. La puntuación será determinada por la audiencia, ya sea por la cantidad de aplausos (el concursante más aplaudido será determinado por el juez), o por cualquier otro mecanismo de votos.

CONCURSO #2: SEGUIMIENTO DE LINEA

Objetivo Construir un robot autónomo que comience en el Area “A” (en la posición “S”), navegue hasta el Area “B” (completamente sobre la línea), y luego navegue hasta el Area “C” (completamente sobre la línea), y luego regrese al Area “A” (en la posición “F”). El robot que haga esto en el menor tiempo (incluyendo los bonos) gana. El robot debe entrar a las áreas “B” y “C” para calificar. La organización del curso no se dará a conocer hasta el día del concurso, pero contará con las tres áreas previamente descritas.


Habilidades Examinadas La habilidad de reconocer un ayudante de navegación (la línea) y usarla para llegar a la meta.

Tiempo Máximo para Completar el Curso Cuatro minutos.

Ejemplo del Curso Todas las medidas en el ejemplo son aproximadas. Existe una línea sólida dividiendo el Area Area “A” y el Area “T” en la posición “F.” Esto indica donde el curso termina. La línea es negra, de aproximadamente 2.25 pulgadas de ancho y con dos pies de espacio de las paredes. Todas las curvas tienen un radio de al menos un pie pero no mayor a tres pies. Las paredes son de 3 1/2 pulgadas de alto y rodean el curso completo. El piso es blanco y está hecho de papel o Dupont Tyvek®. Tyvek es un plástico fuerte usado en sobres de correo y construcción de casas. Las posiciones “S” y “F” son meramente para ilustración y no localidades precisas. Un competidor podrá colocar su robot en cualquier parte del Area “A,” mirando en cualquier dirección al momento de comenzar. El robot deberá estar completamente dentro del Area “A.” Areas “A,” “B” y “C” no están coloreadas en el curso en sí.


Figura H-1 Ejemplo del Curso para el Concurso

Puntuación La puntuación de cada participante es calculada tomando el tiempo requerido para completar el curso (en segundos) menos 10% por cada “meta conseguida.” El concursante con el menor puntaje será el ganador.

Tabla H-1: Puntación del Seguidor de Línea

Meta conseguida Percent Deducted Se detiene en area A luego de llegar a B y C 10% No toca ninguna pared 10% Comienza al indicarse 10%

(“Comienza al indicarse” significa que el robot comienza su operación con una señal externa, no-táctil. Esto podría ser, por ejemplo, una señal de luz o sonido).


CONCURSO#3: SEGUIMIENTO DE LABERINTO

Propósito El gran laberinto tiene como motivo presentar una prueba de habilidades de navegación para un robot autónomo. La puntuación se realiza en una forma que favoriza a aquellos robots que son brutalmente rápidos o que pueden aprender el laberinto luego de una carrera. El objetivo es que un robot, el cual es colocado en la entrada del laberinto, encuentre la manera de llegar a la salida del laberinto en el menor tiempo posible.

Características Físicas El laberinto está construido de madera “shop-grade plywood” de 3/4" de ancho. Estas paredes son de aproximadamente 24 pulgadas de alto, y están pintadas en colores primarios con pintura “glossy.” Las paredes son colocadas en una cuadrícula de 24-pulgadas de separación. Debido al grosor de la madera y las limitaciones de la precisión, los pasillos podrán medir hasta 22 pulgadas de ancho. El laberinto podrá medir hasta 20-pies cuadrados, pero podrá ser más pequeño, dependiendo del espacio disponible para el evento. El laberinto será ensamblado en alfombra de tipo industrial o suelo duro (dependiendo donde sea realizado el evento). El laberinto podrá ser bajo algún tipo de cubierta, de manera que los robots no requieran protección contra la lluvia; de cualquier manera, el robot podrá estar expuesto a varias temperaturas, viento, y relámapagos. El laberinto es un clásico laberinto bi-dimensional: existe un único pasadizo desde el comiento hasta el fin, y no existen islas en el mismo. Ambas entrada y salida están localizadas en las paredes externas. Este tipo de laberintos puede ser resuelto siguiendo cualquiera de las paredes, izquierda o derecha. El laberinto está cuidadosamente diseñado para que no haya ningún tipo de ventaja si se sigue la pared izquierda o derecha.

Limitaciones del Robot La principal limitación en el robot es que debe ser autónomo: una vez que el dueño u operador lo ponga en marcha, no será permitido ningún tipo de interaccion con el robot hasta que éste llegue a la salida, o quede atrapado sin ningún tipo de escape. Obviamente el robot necesita ser lo suficientemente pequeño para poder navegar dentro del laberinto. Podrá tocar las paredes pero no podrá moverlas para su beneficio –no se permiten “tractores.” Los jueces podrán descalificar a cualquier robot que mueva las paredes excesivamente. El robot no deberá dañar las paredes del laberinto, así como tampoco el


piso. Cualquier forma de poder es permitida siempre y cuando las leyes locales no requieran protección auditiva en su presencia o algún otro tipo de limitación para con la misma.

Puntuación Cada robot realizará tres carreras por el laberinto. El robot con el menor tiempo será el ganador. El máximo tiempo permitido por cada carrera es de 10 minutos. Si un robot no puede terminar la carrera en ese período, la carrera es detenida y el robot recibe un tiempo de 10 minutos. Si ninguno de los robots consigue con éxito llegar a la salida del laberinto, el juez del concurso determinará como ganandor a aquél que haya llegado más lejos.

Logística Cada robot realizará una carrera, de tal manera que todos los robots hayan atentado resolver el laberinto. Cada robot hará entonces una segunda carrera a través del laberinto, seguidamente, todos los robots harán una tercera carrera. El juez permitirá cierta flexibilidad si alguno de los participantes retrasa su carrera por alguna dificultad técnica. Un robot podrá recordar lo que encontró en previas carreras para tratar de mejorar su tiempo (elaborando un mapa del laberinto en la primera carrera), y podrá usar esta información en carreras subsiguientes siempre y cuando el robot haga esto por sí mismo. No está permitido “configurar” manualmente ningún aspecto del laberinto en el robot a través del hardware o el programa.

Apéndice I: Glosario· Page 355

Apéndice I: Glosario En este apéndice, hemos incluido cierto términos utilizados por el traductor para describir plabras correspondientes en el texto original de la guía para el estudiante “Robotics with the Boe-Bot, version 2.2” por Andy Lindsay (en inglés). Inclusive, algunos términos se han dejado en el idioma original, en estos casos las palabras son traducidos solamente la primera vez que aparecen en el libro entre paréntesis “( )” que siguen inmediatamente al término en inglés. Por ejemplo: “Los Continuous Rotation servos (servo de Rotación Contínua, en inglés) de Parallax mostrados...”

Términos en Inglés: Robotics with the Boe-Bot: se refiere a la versión en inglés de este texto. What's a Microcontroller?: se refiere a la versión en inglés del texto que precede a Robotics with the Boe-Bot. Este texto ha sido traducido al español (¿Qué es un Microcontrolador?). Stamps in Class: currículum o pénsum para el aula basado en los productos y textos Parallax. Basic Stamp: es el cerebro (i.e., módulo microcontrolador) presente en tu Board of Education o HomeWork Board. La traducción literal de este término es Estampilla Basic. Basic: esta palabra hace referencia al programa que usado para programar el Basic Stamp, dicho programa se llama PBASIC. La traducción literal de esta palabra es básico(a). Board of Education o HomeWork Board: son dos versiones similares de las plaquetas que Parallax ofrece para el desarrollo de circuitos eléctricos y/o mecánicos como es el caso del Boe-Bot. Dichas plaquetas incluyen distintos componentes, entre los que resalta una protoboard para conectar distintos componentes electrónicos. Protoboard: plaqueta que consiste en varios enchufes para conectar componentes electrónicos. Dicha plaqueta se encuentra conectada internamente (i.e., interconectada), por lo que facilita la conexión de dos componentes sin la necesidad de un cable.


BASIC Stamp Editor: programa en tu PC o Laptop donde escribes y descargas los programas que ejecuta el microcontrolador BASIC Stamp. Debug Terminal: ventana en tu PC o Laptop en donde se muestran los mensajes de comunicacion entre el BASIC Stamp y tu PC o Laptop. PBASIC: lenguaje usado en el BASIC Stamp Editor para escribir los programas. Reset: este término se traduce como “Reinicio”. Hemos dejado el término en Inglés, ya que el nombre del boton que ejecuta la función de reiniciar, está etiquetado como “reset”. Transmit windowpane: se refiere al panel-ventana dentro del Debug Terminal utilizado para transmisión de mensajes al BASIC Stamp. Receive windowpane: se refiere al panel-ventana dentro del Debug Terminal utilizado para recepción de mensajes provenientes del BASIC Stamp. Continuous Rotation Servo: se refiere a un servomotor de rotación continua. Término utilizado en inglés para facilitar la adquisición de partes adicionales de acuerdo a su nombre en inglés. Dead reckoning: se refiere a un tipo de navegación por estimación empírica del recorrido o trayectoria. Otros términos usados son, cálculo a ojo, y navegación a estima. Encoders: dispositivo electrónico usado para medir la rotación de una rueda. Conocido en español como codificador de giro. Ramping: término utilizado para referirse (en este contexto) a una aceleración gradual, linear, o en rampa.

Apéndice I: Glosario· Page 357

Términos en Castellano: Salida: esta es la traducción del término “output”, usado para referirse al producto que resulta como consecuencia de una entrada. Entrada: esta es la traducción del término “input”, usado para referirse a cualquier sistema o componente que permita el ingreso de informacion. Energía: esta es una traducción del término “power”, usado para referirnos al Poder (o Potencia) Eléctrico(a) de un componente, circuito, o sistema. La definición de Poder Eléctrico, es la cantidad de trabajo que realiza una corriente eléctrica, o en otras palabras, la tasa de transmisión de energía eléctrica. Escogimos el término Energía, porque resulta intuitivo para muchas personas quiénes se encuentran comenzando en este campo. Fuente de Alimentación: esta es la traducción del término “power supply”, usado para referirse a la fuente que emite la energía a un componente o circuito eléctrico. Estañada(s), estañado(s): esta es la traducción del término “tin” o “tinned”, usado para referirse a las conexiones cubiertas por el elemento químico Estaño. Un sinónimo es el término “pre-soldadas”, refiriéndose a la conexión (cable) bañado con anterioridad en dicho elemento. Conreloj (CNR): término de abreviación usado para indicar el sentido de rotación de las manecillas (agujas) de un reloj.También representado como CNR. Contrareloj (CTR): término de abreviación usado para indicar el sentido contrario a la rotación de las manecillas (agujas) de un reloj. También representado como CTR.

Indice · Page 359

Indice - < -

<>, 192

- … -

…, 52

- A -

Aceleración gradual (ramping), 142 Adaptador USB a Serial, 5, 14 Ajuste de hardware, 133 Ajuste de software, 133 American Standard Code for

Information Interchange, 157 ánodo, 46 Argumento Duration, 54, 112 Argumento Index, 281 ASCII, 157

- B -

barrido de frequencia, 280 Basic Analog and Digital, 56 BASIC Stamp

inserción, 17

modo de baja energía, 28

previniendo daños, 36

BASIC Stamp Editor Identify, 314, 315

instalación, 10

Resolución de Problemas, 313

Software, 4

BASIC Stamp HomeWork Board, 3 BASIC Stamp HomeWork Board, 4

BASIC Stamp HomeWork Board conectando la energía, 20

BASIC Stamp HomeWork Board desconectando la energía, 36

BASIC Stamp Manual, 32 baterías, 60 BIN1, 178 Bit, 72 Board of Education, 3 Board of Education Rev A, 59 Board of Education Rev A or B

desconectando la energía, 36

Board of Education Rev B, 59 Board of Education Rev C

conetando la energía, 16

desconectando la energía, 35

bocina piezoeléctrica símbolo esquemático, 109

bocina piezoeléctrica, 108 bocina piezoeléctrica

dibujo de parte, 109

Botón Reset, 26 Byte, 72

- C -

cable nulo de módem, 313 Cálculo de distancia, 137 capacitor, 211

dibujo de parte, 212


símbolo esquemático, 212

caracter de retorno, 28 cátodo, 46 CdS, 200 Centrando los servos, 67 Comandos PBASIC

DEBUG, 28

DEBUGIN, 115

DO WHILE, 154

ELSE, 184

ELSEIF, 184

ENDIF, 184

FOR…NEXT, 74

FREQOUT, 111

GOSUB, 146

HIGH, 50

IF…THEN, 184

LOOKUP, 281

LOW, 50

PAUSE, 42

PULSOUT, 54

RCTIME, 215

READ, 154

RETURN, 146

SELECT...CASE...ENDSELECT, 155

STOP, 256

CON, 220 corriente (eléctrica), 45 CR, 28 CRSRXY, 179

- D -

DATA, 154 DEBUG, 28 Debug Terminal, 26 DEBUGIN, 115 DEC, 28 declaración, 72 Desconectando la energía, 35 destornillador, 67, 93 detector infrarrojo, 245 diagrama de control de tiempo, 52 dibujo de parte

bocina piezoeléctrica, 109

capacitor, 212

fotoresistor, 199

LED, 46

diodo emisor de luz ánodo, 46

cátodo, 46

terminales, 46

Directiva DATA, 158 Directiva de PBASIC, 28 Directiva del Stamp, 28 Directivas PBASIC

DATA, 154

Directivas PBSIC CON, 220

PBASIC, 28

Stamp, 28

divisor de voltaje, 203 divisor de voltaje con fotoresistor

resolución de problemas, 205

Indice · Page 361

DO WHILE, 154 DO...LOOP, 44

- E -

EEPROM, 151 ELSE, 184 ELSEIF, 184 END, 28 ENDIF, 184 EndValue, 75 etiqueta

subrutina, 146

etiqueta para subrutina, 146

- F -

F, 211 faradio, 211 foot-candle, 200 FOR…NEXT, 74

cuenta regresiva, 76

decreciendo, 76

EndValue, 75

StartValue, 75

STEP StepValue, 76

Formateadores DEBUG ?, 73

BIN, 178

DEC, 28

fotoresistor, 199, 200 dibujo de parte, 199

símbolo esquemático, 199

frecuencia, 109

frecuencia armónica, 248 FREQOUT, 111

Argumento Duration, 112

- G -

Giros de 90°, 136 Giros de 90°, 136 GOSUB, 146 guardando programas, 26, 27

- H -

hertz, 112 hexadecimal, 157 HIGH, 50

argumento PIN, 50

- I -

Identify, 314, 315 IF…THEN, 184

anidando sentencias, 188

indicador start/reset, 108 Industrial Control, 287 inicialización, 72 Interruptores Táctiles, 171

- K -

kilohertz, 112

- L -

LDR, 200 LED, 46 led infrarrojo, 245 linterna, 217 llamada a subrutina, 145 LOOKUP, 281

Argumento Index, 281


Argumento Variable, 281

ValueN argument, 281

LOW, 50 argumento PIN, 50

luminosidad, 199, 200 lux, 200 luz incidente, 200

- M -

Mapa de Memoria (Memory Map), 152 memoria de acceso aleatorio, 152 memoria programable de sólo lectura

eléctricamente borrable, 151 microfaradio, 212 miliamperios, 49 Moción en retroceso, 131

- N -

nanofaradio, 212 Navegación a estima, 137 Nib, 72 nodos, 215 Números negativos, 74

- O -

omega, 46 operador, 72 Operadores PBASIC

<>, 192

orden matemático de operaciones, 291

- P -

paquete de baterias con conexiones estañadas, 64

Parallax Continuous Rotation servos, 41 PAUSE, 42

PBASIC variables, 72

picofaradio, 212 piezobocina, 108 pin metálico, 99 Pines de I/O

como entradas o salidas, 202

plaqueta portadora, 3 programas

guardando, 27

guardar, 26

puente (eléctrico), 60 Puerto COM, 14 PULSOUT, 54


- R -

RAM, 152 RCTIME, 215


Argumento Pin, 215

Argumento State, 215

READ, 154 registro de entrada, 178 Requerimientos del sistema, 5 resistor

divisor de voltaje, 203

patas, 46

resistor dependiente de luz, 199

resistores en serie, 203

resistor dependiente de luz, 199 resolución de problemas

Indice · Page 363

divisor de voltaje con fotoresistor, 205

resolución de problemas Comunicación BASIC Stamp a PC, 313

Resolución de problemas servos, 105, 106, 107

RETURN, 146 RPM, 118

- S -

SELECT...CASE...ENDSELECT, 155 sensibilidad de filtro, 280 separadores, 173 servos

etiquetando, 96

evitando daños, 61

símbolo esquemático bocina piezoeléctrica, 109

capacitor, 212

fotoresistor, 199

resistor, 46

StartValue, 75 STEP StepValue, 76 stepValue, 76 STOP, 256 subrutinas, 145 Sulfuro de Cadmio, 200

- T -

Tiempo de descarga RC, 214 tokens, 151 tornillos, 7/8", 173 Transmit windowpane, 114 Tyvek, 350

- U -

umbral lógico, 203 US232B, 14

- V -

VAR, 72 variable, 72

declaración, 72

inicialización, 72

valor por defecto, 72

VAR, 72

Vbp, 65 Vdd, 49 voltaje umbral, 203

- W -

Word, 72

- Μ -

μF, 212

Las partes y cantidades en los distintos kits robóticos Boe-Bot® están sujetos a cualquier cambio sin previo aviso. Las partes pueden diferir de lo que muestran las imágenes. Por favor contáctanos a la dirección [email protected] (en inglés) si tienes alguna pregunta.

robotics with the boe bot

Documents