Experimentos y Código Fuente para el BASIC Stamp Versión en Castellano 1.1 Sobre la precisión de este texto: Se realizó un gran esfuerzo para asegurar la precisión de este texto y los experimentos, pero puede haber errores aún. Si usted encuentra errores o algún tema que requiera información adicional, por favor infórmelo a aalvarez@parallaxinc.com, así podemos continuar mejorando la calidad de nuestra documentación.
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 usted descubre un defecto, Parallax según corresponda, reparará, reemplazará o regresará el valor de la compra. Simplemente pida un número de autorización de regreso de mercadería (Return Merchandise Authorization, “RMA”), escriba el número en el exterior de la caja y envíela a Parallax. Por favor incluya su nombre, número telefónico, dirección y una descripción del problema. Nosotros le regresaremos su producto o el reemplazo, usando el mismo método de correo que usted usó 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 usted recibió su producto, encuentra que no es conveniente para sus necesidades, puede regresarlo, recibiendo un reembolso. Parallax regresará el precio de compra del producto, excluyendo los costos de manipuleo y correo. Esto no se aplica si el producto a sido alterado o dañado.
Derechos de Copia y Marcas Registradas Esta documentación tiene derechos de copia Copyright 1999 por Parallax, Inc. BASIC Stamp (Estampilla BASIC) es una marca registrada de Parallax, Inc. Si usted decide usar el nombre “BASIC Stamp” en su página web o en material impreso, debe agregar la aclaración: “BASIC Stamp es una marca registrada de Parallax, Inc.” Otros nombres de productos son marcas registradas de sus respectivos dueños.
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. Usted tiene absoluta responsabilidad por la aplicación que desarrolle con el BASIC Stamp.
Acceso en Internet Mantenemos sistemas de Internet para su uso. Estos pueden ser usados para obtener software, comunicarse con miembros de Parallax y comunicarse con otros clientes. Las rutas de acceso a la información se muestran a continuación: E-mail: Web:
aalvarez@parallaxinc.com
http://www.parallaxinc.com y http://www.stampsenclase.com
Lista de Discusión de BASIC Stamp en Internet Mantenemos dos listas de discusión por e-mail para gente interesada en el BASIC Stamp. La lista trabaja así: mucha gente se suscribe a la lista y luego todas las preguntas y respuestas son distribuidas a todos los suscriptos. Es una forma rápida, divertida y gratis de discutir temas sobre el BASIC Stamp y obtener respuestas a preguntas técnicas. Para suscribirse a la lista de BASIC Stamp encuentre la información en www.parallaxinc.com. Esta lista genera aproximadamente 40 mensajes diarios. También mantenemos una lista exclusiva para educadores que usan el BASIC Stamp en el aula. Usted puede unirse a esta lista en el sitio web http://www.stampsinclass.com. Esta lista genera aproximadamente 5 mensajes diarios. Si busca una lista de discusión en castellano puede encontrarla en http://www.stampsenclase.com.
Contenido
Contenido Prefacio ............................................................................................................................... 3 Introducción .............................................................................................................................. 5 Obtenga el Mayor Provecho de las Prácticas de StampWorks ......................................................... 5 Tres Pasos para Tener Éxito con StampWorks .............................................................................. 5 Prepare su Plaqueta StampWorks....................................................................................... 7 Contenido de este Kit ................................................................................................................. 7 Preparación de la Protoboard ...................................................................................................... 8 Bases de la Programación ................................................................................................. 13 Contenido de un Programa ....................................................................................................... 13 Saltos – Redireccionando el Flujo de un Programa ...................................................................... 14 Bucles – Ejecutando el código una y otra vez.............................................................................. 15 Subrutinas – Código reutilizable que ahorra espacio de programa................................................. 17 Estilo de Programación ............................................................................................................. 17 Plantilla ................................................................................................................................... 18 Convención sobre Nombres....................................................................................................... 19 Hora de Experimentar ....................................................................................................... 21 Aprendiendo los Conceptos de Programación.............................................................................. 21 Construcción de Proyectos ........................................................................................................ 21 Que hacer entre proyectos........................................................................................................ 21 Experimento 1: Hacer Titilar un LED .......................................................................................... 23 Experimento 2: Hacer Titilar un LED (Versión 2) ......................................................................... 25 Experimento 3: Contador con LEDs............................................................................................ 29 Experimento 4: Pantalla de LEDs de Ciencia Ficción .................................................................... 33 Experimento 5: Gráficos con LEDs (Punto o Barra)...................................................................... 35 Experimento 6: Un Juego Simple ............................................................................................... 39 Experimento 7: Controlador de Luces......................................................................................... 43 Building Circuits On Your Own .......................................................................................... 47 Usando Displays de 7 Segmentos .............................................................................................. 49 Experimento 8: Contador de un Dígito ....................................................................................... 51 Experimento 9: Dado Digital ..................................................................................................... 55 Experimento 10: Reloj con Pantalla de LEDs ............................................................................... 59
Manual StampWorks Versión 1.1 • Página 1
Contenido Usando LCDs ......................................................................................................................65 Experimento 11: Demostración Básica con LCD .......................................................................... 67 Experimento 12: Creando Caracteres en un LCD ......................................................................... 73 Experimento 13: Leyendo la RAM del LCD .................................................................................. 79 Experimento 14: Juego de la Bola 8 Mágica................................................................................ 85 Avanzando..........................................................................................................................91 Experimento 15: Filtrando Múltiples Entradas ............................................................................. 93 Experimento 16: Contando Eventos ........................................................................................... 97 Experimento 17: Medición de Frecuencia ................................................................................... 99 Experimento 18: Medición Avanzada de Frecuencia....................................................................101 Experimento 19: Theremin Controlado por Luz ..........................................................................103 Experimento 20: Efectos de Sonido ..........................................................................................105 Experimento 21: Entrada Analógica con PULSIN ........................................................................109 Experimento 22: Salida Analógica con PWM ..............................................................................111 Experimento 23: Expandiendo Salidas.......................................................................................113 Experimento 24: Expandiendo Entradas ....................................................................................117 Experimento 25: Control de un Servo .......................................................................................121 Experimento 26: Motor Paso a Paso..........................................................................................125 Experimento 27: Medición de Tensión.......................................................................................129 Experimento 28: Medición de Temperatura ...............................................................................133 Experimento 29: Multiplexado de 7 Segmentos..........................................................................137 Experimento 30: Reloj de Tiempo Real .....................................................................................145 Experimento 31: Comunicaciones Seriales .................................................................................153 Trabajando por su Cuenta................................................................................................161 Apéndice A: Hojas de Datos .............................................................................................163 Apéndice B: Manual del BASIC Stamp II, Versión 2.0 .....................................................177
Página 2 • Manual StampWorks Versión 1.1
Prefacio
Prefacio Estimados Amigos: Probablemente existen tantas formas de aprender un nuevo tema o habilidad, como estudiantes hay, pero todos coinciden en que aprender haciendo produce los resultados más duraderos. Y para ser franco, aprender haciendo es casi siempre la forma más satisfactoria de aprender; involucra más a los sentidos en el proceso de aprendizaje. De eso se trata este manual y el Kit de StampWorks: aprender a programar el BASIC Stamp escribiendo programas en él. Las secciones de teoría son cortas y concisas. Aprenderá la teoría de programación, poniéndola en práctica. No encontrará muchos rodeos; solamente encontrará trabajo, trabajo divertido que le enseñará a programar microcontroladores con el BASIC Stamp de Parallax. ¿Por qué tomar el desafío? ¿Por qué aprender a escribir programas para el microcontrolador BASIC Stamp? La respuesta es simple, sino obvia: los microcontroladores se encuentran por todos lados. Están en nuestros televisores, hornos microondas, teléfonos celulares e incluso en nuestros autos. El hecho es que los automóviles más nuevos tienen diez o más microcontroladores controlando todo, desde el motor, la climatización del habitáculo, la rotación de las ruedas (control de tracción), el sistema de frenos (ABS) y muchas otras funciones. En resumen, los vehículos modernos son más seguros y más confortables debido, en gran medida, al uso de microcontroladores. Con microcontroladores podemos construir circuitos y dispositivos “inteligentes”. En el pasado, debíamos cambiar el conexionado o algunos componentes de un circuito para modificar o crear un nuevo comportamiento. La ventaja del uso del microcontrolador sobre las otras opciones, es que podemos cambiar el comportamiento de nuestro circuito o dispositivo, simplemente modificando el programa. La ventaja de usar el BASIC Stamp es que simplifica la escritura y modificación de programas y con el Kit de StampWorks qué tan fácil puede ser. Diviértase con estos proyectos y piense cómo podría aplicar los conceptos aprendidos en cada uno. Apreciaré recibir sugerencias (en Inglés) en cualquier momento por e-mail a jonwms@aol.com.
Manual StampWorks Versión 1.1 • Página 3
Introducciรณn
Pรกgina 4 โ ข Manual StampWorks Versiรณn 1.1
Introducción
Introducción Obtenga el Mayor Provecho de las Prácticas de StampWorks Este libro está dividido en dos secciones principales: los experimentos de StampWorks y el manual del BASIC Stamp II. Para llevar a cabo los experimentos, deberá moverse constantemente por las dos secciones. Se puede descargar información adicional de la página de StampWorks del sitio web www.parallaxinc.com, incluyendo hojas de datos, actualizaciones y detalles técnicos generados después de emitida esta publicación. Tres Pasos para Tener Éxito con StampWorks: 1. Lea la Sección 1 del manual del BASIC Stamp II (en Inglés). Esta sección le explicará el funcionamiento del BASIC Stamp II y lo guiará en el proceso de instalación del software de programación. Otro recurso útil es el capítulo 1 de ¡Robótica! (en Castellano) que puede descargarse por internet de www.stampsenclase.com. 2. Lea la sección siguiente de este manual, “Prepare su Plaqueta de StampWorks para los Experimentos”. Esta sección describe los pasos necesarios para poner en condiciones la plaqueta de experimentación. 3. Realice los experimentos por su cuenta, refiriéndose a la guía de sintaxis del manual del BASIC Stamp tanto como sea necesario. Esta es la parte divertida, trabajar con el Stamp construyendo circuitos simples y escribiendo el código. Para cuando haya podido realizar todos los experimentos, estará listo para desarrollar sus propios proyectos con el Stamp, desde algunos simples hasta los moderadamente complejos. La clave está en asegurarse haber comprendido todo sobre un experimento en particular antes de pasar al siguiente. Una última indicación: ¡Diviértase!
Manual StampWorks Versión 1.1 • Página 5
Prepare su Plaqueta StampWorks
Prepare su Plaqueta StampWorks Antes de realizar los experimentos, deberá controlar los componentes de su kit y preparar su plaqueta StampWorks. Una vez hecho esto, será capaz de construir con ella, una gran variedad de circuitos controlados por el Stamp. El Kit StampWorks incluye los siguientes componentes de Parallax: Código 150-01020 150-01030 150-02210 150-04720 200-01040 201-01061 251-03230 27000 27220 27964 28135 28162 350-00009 451-00303 602-00009 602-00010 602-00015 603-00001 604-00002 604-00005 604-00009 700-00050 700-00051 700-00052 700-00065 700-00066 750-00007 800-00003 900-00001 900-00005 ADC0831 BS2-IC
Descripción resistor 1K ohm, ¼ W, 5% resistor 10K ohm, ¼ W, 5% resistor 220 ohm, ¼ W, 5% resistor 470 ohm, ¼ W, 5% capacitor 0.1 uF capacitor 10 uF cristal de 32.768 kHz CD-ROM Parallax Manual StampWorks (en Inglés) Motor paso a paso 12 VDC/75 ohm Plaqueta NX-1000 y LCD 2x16 Multímetro Digital Fotorresistor Conector de 3 pines 74HC595 74HC165 Amp. operacional doble LM358 MAX2719, driver de LEDs 7 seg. Termómetro Digital DS1620 Reloj de tiempo real DS1302 Temporizador 555 Cable rojo Cable blanco Cable negro Juego de herramientas Corta / pela cables Fuente de alimentación 12V 1A Cable Serial Parlante Servo común Parallax Conversor A/D de 8-bits ADC0831 Módulo BASIC Stamp II
Cantidad 4 8 3 1 4 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Manual StampWorks Versión 1.1 • Página 7
Prepare su Plaqueta StampWorks Para poder realizar los experimentos de StampWorks, necesitará estos componentes: • • • • • •
Módulo BASIC Stamp II Plaqueta de laboratorio StampWorks (INEX-1000) Fuente de alimentación de 12 V Cable de programación Cables rojo y negro Corta / pela cables
Empiece quitando la envoltura del módulo BASIC Stamp II e insértelo cuidadosamente en el zócalo de StampWorks. Observará que el módulo BASIC Stamp II y la plaqueta de laboratorio StampWorks tienen una marca semicircular. El módulo BASIC Stamp II debería insertarse en el zócalo de forma que las marcas queden alineadas.
Use el cable de programación para conectar la plaqueta de laboratorio StampWorks a su PC. Es recomendable elegir un puerto serial (com) que no se encuentre en uso. Si, sin embargo, se ve forzado a desconectar otro dispositivo, por ejemplo, un PDA u organizador electrónico, de su computadora, asegúrese de deshabilitar el software de comunicación antes de intentar programar el BASIC Stamp. Si aún no ha instalado el software de programación del Stamp, vea la Sección 1 del manual de programación del Stamp II para obtener instrucciones. Asegúrese de que el interruptor de encendido de la plaqueta de laboratorio StampWorks esté en OFF. Conecte la ficha de la fuente de alimentación de 2.1 mm en la ficha DC INPUT. Conecte la fuente de alimentación a un toma (120 VCA o 220 VCA según el caso). En la parte central de la INEX-1000 hay un sector para realizar conexiones sin soldadura para que pueda montar circuitos que no se encuentren en la plaqueta del kit StampWorks (este kit incluye varios circuitos pre-armados). Es importante comprender cómo trabaja la protoboard. Con un poco de preparación, le será aún más fácil usarla en los próximos experimentos.
Página 8 • Manual StampWorks Versión 1.1
Prepare su Plaqueta StampWorks La parte central de la protoboard es la que usaremos para conectar nuestros componentes. Esta sección consiste en varias columnas de conectores (hay un número impreso al margen para referencia). Para cada columna hay dos juegos de filas. El primero está indicado con las letras A hasta la E y el segundo de la F hasta la J. En todas las columnas, los conectores de la A hasta la E se encuentran eléctricamente conectados. Lo mismo se repite entre la F y la J. Por encima y por debajo de la parte principal de la protoboard hay dos filas horizontales, cada una dividida al medio (aproximadamente en la columna 30). Estas líneas horizontales serán usadas para suministrar los +5 volts (Vdd) y masa (Vss). Para preparar la protoboard uniremos las filas para que la alimentación sea accesible en todos los sectores de la protoboard. Así se ve la protoboard desde el exterior:
Si la viéramos con rayos-X, podríamos observar las conexiones internas y los cortes en Vdd y Vss que deberemos unir. Esta es una vista de las conexiones internas de la protoboard:
Manual StampWorks Versión 1.1 • Página 9
Prepare su Plaqueta StampWorks Comience pelando medio centímetro del aislante del extremo de un cable de interconexión negro. Con una pinza, doble cuidadosamente el cable 90 grados para que se vea así:
Ahora introduzca este extremo en la fila del extremo superior (masa), en el conector que se encuentra justo arriba de la columna 29 (este conector es el que se encuentra exactamente en la línea central de la protoboard, hacia el extremo superior). Sostenga el cable de forma que salga hacia el costado derecho. Marque el aislante, realizando un corte superficial a la altura de la columna 32, asegurándose de no dañar el cable. Quite el cable de la protoboard y córtelo medio centímetro más allá de la marca que acaba de realizar. Con la pinza pelacables, quite el aislante a partir de la marca. Ahora doble este extremo a 90 de forma que el cable tome forma de “U” con el aislante en la parte central.
Si midió y cortó cuidadosamente, este cable en forma de “U” debería poder introducirse fácilmente en la fila de masa entre los conectores 29 y 32. Esto creará una fila continua de masa. Repita este procedimiento para la fila del extremo inferior, también con cable negro. Luego conecte ambas filas usando el mismo proceso, en la columna 60 (extremo derecho de cada fila). Con el cable rojo, conecte las filas de alimentación superior e inferior. Estas filas proveerán los +5 volts, o Vdd. Una las filas de Vdd por la columna 59. Ahora corte 4 cm de cable negro y 4 cm de cable rojo y pele medio centímetro en ambos extremos. Doble cada cable con forma de “U” redondeada. Estos cables no quedarán planos como los anteriores, para que sean más fáciles de retirar de la plaqueta StampWorks cuando sea necesario.
Página 10 • Manual StampWorks Versión 1.1
Prepare su Plaqueta StampWorks Enchufe cuidadosamente un extremo del cable rojo en cualquiera de los terminales del bloque de +5V (cerca del interruptor RESET) y el otro extremo a la fila Vdd (+5) en la columna 1 de la protoboard. Luego conecte un extremo del cable negro en cualquiera de los terminales del bloque GND (masa) y el otro extremo en la fila de masa en la columna 19 de la protoboard. TENGA MUCHO CUIDADO al realizar estas últimas dos conexiones. Si las filas Vdd y Vss quedan interconectadas, se podrían producir daños al conectar la alimentación a la plaqueta StampWorks. Cuando termine el conexionado, la protoboard debería verse así:
Encienda la plaqueta StampWorks moviendo el interruptor de energía a la posición ON. Debería encenderse el LED indicador de encendido (ON LED verde). Si no es así, asegúrese de que el transformador esté correctamente enchufado y busque errores en el conexionado de la protoboard. Ejecute el software editor del BASIC Stamp II e ingrese la siguiente línea de código: DEBUG “¡La plaqueta StampWorks está lista!”
Ahora ejecute el programa (Run). Si todo salió bien, el programa se descarga en el Stamp y aparece una ventana DEBUG en la pantalla, mostrando el mensaje que escribimos (en la imagen del ejemplo está en Inglés).
Manual StampWorks Versión 1.1 • Página 11
Prepare su Plaqueta StampWorks
Si ocurre un error, controle los siguientes ítems: • • • • •
¿Está el BASIC Stamp II conectado correctamente en la plaqueta NX-1000? ¿Está el interruptor de encendido en la posición ON? ¿Está encendido el LED verde? ¿El cable de programación está conectado entre la PC y la plaqueta StampWorks? ¿Ha seleccionado (manualmente) un puerto com erróneo de la PC? ¿El puerto com de la PC está siendo usado por otro programa?
Cuando la ventana DEBUG aparece y le dice que la plaqueta StampWorks está lista, es el momento de hablar sobre la programación del Stamp. Conexión de un Chip Hay dos formas de dibujar un esquema. Una considerada “chipcéntrica” en la cual los pines de E/S del chip aparecen de acuerdo a su ubicación física. En StampWorks los esquemas se dibujaron de forma más eficiente, poniendo los pines de E/S en los lugares que hagan el gráfico más claro. Los pines de E/S de todos los chips se cuentan a partir del indicador, comenzando por el Pin 1 y contando en sentido anti-horario.
Página 12 • Manual StampWorks Versión 1.1
Indicador
Bases de la Programación
Bases de la Programación Contenido de un Programa En la sección 1 de “BASIC Stamp II manual” se introduce el BASIC Stamp, su arquitectura y el concepto de variables y constantes. En esta sección, presentaremos varios elementos de un programa: código lineal, saltos, bucles y subrutinas. Los ejemplos siguientes usan pseudo-código para demostrar y describir la estructura del programa. Itálicas se usan para indicar las secciones de pseudo-código que deberían ser reemplazadas por instrucciones de programación válidas para lograr que el ejemplo pueda ser compilado y ejecutado correctamente. Usted no necesita realizar ninguno de estos ejemplos, ya que todos estos conceptos serán usados en los próximos experimentos. La gente a menudo piensa en las computadoras y los microcontroladores como dispositivos “inteligentes” cuando en realidad, no realizan ninguna tarea sin un juego específico de instrucciones. Este juego de instrucciones se llama programa. Escribirlo es nuestro trabajo. Los programas del Stamp se escriben en un lenguaje de programación llamado PBASIC, una versión específica del lenguaje de programación BASIC (Beginners All-purpose Symbolic Instruction Code= Código de Instrucciones Simbólicas Multi-propósito para Principiantes) desarrollada por Parallax. El BASIC es muy popular debido a su simplicidad y a su sintaxis similar al Inglés. Un programa puede ser tan simple como una lista de instrucciones. Algo así: instruccion 1 instruccion 2 instruccion 3 END
Esta es una estructura de programa muy simple, pero válida. Lo que encontrará sin embargo, es que la mayoría de los programas no se ejecutan en forma lineal como en el programa anterior. El flujo del programa es a menudo redirigido con saltos, bucles y subrutinas, intercalando con pequeñas secciones lineales. Los requerimientos del flujo del programa son determinados por el objetivo del programa y las condiciones bajo las cuales se ejecutará.
Manual StampWorks Versión 1.1 • Página 13
Bases de la Programación Saltos – Redireccionando el Flujo de un Programa Un comando de salto es el que causa que el flujo del programa se desvíe de su trayectoria lineal. En otras palabras, cuando el programa encuentra un comando de salto, no ejecutará, en la mayoría de los casos, la siguiente línea de código. El programa normalmente, se dirigirá a otro sector. Hay dos categorías de comandos de salto: incondicional y condicional. El PBASIC tiene dos comandos, GOTO y GOSUB que realizan saltos incondicionales. Este es un ejemplo de salto incondicional usando GOTO: Rotulo: instruccion 1 instruccion 2 instruccion 3 GOTO Rotulo
Lo llamamos salto incondicional debido a que siempre se ejecuta. GOTO redirige el programa hacia otro lugar. La ubicación se especifica como parte del comando GOTO y se denomina dirección. Recuerde que las direcciones están al principio de una línea de código y son seguidas por dos puntos (:). Verá frecuentemente GOTO al final del cuerpo principal del código, haciendo que las instrucciones del programa se ejecuten nuevamente. El salto condicional hará que el flujo del programa se modifique bajo circunstancias específicas. El salto condicional más simple se logra con la función IF-THEN. La función de PBASIC IF-THEN es diferente de la original de BASIC. En PBASIC, THEN siempre es seguido por una dirección de programa (etiqueta), mientras que en el BASIC estándar se permite colocar instrucciones a continuación del THEN. Si la condición que se evalúa es verdadera, el programa saltará a la dirección especificada. Caso contrario, continuará en la siguiente línea de código. Observe este listado: Inicio: instruccion 1 instruccion 2 instruccion 3 IF condicion THEN Inicio
Se ejecutan las instrucciones y se verifica la condición. Si se evalúa como verdadera, el programa saltará hacia atrás a la línea llamada Inicio. Si la condición se evalúa como falsa, el programa continuará por la línea que se encuentre a continuación de la instrucción IF-THEN.
Página 14 • Manual StampWorks Versión 1.1
Bases de la Programación
A medida que sus requerimientos se vuelven más complicados, podría necesitar que su programa salte a un gran número de direcciones, dependiendo de cierta condición. La primera aproximación es usar múltiples instrucciones IF-THEN. IF condicion_0 THEN Etiqueta_0 IF condicion_1 THEN Etiqueta_1 IF condicion_2 THEN Etiqueta_2
Esta aproximación es válida y puede ser usada. Afortunadamente, el PBASIC tiene un comando especial, BRANCH, que permite que un programa salte a distintas direcciones dependiendo del valor de una variable. Esto es muy útil debido a que las condiciones que mencionábamos, a menudo proceden de una variable de control. BRANCH es un poco más sofisticado en su funcionamiento, pero muy poderoso debido a que puede reemplazar múltiples instrucciones IF-THEN. BRANCH requiere una variable de control y una lista de direcciones o etiquetas. En el caso de una única variable de control, el listado anterior puede ser reemplazado por una línea de código: BRANCH controlVar,[ Etiqueta_0, Etiqueta_1, Etiqueta_2]
Cuando controlVar (variable de control) es cero, el programa saltará a Etiqueta_0, cuando controlVar es uno el programa saltará a Etiqueta_1 y así. Bucles – Ejecutando el código una y otra vez Los bucles hacen que secciones del programa se repitan. Los bucles a menudo usan saltos condicionales e incondicionales para crear varias estructuras de repetición. Este es un ejemplo de bucle incondicional: Etiqueta: instruccion 1 instruccion 2 instruccion 3 GOTO Etiqueta
Al usar GOTO las instrucciones se repiten incondicionalmente. Al usar IF-THEN, podemos crear bucles que se repetirán en ciertas condiciones. Los siguientes ejemplos son llamados bucles condicionales. Estos bucles se ejecutarán bajo ciertas circunstancias. La programación condicional es lo que le otorga a los microcontroladores su “inteligencia.”
Manual StampWorks Versión 1.1 • Página 15
Bases de la Programación Etiqueta: instruccion 1 instruccion 2 instruccion 3 IF condicion THEN Etiqueta
Con esta estructura de repetición, las instrucciones se ejecutarán mientras la condición se evalúe como verdadera. Cuando la condición se evalúe como falsa, el programa continuará por la línea de código siguiente a la instrucción IF-THEN. Es importante observar que en el listado anterior las instrucciones siempre se ejecutarán al menos una vez, incluso cuando la condición sea falsa. Para evitar que suceda esto, es necesario probar la condición antes de ejecutar las instrucciones. El código puede escribirse como se muestra a continuación para lograr que las instrucciones (1 – 3) solamente se ejecuten cuando la condición sea verdadera. Cuando la condición es evaluada como falsa, el programa continúa en Etiqueta_2. Etiqueta_1: IF NOT (condicion) THEN Etiqueta_2 instruccion 1 instruccion 2 instruccion 3 GOTO Etiqueta_1 Etiqueta_2: instruccion 4
El último ejemplo de bucle condicional se trata de un bucle programado mediante la sentencia FORNEXT. FOR controlVar = ValInicial TO ValFinal STEP tamañoPaso instruccion 1 instruccion 2 instruccion 3 NEXT
La construcción FOR-NEXT es usada para lograr que una sección de código se ejecute una cantidad determinada de veces. FOR-NEXT usa una variable de control para determinar la cantidad de repeticiones. El tamaño de la variable determinará la cantidad máxima de repeticiones. Por ejemplo, la cantidad máxima de repeticiones cuando se utiliza una variable de control tipo byte será 255.
Página 16 • Manual StampWorks Versión 1.1
Bases de la Programación La opción STEP de FOR-NEXT es usada cuando se necesita que el incremento de la variable en cada repetición sea distinto de uno. Si, por ejemplo, el bucle debe contar en valores pares, el código podría verse así: FOR controlVar = 2 TO 20 STEP 2 instruccion 1 instruccion 2 instruccion 3 NEXT
Subrutinas – Código reutilizable que ahorra espacio de programa El último concepto de programación que discutiremos es la subrutina. Una subrutina es una sección de código que puede ser llamada (ejecutada) desde cualquier punto del programa. GOSUB es usado para redirigir el programa hacia el código de la subrutina. La subrutina termina con el comando RETURN. Este comando hace que el programa salte hacia la línea de código que sigue a la llamada GOSUB original. Inicio: GOSUB MySub PAUSE 1000 GOTO Inicio MySub: instruccion 1 instruccion 2 instruccion 3 RETURN
En este ejemplo, el código de MySub es ejecutado y luego el programa salta hacia atrás a la línea PAUSE 1000. Estilo de Programación El PBASIC es un lenguaje muy flexible. Sus reglas son simples y fáciles de aprender. El PBASIC no es sensible al formato del programa, uso de espacios en blanco (espacios, tabulaciones, líneas en blanco, etc.) y no detecta diferencias entre mayúsculas y minúsculas; esto quiere decir que dirs, Dirs y DIRS significan lo mismo en PBASIC así que podremos elegir la opción que más nos guste para trabajar.
Manual StampWorks Versión 1.1 • Página 17
Bases de la Programación Los programadores experimentados tienden a adoptar o desarrollar un estilo (de formato) de programación consistente. Ya sea que elija adoptar un estilo o desarrollar uno propio, el hecho de mantener la coherencia con el mismo simplificará la solución de problemas y las revisiones futuras. Esto es especialmente cierto cuando quiere modificar un programa en el que no ha trabajado por mucho tiempo. Los programas de este libro y los que se encuentran en el CD de StampWorks usan las siguientes convenciones: Plantilla La estructura de todos los programas es similar. Ésta puede dividirse en cuatro secciones: •
Encabezado: Esta sección contiene el nombre del archivo y una corta descripción de su funcionamiento. También se registran en este sector las revisiones y actualizaciones que se realizan a la versión original. En la Versión 1.1 de este libro, también hemos agregado la directiva del compilador que indica el modelo de BASIC Stamp que estamos usando.
•
Declaraciones: Ésta sección contiene la declaración de los alias para los pines de E/S, valores constantes y variables. En los ejemplos de programación de esta guía, las variables PBASIC siempre tendrán nombres significativos. Los únicos nombres internos que se usarán serán Outs y Dirs y siempre en la sección de inicialización y no en el código principal.
•
Instrucciones DATA: Algunos programas almacenan información adicional en la EEPROM del BAISC Stamp con instrucciones DATA. Esta sección provee el espacio para dicho almacenamiento.
•
Inicialización: Esta sección es usada para inicializar el estado de los pines de E/S, variables del programa y cuando sea necesario, el hardware externo.
•
Código: Es donde reside la parte principal del código del programa.
•
Subrutinas: Las subrutinas están separadas del cuerpo principal del código debido a que pueden ser llamadas desde cualquier parte del programa. La separación entre subrutinas también facilita la portabilidad del código, posibilitando usar la herramienta de edición “cut and paste” (cortar y pegar) para reutilizar las subrutinas en otros programas.
La plantilla se llama BLANK.BS2. Puede cargarla cuando comienza un proyecto nuevo, asegurándose de cambiarle el nombre utilizando la opción “Save As” (Guardar como) del BASIC Stamp Editor.
Página 18 • Manual StampWorks Versión 1.1
Bases de la Programación ' ' ' ' ' ' '
========================================================================= Archivo: BLANK.BS2 { descripción } {$STAMP BS2} =========================================================================
' { pines de E/S } ' { constantes } ' { variables } ' ------------------------------------------------------------------------' { instrucciones DATA } ' ------------------------------------------------------------------------' { inicialización } ' ------------------------------------------------------------------------' { código } Principal: GOTO Principal END ' ------------------------------------------------------------------------' { subrutinas }
Convención sobre Nombres Como se dijo anteriormente, los programas de los experimentos utilizarán alias (sobrenombres) para los pines de E/S y variables internas de PBASIC. Se usarán las siguientes convenciones: •
Constantes: (incluyendo las etiquetas de direccionamiento a subrutinas) utilizarán mezcla de mayúsculas y minúsculas, comenzando siempre en mayúscula. Ejemplos: LimitSw, LMotor, DlyTm, InitLCD
Manual StampWorks Versión 1.1 • Página 19
Bases de la Programación
•
Variables: usarán mezcla de mayúsculas y minúsculas, comenzando siempre en minúscula. Ejemplos: lcdChar, hrs, iCount
•
Palabras reservadas PBASIC: todo en mayúsculas. Ejemplos: FOR, NEXT, GOSUB, RETURN
Nota del traductor La traducción fue realizada por Arístides Alvarez (aalvarez@parallaxinc.com). Los programas se dejaron en su versión original, sin traducir los nombres de variables ni etiquetas, manteniendo el formato del autor original. En algunos casos el traductor no comparte el estilo de programación del autor, pero para mantener la veracidad y equivalencia de la versión en castellano con la versión original en inglés, se mantuvo la estructura original. Si tiene comentarios o sugerencias sobre la traducción, puede enviarlas a aalvarez@parallaxinc.com. Si quiere opinar sobre el libro en sí, puede enviar sus comentarios a Jon Williams, jonwms@aol.com.
Página 20 • Manual StampWorks Versión 1.1
Hora de Experimentar
Hora de Experimentar Aprendiendo los Conceptos de Programación Lo que sigue es una serie de experimentos de programación que usted puede construir y ejecutar en su plaqueta de laboratorio StampWorks. El propósito de estos experimentos es enseñar los conceptos de programación y el uso de componentes externos con el BASIC Stamp. Los experimentos fueron pensados para que gane progresivamente experiencia en programación. Combinando los conceptos individuales aprendidos puede producir programas sofisticados. Construcción de Proyectos Esta sección del manual es simple pero importante debido a que aprenderá lecciones de programación y técnicas de construcción importantes, usando su laboratorio StampWorks. A medida que avance sobre el manual, observará menos detalles de construcción (ya contará con suficiente experiencia como para tomar sus propias decisiones) y la explicación del funcionamiento del programa será menos profunda, enfocándose específicamente en las técnicas especiales o dispositivos externos conectados al BASIC Stamp. Qué hacer entre proyectos El circuito de un proyecto puede no ser eléctricamente compatible con el siguiente pudiendo en algunos casos, causar daños al BASIC Stamp si se ejecuta el programa viejo con el circuito nuevo. Por esta razón, se debería cargar un programa vacío en el Stamp antes de conectar el circuito nuevo. Esto protegerá al Stamp configurando a todos los pines de E/S como entradas. Este es un programa simple de una sola línea que limpiará y protegerá al Stamp. DEBUG "Stamp limpio."
Este programa se llama CLEAR.BS2.
Manual StampWorks Versión 1.1 • Página 21
Experimento 1: Hacer Titilar un LED
Experimento 1: Hacer Titilar un LED El propósito de este experimento es hacer titilar un LED con el BASIC Stamp. Estos se usan a menudo como indicadores de alarma. Nuevos Elementos/Comandos PBASIC: • • • • •
CON HIGH LOW PAUSE GOTO
Construcción del Circuito Todos los experimentos de StampWorks usan una línea punteada para indicar componentes que ya se encuentran montados en la plaqueta NX-1000. El LED se encuentra en el sector “LED MONITOR 16 CHANNELS” (MONITOR DE LEDS DE 16 CANALES) de la plaqueta.
Dado que la plaqueta StampWorks tiene los LEDs montado sobre ella, todo lo que debe hacer es conectar uno al BASIC Stamp. 1. Corte 15 cm de cable blanco. Pele medio centímetro de aislante de cada extremo. 2. Conecte un extremo al Port 0 del BASIC Stamp. 3. Conecte el otro extremo al Channel 0 del LED Monitor
Manual StampWorks Versión 1.1 • Página 23
Experimento 1: Hacer Titilar un LED
' ' ' ' '
========================================================================= Archivo: BLINK1.BS2 Hace titilar un LED conectado a P0 =========================================================================
LEDpin
CON
0
' LED conectado a Pin 0
DlyTm
CON
500
' retardo en milisegundos
' ------------------------------------------------------------------------Principal: HIGH LEDpin PAUSE DlyTm LOW LEDpin PAUSE DlyTm GOTO Principal END
' ' ' '
enciende LED tiempo encendido apaga LED tiempo apagado ' repite todo
Descripción del Programa Cada uno de los pines de E/S del Stamp tiene asociado tres bits de control. Un bit de la palabra Dirs determina si el pin es una entrada (bit = 0) o una salida (bit = 1). Si el pin se configura como salida, el estado del pin dependerá del bit correspondiente de la palabra Outs. Si el pin se configura como entrada, se toma el valor actual y se almacena dentro de la palabra Ins. HIGH y LOW realizan dos funciones en un solo comando: el pin seleccionado es configurado como salida primero y luego se fija el valor correspondiente en la palabra Outs (1 para HIGH, 0 para LOW).
Por ejemplo, esta línea de código: HIGH 0
Realiza la misma función que: Dir0 = 1 Out0 = 1
Página 24 • Manual StampWorks Versión 1.1
' hace salida a Pin 0 ' pone al Pin 0 en estado alto
Experimento 2: Hacer Titilar un LED (Versión 2)
Experimento 2: Hacer Titilar un LED (Versión 2) El propósito de este experimento es hacer titilar un LED con el BASIC Stamp. El método empleado en este experimento agrega flexibilidad al control del LED. Nuevos Elementos/Comandos PBASIC: • • • • •
VAR Out0 – Out15 Dir0 – Dir15 Byte Bit0 – Bit15
Construcción del Circuito. Use el mismo circuito que en el Experimento 1. ' ' ' ' ' '
========================================================================= Archivo: BLINK2.BS2 Hace titilar un LED conectado al Pin 0. El tiempo de encendido y apagado del LED pueden ser distintos. =========================================================================
MiLED
VAR
Out0
' LED conectado a Pin 0
TiempoEnc TiempoAp Encendido Apagado
CON CON CON CON
1000 250 1 0
' tiempo encendido en milisegundos ' tiempo apagado en milisegundos
' ------------------------------------------------------------------------Inicializar: Dir0 = %1 ' hace salida al pin del LED ' ------------------------------------------------------------------------Principal: MiLED = Encendido
Manual StampWorks Versión 1.1 • Página 25
Experimento 2: Hacer Titilar un LED (Versión 2) PAUSE TiempoEnc MiLED = Apagado PAUSE TiempoAp GOTO Principal END
' pausa de encendido ' pausa de apagado ' repite todo
Descripción del Programa Esta versión de BLINK expone las capacidades técnicas de los pines de E/S del BASIC Stamp y su control. Observe cómo usar sobrenombres (o alias) para los pines de E/S, constantes y variables, logrando que el programa sea fácil de leer. No hay errores en la interpretación de: MiLED = Encendido La ventaja en este programa es la capacidad del pin de E/S del BASIC Stamp I/O de seguir el valor de una constante o una variable. Cambie el programa para que se vea como el LED puede seguir a una variable: ' ' ' ' '
========================================================================= Archivo: BLINK2b.BS2 Hace titilar un LED conectado a Pin 0. =========================================================================
MiLED
VAR
Out0
' LED conectado a Pin 0
TiempoEnc TiempoAp Encendido Apagado
CON CON CON CON
1000 250 1 0
' tiempo encendido en milisegundos ' tiempo apagado en milisegundos
cntr
VAR
Byte
' contador para controlar al LED
' ------------------------------------------------------------------------Inicializar: Dir0 = %1
' Hace el pin del LED salida
' ------------------------------------------------------------------------Principal: MiLED = cntr PAUSE TiempoEnc
Página 26 • Manual StampWorks Versión 1.1
' pone cntr.Bit0 en MiLED ' pausa de encendido
Experimento 2: Hacer Titilar un LED (Versión 2) cntr = cntr + 1 GOTO Principal END
' incrementa el contador ' repite todo
¿Puede explicar lo que sucede? Dado que MiLED es una variable tipo bit, el Bit0 de cntr la controlará. Funciona así: cuando cntr es impar (1, 3, 5, etc.), Bit0 será activado (1), haciendo que el LED se encienda. Cuando cntr es un número par, Bit0 se limpiará (0), haciendo que el LED se apague.
Manual StampWorks Versión 1.1 • Página 27
Experimento 3: Contador con LEDs
Experimento 3: Contador con LEDs El propósito de este experimento es mostrar el valor de 8 bits (un byte) usando LEDs. Múltiples LEDs se usan frecuentemente como indicadores. Nuevos Elementos/Comandos PBASIC: • • •
OutL, OutH DirL, DirH FOR-NEXT
Construcción del Circuito. Estos LEDs figuran en el sector “LED MONITOR 16 CHANNELS” de la plaqueta NX-1000.
Manual StampWorks Versión 1.1 • Página 29
Experimento 3: Contador con LEDs Dado que la plaqueta de laboratorio de StampWorks tiene los LEDs montados, lo único que deberá hacer es conectarlos al BASIC Stamp. 1. Comience con seis cables blancos de 15 cm. Pele medio centímetro de aislante en todos los extremos. 2. Conecte un extremo al Pin 0 del BASIC Stamp. 3. Conecte el otro extremo al Channel 0 del LED Monitor. 4. Repita los pasos 2 y 3 para los Channels 1-7 del LED Monitor (pines 1– 7 del Stamp) usando más cables. ' ' ' ' '
========================================================================= Archivo: LEDCNTR.BS2 Muestra un contador binario en los pines 0 - 7 =========================================================================
LEDs
VAR
OutL
' LEDs en pines 0 - 7
MinCnt MaxCnt DlyTm
CON CON CON
0 255 100
' valor inicial del contador ' valor final del contador ' retardo en milisegundos
cntr
VAR
Byte
' contador
' ------------------------------------------------------------------------Inicializar: DirL = %11111111
' hace salidas todos los pines
' ------------------------------------------------------------------------Principal: FOR cntr = MinCnt TO MaxCnt LEDs = cntr PAUSE DlyTm NEXT GOTO Principal END
Página 30 • Manual StampWorks Versión 1.1
' bucle que genera los números ' muestra el número con LEDs ' pausa entre números ' repite todo
Experimento 3: Contador con LEDs Descripción del Programa Como se explicó en el Experimento 1, el estado de salida de los pines del BASIC Stamp se almacenan en el área de memoria llamada Outs (OutL es el byte inferior de la palabra Outs). Dado que OutL es parte de la memoria (RAM) multipropósito del BASIC Stamp, se pueden escribir y leer valores en ésta. En este caso, copiar el valor de nuestro contador en OutL (LEDs es el alias) hace que éste sea mostrado en los LEDs de la plaqueta StampWorks. Desafío Modifique el programa para que cuente hacia atrás.
Manual StampWorks Versión 1.1 • Página 31
Experimento 4: Pantalla de LEDs de Ciencia-Ficción
Experimento 4: Pantalla de LEDs de Ciencia-Ficción El propósito de este experimento es hacer un “ping-pong” de luz a través de los LEDs para crear una pantalla tipo Sci-Fi (ciencia-ficción). Circuitos como éstos se usan en películas y series televisivas. Nuevos Elementos/Comandos PBASIC: • • •
<< (Operador de desplazamiento de bits hacia la izquierda) >> (Operador de desplazamiento de bits hacia la derecha) IF-THEN
Construcción del Circuito Use el mismo circuito del experimento anterior. ' ' ' ' '
========================================================================= Archivo: PONG.BS2 "Ping-Pong" en LED (uno de ocho) =========================================================================
LEDs DlyTm
VAR CON
OutL 50
' LEDs se conectan a los pines 0 - 7 ' retardo en milisegundos
' ------------------------------------------------------------------------Inicializar: DirL = %11111111 LEDs = %00000001
' configura todos los pines como salidas ' comienza con un LED encendido
' ------------------------------------------------------------------------Adelante: PAUSE DlyTm LEDs = LEDs << 1 IF LEDs = %10000000 THEN Atras GOTO Adelante
' ' ' '
Atras: PAUSE DlyTm
' muestra el LED
muestra el LED desplaza el LED a la izquierda verifica posición final continua en esta dirección
Manual StampWorks Versión 1.1 • Página 33
Experimento 4: Pantalla de LEDs de Ciencia-Ficción LEDs = LEDs >> 1 IF LEDs = %00000001 THEN Adelante GOTO Atras
' desplaza el LED a la derecha ' verifica posición final ' continua en esta dirección
END
Descripción del Programa Este programa demuestra la habilidad del BASIC Stamp para manipular sus salidas. El programa inicializa los LEDs en %00000001 (el LED 0 está encendido) luego utiliza el operador de desplazamiento a la izquierda (<<) para mover el LED encendido una posición a la izquierda. Con números binarios, desplazar un lugar a la izquierda es lo mismo que multiplicar por dos. Desplazar un lugar a la derecha (>>) es lo mismo que dividir por dos. Ambas secciones principales del código usan IF-THEN para controlar el límite de la cuenta, haciendo que el programa salte a la otra sección cuando llega al valor límite. Desafío Cree un retardo variable y agregue alguna curiosidad al programa (vea PONG2.BS2 por ejemplo).
Página 34 • Manual StampWorks Versión 1.1
Experimento 5: Gráficos con LEDs (Punto o Barra)
Experimento 5: Gráficos con LEDs (Punto o Barra) El propósito de este experimento es crear un gráfico configurable con LEDs (punto o barra). Este tipo de gráficos es muy común en equipamiento de audio, específicamente para indicadores de volumen (VU meters). El valor a graficar en el experimento se tomará de la posición de un potenciómetro. Nuevos Elementos/Comandos PBASIC: • • • • •
Word RCTIME */ (operador estrella-barra) GOSUB-RETURN DCD
Construcción del Circuito Agregue este circuito al Experimento 4.
Manual StampWorks Versión 1.1 • Página 35
Experimento 5: Gráficos con LEDs (Punto o Barra) 1. 2. 3. 4. 5. 6. ' ' ' ' ' ' '
Usando cable rojo (corte el largo necesario), conecte la pista Vdd (+5) al punto A15. Conecte un capacitor de 0.1 uF (104K) entre los puntos B14 y B15. conecte un resistor de 220-ohm (rojo-rojo-marrón) entre los puntos C10 y C14. Usando cable blanco, conecte A10 al Port 15 del BASIC Stamp. Usando cable blanco, conecte E14 al cursor del potenciómetro de 10K Usando cable negro, conecte la pista Vss (masa) al terminal inferior del potenciómetro de 10K.
========================================================================= Archivo: LEDGRAGH.BS2 Muestra una barra o un punto en la barra de 8 LEDs {$STAMP BS2} =========================================================================
LEDs PotPin
VAR CON
OutL 15
' salidas para LEDs
DotGraf BarGraf GrMode
CON CON CON
0 1 BarGraf
' define tipo de gráfico
rawVal grafVal bits newBar
VAR VAR VAR VAR
Word Byte Byte Byte
' ' ' '
' define modo gráfico actual valor medido en el potenciómetro valor a graficar bit más alto que se enciende espacio de trabajo para la barra
' ------------------------------------------------------------------------Inicializar: DirL = %11111111
' todas salidas
' ------------------------------------------------------------------------Principal: HIGH PotPin PAUSE 1 RCTIME PotPin,1,rawVal grafVal = rawVal */ $005F
Página 36 • Manual StampWorks Versión 1.1
' descarga el capacitor ' durante 1 ms ' lee el potenciómetro ' escala grafVal (0 - 255) ' – equivalente a rawVal * 0.372
Experimento 5: Gráficos con LEDs (Punto o Barra) GOSUB ShowGraph PAUSE 50 GOTO Principal END
' muestra ' repite todo
' ------------------------------------------------------------------------ShowGraph: IF GrMode = BarGraf THEN ShowBar
' salta al código de modo gráfico
ShowDot: LEDs = DCD (grafVal / 32) RETURN
' muestra el valor (punto)
ShowBar: bits = DCD (grafVal / 32) newBar = 0
' obtiene el bit más alto
BuildBar: IF bits = 0 THEN BarDone newBar = newBar << 1 newBar.Bit0 = 1 bits = bits >> 1 GOTO BuildBar BarDone: LEDs = newBar RETURN
' ' ' ' '
¿se encendieron todos los LEDs? no – desplazar a la izquierda enciende el primer LED desplaza el valor de bits continuar
' mostrar nuevo nivel
Descripción del Programa Después de inicializar las salidas, este programa lee el potenciómetro de 10K (ubicado en la plaqueta de laboratorio StampWorks) con RCTIME. Usa DEBUG para mostrar el valor directo que se obtuvo con RCTIME, entre uno (con el potenciómetro completamente en sentido anti-horario) y 685 (con el potenciómetro completamente en sentido horario). Dado que grafVal es una variable de un byte, el valor rawVal debe afectarse por un factor de escala para corregir su rango. Para determinar el factor de escala, hay que dividir 255 (el máximo valor posible para grafVal) por 685 (máximo valor que entrega rawVal). El resultado es 0.372. Trabajar con valores fraccionarios dentro del sistema algebraico de números enteros del PBASIC, es posible gracias al operador */ (estrella-barra). El parámetro para */ es una variable de 16-bit
Manual StampWorks Versión 1.1 • Página 37
Experimento 5: Gráficos con LEDs (Punto o Barra) (word). Los primeros ocho bits (byte superior) se multiplican como un número entero. Los últimos ocho bits (byte bajo) se multiplican como número fraccionario. Para determinar el valor del byte de la parte fraccionaria, multiplique el valor fraccionario decimal por 255 y conviértalo a formato hexadecimal. Ejemplo: 0.372 x 255 = 95 (o $5F) Dado que el factor en el experimento es 0.372, el valor */ es $005F. El programa usa el operador DCD para determinar el valor del bit más alto de grafVal. Con ocho LEDs en el gráfico, grafVal es dividido por 32, forzando el resultado de DCD a valores de salida entre %00000001 (DCD 0) y %10000000 (DCD 7). En el modo Dot, esto es todo lo que se requiere para encender un solo LED. En el Bar Mode, los LEDs inferiores también deben encenderse. Esto es realizado por un bucle. El valor de control del bucle es la variable bits, que también se calcula en base a DCD. Este bucle se controla por valor de bits, saliendo cuando este es igual a cero, mientras que cada iteración decrementa su valor. Si bits es mayor que cero, la variable de espacio de trabajo del gráfico, newBar, se desplaza a la izquierda y su bit 0 es activado. Por ejemplo, si DCD asigna %1000 a bits, esta es la forma en que bits y newBar se verán afectadas en cada iteración del bucle: bits
newBar
1000 0100 0010 0001 0000
0001 0011 0111 1111 (listo – salir del bucle y mostrar el valor)
El propósito de la variable newBar, es evitar que los LEDs parpadeen con cada actualización. Esto permite que el programa comience con una barra gráfica “vacía” que se construye hasta el valor actual. Con esta técnica, el programa no debe recordar el valor del gráfico anterior.
Página 38 • Manual StampWorks Versión 1.1
Experimento 6: Un Juego Simple
Experimento 6: Un Juego Simple El propósito de este experimento es crear un juego simple con el BASIC Stamp. Nuevos Elementos/Comandos PBASIC: • • • • •
RANDOM & (operador And) FREQOUT BUTTON LOOKUP
Construcción del Circuito
Manual StampWorks Versión 1.1 • Página 39
Experimento 7: Controlador de Luces Si quiere puede usar el piezoeléctrico del kit en lugar del de la NX-1000 que parece tener mejor volumen. 1. 2. 3. 4. ' ' ' ' '
Usando Usando Usando Usando
cables blancos, conecte los puertos 0 – 5 del BASIC Stamp a los LEDs 0 – 5. cable blanco, conecte el puerto 6 del BASIC Stamp al lado + del piezoeléctrico. cable negro, conecte el lado – del piezoeléctrico a masa (ground). un cable negro conecte el puerto 7 del BASIC Stamp al pulsador D0.
========================================================================= Archivo: LASVEGAS.BS2 Máquina tragamonedas basada en un BASIC Stamp =========================================================================
LEDs Spkr Swtch
VAR CON CON
OutL 6 7
' salidas LED ' salida parlante ' pulsador de entrada
randW pattern tone swData delay spin1 spin2
VAR VAR VAR VAR VAR VAR VAR
Word Byte Word Byte Word Byte Byte
' ' ' ' ' ' '
número aleatorio patrón de luces tono de salida variable para BUTTON retardo variable de "giro" contador bucle contador bucle
' ------------------------------------------------------------------------Inicializar: DirL = %00111111
' configura LEDs como salidas
' ------------------------------------------------------------------------Attention: GOSUB GetRnd FREQOUT Spkr,35,tone PAUSE 100 BUTTON Swtch,0,255,10,swData,1,Spin GOTO Attention Spin: LEDs = %00111111 PAUSE 750
Página 40 • Manual StampWorks Versión 1.1
' obtiene número aleatorio ' emite un sonido ' controla el pulsador de juego
' simula un reinicio del juego
Experimento 6: Un Juego Simple LEDs = %00000000 PAUSE 500 delay = 75
' retardo de inicialización
FOR spin1 = 1 TO 25 GOSUB GetRnd FREQOUT Spkr,25,425 PAUSE delay delay = delay */ $0119 NEXT
' ' ' ' '
IF pattern = %00111111 THEN YouWin FREQOUT Spkr,1000,150 LEDs = %00000000 PAUSE 1000 GOTO Attention
' si todos se encienden, gana ' caso contrario, pierde... ' limpia los LEDs
YouWin: FOR spin1 = 1 TO 5 FOR spin2 = 0 TO 3 LOOKUP spin2,[$00,$0C,$12,$21],LEDs LOOKUP spin2,[665,795,995,1320],tone FREQOUT Spkr,35,tone PAUSE 65 NEXT NEXT LEDs = %00000000 PAUSE 1000 GOTO Attention END
gira la rueda obtiene número aleatorio ruido de la rueda pausa entre ruidos multiplica la pausa por 1.1
' repite todo ' luces y sonidos para indicar que ´ ganó
' limpia los LEDs ' repite todo
' ------------------------------------------------------------------------GetRnd: RANDOM randW tone = randW & $7FF pattern = randW & %00111111 LEDs = pattern RETURN
' ' ' '
obtiene número pseudo aleatorio no deja que el tono sea muy alto borra bits sin uso muestra el patrón
Manual StampWorks Versión 1.1 • Página 41
Experimento 7: Controlador de Luces Descripción del Programa Este programa demuestra cómo agregar más aleatoriedad al número pseudo aleatorio generado por el comando RANDOM, agregando el efecto humano. El programa espera en un bucle llamado Attention. Al principio del bucle se llama a GetRnd para crear un valor pseudo aleatorio, un tono para el parlante y para poner un patrón nuevo en los LEDs. Al regresar a Attention, se emite el sonido y se revisa si se ha presionado el botón. El programa repetirá el bucle sobre Attention hasta que se presione el botón. El comando BUTTON es usado para eliminar el rebote en la entrada. Lo que hace aleatorio al programa es el tiempo que permanece presionado el botón. Cuando se presiona, los LEDs se encienden y luego se apagan para simular que el juego se reinicia. Luego, un bucle FOR-NEXT es usado para simular el giro de los rodillos de la máquina tragamonedas. En cada giro, un sonido “clic” es generado mientras se aumenta la pausa entre los mismos para simular la desaceleración natural de los discos de la máquina. Si se encienden los seis LEDs antes del último giro, el programa salta a YouWin. Esta rutina usa LOOKUP para encender un patrón predefinido de LEDs y sonidos antes de regresar al principio del programa. Si alguno de los LEDs no se enciende, se escuchará el sonido de la derrota en el parlante y el juego se reiniciará. Desafío Modifique el juego para que se pueda ganar con menos de seis LEDs encendidos. Por ejemplo, vea LASVGAS2.BS2.
Página 42 • Manual StampWorks Versión 1.1
Experimento 7: Controlador de Luces
Experimento 7: Controlador de Luces El propósito de este experimento es crear un pequeño controlador de luces, conveniente para árboles de navidad y decoraciones externas. Las salidas de este circuito serán solamente LEDs (Para controlar luces de alta tensión vea el libro de Matt Gilliland, Microcontroller Application Cookbook). Nuevos Elementos/Comandos PBASIC: • • • •
DATA MIN // (Operador módulo) BRANCH
Construcción del Circuito.
Manual StampWorks Versión 1.1 • Página 43
Experimento 7: Controlador de Luces 1. 2. 3. 4. 5. 6. 7.
Usando cables blancos, conecte los puertos 0-5 del BASIC Stamp a los LEDs 0– 5. Usando cable rojo, conecte la línea de Vdd (+5) al punto A15. Conecte un capacitor de 0.1 uF (104K) entre B14 y B15. Conecte un resistor de 220-ohm (rojo-rojo-marrón) entre C10 y C14. Usando cable blanco, conecte A10 al puerto 6 del BASIC Stamp. Usando cable blanco, conecte E14 al terminal superior del potenciómetro de 10K. Usando cable negro, conecte la línea de Vss (ground) al cursor (terminal central) del potenciómetro de 10K. 8. Usando un cable blanco conecte el puerto 7 del BASIC Stamp al pulsador D7. ' ========================================================================= ' Archivo: LTSHOW.BS2 ' ' mini controlador de luces ' ' {$STAMP BS2}
' ========================================================================= Select PotPin Lights
CON CON VAR
7 6 OutL
' botón en pin 7 ' pot. control veloc. en pin 6 ' salidas de control de luces
delay btnVar mode offset randW
VAR VAR VAR VAR VAR
Word Byte Byte Byte Word
' ' ' ' '
pausa entre patrones variable para BUTTON modo seleccionado offset del patrón de luz variable para RANDOM
' ------------------------------------------------------------------------SeqA SeqB SeqC SeqD SeqE
DATA DATA DATA DATA DATA DATA
%000001, %100000, %000001, %000000, %100100, %0
AMax BMax CMax DMax
CON CON CON CON
SeqB-SeqA SeqC-SeqB SeqD-SeqC SeqE-SeqD
%000010, %010000, %000010, %001100, %010010,
%000100, %001000, %000100, %010010, %001001
%001000, %010000, %100000 %000100, %000010 %001000, %010000 %100001
' calcula largo de secuencia
' -------------------------------------------------------------------------
Página 44 • Manual StampWorks Versión 1.1
Experimento 7: Controlador de Luces Inicializar: DirL = %00111111
' configura LEDs como salidas
' ------------------------------------------------------------------------Principal: HIGH PotPin PAUSE 1 RCTIME PotPin,1,delay delay = (delay */ $018A) MIN 50 PAUSE delay
' lee potenciómetro de velocidad ' calcula retardo (50 ms ~ 1 sec) ' espera entre patrones
SwitchCheck: BUTTON Select,0,255,0,btnVar,0,Show mode = mode + 1 // 5
' ¿nuevo modo? ' si, actualizar la var. mode
' descarga el capacitor
Show: BRANCH mode,[ModeA,ModeB,ModeC,ModeD,ModeE] GOTO Principal END ' ------------------------------------------------------------------------ModeA: offset = offset + 1 // AMax READ (SeqA + offset),Lights GOTO Principal
' actualiza el offset (0 - 5) ' sale nuevo patrón de luces ' repite
ModeB: offset = offset + 1 // BMax READ (SeqB + offset),Lights GOTO Principal ModeC: offset = offset + 1 // CMax READ (SeqC + offset),Lights GOTO Principal ModeD: offset = offset + 1 // DMax READ (SeqD + offset),Lights GOTO Principal ModeE:
Manual StampWorks Versión 1.1 • Página 45
Experimento 7: Controlador de Luces RANDOM randW Lights = randW & %00111111 GOTO Principal
' obtiene número aleatorio ' enciende canales aleatorios
Descripción del Programa Este programa es más simple de lo que parece. El cuerpo principal del programa es un bucle. La velocidad de ejecución del bucle principal es controlada por la posición del potenciómetro. RCTIME es usada para leer el potenciómetro y normalmente el número máximo que se obtuvo en su lectura fue 648. Multiplicando el máximo valor del potenciómetro por 1.54 (delay */ $018A) se obtiene un máximo de 1000, para producir una pausa de un segundo de duración. El operador MIN es usado para garantizar que la pausa más corta posible sea de 50 milisegundos. El código SwitchCheck revisa si D7 es presionado. Si es así, la variable mode, es incrementada (en una unidad). El operador de módulo (//) es usado para mantener a mode en el rango de cero a cuatro. Esto funciona debido a que el operador de módulo entrega el resto de una división. Dado que cualquier número dividido por sí mismo da un resto de cero, usar el operador de esta manera hace que mode esté entre cuatro y cero. El elemento final del bucle principal es Show. Este código usa BRANCH para llamar a la subrutina que emitirá la secuencia de luces especificada por mode. Los modos A hasta D trabajan en forma similar, obteniendo secuencias de luces de la EEPROM del BASIC Stamp (almacenada por las instrucciones DATA). El modo E genera un patrón aleatorio de luces. Mire el código de la subrutina ModeA. Lo primero que se hace es actualizar el valor de la variable offset, usando la técnica del operador módulo. El valor de offset es agregado al principio de la secuencia de luz especificada, y el patrón de luces actual es obtenido con READ. Observe que las instrucciones DATA de cada secuencia están etiquetadas (SeqA, SeqB, etc.). Internamente, cada una
de esas etiquetas es convertida a un valor constante que es igual a la dirección de inicio de cada secuencia. La longitud de cada secuencia es calculada con esas constantes. Al emplear esta técnica, los patrones de luces pueden ser actualizados (alargados o acortados) sin necesidad de modificar el código llamado por Show. ModeE es muy directo, usando la función RANDOM para presentar nuevos patrones de luces en cada pasada a través del bucle principal. Desafío Agregue una nueva secuencia de luces. ¿Qué secciones del programa deben ser modificadas para realizar esta tarea?
Página 46 • Manual StampWorks Versión 1.1
Construyendo Circuitos
Construyendo Circuitos por su Cuenta Con la experiencia que obtuvo en la sección anterior, ya está en condiciones de montar los circuitos restantes sin instrucciones específicas. Estos proyectos son bastante simples y los encontrará eléctricamente similares a varios de los proyectos que ya construyó. Proceda lentamente y controle dos veces sus conexiones antes de aplicar la alimentación al circuito. A partir de ahora entonces, usted deberá montar sus propios proyectos y experimentos con el Stamp. Ahora continuemos con los displays de 7 segmentos …
Manual StampWorks Versión 1.1 • Página 47
Usando Displays de 7 Segmentos
Usando Displays de 7 Segmentos Un display de 7 segmentos está formado por siete LEDs comunes (ocho contando el punto decimal) que han sido empacados con el patrón que se muestra en la Figura 8. Los LEDs tienen un elemento en común (ánodo o cátodo).
Iluminando combinaciones específicas de LEDs podemos crear los dígitos e incluso algunos caracteres alfanuméricos (letras y símbolos). Los LEDs de siete segmentos normalmente se usan en letreros numéricos. La plaqueta de StampWorks tiene cuatro displays de siete segmentos de cátodo común. Los experimentos de esta sección le mostrarán como aprovechar al máximo estos componentes tan versátiles.
Manual StampWorks Versión 1.1 • Página 49
Experimento 8: Contador de un Dígito
Experimento 8: Contador de un Dígito El propósito de este experimento es demostrar el uso del módulo de 7 segmentos, creando un contador decimal simple. Nuevos Elementos/Comandos PBASIC: •
Nib
Construcción del Circuito.
Manual StampWorks Versión 1.1 • Página 51
Experimento 8: Contador de un Dígito ' ' ' ' '
========================================================================= Archivo: 7SEGS.BS2 Muestra un dígito de 7 segmentos =========================================================================
segs
VAR
OutL
' LEDs del 7 segmentos
cntr
VAR
Nib
' contador
' ------------------------------------------------------------------------' Segmentos ' DecDig DATA DATA DATA DATA DATA DATA DATA DATA DATA DATA
.abcdefg -------%01111110 %00110000 %01101101 %01111001 %00110011 %01011011 %01011111 %01110000 %01111111 %01111011
' ' ' ' ' ' ' ' ' '
0 1 2 3 4 5 6 7 8 9
' ------------------------------------------------------------------------Inicializar: DirL = %01111111
' configura como salidas los 7 seg.
' ------------------------------------------------------------------------Principal: FOR cntr = 0 TO 9 READ (DecDig + cntr),segs PAUSE 1000 NEXT GOTO Principal END
Página 52 • Manual StampWorks Versión 1.1
' cuenta ' muestra el dígito ' durante un segundo ' repite todo
Experimento 8: Contador de un Dígito Descripción del Programa Este programa es muy similar al del control de luces: se lee un patrón de la EEPROM y se pone en la salida de los LEDs. En este programa, el envío de patrones específicos a los LEDs del 7 segmentos, crea los dígitos del cero al nueve. Desafío Actualice el programa para crear un contador hexadecimal de un dígito. Use el patrón que se muestra a continuación para generar los últimos dígitos hexadecimales.
Manual StampWorks Versión 1.1 • Página 53
Experimento 9: Dado Digital
Experimento 9: Dado Digital El propósito de este experimento es crear un dado digital. Construcción del Circuito. Agregue este pulsador al circuito del experimento anterior.
' ' ' ' '
========================================================================= Archivo: ROLLER.BS2 Dado Digital. Muestra un número del 1 al 6 cuando se presiona D7. =========================================================================
RollBtn Segs
CON VAR
15 OutL
' botón en Pin 7 ' LEDs del 7 segmentos
swData dieVal spinPos doSpin
VAR VAR VAR VAR
Byte Nib Nib Nib
' ' ' '
datos del comando BUTTON nuevo valor del dado posición de giro control de actualización de giro
' ------------------------------------------------------------------------' ' DecDig
DATA DATA DATA DATA
.abcdefg -------%01111110 %00110000 %01101101 %01111001
' ' ' '
0 1 2 3
Manual StampWorks Versión 1.1 • Página 55
Experimento 9: Dado Digital
Bug
DATA DATA DATA DATA DATA DATA
%00110011 %01011011 %01011111 %01110000 %01111111 %01111011
' ' ' ' ' '
4 5 6 7 8 9
DATA DATA DATA DATA DATA DATA
%01000000 %00100000 %00010000 %00001000 %00000100 %00000010
' indicador de giro
' ------------------------------------------------------------------------Inicializar: DirL = %01111111
' define salidas
' ------------------------------------------------------------------------Principal: GOSUB GetDie PAUSE 5 ' ¿Está presionado el botón? BUTTON RollBtn,0,255,10,swData,1,ShowDie GOTO Principal ShowDie: READ (DecDig + dieVal),Segs PAUSE 3000 GOTO Principal END
' obtiene valor del dado
' muestra el valor ' durante tres segundos ' repite
' ------------------------------------------------------------------------GetDie: dieVal = dieVal // 6 + 1 READ (Bug + spinPos),segs doSpin = doSpin + 1 // 7 IF doSpin > 0 THEN GetDieX spinPos = spinPos + 1 // 6 GetDieX: RETURN
Página 56 • Manual StampWorks Versión 1.1
' ' ' ' '
limita entre 1 y 6 muestra patrón de giro ¿actualiza el indicador de giro? solo si doSpin = 0 actualiza el indicador de giro
Experimento 9: Dado Digital Descripción del Programa Este programa se basa en todo lo que hemos hecho hasta el momento y debería resultarle fácil de comprender. Hemos agregado un poco de creatividad en la programación para lograr que un programa simple se vea más interesante. Hay que remarcar el uso de la variable doSpin. Para crear un valor aleatorio, la variable dieVal es actualizada rápidamente hasta que el botón es presionado. Esta velocidad de cambio, es demasiado rápida para usarla en el indicador de giro del dado. La variable doSpin entonces, actúa como un retardo, haciendo que el valor indicado por los LEDs sea actualizado cada séptimo paso por la rutina GetDie. Esto nos permite ver los números claramente y crea un efecto de display agradable.
Manual StampWorks Versión 1.1 • Página 57
Experimento 10: Reloj con Pantalla de LEDs
Experimento 10: Reloj con Pantalla de LEDs El propósito de este experimento es crear una pantalla simple de reloj usando cuatro módulos LED de 7 segmentos. Nuevos Elementos/Comandos PBASIC: • • • •
OutA,OutB,OutC,OutD DirA,DirB,DirC,DirD In0 - In15 DIG
Construcción del Circuito
Manual StampWorks Versión 1.1 • Página 59
Experimento 10: Reloj con Pantalla de LEDs ' ' ' ' '
========================================================================= Archivo: CLOCK.BS2 Simula un reloj digital usando cuatro displays 7-segmentos =========================================================================
segs digSel tic
VAR VAR VAR
OutL OutC In15
' segmentos ' selector de dígito ' generador de pulsos de 1 Hz
DPoint
CON
%10000000
' bit de punto decimal
secs time digit
VAR VAR VAR
Word Word Nib
' segundos ' tiempo con formato ' dígito actual
' ------------------------------------------------------------------------' ' DecDig
DATA DATA DATA DATA DATA DATA DATA DATA DATA DATA
.abcdefg -------%01111110 %00110000 %01101101 %01111001 %00110011 %01011011 %01011111 %01110000 %01111111 %01111011
' ' ' ' ' ' ' ' ' '
0 1 2 3 4 5 6 7 8 9
' ------------------------------------------------------------------------Inicializar: DirL = %11111111 DirC = %1111 digSel = %1111
' configura segmentos como salidas ' selector de dígito como salida ' todos los dígitos apagados
' ------------------------------------------------------------------------Principal: GOSUB ShowTime IF tic = 1 THEN IncSec GOTO Principal
Página 60 • Manual StampWorks Versión 1.1
' muestra dígito actual ' ¿nuevo segundo? ' repite
Experimento 10: Reloj con Pantalla de LEDs IncSec: secs = (secs + 1) // 3600
' actualiza el contador de seg.
Waiting: GOSUB ShowTime IF tic = 0 THEN Principal
' muestra dígito actual ' si pasó el pulso salta al inicio
' código adicional podría ponerse aquí GOTO Waiting END
' repite
' ------------------------------------------------------------------------ShowTime: time = (secs / 60) * 100 ' obtiene minutos, en centenas time = time + (secs // 60) ' obtiene segundos segs = %00000000 ' pantalla en blanco ' habilita dígito LOOKUP digit,[%1110,%1101,%1011,%0111],digSel READ (DecDig + (time DIG digit)),segs ' pone el patrón de segmento PAUSE 1 ' muestra digit = (digit + 1) // 4 ' obtiene siguiente dígito RETURN
Descripción del Programa Los dos primeros proyectos con los displays de siete segmentos usaron solamente un dígito. Este proyecto usa los cuatro. Un nuevo problema se presenta; dado que los ánodos de los cuatro displays están unidos, solamente podemos mostrar uno a la vez. Esto se realiza mediante el patrón de segmento que determina el dígito que se encuentra activo en cada momento (poniendo en estado bajo su cátodo). El objetivo de este programa sin embargo, es crear la pantalla de un reloj, en el cual los cuatro dígitos deben mostrarse al mismo tiempo. Si bien en la realidad no podemos tener a los cuatro encendidos a la vez, podemos engañar al ojo humano y hacerle creer que es así. El ojo humano tiene una propiedad conocida como Persistencia de Visión (POV), que hace que retenga una imagen durante un breve lapso de tiempo. A mayor brillo de la imagen, más tiempo permanece en nuestros ojos. Este fenómeno es el que hace que veamos un punto de luz después de observar el flash de una cámara fotográfica. Podemos usar esta propiedad en nuestro beneficio haciendo un barrido rápido a través de cada uno de los cuatro dígitos, mostrando cada dígito en un
Manual StampWorks Versión 1.1 • Página 61
Experimento 10: Reloj con Pantalla de LEDs segmento durante un corto período. Si el ciclo es suficientemente rápido, la POV de nuestros ojos nos hará creer que los cuatro dígitos se encuentran encendidos a la vez. Este proceso se llama multiplexado. Multiplexado es el proceso de compartir líneas de datos; es este caso, las líneas de los segmentos de los displays son compartidas. Si no multiplexáramos, se necesitarían 28 líneas de salida para controlar los cuatro displays de 7 segmentos. Son 12 líneas más de las que se encuentran disponibles en un BASIC Stamp. El verdadero trabajo de este programa lo realiza la subrutina llamada ShowTime. Su propósito es darle formato de tiempo (MMSS) al contador de segundos y actualizar el dígito actual. Dado que la rutina solamente puede mostrar un dígito a la vez, debe ser llamada frecuentemente, caso contrario la pantalla parpadearía. Este programa actualizará la pantalla mientras espera que sucedan otras cosas. La pantalla del reloj se crea moviendo el valor de los minutos a las columnas de millares y centenas (secs / 60) de la variable time. Los segundos restantes (secs // 60) se suman a time, colocándolos en las columnas de decenas y unidades. Así funciona el sistema: Ejemplo: 754 segundos 754 / 60 = 12 12 x 100 = 1200 (tiempo = 1200) 754 // 60 = 34 1200 + 34 = 1234 (tiempo = 1234; 12 minutos y 34 segundos) Ahora que el valor time está listo, los segmentos se borran para la próxima actualización. Este procedimiento mantiene limpia la imagen. Si esto no se hace, el valor anterior de los segmentos aparecerá como un fantasma en el display. Una tabla LOOKUP se usa para habilitar el dígito actual y los segmentos que usará ese dígito se leen con READ de una tabla DATA de la EEPROM. El display de StampWorks no tiene dos puntos (:) que normalmente se usan en los relojes digitales, así que lo reemplazaremos por un punto decimal a continuación del segundo dígito. El paso final es agregar una pequeña pausa mientras está encendido el dígito y se actualiza la variable digit. El bucle principal de este programa espera la entrada de una señal de onda cuadrada, producida por el generador de señales del StampWorks. Cuando se fija en 1 Hz, esta señal pasa de LOW (bajo) a HIGH (alto), una vez por segundo. Cuando se presenta la transición de bajo a alto, el contador de
Página 62 • Manual StampWorks Versión 1.1
Experimento 10: Reloj con Pantalla de LEDs segundos es actualizado. El operador de módulo (//) es usado para mantener los segundos en el rango de 0 a 3599 (rango de una hora). Cuando se actualiza el contador de segundos, se refresca la pantalla y luego el programa espera hasta que la señal de entrada pase a estado bajo, actualizando la pantalla durante la espera. Si el programa regresara al principio mientras la señal de entrada estuviese aún en estado alto, el contador de segundos podría actualizarse prematuramente, causando que el reloj corriera más rápido. Una vez que la señal de entrada pasa a estado bajo, el programa salta al principio, donde espera a la siguiente transición de bajo a alto del pulso del generador. Desafío Si se modifica la posición del punto decimal como se muestra a continuación, ¿qué sucederá? Modifique y descargue el programa para controlar su respuesta. segs = segs + (DPoint * time.Bit0)
' ilumina el punto decimal
Manual StampWorks Versión 1.1 • Página 63
Usando LCDs
Usando LCDs Si bien los LEDs y los displays de siete segmentos son muy buenos como dispositivos de salida, habrá proyectos que requerirán proveer información más compleja al usuario. Por supuesto, nada supera la pantalla de video de una PC, pero estos son grandes, caros y casi siempre imprácticos para concretar proyectos con microcontroladores. Los módulos LCD de caracteres por otro lado, son ideales para estas aplicaciones. Estos módulos económicos permiten imprimir salidas alfanuméricas, usando muy pocas líneas de E/S y muy poco esfuerzo del BASIC Stamp. Los módulos de caracteres LCD están disponibles en gran variedad de configuraciones: una línea, dos líneas y cuatro líneas, son los más comunes. También es variable el ancho de la pantalla, aunque normalmente es de 16 o 20 caracteres por línea.
Módulo LCD del StampWorks (2 líneas x 16 caracteres). Se puede bajar la hoja de datos desde www.parallaxinc.com. El módulo LCD del StampWorks se conecta a la plaqueta de laboratorio mediante una ficha IDC de 14 pines. La ficha tiene una traba para evitar que se conecte en sentido inverso.
Manual StampWorks Versión 1.1 • Página 65
Usando LCDs Inicialización El LCD de caracteres debe ser inicializado antes de comenzar a enviarle información. Los proyectos de este libro inicializan el LCD de acuerdo con la especificación del controlador Hitachi HD44780. El controlador Hitachi es el que se encuentra comúnmente y muchos otros controladores son compatibles con él. Modos de Operación Hay dos modos principales de operar con LCDs: enviar un caracter y enviar un comando. Cuando se envía un caracter, la línea RS está en estado alto y el dato enviado es interpretado como un caracter que debe ser mostrado en la posición actual del cursor. El caracter normalmente es enviado en código ASCII. También se pueden enviar caracteres no ASCII al LCD, así como también hasta ocho caracteres programables personalizados. Los comandos se envían al LCD luego de poner en estado bajo la línea RS. Hay varios comandos estándar para controlar y manipular la pantalla LCD. Clear Home Cursor Izq. Cursor Der. Display Izq. Display Der.
$01 $02 $10 $14 $18 $1C
Limpia el LCD y mueve el cursor a “home” o inicio Mueve el cursor a la primer posición de la primer línea Mueve el cursor a la izquierda Mueve el cursor a la derecha Desplaza todo el display a la izquierda Desplaza todo el display a la derecha
Conexión del LCD El LCD del StampWorks tiene un conector IDC de 14 pines en el extremo de su cable. Simplemente coloque la ficha sobre el puerto de conexión de LCD de la plaqueta y presiónela hasta que quede firmemente conectado.
Página 66 • Manual StampWorks Versión 1.1
Experimento 11: Demostración Básica con LCD
Experimento 11: Demostración Básica con LCD Este programa demuestra las bases del LCD poniendo a funcionar el módulo LCD del StampWorks. Nuevos Elementos/Comandos PBASIC: • • •
PULSOUT HighNib, LowNib ^ (operador OR Exclusiva)
Construcción del Circuito
' ' ' ' ' '
========================================================================= Archivo: LCDDEMO.BS2 Demostración Básica de LCD Ver 1.1 – Actualizado de acuerdo a las conexiones de LCD del BS2p =========================================================================
E RS LCDout
CON CON VAR
0 3 OutB
' pin habilitación LCD ' Selección registro (1 = carac.) ' datos de 4-bits del LCD
ClrLCD CrsrHm
CON CON
$01 $02
' limpia el LCD ' mueve el cursor a home
Manual StampWorks Versión 1.1 • Página 67
Experimento 11: Demostraciรณn Bรกsica con LCD CrsrLf CrsrRt DispLf DispRt DDRam
CON CON CON CON CON
$10 $14 $18 $1C $80
' ' ' ' '
mueve cursor a la izq. mueve cursor a la der. desplaza caracteres a la izq. desplaza caracteres a la der. control RAM de datos
char index
VAR VAR
Byte Byte
' caracter enviado al LCD ' contador del bucle
' ------------------------------------------------------------------------Msg
DATA
"El BASIC STAMP!",0
' mensaje pregrabado en EEPROM
' ------------------------------------------------------------------------Inicializar: DirL = %11111001 GOSUB LCDinit
' configura pines para el LCD ' inicializa LCD en modo 4-bits
' ------------------------------------------------------------------------Principal: char = ClrLCD GOSUB LCDcommand PAUSE 500 index = Msg ReadChar: READ index,char IF char = 0 THEN MsgDone GOSUB LCDwrite index = index + 1 GOTO ReadChar MsgDone: PAUSE 2000
' limpia el LCD ' obtiene direcciรณn EE del mensaje ' ' ' ' ' ' '
obtiene caracter de EEPROM si es 0, mensaje finalizado escribe el caracter apunta al siguiente caracter y lo obtiene mensaje completo espera 2 segundos
char = CrsrHm GOSUB LCDcommand
' mueve el cursor a home
char = %00001110 GOSUB LCDcommand
' enciende el cursor
PAUSE 500
Pรกgina 68 โ ข Manual StampWorks Versiรณn 1.1
Experimento 11: Demostración Básica con LCD char = CrsrRt FOR index = 1 TO 15 GOSUB LCDcommand PAUSE 150 NEXT
' mueve el cursor por la pantalla
FOR index = 14 TO 0 char = DDRam + index GOSUB LCDcommand PAUSE 150 NEXT
' regresa el cursor a una ' dirección específica
char = %00001101 GOSUB LCDcommand
' apaga el cursor, enciende blink
PAUSE 2000 char = %00001100 GOSUB LCDcommand FOR index = 1 TO 10 char = char ^ %00000100 GOSUB LCDcommand PAUSE 250 NEXT
' apaga blink
' invierte los bits
PAUSE 1000 FOR index = 1 TO 16 char = DispRt GOSUB LCDcommand PAUSE 100 NEXT PAUSE 1000 FOR index = 1 TO 16 char = DispLf GOSUB LCDcommand PAUSE 100 NEXT PAUSE 1000 GOTO Principal END
' desplaza la pantalla
' desplaza en sentido contrario
' repite todo
Manual StampWorks Versión 1.1 • Página 69
Experimento 11: Demostración Básica con LCD
' ------------------------------------------------------------------------LCDinit: PAUSE 500 LCDout = %0011 PULSOUT E,1 PAUSE 5 PULSOUT E,1 PULSOUT E,1 LCDout = %0010 PULSOUT E,1 char = %00001100 GOSUB LCDcommand char = %00000110 GOSUB LCDcommand RETURN LCDcommand: LOW RS LCDwrite: LCDout = char.HighNib PULSOUT E,1 LCDout = char.LowNib PULSOUT E,1 HIGH RS RETURN
' deja descansar el LCD ' modo de 8-bits
' modo de 4-bits ' enciende disp y configura
' ingresa modo comando ' salen los 4 bits altos ' pulso en línea Enable ' salen los 4 bits bajos ' regresa al modo caracter
Descripción del Programa Este es un programa muy simple que demuestra las funciones básicas de un LCD. El LCD es inicializado usando el modo de cuatro-bits de acuerdo con las especificaciones del controlador Hitachi HD44780. Este modo es usado para minimizar la cantidad de líneas de E/S del BASIC Stamp necesarias para controlar el LCD. Si bien es posible conectar y controlar el LCD con ocho líneas de datos, no se lograría una mejora notable en el rendimiento del programa y se necesitarían cuatro líneas más de E/S.
Página 70 • Manual StampWorks Versión 1.1
Experimento 11: Demostración Básica con LCD Las bases de la inicialización son apropiadas para la mayoría de las aplicaciones: • • • • •
Se enciende el display Se apaga el cursor Se deshabilita el parpadeo del display El cursor se incrementa automáticamente después de cada escritura El display no se desplaza
Con el uso de cuatro bits de datos, se necesitan dos ciclos de escritura para enviar un byte al LCD. Los modificadores de variables HighNib y LowNib del BASIC Stamp hacen que este proceso sea extremadamente fácil. Cada nibble se envía al LCD con un pulso en la línea E (habilitación) con PULSOUT. La demo comienza limpiando el LCD y mostrando un mensaje que ha sido almacenado con una instrucción DATA. Esta técnica de almacenar mensajes en la EEPROM es muy útil y hace que los programas sean fácilmente actualizables. En este programa, se escriben caracteres hasta que se encuentra un cero. Este método nos permite modificar la longitud de la cadena de texto, sin tener que preocuparnos por la configuración de un bucle FOR-NEXT. Una vez mostrado el mensaje, el cursor se envía al inicio (primera posición de la primera línea) y se enciende (aparece un cursor subrayado). El cursor se envía hacia adelante y hacia atrás por el LCD usando dos técnicas. La primera usa el comando “cursor a la derecha”. Para mover el cursor hacia atrás se optó por modificar manualmente su posición. Esta última técnica es necesaria en algunos LCD para poder brindar un formato preciso en la pantalla. Con el cursor nuevamente en el inicio, se lo apaga y se habilita la función blink (parpadeo). Blink hace que la posición actual del cursor alterne entre el caracter y un recuadro negro sólido. Esto puede ser útil para llamar la atención. Otra forma de llamar la atención es hacer parpadear la pantalla completa. Esto se logra invirtiendo el estado del bit de habilitación (enable). El operador OR exclusiva (^) simplifica esta tarea, debido a que la operación con un “1” invertirá el estado del bit (1 XOR 1 = 0, 0 XOR 1 = 1). Usando los comandos de desplazamiento de pantalla, se puede desplazar todo el texto fuera de la pantalla hacia la derecha y luego regresar. Esto demuestra que la pantalla en realidad es una ventana dentro de la memoria del LCD. Un método para sacar ventaja de esta memoria adicional es escribir mensajes fuera de la pantalla y luego desplazarlos hasta que estén visibles.
Manual StampWorks Versión 1.1 • Página 71
Experimento 12: Creando Caracteres en un LCD
Experimento 12: Creando Caracteres en un LCD Este programa demuestra cómo crear caracteres en un LCD, realizar animaciones y la inicialización del LCD en modo multi-línea. Construcción del Circuito Use el mismo circuito que en el Experimento 11. ' ' ' ' ' '
========================================================================= Archivo: LCDCHARS.BS2 Animación usando caracteres personalizados en LCD Ver 1.1 – Actualizado de acuerdo a las conexiones de LCD del BS2p =========================================================================
' pin habilitación LCD ' Selección registro (1 = carac.) ' datos de 4-bits del LCD
E
CON
0
RS LCDout
CON VAR
3 OutB
ClrLCD CrsrHm CrsrLf CrsrRt DispLf DispRt DDRam CGRam Line1 Line2
CON CON CON CON CON CON CON CON CON CON
$01 $02 $10 $14 $18 $1C $80 $40 $80 $C0
' ' ' ' ' ' ' '
limpia el LCD mueve el cursor a home mueve cursor a la izq. mueve cursor a la der. desplaza caracteres a la izq. desplaza caracteres a la der. control RAM de datos Caracter creado en RAM
char newChr index1 index2
VAR VAR VAR VAR
Byte Byte Byte Byte
' ' ' '
caracter caracter contador contador
enviado al LCD nuevo para animación de bucle de bucle
' ------------------------------------------------------------------------Msg1 Msg2
DATA DATA
"EL BASIC STAMP " " ES GENIAL! "
' mensaje pregrabado en EEPROM
Manual StampWorks Versión 1.1 • Página 73
Experimento 12: Creando Caracteres en un LCD CC0 CC1 CC2
DATA DATA DATA
$0E,$1F,$1C,$18,$1C,$1F,$0E,$00 $0E,$1F,$1F,$18,$1F,$1F,$0E,$00 $0E,$1F,$1F,$1F,$1F,$1F,$0E,$00
' caracter 0 ' caracter 1 ' caracter 2
' ------------------------------------------------------------------------Inicializar: DirL = %11111001
GOSUB LCDinit DLChars: char = CGRam GOSUB LCDcommand FOR index1 = CC0 TO (CC2 + 7) READ index1,char GOSUB LCDwrite NEXT
' configura pines para el LCD ' inicializa LCD en modo 4-bits
'descarga caracteres nuevos al LCD ' apunta al caracter creado en RAM ' prepara para escribir ' arma 3 caracteres ' obtiene byte de EEPROM ' lo pone en CG RAM del LCD
' ------------------------------------------------------------------------Principal: char = ClrLCD GOSUB LCDcommand PAUSE 250
' limpia el LCD
FOR index1 = 0 TO 15 READ (Msg1 + index1),char GOSUB LCDwrite NEXT
' obtiene mensaje de EEPROM ' lee un caracter ' lo escribe
PAUSE 2000
' espera 2 segundos
' Animaciรณn por reemplazo de caracteres FOR index1 = 0 TO 15 READ (Msg2 + index1),newChr FOR index2 = 0 TO 4 char = Line2 + index1 GOSUB LCDcommand LOOKUP index2,[2,1,0,1,newChr],char GOSUB LCDwrite PAUSE 50 NEXT NEXT
Pรกgina 74 โ ข Manual StampWorks Versiรณn 1.1
' ' ' '
cubre 16 caracteres obtiene letras del 2ยบ mensaje 5 caracteres en ciclo de animac. nuevo acceso a DDRAM
' escribe caracter de animaciรณn ' pausa entre caracteres
Experimento 12: Creando Caracteres en un LCD
PAUSE 1000 GOTO Principal END
' repite todo
' ------------------------------------------------------------------------LCDinit: PAUSE 500 LCDout = %0011 PULSOUT E,1 PAUSE 5 PULSOUT E,1 PULSOUT E,1 LCDout = %0010 PULSOUT E,1 char = %00101000 GOSUB LCDcommand char = %00001100 GOSUB LCDcommand char = %00000110 GOSUB LCDcommand RETURN LCDcommand: LOW RS LCDwrite: LCDout = char.HighNib PULSOUT E,1 LCDout = char.LowNib PULSOUT E,1 HIGH RS RETURN
' deja reposar el LCD ' modo de 8-bits
' modo de 4-bits ' modo multi-línea ' config. LCD ' config. LCD
' ingresa modo comando ' salen 4 bits altos ' pulso en línea Enable ' salen 4 bits bajos ' regresa a modo caracter
Manual StampWorks Versión 1.1 • Página 75
Experimento 12: Creando Caracteres en un LCD Descripción del Programa En este programa, el LCD es inicializado en modo multi-línea. Esto permitirá que las dos líneas del LCD de StampWorks muestren información. Con la pantalla inicializada, los caracteres nuevos son descargados en el LCD. El LCD tiene lugar para ocho caracteres definidos por el usuario. Los datos para estos caracteres se almacenan en el sector llamado CGRAM y deben ser descargados en el LCD después de encenderlo e inicializarlo (los caracteres definidos por el usuario se pierden al apagar el LCD). Cada caracter requiere ocho bytes de datos. El octavo byte normalmente es $00, debido a que es donde el cursor se posiciona, por debajo del caracter. La fuente estándar del LCD tiene 5 bits de ancho por 7 bits de alto. Puede crear caracteres personalizados de 8 bits de alto, pero la octava línea generalmente es reservada para el cursor de subrayado. Este es un ejemplo de la definición de un caracter personalizado:
La forma del caracter es determinada por los unos y ceros en los bytes de datos. Un uno en un bit de cierta posición, activará ese píxel; un cero lo apagará. Los patrones de bits de los caracteres personalizados se almacenan en la EEPROM del BASIC Stamp con instrucciones DATA. Para mover los patrones al LCD, el comando CGRam es ejecutado y los caracteres se escriben en la pantalla. Antes de poder usar los caracteres, el display debe regresar al modo “normal”. El método más común es limpiar la pantalla o enviar el cursor al inicio. Es interesante notar que el LCD entrega los patrones de bits de su memoria mientras actualiza el display. En aplicaciones avanzadas, la memoria CGRam puede ser actualizada mientras el programa se está ejecutando, para crear efectos de pantalla inusuales.
Página 76 • Manual StampWorks Versión 1.1
Experimento 12: Creando Caracteres en un LCD El corazón de este programa es el bucle de animación. Este código toma un caracter del segundo mensaje y luego muestra la secuencia de animación en la segunda línea del LCD. Una tabla LOOKUP es usada para llevar a cabo la secuencia de animación cíclica. Al final de la secuencia, se revela el nuevo caracter. Desafío Cree su propia secuencia de caracteres personalizados. Actualice la inicialización y el código de animación de acuerdo a sus propios caracteres.
Manual StampWorks Versión 1.1 • Página 77
Experimento 13: Leyendo la RAM del LCD
Experimento 13: Leyendo la RAM del LCD Este programa demuestra el uso del espacio CGRAM del LCD como memoria externa. Nuevos Elementos/Comandos PBASIC: •
InA, InB, InC, InD
Construcción del Circuito
' ' ' ' ' '
========================================================================= Archivo: LCDREAD.BS2 Use la RAM del LCD como memoria externa (64 bytes) Ver 1.1 – Actualizado según las conexiones de LCD del BS2p ========================================================================= 0 2 3 DirB OutB
pin habilitación LCD pin leer/escribir del LCD Selección registro (1 = carac.) dirección del puerto datos salida de 4-bits del LCD entrada de datos de 4-bits LCD
E RW RS LCDddir LCDout LCDin
CON CON CON VAR VAR VAR
InB
' ' ' ' ' '
ClrLCD CrsrHm
CON CON
$01 $02
' limpia el LCD ' mueve el cursor a home
Manual StampWorks Versión 1.1 • Página 79
Experimento 13: Leyendo la RAM del LCD CrsrLf CrsrRt DispLf DispRt DDRam CGRam
CON CON CON CON CON CON
$10 $14 $18 $1C $80 $40
' ' ' ' ' '
mueve cursor a la izq. mueve cursor a la der. desplaza caracteres a la izq. desplaza caracteres a la der. control RAM de datos Caracter creado en RAM
char addr index rVar tOut temp width
VAR VAR VAR VAR VAR VAR VAR
Byte Byte Byte Word Byte Word Nib
' ' ' ' ' ' '
caracter enviado al LCD dirección lectura/escritura contador de bucle número aleatorio valor de prueba a leer del LCD valor temporal ancho del número a mostrar
' ------------------------------------------------------------------------Inicializar: DirL = %11111101 GOSUB LCDinit
' configura pines para el LCD ' inicializa LCD en modo 4-bits
' ------------------------------------------------------------------------Principal: char = ClrLCD GOSUB LCDcommand FOR index = 0 TO 14 LOOKUP index,["ADDR=?? ???/???"],char GOSUB LCDwrite NEXT Loop: RANDOM rVar addr = rVar.LowByte & $3F tOut = rVar.HighByte
' limpia el LCD ' crea pantalla
' genera número aleatorio ' crea dirección (0 a 63) ' crea valor de prueba (0 a 255)
char = CGRam + addr GOSUB LCDcommand char = tOut GOSUB LCDwrite
' puntero de CGRAM
PAUSE 100
' espera y luego lo obtiene
Página 80 • Manual StampWorks Versión 1.1
' mueve el valor a CGRAM
Experimento 13: Leyendo la RAM del LCD char = CGRam + addr GOSUB LCDcommand GOSUB LCDread tIn = char
' puntero de CGRAM ' lee valor del LCD
' muestra resultados char = DDRam + 5 GOSUB LCDcommand temp = addr width = 2 GOSUB PutVal
' muestra dirección en posición 5
char = DDRam + 8 GOSUB LCDcommand temp = tOut width = 3 GOSUB PutVal
' muestra salida en posición 8
char = DDRam + 12 GOSUB LCDcommand temp = tIn width = 3 GOSUB PutVal
' muestra entrada en posición 12
PAUSE 1000 GOTO Loop END
' repite todo
' ------------------------------------------------------------------------PutVal: FOR index = (width - 1) TO 0 char = (temp DIG index) + 48 GOSUB LCDwrite NEXT RETURN LCDinit: PAUSE 500 LCDout= %0011 PULSOUT E,1 PAUSE 5 PULSOUT E,1
' muestra dígitos de izq. a der. ' convierte dígitos a ASCII ' pone dígito en display
' deja reposar el LCD ' modo de 8 bits
Manual StampWorks Versión 1.1 • Página 81
Experimento 13: Leyendo la RAM del LCD PULSOUT E,1 LCDout = %0010 PULSOUT E,1 char = %00001100 GOSUB LCDcommand char = %00000110 GOSUB LCDcommand RETURN LCDcommand: LOW RS LCDwrite: LCDout = char.HighNib PULSOUT E,1 LCDout = char.LowNib PULSOUT E,1 HIGH RS RETURN LCDread: HIGH RS HIGH RW LCDddir= %0000 HIGH E char.HighNib = LCDin LOW E HIGH E char.LowNib = LCDin LOW E LCDddir= %1111 LOW RW RETURN
Página 82 • Manual StampWorks Versión 1.1
' modo de 4-bits ' config. LCD ' config. LCD
' ingresa modo comando ' salen 4 bits altos ' pulso en línea Enable ' salen 4 bits bajos ' regresa a modo caracter
' comando de datos ' leer ' hace entradas líneas de datos ' obtiene 4 bits superiores ' obtiene 4 bits inferiores ' líneas de datos como salidas
Experimento 13: Leyendo la RAM del LCD Descripción del Programa Este programa demuestra la versatilidad de las líneas de E/S del BASIC Stamp y su capacidad para ser reconfiguradas en la mitad del programa. La escritura en el LCD se trató en los últimos dos experimentos. Para leer los datos, las líneas de E/S del BASIC Stamp deben ser reconfiguradas como entradas. Esto no representa un problema para el BASIC Stamp. Además de la reconfiguración de las líneas de E/S, para leer valores del LCD se requiere una línea de control adicional: RW. En la mayoría de los programas, ésta línea puede ser fijada en estado bajo, para poder escribir datos en el LCD. Para leer desde el LCD la línea RW se pone en estado alto. El programa genera datos y una dirección usando la función RANDOM. La dirección se mantiene en el rango de 0 a 63 poniendo una máscara en los bits más altos de LowByte que entrega la función RANDOM. HighByte representa el dato a ser guardado y leído del LCD. Los datos se almacenan en el área de CGRAM del LCD. Esto significa, en este programa, que la memoria CGRAM no puede ser usada para mostrar caracteres personalizados. En programas que requieran menos de ocho caracteres definidos por el usuario, los bytes restantes de la CGRAM pueden ser usados como memoria complementaria. Los datos se leen del LCD de la misma forma en que se escriben: se fija la dirección y se recuperan los datos. Para poder hacer esto, las líneas de datos del LCD deben ser reconfiguradas como entradas. Enviando pulsos en la línea E (habilitación) se logra que los datos (de a cuatro bits) estén disponibles para el BASIC Stamp. Nuevamente, se usan HighNib y LowNib, esta vez para armar un byte a partir de dos nibbles (paquetes de 4 bits) recibidos durante la operación de lectura. Cuando todo está listo, la dirección, los datos de salida y los datos de entrada se escriben en el LCD. La subrutina PutVal, se encarga de escribir valores numéricos en el LCD. Para usar esta subrutina, mueva el cursor a la posición deseada, coloque el valor a mostrar en temp, la cantidad de caracteres a mostrar en width, llamando luego a PutVal. La subrutina usa el operador DIG para extraer un dígito de temp y le suma 48 para convertirlo en ASCII de forma que pueda ser mostrado en el LCD.
Manual StampWorks Versión 1.1 • Página 83
Experimento 14: Juego de la Bola 8 Mágica
Experimento 14: Juego de la Bola 8 Mágica Este programa muestra la capacidad de mostrar fuentes de 8x10 del módulo LCD del StampWorks. De esta forma se pueden mostrar correctamente caracteres en minúscula que pasan por debajo del renglón (g, j, p, q e y). Nuevos Elementos/Comandos PBASIC: •
LOOKDOWN
Construcción del Circuito Agregue este pulsador al circuito del Experimento 11 (recuerde conectar LCD.RW a Vss).
' ' ' ' ' '
========================================================================= Archivo: LCD8BALL.BS2 Programa de la Bola 8 Mágica con BASIC Stamp y LCD Ver 1.1 – Actualizado de acuerdo con las conexiones de LCD del BS2p =========================================================================
E RS LCDout AskBtn
CON CON VAR CON
0 3 OutB 15
' ' ' '
pin habilitación LCD Selección registro (1 = carac.) datos salida de 4-bits del LCD pin del botón
ClrLCD CrsrHm
CON CON
$01 $02
' limpia el LCD ' mueve el cursor a home
Manual StampWorks Versión 1.1 • Página 85
Experimento 14: Juego de la Bola 8 Mágica CrsrLf CrsrRt DispLf DispRt DDRam CGRam
CON CON CON CON CON CON
$10 $14 $18 $1C $80 $40
' ' ' ' ' '
mueve cursor a la izq. mueve cursor a la der. desplaza caracteres a la izq. desplaza caracteres a la der. control RAM de datos Caracter creado en RAM
NumAns
CON
6
' 6 respuestas posibles
_g _j _p _q _y
CON CON CON CON CON
$E7 $EA $F0 $F1 $F9
' direcciones DDROM
char addr swData answer clock pntr
VAR VAR VAR VAR VAR VAR
Byte Byte Byte Nib Nib Nib
' ' ' ' ' '
caracter enviado al LCD dirección del mensaje variable para BUTTON puntero de respuesta reloj de animación puntero al caract. de animación
' ------------------------------------------------------------------------Prompt
DATA
"Pregunte",0
Ans0 Ans1 Ans2 Ans3 Ans4 Ans5
DATA DATA DATA DATA DATA DATA
"Seguro que SI",0 "Posible...",0 "Rotundamente NO",0 "No es seguro...",0 "No se...",0 "Tal vez...",0
' ------------------------------------------------------------------------Inicializar: DirL = %11111001 GOSUB LCDinit
' configura pines para el LCD ' inicializa LCD en modo 4-bits
' ------------------------------------------------------------------------Principal: char = ClrLCD
Página 86 • Manual StampWorks Versión 1.1
' limpia el LCD
Experimento 14: Juego de la Bola 8 Mágica GOSUB LCDcommand addr = Prompt GOSUB ShowMsg
' muestra cursor
Rollem: GOSUB Shuffle ' Mezcla hasta que se presiona PAUSE 5 ‘ el botón BUTTON AskBtn,0,255,10,swData,1,ShowAnswer GOTO Rollem ShowAnswer: ' obtener dirección de mensaje de respuesta LOOKUP answer,[Ans0,Ans1,Ans2,Ans3,Ans4,Ans5],addr char = ClrLCD GOSUB LCDcommand GOSUB ShowMsg PAUSE 2000 GOTO Principal END
' tiempo para leer respuesta ' repite todo
' ------------------------------------------------------------------------LCDinit: PAUSE 500 LCDout= %0011 PULSOUT E,1 PAUSE 5 PULSOUT E,1 PULSOUT E,1 LCDout = %0010 PULSOUT E,1 char = %00100100 GOSUB LCDcommand char = %00001100 GOSUB LCDcommand char = %00000110 GOSUB LCDcommand RETURN LCDcommand: LOW RS
' deja reposar el LCD ' modo de 8 bits
' modo de 4-bits ' selec. fuente 5x10 ' config. LCD ' config. LCD
' ingresa modo comando
Manual StampWorks Versión 1.1 • Página 87
Experimento 14: Juego de la Bola 8 Mágica
LCDwrite: LCDout = char.HighNib PULSOUT E,1 LCDout = char.LowNib PULSOUT E,1 HIGH RS RETURN ShowMsg: READ addr,char IF char = 0 THEN MsgDone GOSUB Translate GOSUB LCDwrite addr = addr + 1 GOTO ShowMsg MsgDone: RETURN
' salen 4 bits altos ' pulso en línea Enable ' salen 4 bits bajos ' regresa a modo caracter
' ' ' ' '
lee un caracter si es 0, mensaje listo cambia letras bajo renglón escribe el caracter apunta al caracter siguiente
' cambia las letras minúsculas que pasan por debajo del renglón ' – no modifica otros caracteres Translate: LOOKDOWN char,["g","j","q","p","y"],char LOOKUP char,[_g,_j,_q,_p,_y],char RETURN Shuffle: answer = answer + 1 // NumAns clock = clock + 1 // 15 IF (clock > 0) THEN ShuffleDone char = DDRam + 15 GOSUB LCDcommand LOOKUP pntr,["-+|*"],char GOSUB LCDwrite pntr = pntr + 1 // 4 ShuffleDone: RETURN
Página 88 • Manual StampWorks Versión 1.1
' ' ' '
actualiza puntero de respuesta actualiza puntero de reloj tiempo para actualiz. animación? si, escribe en pos. 15
' carga caracter de animación ' lo escribe ' actualiza caracter de animación
Experimento 14: Juego de la Bola 8 Mágica Descripción del Programa Las fuentes comunes de 5x7 de LCD deforman mucho las letras que tienen partes que pasan por debajo del renglón (g, j, p, q e y). Estas fuentes cortan o aplastan estos caracteres al mostrarlos en la pantalla. Muchos LCDs soportan fuentes de caracteres de 5x10 logrando que ninguna letra luzca deformada. Usar la fuente de 5x10 es muy simple; se requiere un solo comando adicional en la secuencia de inicialización. Para que estos caracteres especiales se vean correctamente sin embargo, hay que hacer un pequeño truco debido a que fueron mapeados con un desplazamiento con respecto a los demás caracteres ASCII. Por suerte, el BASIC Stamp tiene un par de comandos para manejo de tablas que simplifican el proceso de transformación. Después de la inicialización, se limpia la pantalla y se le indica al usuario que piense una pregunta. La subrutina ShowMsg muestra un mensaje en la posición actual del cursor. El mensaje es almacenado en una instrucción DATA y pasado a la subrutina por su dirección de EEPROM. ShowMsg lee los caracteres de la EEPROM hasta que encuentra un cero, pasando cada caracter a la subrutina Translate, que redibuja el valor ASCII para los caracteres especiales. Translate usa un truco astuto con LOOKUP y LOOKDOWN. Cuando se pasa un caracter a Translate, es comparado con la lista de caracteres especiales. Si el caracter está en la lista, es convertido a un valor que será usado por LOOKUP para rediseñar el caracter para que se vea correctamente en el LCD. Si el caracter no está en la lista, pasará a través de Translate sin ser afectado. El bucle principal del programa espera a que presione un botón, creando una respuesta aleatoria al llamar continuamente a la subrutina Shuffle. Shuffle actualiza la variable de respuesta y crea una animación. La animación es creada con caracteres comunes y se actualiza cada 15 pasadas por la subrutina Shuffle. Cuando finalmente se presiona el botón, la dirección de la EEPROM de la respuesta correspondiente es cargada con LOOKUP y la respuesta “mágica” es mostrada. Desafío Cree caracteres personalizados que usen el modo de fuente de 5x10. Nota: se deben usar 16 bytes por cada caracter, incluso aunque se muestren solamente 10. Vea LCD8BAL2.BS2 como ejemplo.
Manual StampWorks Versión 1.1 • Página 89
Avanzando
Avanzando Las primeras tres secciones de este manual trataron específicamente con dispositivos de salida, debido a que estos son críticos para el éxito de un proyecto. Hasta ahora, debería sentirse cómodo empleando LEDs, displays de 7 segmentos y LCDs. A partir de este momento presentaremos una variedad de experimentos, algunos simples y otros no tanto, que completarán su educación como programador del BASIC Stamp y le darán la confianza que necesita para desarrollar sus propias aplicaciones con el BASIC Stamp. Recuerde que la clave del éxito es completar cada experimento con su correspondiente desafío. Luego, avance planteando sus propios desafíos. Cada vez que modifique un programa aprenderá algo. Es normal que sus experimentos no funcionen como se esperaba, debido a que aún está aprendiendo.
Manual StampWorks Versión 1.1 • Página 91
Experimento 15: Filtrando Múltiples Entradas
Experimento 15: Filtrando Múltiples Entradas El experimento le enseñará cómo eliminar el rebote en múltiples entradas del BASIC Stamp. Con alguna modificación, se puede eliminar el rebote de cualquier número de entradas (entre 2 y 16), con este código. Nuevos Elementos/Comandos PBASIC: • • •
~ (operador de complemento a 1) CLS (modificador de DEBUG) IBIN, IBIN1 – IBIN16 (modificadores de DEBUG)
Construcción del Circuito
' ' ' ' '
========================================================================= Archivo: DEBOUNCE.BS2 Eliminación simultánea del rebote en múltiples entradas. =========================================================================
Manual StampWorks Versión 1.1 • Página 93
Experimento 15: Filtrando Múltiples Entradas SwIn swtches x
VAR VAR VAR
InA Nib Nib
' entradas pines 0 - 3 ' entradas sin rebote ' contador del bucle
' ------------------------------------------------------------------------Principal: GOSUB GetSwitches DEBUG CLS, IBIN4 swtches PAUSE 100 GOTO Principal END
' ' ' '
obtiene entradas sin rebote muestra en modo binario pausa entre lecturas repite todo
' ------------------------------------------------------------------------GetSwitches: swtches = %1111 FOR x = 1 TO 10 swtches = swtches & ~SwIn PAUSE 5 NEXT RETURN
' habilita las 4 entradas ' controla las entradas ' pausa entre controles
Descripción del Programa Cuando se quiere filtrar el rebote en una sola entrada, la función BUTTON del BASIC Stamp funciona perfectamente e incluso agrega un par de características bastante útiles (como auto repetir). Para filtrar el rebote de dos o más entradas, necesitamos crear un poco de código. El trabajo de este experimento lo realiza la subrutina GetSwitches. Como se muestra, funciona para cuatro entradas. Puede ser modificada para cualquier cantidad de entradas entre 2 y 16. El propósito de GetSwitches es asegurarse que las entradas están estables durante 50 milisegundos. El estado de las entradas es almacenado en la variable switches, equivaliendo un 1 a una entrada activada en el interruptor de esa posición. La rutina GetSwitches comienza asumiendo que todos los interruptores de entrada están presionados, poniendo todos los bits en uno. Luego, usando un bucle FOR-NEXT, se controlan las entradas y se comparan con el estado anterior. Dado que las entradas son activo bajas (cero cuando se presiona), el operador de complemento a uno (~) las invierte. El operador And (&) es usado para actualizar el estado actual. Para que un interruptor sea detectado, debe permanecer presionado durante todo el bucle FOR-NEXT.
Página 94 • Manual StampWorks Versión 1.1
Experimento 15: Filtrando Múltiples Entradas Así es como funciona la técnica para eliminar el rebote: cuando se presiona un interruptor, la entrada del BASIC Stamp será cero. El operador de complemento a uno invertirá este valor. Uno “&” uno, sigue siendo uno, así que el interruptor sigue figurando como presionado. Si no se presiona el interruptor, la entrada del BASIC Stamp será uno (debido a la resistencia de pull-up de 10K a Vdd). El uno es invertido y convertido en cero. Cero “&” cualquier otro número es cero y hará que el interruptor figure como no presionado durante todo el resto del ciclo. El filtrado del rebote de las entradas es mostrado en la ventana DEBUG con el modificador IBIN4 para lograr distinguir claramente el estado de cada interruptor de entrada. Desafío Modifique el programa para que elimine el rebote y muestre el estado de ocho interruptores.
Manual StampWorks Versión 1.1 • Página 95
Experimento 16: Contando Eventos
Experimento 16: Contando Eventos Este experimento demuestra un retardo programado por eventos externos. Construcción del Circuito
' ' ' ' ‘ '
========================================================================= Archivo: COUNTER.BS2 Retarda la ejecución del programa al esperar por una cantidad específica de eventos =========================================================================
E_in
VAR
In15
' pin de entrada de eventos
IsLow IsHigh Target
CON CON CON
0 1 1000
' cantidad final
eCount
VAR
Word
' contador de eventos
' ------------------------------------------------------------------------Principal: eCount = 0 DEBUG "Iniciado... ", CR GOSUB WaitForCount DEBUG "Cuenta completa." END
' limpia el contador ' espera por 1000 pulsos
' ------------------------------------------------------------------------WaitForCount: IF E_in = IsLow THEN WaitForCount ' espera que la ent. pase a alto eCount = eCount + 1 ' incrementa el cont. de eventos DEBUG Home, 10, "Cuenta = ", DEC eCount, CR IF eCount = Target THEN WaitDone ' compara con la cantidad final
Manual StampWorks Versión 1.1 • Página 97
Experimento 16: Contando Eventos WaitLow: IF E_in = IsHigh THEN WaitLow GOTO WaitForCount WaitDone: RETURN
' espera que la ent. pase a bajo
Descripción del Programa El propósito de la subrutina WaitForCount es hacer que el programa espere durante una cantidad específica de eventos. En una aplicación industrial por ejemplo, un sistema de empaque puede tener que hacer funcionar la cinta transportadora hasta que pasen 100 cajas. Cuando el programa pasa a WaitForCount, se controlan las transiciones de bajo a alto en el pin de entrada. Cuando la línea pasa a alto, el contador es incrementado y el programa espera hasta que la línea regresa a estado bajo. Cuando esto sucede, el código se repite buscando la siguiente transición ascendente. Cuando se alcanza el valor final, la subrutina regresa al programa principal. El tiempo que tarda la subrutina es determinado por la velocidad de los eventos externos. Observe que la subrutina espera una entrada limpia. Una entrada ruidosa podría causar una cuenta errónea, anticipando el fin de la subrutina. Un método para tratar una entrada ruidosa (cuando se conoce de antemano el tiempo estimado entre eventos) es agregar una instrucción PAUSE inmediatamente después de cada evento. La idea es hacer una pausa desde que se produce el evento y finalizarla justo antes de que se produzca el próximo. El código que sigue funciona correctamente cuando los eventos duran aproximadamente medio segundo y están separados entre sí por 2 segundos: WaitForCount: IF P_in = IsLow THEN WaitForCount ' espera un pulso en alto pCount = pCount + 1 ' incrementa contador DEBUG Home, 10, "Cuenta = ", DEC eCount, CR IF pCount = Target THEN WaitDone ' controla con valor final PAUSE 1500 ' limpia entrada ruidosa WaitLow: IF P_in = IsHigh THEN WaitLow ' espera a que pase a estado bajo GOTO WaitForCount WaitDone: RETURN
Página 98 • Manual StampWorks Versión 1.1
Experimento 17: Medición de Frecuencia
Experimento 17: Medición de Frecuencia Este experimento determina la frecuencia de un tren de pulsos usando la función COUNT del BASIC Stamp. Nuevos Elementos/Comandos PBASIC: •
COUNT
Construcción del Circuito (Note que el esquema NO es chip-céntrico)
' ' ' ' '
========================================================================= Archivo: FREQ1.BS2 Cuenta y muestra la frecuencia de los pulsos que entran por el Pin 0 =========================================================================
F_in
CON
0
' pin de entrada de pulsos
freq
VAR
Word
' frecuencia
' -------------------------------------------------------------------------
Manual StampWorks Versión 1.1 • Página 99
Experimento 17: Medición de Frecuencia
Principal: COUNT F_in, 1000, freq
' cuenta pulsos durante 1 segundo
' muestra en la pantalla DEBUG DEBUG CLS, "Frecuencia: ", DEC freq, " Hz" GOTO Principal END
' repite todo
Descripción del Programa En el experimento anterior, se usaron varias líneas de código para contar pulsos en un pin de entrada. Ese método es útil cuando se cuenta hasta un valor específico. Otros programas necesitan contar la cantidad de pulsos que arriban durante un período de tiempo específico. La función COUNT del BASIC Stamp fue diseñada para este propósito. La frecuencia de una señal oscilatoria representa la cantidad de ciclos por segundo y se expresa en Hertz. La función COUNT del BASIC Stamp controla el pin especificado durante la cantidad de tiempo dada. Para obtener la medición de frecuencia, se especificó un tiempo de 1000 milisegundos (un segundo). Desafío Mejore la respuesta (que se actualice más frecuentemente) de este programa modificando el período de COUNT. ¿Qué otro ajuste debe realizarse? ¿Cómo afecta este cambio la capacidad de medir señales de frecuencias muy bajas?
Página 100 • Manual StampWorks Versión 1.1
Experimento 18: Medición Avanzada de Frecuencia
Experimento 18: Medición Avanzada de Frecuencia Este experimento usa PULSIN para crear un frecuencímetro de respuesta rápida. Nuevos Elementos/Comandos PBASIC: •
PULSIN
Construcción del Circuito Use el mismo circuito del Experimento 17. ' ' ' ' ' ' '
========================================================================= Archivo: FREQ2.BS2 Muestra la frecuencia de los pulsos que entran por Pin 0 {$STAMP BS2} =========================================================================
F_pin
CON
0
' pin de entrada de frecuencia
pHigh pLow period freq
VAR VAR VAR VAR
Word Word Word Word
' ' ' '
ancho de pulso alto ancho de pulso bajo período (alto+bajo) frecuencia
' ------------------------------------------------------------------------Principal: PULSIN F_pin, 0, pHigh PULSIN F_pin, 1, pLow period = pHigh + pLow freq = 50000 / period * 10
' ' ' '
obtiene obtiene calcula calcula
parte alta de la entrada parte baja de la entrada el período la frecuencia
' muestra en la pantalla DEBUG DEBUG Home DEBUG "Período...... ", DEC period * 2, " uS DEBUG "Frecuencia... ", DEC freq, " Hz "
", CR
Manual StampWorks Versión 1.1 • Página 101
Experimento 18: Medición Avanzada de Frecuencia GOTO Principal END
' repite todo
Descripción del Programa En el último experimento, aprendió que la frecuencia de una señal se define como la cantidad de ciclos por segundo. Creó un frecuencímetro simple contando la cantidad de pulsos (ciclos) durante un segundo. Este método funciona bien, especialmente para señales de baja frecuencia. Habrá veces sin embargo, que un proyecto necesitará una respuesta más rápida en la medición de frecuencia. La frecuencia de una señal puede ser calculada a partir de su período, o el tiempo de un ciclo completo.
Midiendo el período de una señal entrante, su frecuencia puede ser calculada con la ecuación (donde el período es expresado en segundos): frecuencia = 1 / período La función PULSIN del BASIC Stamp está diseñada para medir el ancho de un pulso entrante. Usando PULSIN para medir las partes en estado alto y bajo de la señal, se pueden determinar el período y la frecuencia. El resultado de PULSIN está expresado en unidades de 2 microsegundos. Así, la fórmula para calcular la frecuencia sería: frecuencia = 500.000 / período Esto representa un inconveniente algebraico para el BASIC Stamp porque solamente puede realizar cálculos con números de 16-bits (el valor máximo es 65.535). Para corregir la fórmula, convertimos 500.000 en 50.000 x 10 y la rescribimos así frecuencia = 50.000 / período * 10 Ejecute el programa y ajuste el potenciómetro de 10K. Observe que la pantalla DEBUG se actualiza sin demoras y que no hay “saltos” como cuando usó COUNT para determinar la frecuencia.
Página 102 • Manual StampWorks Versión 1.1
Experimento 19: Theremin Controlado por Luz
Experimento 19 Theremin Controlado por Luz Este experimento demuestra el uso de FREQOUT creando un Theremin (primer instrumento musical electrรณnico que se produjo) controlado por luz. Construcciรณn del Circuito
' ' ' ' ' ' '
========================================================================= Archivo: THEREMIN.BS2 Usa RCTIME con una LDR para crear un a Theremin controlado por luz {$STAMP BS2} =========================================================================
Speaker Sensor
CON CON
0 1
' salida del piezo ' entrada del sensor (RCTIME)
Threshold
CON
200
' frecuencia de corte
tone
VAR
Word
' frecuencia de salida
' ------------------------------------------------------------------------Principal: HIGH Sensor PAUSE 1
' descarga el cap. ' durante 1 ms
Manual StampWorks Versiรณn 1.1 โ ข Pรกgina 103
Experimento 19: Theremin Controlado por Luz RCTIME Sensor,1,tone IF (tone < Threshold) THEN Principal FREQOUT Speaker,20,tone GOTO Principal END
' lee el sensor de luz ' saltea por luz ambiental ' toca el tono
Descripción del Programa Un Theremin es un dispositivo musical interesante usado para crear esos sonidos escalofriantes que se escuchan en las películas de terror antiguas. Esta versión usa la luz incidente en un Fotorresistor para crear el tono de salida. Dado que el Fotorresistor es un dispositivo resistivo, RCTIME puede usarse para leer su valor. FREQOUT se usa para emitir el sonido. La constante Threshold, se usa para controlar el punto de corte del Theremin. Cuando la lectura del Fotorresistor cae por debajo de este valor, no se emite ningún sonido. Este valor podría ajustarse para que el Theremin deje de tocar cuando el fotoresistor recibe la luz ambiente en forma directa. Desafío Agregue un segundo circuito RC usando un potenciómetro de 10K en lugar de un fotoresistor. Use este circuito para ajustar el valor de corte para condiciones de iluminación variables.
Página 104 • Manual StampWorks Versión 1.1
Experimento 20: Efectos de Sonido
Experimento 20 Efectos de Sonido Este experimento usa FREQOUT y DTMFOUT para crear efectos de sonido de teléfono. Nuevos Elementos/Comandos PBASIC: •
DTMFOUT
Construcción del Circuito
' ' ' ' ' ' '
========================================================================= Archivo: PHONE.BS2 Usa FREQOUT y DTMFOUT para crear (US) sonidos telefónicos {$STAMP BS2} =========================================================================
Speaker
CON
0
' piezo en pin 0
R C Cs D E F G Gs A As B
CON CON CON CON CON CON CON CON CON CON CON
0 33 35 39 41 44 49 52 55 58 62
' ' ' ' ' ' ' ' ' ' '
silencio ideal es ideal es ideal es ideal es ideal es ideal es ideal es ideal es ideal es ideal es
32.703 34.648 38.891 41.203 46.249 48.999 51.913 55.000 58.270 61.735
Manual StampWorks Versión 1.1 • Página 105
Experimento 20: Efectos de Sonido N1 N2 N3 N4 N8
CON CON CON CON CON
500 N1/2 N1/3 N1/4 N1/8
' ' ' ' '
duración nota completa media nota un tercio de nota un cuarto de nota un octavo de nota
x note octave dur
VAR VAR VAR VAR
Byte Word Nib Word
' ' ' '
contador del bucle nota a tocar octava de la nota (1 - 7) longitud de la nota
' ------------------------------------------------------------------------Principal: DEBUG CLS, "Sonidos Telefónicos", CR, CR Dial_Tone: DEBUG "Tono de Marcado", CR FREQOUT Speaker,35,35 PAUSE 100 FREQOUT Speaker,2000,350,440
' "clic" ' combina 350 Hz y 440 Hz
Dial_Number: DEBUG "Llamando a Parallax (916-624-8333)", CR DTMFOUT Speaker,[9,1,6,6,2,4,8,3,3,3] PAUSE 500 Phone_Busy: DEBUG "Señal de Ocupado", CR FOR x = 1 TO 6 FREQOUT Speaker,400,480,620 PAUSE 620 NEXT FREQOUT Speaker,35,35 PAUSE 1000 Dial_Number2: DEBUG "Llamando otra vez", CR DTMFOUT Speaker,[9,1,6,6,2,4,8,3,3,3] PAUSE 500 Phone_Rings: DEBUG "Llamando", CR FOR x = 1 TO 2
Página 106 • Manual StampWorks Versión 1.1
' combina 480 Hz y 620 Hz ' "clic"
Experimento 20: Efectos de Sonido FREQOUT Speaker,2000,440,480 PAUSE 4000 NEXT
' combina 440 Hz y 480 Hz
Play_Song: DEBUG "Pequeña melodía", CR FOR x = 0 TO 7 LOOKUP x,[ G, G, E, G, A, G, E, R],note LOOKUP x,[ 4, 4, 4, 4, 4, 4, 4, 1],octave LOOKUP x,[N2,N2,N2,N2,N2,N2,N1,N8],dur GOSUB PlayNote NEXT END ' ------------------------------------------------------------------------PlayNote: note = note << (octave-1) FREQOUT Speaker,dur,note RETURN
' frecuencia de nota + octava ' emite sonido
Descripción del Programa Con un poco de creatividad en la programación, el BASIC Stamp puede emitir unos efectos de sonido muy interesantes. Dado que la mayoría de los sonidos que escuchamos en el teléfono (que no sean de voz) son generados con dos tonos, las funciones FREQOUT y DTMFOUT del BASIC Stamp pueden ser usadas para generarlos. DTMFOUT en realidad es una versión especializada de FREQOUT. Su propósito es tocar los tonos
dobles que se requieren para marcar números telefónicos. En lugar de escribir el tono (o tonos), directamente se usan los números a ser marcados. En verdaderas aplicaciones de marcado, la duración y la separación de los tonos del DTMF puede ser especificada, para ajustarse a la calidad de la línea telefónica.
Este programa también presenta la habilidad musical básica del BASIC Stamp tocando una pequeña melodía. Las constantes con las frecuencias de las notas (primer octava) y las duraciones, simplifican el código operacional. La subrutina PlayNote ajusta la frecuencia de la nota para la octava especificada. La calidad musical puede verse afectada para octavas más altas debido a errores de redondeo. Usando los valores ideales que se muestran, la tabla de constantes puede ser expandida
Manual StampWorks Versión 1.1 • Página 107
Experimento 20: Efectos de Sonido para obtener notas musicales precisas. Tenga en cuenta que cada octava duplica la frecuencia de una nota. Octava 2 = Octava 1 * 2 Octava 3 = Octava 2 * 2 Octava 4 = Octava 3 * 2 Y así… Desafío Convierta (una parte de) su canción favorita para que suene en el BASIC Stamp.
Página 108 • Manual StampWorks Versión 1.1
Experimento 21: Entrada Analógica con PULSIN
Experimento 21 Entrada Analógica con PULSIN Este experimento lee el valor de un componente resistivo usando PULSIN y un oscilador. Construcción del Circuito (Note que el esquema NO es chip-céntrico)
' ' ' ' ' ' '
========================================================================= Archivo: A2D.BS2 Lee componente resistivo con filtro digital {$STAMP BS2} =========================================================================
P_pin
CON
0
' pin de entrada de pulso
P75 P50 P25
CON CON CON
$00C0 $0080 $0040
' 0.75 ' 0.50 ' 0.25
rValue sValue
VAR VAR
Word Word
' valor directo ' valor suavizado
' -------------------------------------------------------------------------
Manual StampWorks Versión 1.1 • Página 109
Experimento 21: Entrada Analógica con PULSIN Principal: PULSIN P_pin, 1, rValue
' obtiene parte estado bajo
sValue = (rValue */ P25) + (sValue */ P75) DEBUG Home DEBUG "Valor directo... ", DEC rValue, " DEBUG "Valor filtrado.. ", DEC sValue, " GOTO Principal END
", CR " ' repite
Descripción del Programa En este experimento, el 555 es configurado como un oscilador. Analizando la salida, el ancho de la porción de estado bajo es controlado por el valor de la resistencia del fotoresistor. Midiendo la parte baja de la señal de salida del 555 con PULSIN, el BASIC Stamp es capaz de determinar el valor relativo del fotoresistor. Una vez que el valor directo está disponible, podemos sumar una parte de éste al valor digitalmente filtrado anterior (método iterativo) para obtener un valor suavizado. La relación entre lectura directa sobre filtrada de esta ecuación, determinará la respuesta del filtro. A mayor porcentaje de valor directo, más rápidos son los cambios. Desafío Cree un valor de salida final que esté afectado por un factor de escala, de forma que el rango de salida sea de cero a 1000.
Página 110 • Manual StampWorks Versión 1.1
Experimento 22: Salida Analógica con PWM
Experimento 22: Salida Analógica con PWM Este programa muestra como crear una salida de tensión variable con PWM. Nuevos Elementos/Comandos PBASIC: •
PWM
Construcción del Circuito
Note que este circuito requiere 12V. El único lugar donde podrá obtener 12V en la plaqueta NX-1000 es desde el tornillo del terminal +V, en el sector de alta corriente que se encuentra en la esquina inferior derecha. ' ' ' ' ' ' '
========================================================================= Archivo: THROB.BS2 Cambia el brillo de un LED usando PWM {$STAMP BS2} =========================================================================
D2Aout
CON
0
' pin de salida analógica
level
VAR
Byte
' nivel analógico
' -------------------------------------------------------------------------
Manual StampWorks Versión 1.1 • Página 111
Experimento 22: Salida Analógica con PWM
Principal: FOR level = 0 TO 255 PWM D2Aout,level,25 NEXT
' aumenta la tensión del LED
PAUSE 100 FOR level = 255 TO 0 PWM D2Aout,level,25 NEXT
' disminuye la tensión del LED
GOTO Principal END
' repite
Descripción del Programa Mientras que en la mayoría de las aplicaciones el BASIC Stamp trabajará con señales digitales, en algunas necesitarán una salida analógica; una tensión variable entre cero y algún valor máximo. La función PWM del BASIC Stamp está diseñada para generar tensiones analógicas cuando se combina con un filtro RC. La función PWM genera una serie de pulsos que tienen una relación de tiempo de encendido y apagado programable (ciclo de trabajo). A mayor ciclo de trabajo, mayor tensión de salida. Un ciclo de trabajo de 255 cargará al capacitor con 5 volts. En este experimento, se usa medio LM358 como fuente de tensión para el LED. El op-amp (amplificador operacional) evita que el capacitor se descargue rápidamente bajo condiciones de trabajo. El brillo del LED varía debido a que la caída de tensión sobre el resistor que está en serie, modifica la corriente que circula a través del LED. Observe que el LED se enciende en forma cada vez más brillante y luego, se oscurece hasta apagarse. Esto sucede cuando la salida del LM358 cruza el umbral de tensión de polarización directa (la tensión mínima para que el LED se ilumine) del LED (aproximadamente 1,5 volts). Usando el Multímetro digital, controle la tensión del Pin 1 del LM358.
Página 112 • Manual StampWorks Versión 1.1
Experimento 23: Expandiendo Salidas
Experimento 23: Expandiendo Salidas Este experimento demuestra cómo expandir las salidas del BASIC Stamp con un simple registro de desplazamiento. Se emplean tres líneas para controlar ocho LEDs con un registro de desplazamiento 74x595. Nuevos Elementos/Comandos PBASIC: •
SHIFTOUT
Construcción del Circuito (Note que el esquema NO es chip-céntrico)
Manual StampWorks Versión 1.1 • Página 113
Experimento 23: Expandiendo Salidas
' ' ' ' '
========================================================================= Archivo: 74x595.BS2 Use tres líneas para controlar 8 con un registro de desplazamiento 74x595 =========================================================================
D_out Clock Latch
CON CON CON
0 1 2
DlyTm
CON
100
pattern
VAR
Byte
' salida serial (74x595.14) ' reloj de desp. (74x595.11) ' salida de latch (74x595.12)
' patrón de salida
' ------------------------------------------------------------------------Inicializar: LOW Latch pattern = %00000001
' salida en estado bajo
' ------------------------------------------------------------------------Adelante: GOSUB Out595 PAUSE DlyTm pattern = pattern << 1 IF pattern = %10000000 THEN Atras GOTO Adelante
' ' ' '
pone patrón en 74x595 desplaza patrón a la izq. comprueba posición final continua en esta dirección
Atras: GOSUB Out595 PAUSE DlyTm pattern = pattern >> 1 IF pattern = %00000001 THEN Adelante GOTO Atras END ' ------------------------------------------------------------------------Out595: SHIFTOUT D_out,Clock,MSBFirst,[pattern] PULSOUT Latch,3 RETURN
Página 114 • Manual StampWorks Versión 1.1
' envía patrón al 74x595 ' bloquea (latch) las salidas
Experimento 23: Expandiendo Salidas Descripción del Programa El BASIC Stamp es extraordinariamente flexible en su habilidad para redefinir la dirección (entrada o salida) de sus pines de E/S, aunque muy pocas aplicaciones requieren tanta flexibilidad. La mayoría de las aplicaciones de microcontroladores definirán los pines como entradas o salidas en la inicialización y esta definición quedará sin cambios durante el resto del programa. Si hay líneas que solamente se usarán como salidas podemos ahorrar líneas de E/S del BASIC Stamp usando un componente simple llamado registro de desplazamiento de entrada serial, salida paralelo. En este experimento se usó el 74x595. Con solamente tres líneas del BASIC Stamp, este programa es capaz de controlar ocho LEDs a través del 74x595. El 74x595 convierte una cadena de datos seriales sincrónicos en ocho salidas paralelas. Los datos seriales sincrónicos tienen en realidad dos componentes: los datos seriales y el reloj (clock) serial. El comando SHIFTOUT del BASIC Stamp se encarga de los detalles de las líneas de datos y reloj, escribiendo los datos en un dispositivo sincrónico, en este caso 74x595. Con el 74x595, los datos deben ser bloqueados (latch) en las salidas después del proceso de desplazamiento. El bloqueo se realiza enviando un breve pulso por la línea de control de Latch. Esto evita que las salidas se modifiquen a medida que datos nuevos son cargados “. Como dispositivos seriales, los registros de desplazamiento pueden ser conectados en cascada. De esta forma el BASIC Stamp es capaz de controlar docenas de salidas de varios 74x595s con las mismas tres líneas de control. Para conectar varios 74x595s en cascada, las líneas de reloj y de latch se conectan juntas y la salida de SQ de una etapa se conecta a la entrada serial de la siguiente. Desafío Conecte un segundo 74x595 al primero de forma que las mismas tres líneas del BASIC Stamp puedan controlar 16 salidas.
Manual StampWorks Versión 1.1 • Página 115
Experimento 24: Expandiendo Entradas
Experimento 24: Expandiendo Entradas Este experimento demuestra la expansión de entradas del BASIC Stamp con un registro de desplazamiento. Tres líneas se usan para leer un DIP-switch de ocho posiciones. Nuevos Elementos/Comandos PBASIC: •
SHIFTIN
Construcción del Circuito (Note que el esquema NO es chip-céntrico)
Manual StampWorks Versión 1.1 • Página 117
Experimento 24: Expandiendo Entradas ' ' ' ' '
========================================================================= Archivo: 74x165.BS2 Lea 8 interruptores usando solamente 3 líneas y un registro de desp. 74x165 =========================================================================
D_in Clock Load
CON CON CON
0 3 4
' desplazam. datos (74x165.7) ' reloj (74x165.2) ' carga de entrada (74x165.1)
switches
VAR
Byte
' interruptores de entrada
' ------------------------------------------------------------------------Inicializar: HIGH Load
' hace salida en estado alto
' ------------------------------------------------------------------------Principal: GOSUB ReadSwitches DEBUG Home, IBIN8 switches PAUSE 100 GOTO Principal END
' lee 8-pos. del dip switch ' muestra en modo binario ' repite
' ------------------------------------------------------------------------ReadSwitches: PULSOUT Load,3 SHIFTIN D_in,Clock,MSBPre,[switches] RETURN
' toma valores interruptores ' desplaza valores
Descripción del Programa El experimento demuestra el uso de SHIFTIN, la función complementaria de SHIFTOUT. En este caso, tres líneas de E/S del BASIC Stamp son usadas para leer el estado de ocho interruptores de entrada. Para leer datos del 74x165, las entradas paralelas son bloqueadas en sus estados mediante un breve pulso en la línea Load, luego se usa SHIFTIN para ingresar los datos al BASIC Stamp.
Página 118 • Manual StampWorks Versión 1.1
Experimento 24: Expandiendo Entradas Note que los DIP-switches tienen resistencias de pull-up a Vdd, así que al ponerlos en posición “ON” se crea una entrada lógica baja al registro de desplazamiento. Usando la salida Q\ (invertida) del 74x165, los datos llegan al BASIC Stamp con un Bit 1 que indica que el interruptor está encendido (en “on”). Desafío Conecte un segundo registro de desplazamiento 74x165 para leer 16 entradas. Vea las hojas de datos del 74HC165 para obtener información de conexionado.
Manual StampWorks Versión 1.1 • Página 119
Experimento 25: Control de un Servo
Experimento 25: Control de un Servo Este experimento demuestra cómo controlar un servo común. Los servos son muy usados en la robótica amateur. Nuevos Elementos/Comandos PBASIC: •
SDEC, SDEC1 – SDEC16 (modificador de DEBUG)
Construcción del Circuito
' ' ' ' ' ' '
========================================================================= Archivo: SERVO.BS2 Controlador de la posición de un Servo {$STAMP BS2} =========================================================================
PotCW
CON
0
' entrada pot sentido horario
Manual StampWorks Versión 1.1 • Página 121
Experimento 25: Control de un Servo PotCCW Servo
CON CON
1 2
' entrada pot sentido anti-horario ' pin control de servo
rcRt rcLf diff sPos
VAR VAR VAR VAR
Word Word Word Word
' ' ' '
lectura rc - derecha lectura rc - izquierda diferencia entre lecturas posición del servo
' ------------------------------------------------------------------------Principal: HIGH PotCW HIGH PotCCW PAUSE 1 RCTIME PotCW,1,rcRt RCTIME PotCCW,1,rcLf
' descarga capacitores ' lee sentido horario ' lee sentido anti-horario
rcRt = rcRt */ $0068 MAX 250 rcLf = rcLf */ $0068 MAX 250 sPos = rcRt - rcLf
' escala RCTIME a 0-250
PULSOUT Servo,(750 + sPos) PAUSE 15
' mueve el servo
' calcula posición (-250 a 250)
GOTO Principal END
Descripción del Programa Los servos son dispositivos electromecánicos especializados usados frecuentemente para posicionar los planos de control de aeromodelos. La posición del engranaje de salida del servo es determinada por el ancho de un pulso de control. El pulso de control normalmente tiene un ancho de entre uno y dos milisegundos. El servo se centrará cuando la señal de control es de 1,5 milisegundos. Para mantener esta posición, el servo debe ser actualizado constantemente. La frecuencia de actualización típica es de aproximadamente 50 veces por segundo. El comando PULSOUT del BASIC Stamp es ideal para controlar los servos. En este experimento, dos circuitos RCTIME se construyen sobre un potenciómetro de 10K. Este circuito y el código pueden ser usados para determinar la posición relativa del potenciómetro. Las lecturas de cada lado del potenciómetro se multiplican por un factor de escala para obtener un rango de 0 a 250 con los operadores */ y MAX. Restando un lado del otro, se obtiene un valor de posición del servo entre–250 y +250.
Página 122 • Manual StampWorks Versión 1.1
Experimento 25: Control de un Servo Este valor se agrega a la posición central de 750. Recuerde que PULSOUT trabaja en unidades de 2 microsegundos, así que un valor de PULSOUT de 750 creará un pulso de 1.5 milisegundos de ancho, haciendo que el servo se centre. Cuando la posición del servo es –250, el valor de PULSOUT es 500, creando un pulso de 1,0 milisegundos. Con un valor sPos de +250, el valor de PULSOUT es 1000, creando un pulso de control de 2,0 milisegundos. Este código demuestra que el BASIC Stamp trabaja con números negativos. Puede ver el valor de
sPos insertando esta línea después del cálculo:
DEBUG Home, "Posición: ", SDEC sPos, "
"
Los números negativos son almacenados con el formato de complemento a dos. El modificador SDEC (decimal con signo) imprime valores decimales con su signo. Desafío Reemplace el potenciómetro con dos fotorresistores y actualice el código para hacer que el servo se centre hacia la fuente de luz más brillante.
Manual StampWorks Versión 1.1 • Página 123
Experimento 26: Motor Paso a Paso
Experimento 26: Motor Paso a Paso Este experimento demuestra el control de un pequeño motor paso a paso unipolar de 12-volt. Los motores paso a paso se usan en dispositivos de posicionamiento de precisión en aplicaciones de control industrial y robótica. Nuevos Elementos/Comandos PBASIC: •
ABS
Construcción del Circuito
Manual StampWorks Versión 1.1 • Página 125
Experimento 26: Motor Paso a Paso
' ' ' ' ' ' '
========================================================================= Archivo: STEPPER.BS2 control de motor paso a paso unipolar {$STAMP BS2} =========================================================================
PotCW PotCCW Coils
CON CON VAR
0 1 OutB
' entrada pot. sentido horario 'entrada pot. sentido anti-horario ' salida a bobinas del paso a paso
speed x sAddr rcRt rcLf diff
VAR VAR VAR VAR VAR VAR
Word Byte Byte Word Word Word
' ' ' ' ' '
retardo entre pasos contador de bucle direcciรณn de EE de datos de paso lectura rc - derecha lectura rc - izquierda diferencia entre lecturas
' ------------------------------------------------------------------------' __ ' ABAB ' ----Step1 DATA %1100 ' A on B on A\ off B\ off Step2 DATA %0110 ' A off B on A\ on B\ off Step3 DATA %0011 ' A off B off A\ on B\ on Step4 DATA %1001 ' A on B off A\ off B\ on ' ------------------------------------------------------------------------Inicializar: DirB = %1111 speed = 5
' config. Pines motor como salidas ' fija velocidad inicial
' ------------------------------------------------------------------------Principal: FOR x = 1 TO 100 GOSUB StepFwd NEXT PAUSE 200 FOR x = 1 TO 100
Pรกgina 126 โ ข Manual StampWorks Versiรณn 1.1
' 1 rev. adelante
' 1 rev. atrรกs
Experimento 26: Motor Paso a Paso GOSUB StepRev NEXT PAUSE 200 StepDemo: HIGH PotCW HIGH PotCCW PAUSE 1 RCTIME PotCW,1,rcRt RCTIME PotCCW,1,rcLf
' descarga capacitores ' lee sentido horario ' lee sentido anti-horario
rcRt = rcRt MAX 600 rcLf = rcLf MAX 600
' fija límites de velocidad
diff = ABS(rcRt - rcLf) IF (diff < 25) THEN StepDemo
' obtiene dif. Entre lecturas ' zona muerta
IF (rcLf > rcRt) THEN StepCCW StepCW: speed = 60 - (rcRt / 10) GOSUB StepFwd GOTO StepDemo
' calcula velocidad ' da un paso
StepCCW: speed = 60 - (rcLf / 10) GOSUB StepRev GOTO StepDemo ' ------------------------------------------------------------------------StepFwd: sAddr = sAddr + 1 // 4 READ (Step1 + sAddr),Coils PAUSE speed RETURN StepRev: sAddr = sAddr + 3 // 4 READ (Step1 + sAddr),Coils PAUSE speed RETURN
' apunta al siguiente paso ' datos de paso de salida ' pausa entre pasos
' apunta al paso anterior
Manual StampWorks Versión 1.1 • Página 127
Experimento 26: Motor Paso a Paso Descripción del Programa Los motores paso a paso se diferencian de los motores de CC en que no giran libremente cuando se les aplica la alimentación. Para que un motor paso a paso gire, la alimentación debe pulsarse continuamente en un patrón específico. La secuencia de pasos (patrón) determina el sentido de rotación del motor paso a paso. El tiempo entre pasos determina la velocidad de giro. Cada paso hace que el motor paso a paso gire un incremento angular fijo predefinido. El motor suministrado con el kit de StampWorks rota 3,6 grados por paso. Esto significa que para lograr un giro completo (360 grados) se requieren 100 pasos. Las secuencias de pasos para el motor se almacenan en instrucciones DATA. La subrutina StepFwd leerá de la tabla, la siguiente secuencia a ser aplicada a las bobinas. La subrutina StepRev es idéntica excepto en que leerá el paso anterior. Note el truco con el operador módulo (//) usado en StepRev. Agregando el valor máximo de la secuencia al valor actual y luego aplicando el operador módulo, la secuencia va a la inversa. Esta el la matemática involucrada: 0 3 2 1
+ + + +
3 3 3 3
// // // //
4 4 4 4
= = = =
3 2 1 0
Este experimento lee ambos lados del potenciómetro de 10K para determinar su posición relativa. El valor diferencial entre las dos lecturas se mantiene positivo mediante el uso de la función ABS. La posición es usada para determinar la dirección de giro y la magnitud es la que define la velocidad angular. Recuerde, a menor pausa entre pasos, mayor es la velocidad de giro. Una zona muerta es usada para hacer que el motor deje de girar cuando las lecturas de RCTIME son muy parecidas. Desafío Rescriba el programa para hacer girar el motor en 200 medios pasos. Esta es la secuencia para lograr pasos intermedios: Step1 = %1000 Step2 = %1100 Step3 = %0100 Step4 = %0110 Step5 = %0010 Step6 = %0011 Step7 = %0001 Step8 = %1001
Página 128 • Manual StampWorks Versión 1.1
Experimento 27: Medición de Tensión
Experimento 27: Medición de Tensión Este experimento demuestra el uso de un conversor analógico-digital para leer una entrada de tensión variable. Construcción del Circuito (Note que el esquema NO es chip-céntrico)
' ' ' ' '
========================================================================= Archivo: ADC0831.BS2 Leer tensión en el cursor del potenciómetro con un ADC-0831 =========================================================================
ADdata ADclock ADcs
CON CON CON
0 1 2
' línea de datos A/D ' reloj A/D ' chip select A/D (act. bajo)
result mVolts
VAR VAR
Byte Word
' resultado de conversión ' convierte a milivolts
' ------------------------------------------------------------------------Inicializar: HIGH ADcs ' -------------------------------------------------------------------------
Manual StampWorks Versión 1.1 • Página 129
Experimento 27: Mediciรณn de Tensiรณn Principal: GOSUB Read0831 volts = result */ $139C
' x 19.6 (mv / unidad)
DEBUG Home DEBUG "ADC..... ", DEC result, " ", CR DEBUG "volts... ", DEC mVolts DIG 3, ".", DEC3 mVolts PAUSE 100 GOTO Principal END
' pausa entre lecturas ' repite
' ------------------------------------------------------------------------Read0831: LOW ADcs SHIFTIN Addata,ADclock,MSBPost,[result\9] HIGH ADcs RETURN
Pรกgina 130 โ ข Manual StampWorks Versiรณn 1.1
Experimento 27: Medición de Tensión Descripción del Programa Proyectos anteriores usaban RCTIME para leer componentes resistivos. Esto sirve para ingresar valores analógicos, pero no sirve para leer tensiones. Para medir tensiones el BASIC Stamp la ayuda de un dispositivo externo. La forma más simple de medir una tensión variable es con un conversor analógico-digital. En este experimento, el National Semiconductor ADC0831 es usado para convertir una tensión (0 – 5) en una señal serial sincrónica que puede ser leída por el BASIC Stamp con SHIFTIN. El ADC0831 requiere nueve bits para obtener el resultado. Este no es un problema para el BASIC Stamp debido a que la función SHIFTIN permite especificar la cantidad de bits que serán desplazados. El resultado de 8 bits será de cero (cero volts) a 255 (cinco volts). Dividiendo 5 (volts) por 255, obtenemos que cada bit en el resultado es igual a 19,6 milivolts. Para mostrar el resultado, convertimos el valor obtenido en milivolts multiplicándolo por 19,6 (result */ $139C). Se usa un truco interesante con DEBUG para mostrar la variable mVolts. La operación “DIG 3“ imprime el valor entero y el modificador DEC3 la parte fraccionaria. Desafío Conecte la salida del Experimento 22 (Pin 1 del LM358) a la entrada del ADC0831. Escriba un programa que cree una tensión usando PWM y lea el valor resultante con el ADC0831.
Manual StampWorks Versión 1.1 • Página 131
Experimento 28: Medición de Temperatura
Experimento 28: Medición de Temperatura Este experimento demuestra el uso de un sensor de temperatura digital. La medición de temperatura es un componente esencial en aplicaciones de control ambiental (calefacción y aire acondicionado). Construcción del Circuito (Note que el esquema NO es chip-céntrico)
' ' ' ' '
========================================================================= Archivo: DS1620.BS2 Lee la temperatura con un Dallas Semiconductor DS1620 =========================================================================
DQ Clock Reset
CON CON CON
0 1 2
' DS1620.1 (E/S de datos) ' DS1620.2 ' DS1620.3
RdTmp WrHi WrLo RdHi RdLo StartC StopC WrCfg RdCfg
CON CON CON CON CON CON CON CON CON
$AA $01 $02 $A1 $A2 $EE $22 $0C $AC
' ' ' ' ' ' ' ' '
tempIn
VAR
Word
' temperatura directa
lee temperatura escribe TH (Temp. alta) escribe TL (Temp. baja) lee TH lee TL inicia conversión detiene conversión escribe registro config. lee registro config.
Manual StampWorks Versión 1.1 • Página 133
Experimento 28: Mediciรณn de Temperatura sign tSign tempC tempF
VAR VAR VAR VAR
tempIn.Bit8 Bit Word Word
' 1 = temperatura negativa ' Celsius ' Fahrenheit
' ------------------------------------------------------------------------Inicializar: GOSUB DS1620init
' inicializa el DS1620
' ------------------------------------------------------------------------Principal: GOSUB GetTemperature DEBUG DEBUG DEBUG DEBUG DEBUG
Home "DS1620",CR "------",CR SDEC tempC," C SDEC tempF," F
' lee el DS1620
",CR ",CR
PAUSE 1000 GOTO Principal END
' pausa entre lecturas
' ------------------------------------------------------------------------DS1620init: HIGH Reset SHIFTOUT DQ,Clock,LSBFirst,[WrCfg,%10] LOW Reset PAUSE 10 HIGH Reset SHIFTOUT DQ,Clock,LSBFirst,[StartC] LOW Reset RETURN GetTemperature: HIGH Reset SHIFTOUT DQ,Clock,LSBFIRST,[RdTmp] SHIFTIN DQ,Clock,LSBPRE,[tempIn\9] LOW Reset
Pรกgina 134 โ ข Manual StampWorks Versiรณn 1.1
' activa el DS1620 ' use con CPU; func. Continuo
' inicia conversiones
' ' ' '
activa el DS1620 entrega comando leer Temp.. la lee libera al DS1620
Experimento 28: Medición de Temperatura tSign = sign tempIn = tempIn/2 IF tSign = 0 THEN NoNeg1 tempIn = tempIn | $FF00
' guarda el bit de signo ' redondea a grados enteros ' extiende bits de signo en neg.
NoNeg1: tempC = tempIn tempIn = tempIn */ $01CC IF tSign = 0 THEN NoNeg2 tempIn = tempIn | $FF00
' guarda valor Celsius ' multiplica por 1.8 ' si negativo, extiende bits signo
NoNeg2: tempIn = tempIn + 32 tempF = tempIn RETURN
' finaliza conversión C -> F ' guarda valor Fahrenheit
Descripción del Programa El órgano más grande del cuerpo humano es la piel y es el más rápidamente afectado por la temperatura. Esta es la razón por la que se pone tanto esfuerzo en los sistemas de control ambiental (calefacción y aire acondicionado). Este experimento usa el tremostato/termómetro digital Dallas Semiconductor DS1620. Este chip mide la temperatura y la pone a disponibilidad del BASIC Stamp mediante una interfaz serial sincrónica. El DS1620 es un dispositivo inteligente y una vez programado, es capaz de operar autónomamente con termostato usando las salidas T(com), T(hi) y T(lo). El DS1620 debe ser inicializado antes de usarse. En aplicaciones activas como ésta, el DS1620 es configurado para funcionar en modo continuo con una CPU. Luego de enviar los datos de configuración al DS1620, se necesita un retardo de 10 milisegundos para que la configuración sea escrita en la EEPROM interna del DS1620. Luego del retardo, el DS1620 es instruido para comenzar las conversiones continuas. Esto asegurará una lectura de la temperatura actual cuando el BASIC Stamp la solicite. Para obtener el valor de la temperatura actual, el byte de comando Read Temperature (Leer Temperatura=$AA) es enviado al DS1620. Luego se puede leer el último valor de temperatura obtenido. El dato obtenido tiene una extensión de nueve bits. El bit 8 indica el signo de la temperatura. Si es negativo (el bit de signo es 1), los 8 bits restantes almacenan el valor del complemento a dos de la temperatura. Tanto en valores positivos o negativos, cada bit de temperatura es igual a 0,5 grados Celsius (centígrados).
Manual StampWorks Versión 1.1 • Página 135
Experimento 28: Medición de Temperatura La temperatura en Celsius se calcula dividiendo por dos el valor obtenido del sensor. Si es negativo, los bits del byte superior se ponen en 1 para que los números mantengan su signo con SDEC (los números con signo en el BASIC Stamp deben tener una longitud de 16 bits). La temperatura es convertida a Fahrenheit usando la fórmula: F = (C * 1.8) + 32 Desafío Rescriba el programa para que muestre los valores de temperatura en el módulo LCD del StampWorks.
Página 136 • Manual StampWorks Versión 1.1
Experimento 29: Multiplexado de 7 Segmentos
Experimento 29: Multiplexado de 7 Segmentos Este experimento demuestra el uso de displays de 7 segmentos con un multiplexor externo. Displays de 7 segmentos de varios dígitos son usados frecuentemente en máquinas expendedoras para mostrar la cantidad de dinero ingresada. Construcción del Circuito (Note que el esquema NO es chip-céntrico)
Manual StampWorks Versión 1.1 • Página 137
Experimento 29: Multiplexado de 7 Segmentos
Pรกgina 138 โ ข Manual StampWorks Versiรณn 1.1
Experimento 29: Multiplexado de 7 Segmentos ' ' ' ' ' ' '
========================================================================= Archivo: CHNGCNTR.BS2 Cuenta monedas de 1, 5 ,10 y 25 centavos y muestra el total en cuatro displays de 7 segmentos. Se usa un MAX7219 para controlar el el multiplexado. =========================================================================
Dpin Clock Load Coins
CON CON CON VAR
7 6 5 InL
' ' ' '
pin de datos(MAX7219.1) pin de reloj(MAX7219.13) pin de carga(MAX7219.12) entradas de monedas
Decode Brite Scan ShutDn Test DecPnt Blank
CON CON CON CON CON CON CON
$09 $0A $0B $0C $0F %10000000 %1111
' ' ' ' '
decodificador bcd registro de intensidad reg. De límite de búsqueda registro de apagado (1 = enc.) modo de prueba de display
Yes No
CON CON
1 0
money deposit penny nickel dime quarter dollar digit d7219 index idxOdd
VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR
Word Byte deposit.Bit0 deposit.Bit1 deposit.Bit2 deposit.Bit3 deposit.Bit4 Nib Byte Nib index.Bit0
' limpia un dígito
' Contador de dinero ' monedas depositadas ' bits de valores
' ' ' '
muestra dígito datos para el MAX7219 contador de bucle es impar el índice? (1 = si)
' ------------------------------------------------------------------------' Segmentos ' Full DATA DATA DATA DATA
.abcdefg -------%01000111 %00111110 %00001110 %00001110
' ' ' '
F U L L
Manual StampWorks Versión 1.1 • Página 139
Experimento 29: Multiplexado de 7 Segmentos
' ------------------------------------------------------------------------Inicializar: DirL = %11100000
' salidas al 7219 ' monedas como entradas
FOR index = 0 TO 7 LOOKUP index,[Scan,3,Brite,3,Decode,$0F,ShutDn,1],d7219 SHIFTOUT Dpin,Clock,MSBFirst,[d7219] IF idxOdd = No THEN NoLoad PULSOUT Load,3 ' carga parรกmetro NoLoad: NEXT GOSUB ShowTheMoney ' ------------------------------------------------------------------------Principal: GOSUB GetCoins IF deposit = 0 THEN Principal money money money money money
= = = = =
money money money money money
+ + + + +
(penny * 1) (nickel * 5) (dime * 10) (quarter * 25) (dollar * 100)
GOSUB ShowTheMoney PAUSE 100 GOTO Principal END
' espera monedas ' suma monedas
' actualiza el display
' ------------------------------------------------------------------------GetCoins: deposit = %00011111 FOR index = 1 TO 10 deposit = deposit & ~Coins PAUSE 5 NEXT RETURN
Pรกgina 140 โ ข Manual StampWorks Versiรณn 1.1
' habilita todas las entradas ' controla entradas ' retardo entre controles
Experimento 29: Multiplexado de 7 Segmentos
ShowTheMoney: IF (money >= 9999) THEN ShowFull FOR index = 4 TO 1 d7219 = Blank IF (index = 4) AND (money < 1000) THEN PutDigit d7219 = money DIG (index - 1) IF (index <> 3) THEN PutDigit d7219 = d7219 | DecPnt ' punto decimal en DIGIT 3 PutDigit: SHIFTOUT Dpin,Clock,MSBFirst,[index,d7219] PULSOUT Load,3 NEXT RETURN ShowFull: SHIFTOUT Dpin,CLOCK,MSBFIRST,[Decode,0] ' apaga decodif. BCD PULSOUT Load,1 FOR index = 4 TO 1 READ (4 – index + Full),d7219 ' lee y envía una letra SHIFTOUT Dpin,Clock,MSBFirst,[index,d7219] PULSOUT Load,3 NEXT
Descripción del Programa Multiplexar varios displays de 7 segmentos requiere un gran esfuerzo y la mayoría de los recursos de cómputo del BASIC Stamp. Usando el multiplexor MAXIM MAX7219 solamente son necesarios tres líneas de E/S del BASIC Stamp. El MAX7219 puede ser usado para controlar hasta ocho displays de 7 segmentos, o 64 LEDs sueltos (cuatro veces la cantidad de pines de E/S disponibles en el BASIC Stamp). El MAX7219 se conecta a los displays de LEDs en una forma directa; los pines SEG A hasta SEG G y SEG DP se conectan a los segmentos A hasta G y el punto decimal de todos los displays de cátodo común. Los pines DIGIT 0 hasta DIGIT 7 se conectan individualmente a los cátodos de cada uno de los displays. Si usa menos de ocho dígitos, omita los números superiores. Por ejemplo, este experimento usa cuatro dígitos, numerados de 0 a 3, no de 4 a 7.
Manual StampWorks Versión 1.1 • Página 141
Experimento 29: Multiplexado de 7 Segmentos El MAX7219 tiene una característica que limita el barrido de displays a los dígitos 0 a n, donde n es el número de dígito más alto. Esto hace que el chip no pierda tiempo y ciclos de trabajo (perdiendo brillo) tratando de componer dígitos inexistentes. Cuando el MAX7219 es usado con displays de 7 segmentos, puede ser configurado para convertir automáticamente valores decimales codificados en binario (BCD) en patrones apropiados de segmentos. Esto hace que mostrar números decimales sea muy simple. La característica de decodificación BCD puede deshabilitarse para mostrar caracteres personalizados. Este experimento hace las dos cosas. Desde el punto de vista del software, para manejar el MAX7219 se requiere que el controlador: Desplace 16 bits de datos al dispositivo, primero el más significativo (MSB). Emita un pulso en la línea Load para transferir los datos. Cada paquete de datos de 16-bits consiste en una dirección de registro seguida por los datos a almacenar en ese registro. Por ejemplo, el valor de 16-bits $0407 (hexadecimal) escribe un “7” en el cuarto dígito del display. Si se enciende el decodificador BCD para ese dígito, el número “7” aparecerá en el display. Si no se enciende la decodificación, se encenderán tres LEDs, correspondientes a los segmentos G, F y E. En este experimento, el MAX7219 se inicializa para: Scan = 3 (Muestra dígitos 0 – 3) Brightness = 5 (Brillo) Decode = $0F (decodificación BCD 0 – 3) Shutdown = 1 (operación normal) La inicialización del MAX7219 es realizada en un bucle. En cada pasada lee una dirección de registro o valor de datos de la tabla LOOKUP. Después de que cada valor es enviado, la dirección y el dato son bloqueados en el MAX7219 mediante un pulso en la línea Load. La mayoría del trabajo tiene lugar en la subrutina llamada ShowTheMoney. Cuando la cantidad de dinero es menor que 9999, el valor será mostrado en los dígitos de 7 segmentos, caso contrario la pantalla mostrará el mensaje “FULL” (lleno). La rutina examina cada dígito del dinero y envía la posición y el valor (con el operador DIG) al MAX7219. Dado que el display muestra dólares y centavos, se habilita el punto decimal en el tercer dígito. Cuando el dígito y la posición han sido enviados, el display se actualiza enviando un pulso en la línea Load. Para mantener la pantalla prolija, el primer cero se elimina cuando el valor del dinero es menor que 1000.
Página 142 • Manual StampWorks Versión 1.1
Experimento 29: Multiplexado de 7 Segmentos
Cuando el dinero llega a 9999, el display mostrará “FULL.” Esto se logra deshabilitando el modo de decodificación BCD del MAX7219 y enviando patrones de letras personalizados al MAX7219. Estos patrones se almacenan en instrucciones DATA. El bucle principal del programa es simple: controla si se presiona algún botón con GetCoins y actualiza los contadores de cada moneda cada vez que se presiona un botón. Este código en particular es un ejemplo excelente del uso de sobrenombres o alias para las variable para mejorar la claridad del programa. Desafío Modifique el código del Experimento 27 para que muestre la tensión de entrada en los displays de 7 segmentos.
Manual StampWorks Versión 1.1 • Página 143
Experimento 30: Reloj de Tiempo Real
Experimento 30: Reloj de Tiempo Real Este experimento demuestra la capacidad de las funciones temporales del BASIC Stamp mediante el uso de un reloj de tiempo real externo (RTC). La capacidad de temporización RTC es crucial para aplicaciones que dependen de la hora del día o aquellas que deben medir el tiempo transcurrido. Construcción del Circuito (Note que el esquema NO es chip-céntrico)
' ' ' ' ' '
========================================================================= Archivo: DS1302.BS2 Este programa demuestra las funciones temporales básicas usando el DS1302 de Dallas Semiconductor. =========================================================================
Dio Clock CS_1302 BtnsIn
CON CON CON VAR
0 1 2 InB
' ' ' '
DS1302.6 DS1302.7 DS1302.5 entrada de pulsadores
Manual StampWorks Versión 1.1 • Página 145
Experimento 30: Reloj de Tiempo Real WrSecs RdSecs WrMins RdMins WrHrs RdHrs CWPr WPr1 WPr0 WrBurst RdBurst WrRam RdRam
CON CON CON CON CON CON CON CON CON CON CON CON CON
$80 $81 $82 $83 $84 $85 $8E $80 $00 $BE $BF $C0 $C1
Yes No
CON CON
1 0
Hr24 Hr12
CON CON
0 1
ClockMode
CON
Hr12
' usa modo AM/PM
index reg ioByte
VAR VAR VAR
Byte Byte Byte
' contador de bucle ' dirección DS1302 para leer/esc. ' datos hacia/desde el DS1302
secs secs01 secs10 mins mins01 mins10 hrs hrs01 hrs10 day
VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR
Byte secs.LowNib secs.HighNib Byte mins.LowNib mins.HighNib Byte hrs.LowNib hrs.HighNib Byte
' segundos
ampm tMode
VAR VAR
hrs.Bit5 hrs.Bit7
' 0 = AM, 1 = PM ' 0 = 24, 1 = 12
rawTime work oldSecs apChar
VAR VAR VAR VAR
Word Byte Byte Byte
' ' ' '
Página 146 • Manual StampWorks Versión 1.1
' ' ' ' ' ' ' ' ' ' ' '
escribe segundos lee segundos escribe minutos lee minutos escribe horas lee horas reg. de protección de escritura activa protec. de escritura desactiva protec. de escritura escribe tren de datos tren de datos control de direcciones de RAM
' minutos ' horas ' día
valores temporales directos variable para mostrar salida valor de segundos anterior "A" o "P"
Experimento 30: Reloj de Tiempo Real
btns btnMin btnHrs btnDay btnBack
VAR VAR VAR VAR VAR
Nib btns.Bit0 btns.Bit1 btns.Bit2 btns.Bit3
' ' ' ' '
botones entradas actualiza minutos actualiza horas actualiza día hacia atrás
' ------------------------------------------------------------------------Su Mo Tu We Th Fr Sa
DATA DATA DATA DATA DATA DATA DATA
"Domingo", 0 "Lunes", 0 "Martes", 0 "Miercoles", 0 "Jueves", 0 "Viernes", 0 "Sabado", 0
' ------------------------------------------------------------------------Inicializar: DirL = %00000111
' interrup. entradas
reg = CWPr ioByte = WPr0 GOSUB RTC_out
' deshabilita protec. de escritura
oldSecs = $99 hrs = $06 GOSUB SetTime
' habilita la bandera display ' fija hora del DS3102 a 6:00 AM
' -------------------------------------------------------------------------Main1: GOSUB GetTime IF secs = oldSecs THEN CheckButtons Main2: GOSUB ShowTime oldSecs = secs CheckButtons: GOSUB GetButtons IF btns = 0 THEN DoSomeTask IF btnBack = Yes THEN GoBack
' lee el DS1302 ' tiempo para actualizar? ' si, lo muestra ' lo marca
' permite al BS hacer otro trabajo ' botón hacia atrás presionado?
Manual StampWorks Versión 1.1 • Página 147
Experimento 30: Reloj de Tiempo Real
Adelante: rawTime = rawTime + btnMin rawTime = rawTime + (btnHrs * 60) day = (day + btnDay) // 7 GOTO UpdateClock GoBack: IF (btns <= %1000) THEN DoSomeTask rawTime = rawTime + (btnMin * 1439) rawTime = rawTime + (btnHrs * 1380) day = (day + (btnDay * 6)) // 7
' agrega un minuto ' agrega una hora ' día siguiente
' ' ' '
no se presiona botón actualizar resta un minuto resta una hora día anterior
UpdateClock: rawTime = rawTime // 1440 GOSUB SetRawTime GOTO Main2
' envía valor actualiz. al DS1302 ' limpia modos de tiempo ' conf. Reloj para tiempo directo
DoSomeTask:
' trabaja cuando no usa el reloj
' otro código aquí GOTO Main1 END ' ------------------------------------------------------------------------ShowTime: DEBUG Home LOOKUP day,[Su,Mo,Tu,We,Th,Fr,Sa],work ' obtiene dirección de día GetDayChar: READ work,ioByte ' obtiene un caracter IF ioByte = 0 THEN CheckClockMode ' si 0, día terminado DEBUG ioByte ' imprime el caracter work = work + 1 ' apunta al siguiente GOTO GetDayChar CheckClockMode: DEBUG " ", CR ' limpia restos de día anterior IF (ClockMode = Hr24) THEN Show24 Show12: DEBUG DEC2 12 - (24 - (hrs10 * 10 + hrs01) // 12) DEBUG ":", HEX2 mins, ":", HEX2 secs apChar = "A" ' asume AM IF (hrs < $12) THEN ShowAMPM ' controla el tiempo
Página 148 • Manual StampWorks Versión 1.1
Experimento 30: Reloj de Tiempo Real apChar = "P" ' hrs >= $12 ShowAMPM: DEBUG " ", apChar, "M" ' imprime AM o PM GOTO ShowTimeDone Show24: DEBUG HEX2 hrs, ":", HEX2 mins, ":", HEX2 secs ShowTimeDone: RETURN GetButtons: btns = %1111 FOR index = 1 TO 10 btns = btns & ~BtnsIn PAUSE 5 NEXT PAUSE 200 RETURN
' habilita todas las entradas ' controla botones ' pausa entre controles
RTC_out: HIGH CS_1302 SHIFTOUT Dio,Clock,LSBFirst,[reg,ioByte] LOW CS_1302 RETURN
' envía ioByte al reg. en DS1302
RTC_in: HIGH CS_1302 SHIFTOUT Dio,Clock,LSBFirst,[reg] SHIFTIN Dio,Clock,LSBPre,[ioByte] LOW CS_1302 RETURN
' lee ioByte del reg. del DS1302
SetRawTime: hrs10 = rawTime / 600 hrs01 = rawTime // 600 / 60 mins10 = rawTime // 60 / 10 mins01 = rawTime // 10
' convierte rawTime a BCD
SetTime: HIGH CS_1302
' escribe datos en modo burst
Manual StampWorks Versión 1.1 • Página 149
Experimento 30: Reloj de Tiempo Real SHIFTOUT Dio,Clock,LSBFirst,[WrBurst] SHIFTOUT Dio,Clock,LSBFirst,[secs,mins,hrs,0,0,day,0,0] LOW CS_1302 RETURN GetTime: ' lee datos en modo burst HIGH CS_1302 SHIFTOUT Dio,Clock,LSBFirst,[RdBurst] SHIFTIN Dio,Clock,LSBPre,[secs,mins,hrs,day,day,day] LOW CS_1302 rawTime = ((hrs10 & %11) * 600) + (hrs01 * 60) rawTime = rawTime + (mins10 * 10) + mins01 RETURN
Descripción del Programa Si bien es posible implementar funciones temporales rudimentarias con PAUSE, se encuentran inconvenientes cuando el BASIC Stamp debe supervisar otras actividades. Esto es especialmente cierto cuando la aplicación debe llevar registro de la hora y la fecha. La solución más limpia es usar un reloj de tiempo real externo. En este experimento, usamos el Dallas Semiconductor DS1302. Como el DS1620, el DS1302 requiere solamente tres líneas para comunicarse con el BASIC Stamp. Dado que los dos dispositivos son compatibles, el reloj y las líneas de datos pueden ser compartidas pudiendo el BASIC Stamp realizar mediciones de temperatura y tiempo usando solamente cuatro pines de E/S.
Página 150 • Manual StampWorks Versión 1.1
Experimento 30: Reloj de Tiempo Real
Una vez programado, el DS1302 funciona por su cuenta y mantiene registro preciso de segundos, minutos, horas (con un indicador AM/PM, si funciona en modo 12-horas), día del mes, mes, día de la semana y año con compensación de bisiestos hasta el año 2100. Como extra, el DS1302 contiene 31 bytes de RAM que podemos usar como queramos. Y para proyectos que usan la alimentación principal, el DS1302 también tiene un circuito de carga que mantiene cargada una batería de respaldo. El DS1302 es un dispositivo basado en registros, lo que quiere decir que cada elemento de tiempo y fecha es almacenado en su propio registro (dirección de memoria). Por conveniencia, están disponibles dos modos de lectura y escritura: registro y completo. Con el acceso a registros, se pueden leer o escribir elementos individuales. Con el acceso completo, se pueden escribir o leer todos los registros de una sola vez (comenzando con los segundos). Para mantener nuestra conexión con el DS1302 simple, este experimento solamente usa el modo 24horas. En este modo, no necesitamos trabajar con el bit indicador AM/PM del DS1302. Para mostrar la hora en el formato de 12-horas, calcularemos AM/PM matemáticamente. En el código, la hora es manejada como una única variable tamaño word (rawTime) que representa el número de minutos pasada la medianoche. De esta forma se pueden realizar cálculos de duraciones y comparar tiempos de alarmas con la hora actual en forma directa. Otra buena razón para usar el formato de tiempo directo es que el DS1302 almacena sus registros en formato BCD (decimal codificado en binario). BCD es un método para almacenar un valor entre cero y 99 en una variable de un byte. Las unidades ocupan la nibble inferior(cuatro bits), las decenas la superior. Ninguna nibble de un byte BCD puede tener un valor mayor que 9. Por suerte el BASIC Stamp trabaja con variables tamaño nibble y más importante aún, permite poner sobrenombres a las variables. Este experimento demuestra lo básico del DS1302 configurando el reloj y luego actualizándolo. Las conversiones del registro de formato BCD hacia y desde el DS1320 son realizadas por las subrutinas que envían y reciben datos en el modo burst (completo). Se usan cuatro pulsadores para fijar el día, horas y minutos del reloj. Normalmente, los botones incrementan cada valor. Manteniendo presionado el cuarto botón, cada elemento correrá hacia atrás. Mientras no se presiona ningún botón, el programa pasa a una subrutina llamada DoSomeTask. Este es el sector donde podría poner código adicional (leer un DS1620, por ejemplo). La salida del programa es mediante una ventana DEBUG. La subrutina ShowTime se encarga de imprimir el día y la hora en el formato especificado por ClockMode.
Manual StampWorks Versión 1.1 • Página 151
Experimento 30: Reloj de Tiempo Real Desafío (Avanzado) Agregue un DS1620 usando las conexiones que se muestran abajo. Escriba un programa que registre la temperatura actual, la mínima y la máxima y que muestre (use DEBUG) la hora y la fecha en que se tomaron estas temperaturas.
Página 152 • Manual StampWorks Versión 1.1
Experimento 31: Comunicaciones Seriales
Experimento 31: Comunicaciones Seriales Este experimento demuestra la capacidad del BASIC Stamp de comunicarse con otras computadoras a través de cualquiera de sus pines de E/S. También demuestra la capacidad de almacenar información en la EEPROM del BASIC Stamp. Nuevos Elementos/Comandos PBASIC: • • • • • •
SERIN SEROUT WAIT (modificador de SERIN) HEX (modificador de SERIN/SEROUT) BIN (modificador de SERIN/SEROUT) WRITE
Construcción del Circuito (Note que el esquema NO es chip-céntrico)
Manual StampWorks Versión 1.1 • Página 153
Experimento 31: Comunicaciones Seriales ' ' ' ' ' ' '
========================================================================= Archivo: POLLSTMP.BS2 Se comunica e intercambia información con el BASIC Stamp vía conexión RS-232 {$STAMP BS2} =========================================================================
LEDs DQ Clock Reset
VAR CON CON CON
OutA 4 5 6
' ' ' '
RxD TxD
CON CON
14 15
' entrada serial - a INEX RxD ' salida serial - a INEX TxD
Baud96
CON
84
' 9600-8-N-1 (compatible DEBUG)
CMenu CID CSet CTmp CTmpC CTmpF CStat CLEDs
CON CON CON CON CON CON CON CON
$FF $F0 $F1 $A0 $A1 $A2 $B0 $B1
' ' ' ' ' ' ' '
muestra menu de comandos obtiene ID de cadena fija ID de cadena DS1620 - display valor directo DS1620 - display en C DS1620 - display en F estado de salida digital config. LEDs salidas
RTmp WTHi WTLo RTHi RTLo StartC StopC WrCfg RdCfg
CON CON CON CON CON CON CON CON CON
$AA $01 $02 $A1 $A2 $EE $22 $0C $AC
' ' ' ' ' ' ' ' '
lee temperatura escribe TH (reg. Temp. alta) escribe TL (reg. Temp. baja) lee TH lee TL inicia conversión detiene conversión escribe reg. configuración lee reg. configuración
cmd eeAddr eeData param char tmpIn halfBit
VAR VAR VAR VAR VAR VAR VAR
Byte Byte Byte Word param.LowByte Word tmpIn.Bit0
' ' ' ' ' ' '
comando de la PC puntero de dirección EE dato EE parámetro desde la PC caracter de la terminal valor directo del DS1620 indicador de 0,5 grados C
Página 154 • Manual StampWorks Versión 1.1
salidas LED DS1620.1 (a través de 1K) DS1620.2 DS1620.3
Experimento 31: Comunicaciones Seriales sign tempC tempF potVal buttons
VAR VAR VAR VAR VAR
tmpIn.Bit8 Word Word Word Nib
' ' ' ' '
1 = temperatura negativa grados C en décimas F en décimas lectura de BSAC botones de entrada
' ------------------------------------------------------------------------ID
DATA "Parallax",CR
' cadena terminada en CR
' ------------------------------------------------------------------------Inicializar: DirA = %1111 GOSUB DS1620init
' hace salidas los LEDs ' inicializa el DS1620
GOTO ShowMenu ' ------------------------------------------------------------------------Principal: cmd = 0 SERIN RxD,Baud96,[WAIT ("?"),HEX cmd] ' espera pedido del menu IF cmd = CMenu THEN ShowMenu ' convierte el comando para saltar LOOKDOWN cmd,[CID,CSet,CTmp,CTmpC,CTmpF,CStat,CLEDs],cmd BRANCH cmd,[ShowID,SetID,ShowTemp,ShowTempC,ShowTempF,ShowStat,SetLEDs] BadCommand: SEROUT TxD,Baud96,["Comando inválido: ",HEX2 cmd,CR] GOTO Principal END ' ------------------------------------------------------------------------DS1620init: HIGH Reset SHIFTOUT DQ,Clock,LSBFirst,[WrCfg,%10] LOW Reset PAUSE 10 HIGH Reset
' activa el DS1620 ' usa con CPU; modo continuo
Manual StampWorks Versión 1.1 • Página 155
Experimento 31: Comunicaciones Seriales SHIFTOUT DQ,Clock,LSBFirst,[StartC] LOW Reset RETURN
' inicia conversiones
ShowMenu: SEROUT TxD,Baud96,[CLS] SEROUT TxD,Baud96,["========================",CR] SEROUT TxD,Baud96,[" StampWorks Monitor ",CR] SEROUT TxD,Baud96,["========================",CR] SEROUT TxD,Baud96,["?FF – Ver Menú",CR] SEROUT TxD,Baud96,["?F0 - Mostrar ID",CR] SEROUT TxD,Baud96,["?F1 - Fijar ID",CR] SEROUT TxD,Baud96,["?A0 - DS1620 (directo)",CR] SEROUT TxD,Baud96,["?A1 - Temperatura (C)",CR] SEROUT TxD,Baud96,["?A2 - Temperatura (F)",CR] SEROUT TxD,Baud96,["?B0 – Estado de LEDs",CR] SEROUT TxD,Baud96,["?B1 - Activa LEDs",CR,CR] SEROUT TxD,Baud96,["Ingrese un comando.",CR,CR] GOTO Principal ShowID: SEROUT TxD,Baud96,["ID="] eeAddr = ID GetEE: READ eeAddr,eeData SEROUT TxD,Baud96,[eeData] eeAddr = eeAddr + 1 IF (eeData <> CR) THEN GetEE GOTO Principal SetID: eeAddr = ID GetC: SERIN RxD,Baud96,[char] WRITE eeAddr,char eeAddr = eeAddr + 1 IF (char <> CR) THEN GetC GOTO ShowID
Página 156 • Manual StampWorks Versión 1.1
' etiqueta o rótulo ' puntero al primer caracter de ID ' ' ' '
lee caracter de EEPROM imprime caracter apunta al siguiente si no CR, lee otro
' apunta a ubicación ID ' ' ' ' '
obtiene caracter de PC escribe caracter en EEPROM apunta a siguiente ubicación si no CR, espera otro confirma nueva ID
Experimento 31: Comunicaciones Seriales ShowTemp: GOSUB GetTemp ' envía valor directo a la PC SEROUT TxD,Baud96,["DS1620=",DEC tmpIn,CR] GOTO Principal ShowTempC: GOSUB GetTemp IF sign = 0 THEN NoNegC tmpIn = 0 ' solo Temp. por encima de cero NoNegC: tempC = tmpIn * 5 ' conv. val. direc. en décimas C SEROUT TxD,Baud96,["TempC=",DEC (tempC/10),".",DEC (tempC//10),CR] GOTO Principal ShowTempF: GOSUB GetTemp IF sign = 0 THEN NoNegF tmpIn = 0 NoNegF: tempF = (tmpIn * 9) + 320 ' conv. val en décimas de F SEROUT TxD,Baud96,["TempF=",DEC (tempF/10),".",DEC (tempF//10),CR] GOTO Principal ShowStat: SEROUT TxD,Baud96,["Estado=", BIN4 LEDs, CR] GOTO Principal SetLEDs: ' espera bits de salida ' – como cadena binaria ' SERIN RxD,Baud96,[BIN param] LEDs = param.LowNib GOTO ShowStat
' configura salidas ' confirma nuevas salidas
GetTemp: HIGH Reset SHIFTOUT DQ,Clock,LSBFirst,[RTmp]
' activa el DS1620 ' lee la temperatura
Manual StampWorks Versión 1.1 • Página 157
Experimento 31: Comunicaciones Seriales SHIFTIN DQ,Clock,LSBPre,[tmpIn\9] LOW Reset RETURN
' obtiene la temperatura
Descripción del Programa Sin comunicación serial asincrónica el mundo no sería lo que es hoy. No habría cajeros automáticos para controlar el estado de nuestras cuentas y retirar fondos. No podría haber Internet. Los experimentos anteriores han usado comunicación serial sincrónica. En ese esquema, se necesitaban dos líneas: reloj y datos. El beneficio es la sincronización automática del transmisor y receptor. El precio que pagamos es que se necesitan al menos dos cables para enviar un mensaje. La comunicación serial asincrónica solamente necesita un cable para transmitir un mensaje. En este caso es necesario que el emisor y el receptor estén de acuerdo en la velocidad de la comunicación antes de iniciar la transmisión de datos. Algunos sistemas “inteligentes” pueden detectar la velocidad de la comunicación (baud rate), pero el BASIC Stamp no puede. En este experimento usamos SEROUT para enviar información a una terminal y SERIN para recibir datos. La entrada normalmente será un comando y a veces el comando será acompañado por datos nuevos. Después de inicializar los LEDs de salida y el DS1620, el programa ingresa en el bucle principal y espera que se produzca una entrada desde la terminal. Primero, SERIN espera el caracter “?”, ignorando cualquier otra cosa que suceda. El símbolo de interrogación, significa que comienza una pregunta. Una vez que ingresa el signo de interrogación, el modificador HEX hace que el BASIC Stamp busque caracteres hexadecimales válidos (0 - 9, A - F). La llegada de cualquier caracter no hexadecimal (normalmente un [Enter] cuando se usa la terminal) le avisa al BASIC Stamp que deje de recibir datos (a la variable llamada param en nuestro caso) y continúe con el programa. Lo que en realidad sucede es que el BASIC Stamp ha usado la función SERIN para realizar una conversión de texto a número. Ahora que está disponible un comando, el programa usa LOOKDOWN para decodificar este comando y saltar con BRANCH a la subrutina conveniente si el comando era válido. Si el comando no es válido, se muestra un mensaje indicándolo.
Página 158 • Manual StampWorks Versión 1.1
Experimento 31: Comunicaciones Seriales El BASIC Stamp responde al pedido enviando una cadena de texto usando SEROUT a 9600 baudios (así podemos usar la terminal de DEBUG del BASIC Stamp). Cada una de las cadenas consiste de una etiqueta, el signo igual, el valor del parámetro y finalmente, un salto de línea. Cuando usa un programa terminal, la salida es fácil de leer. Algo así: ID=Parallax BS2 El salto de línea al final de la salida nos envía a la línea siguiente cuando se usa un programa terminal y sirve como indicador de “fin de entrada” cuando procesemos esta entrada en nuestro programa (similar al BASIC Stamp Plot Lite). El signo igual puede ser usado como separador cuando otro programa de computadora se comunica con el BASIC Stamp. Lo usaremos para distinguir la etiqueta de su valor respectivo. La mayoría de las preguntas son pedidos de información. Dos de ellas sin embargo, pueden modificar la información que está almacenada en el BASIC Stamp. La primera es “?F1” que nos permite escribir una cadena en la EEPROM del BASIC Stamp (en la ubicación llamada ID). Cuando F1 es recibido como valor de comando, el programa salta a la subrutina llamada SetID. Al ingresar a SetID, el puntero de EE llamado addr es inicializado, luego el BASIC Stamp espera que llegue un caracter. Observe que no se usan modificadores aquí. Dado que los programas terminal y el BASIC Stamp representan caracteres usando el código ASCII, no necesitamos hacer ningún tratamiento especial. Cuando llega un caracter, WRITE es usada para almacenarlo en la EEPROM y se incrementa el puntero de dirección. Si el último caracter era un salto de línea (13), el programa emite la cadena nueva (usando el código de ShowID), caso contrario repite la secuencia esperando el próximo caracter. La segunda es “?B1” que nos permite modificar el estado de cuatro LEDs. Mire la subrutina llamada SetLEDs. Esta vez, el modificador BIN de SERIN es usado para que podamos definir fácilmente bits individuales que queramos controlar. Usando el modificador BIN, nuestra entrada será una cadena de ceros y unos (cualquier otro caracter finalizará la entrada binaria). En este programa, un “1” hará que el LED se encienda y un “0” hará que el LED se apague. Este es un ejemplo del uso de B1. ?B1 0011 <CR>
Manual StampWorks Versión 1.1 • Página 159
Experimento 31: Comunicaciones Seriales La figura de abajo muestra una sesión real usando la terminal DEBUG del BASIC Stamp. Para ejecutar el experimento, siga estos pasos: 1. 2. 3. 4. 5. 6.
Quite todos los componentes de los experimentos anteriores. Ingrese y descargue el programa Apague la plaqueta StampWorks y arme el circuito Mueva el cable de programación al puerto “RS-232 Interfacing” Abra una ventana DEBUG haciendo clic en el ícono DEBUG Encienda la plaqueta StampWorks.
Desafío (para programadores de PC) Escriba un programa de PC que se comunique con este experimento.
Página 160 • Manual StampWorks Versión 1.1
Trabajando por su Cuenta
Trabajando por su Cuenta ¡Felicitaciones, usted es un programador de BASIC Stamps! Entonces, ¿qué sigue? Bien, eso depende de usted. Muchos programadores novatos se bloquean cuando intentan desarrollar sus propios proyectos. No se preocupe, esto es natural. Las siguientes ideas lo ayudarán a llevar a la realidad sus ideas. Planifique su trabajo, Trabaje según lo planificó Lo ha escuchado millones de veces: planifique, planifique y planifique. Nada causa más problemas a un programador que una planificación inadecuada. Esto es especialmente cierto con el BASIC Stamp debido a que los recursos son limitados. La mayoría de los programas que hemos reparado habían fallado debido a falta de planificación y formato pobre (que los hace difíciles de revisar). Hable Hable sobre el programa. No solo piense, hable. Hable en voz alta como si estuviese explicando la operación del programa a un compañero programador. A menudo, escuchar su propia voz es lo que marca la diferencia. Mejor aún, hable como si la persona a la que le estuviese narrando el programa no fuese un programador. Esto lo forzará a explicar los detalles. Muchas veces tomamos cosas por ciertas cuando hablamos con personas con habilidades similares a las nuestras. Escriba Diseñe los detalles de su programa por escrito antes de sentarse en su computadora. Use muchos colores. Encontrará que al trabajar visualmente en un diseño ideará nuevas aproximaciones y el uso de estos medios le permitirá escribir segmentos de programa dentro de sus diagramas funcionales. Diseñe con “Notas Autoadhesivas” Consiga un bloque de “notas autoadhesivas”. Escriba los nombres de los módulos o fragmentos concisos de código sobre papeles individuales y luego péguelos en la pared. Luego siéntese y écheles una mirada. Luego de un pequeño paseo. Agregue notas, quite algunas; simplemente haga lo que le parece correcto. Este ejercicio funciona especialmente bien con grupos. ¿Cómo sabe que terminó de diseñar el programa? ¡Cuando las notas adhesivas dejan de moverse! Es una buena idea escribir la versión final antes de abrir el editor. Otra idea: esta técnica funciona mejor si se la mezcla con la anterior, dibujando líneas que indiquen el flujo del programa. Si se equivoca, borre las líneas o mueva las notas. Intente esto, realmente funciona.
Manual StampWorks Versión 1.1 • Página 161
Trabajando por su Cuenta Vaya más allá de la caja A esta altura de las circunstancias, su apetito por los proyectos con BASIC Stamps seguramente habrá crecido mas allá de lo que usted originalmente esperaba. Así que, ¿hacia dónde puede ir ahora? No se preocupe, hay muchos recursos relacionados a los BASIC Stamps disponibles, en formato impreso o por Internet. Esta es una lista con recursos en Ingles y Castellano: Libros y revistas • • • • • • •
Microcontroller Application Cookbook por Matt Gilliland Microcontroller Projects with BASIC Stamps por Al Williams Programming and Customizing the BASIC Stamp Computer por Scott Edwards BASIC Stamp por Claus Kühnel y Klaus Zahnert Getting Started In Electronics por Forrest Mims Engineer’s Notebook por Forrest Mims Nuts & Volts Magazine “Stamp Applications” column
Sitios Web www.parallaxinc.com
www.stampsinclass.com www.al-williams.com/awce/index.htm www.seetron.com www.hth.com/losa www.emesystems.com/BS2index.htm
Sitio principal de Parallax Sitio educativo de Parallax Sitio web de Al Williams Sitio web de Scott Edwards Electronics Fuente de ideas: List of Stamp Applications Recursos técnicos de Tracy Allen
Sitios web en castellano www.stampsenclase.com www.cursoderobotica.com.ar
Sitio educativo de Parallax en castellano Sitio web del Curso de Robotica con recursos
Libros en castellano En los sitios web en castellano encontrará manuales del programa Stamps en Clase, que puede bajar gratuitamente.
Página 162 • Manual StampWorks Versión 1.1
Apéndice A: Hojas de Datos
Apéndice A: Hojas de Datos Las primeras páginas de las hojas de datos (en Inglés) de los fabricantes se incluyeron en el Apéndice A. Las hojas de datos completas se pueden bajar de la página de StampWorks en www.parallaxinc.com o de los sitios web de los fabricantes. • • • • • • • • • • • •
Plaqueta NX-1000 - Innovative Experiment Company Conversor A/D ADC0831 8-bit– National Semiconductor Registro de desplazamiento 74HC165 entrada paralela-salida serial 8-bit– National Semiconductor Registro de desplazamiento 74HC595 entrada serial-salida paralela 8-bit– Motorola Reloj de tiempo real DS1302– Dallas Semiconductor Termómetro digital DS1620– Dallas Semiconductor Display de cristal líquido de matriz de puntos HD44780U (compatible Hitachi) – Innovative Experiment Company Driver ULN2003– Texas Instruments Motor paso a paso 12V 75 ohm– Jameco Driver de 7 segmentos MAX7219 8-Digit– Maxim Integrated Products Temporizador LM555– National Semiconductor Amplificador operacional doble LM358– National Semiconductor
Manual StampWorks Versión 1.1 • Página 163
Página 164 • Manual StampWorks Versión 1.1 FREQUENCY
GND
a b c d e f g dp
DIGIT 4 3 2 1
13 5
14 6
S1
S2
S3
S4
S5
PUSH BUTTON SWITCH
S3
S4
S5
PROTO BOARD AREA
2
10
8 0
9 1
+V 1
2
RS R/W E D0 D1 D2 D3 D4 D5 D6 D7
LCD CONNECTOR
7 6 5 4 3 2 1 0
3
11
1 2 3 4
4
12
LED MONITOR 16 CHANNELS
15 14 13 12 11 10 9 8
7
15
NX-1000 Univeersal training board
BASIC Stamp II Connector 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
LED 7 SEGMENT DISPLAY
3
4 OUTPUT
4 CHANNELS DRIVER
VR-10k
PIEZO
+
1Hz 10Hz 100Hz 1kHz
GND
TxD
RxD
+5V
BS2-IC/BS2SX-IC
PULSE GENERATOR
POWER
RESET
RS-232 INTERFACING
7805
DOWNLOAD
D7 D6 D5 D4 D3 D2 D1 D0
DC INPUT
Apéndice A: Hojas de Datos
2 3 4 5
9
6 7 8
K16 RS-232 2 3 4 5
1
+5V
R31 4k7
10 P5 11 P6 12 P7
1 Sin 2 Sout 3 ATN 4 GND 5 P0 6 P1 7 P2 8 P3 9 P4
R35 1k8
Q2 BC557 C5 10/50V
R34 4k7
R33 4k7
+5V
GND
TxD
RxD
LED1
R27 10k
K2 GND
K1 +5V
S10 FREQ.
POWER
R1 220
SW1
RESET
RS-232 INTERFACING
IC1 7805
+V
+V ~12V
P10 15 P9 14 P8 13
PWR 24 GND 23 RES\ 22 +5V 21 P15 20 P14 19 P13 18 P12 17 P11 16
C3 0.1/50V
SK1
Q1 BC547
C2 220/25V
D1-D4 1N4001 x4
D6 1N4148
R32 4k7
D5 1N4148
C1 0.1/50V
Power Supply
J1 DC IN 9-12V
7
6
K1 RS-232 DOWNLOAD
BASIC Stamp II Front-end
4
C4 0.1/50V
+5V
R2 10k*1
K5 DIP SWITCH
D7 D6 D5 D4 D3 D2 D1 D0
D7 D6 D5 D4 D3 D2 D1 D0
LED2-LED5 5 6
8
3
VR2 10k
K12 OUT
1k 100 10
HERTZ (Hz) 1
R28-R31 510 X4
PULSE GENERATOR
SP1 PIEZO SPEAKER
IC 3 7 P GX4100 2
1
+5V
+
K13
+5V
P4
P3
P2
P1
K14
K10
D2 D1 D0
RS R/W E D7 D6 D5 D4 D3
D7 D6 D5 D4 D3 D2 D1 D0
K11 INPUT
S9 DIP SW. *8
S8 S7 S6 S5 S4 S3 S2 S1
VARIABLE RESISTOR
K4 PUSH BUTTON SWITCH
Switch circuit
Piezo Speaker
-
P15 P14 P13 P12 P11 P10 P9 P8 P7 P6 P6 P5 P4 P3 P2 P1 P0
K3 BASIC Stamp CONNECTOR
3
4
5
6
DIGIT4
K9
a b c d e f g dp
8
9
R19-R26 220x8
a b c d e f g dp
DSP304
+5V
RS E D1 D3 D5 D7
IC2 ULN2003
14
13
12
11
OUT4
K13 DRIVER OUT3 OUTPUT
OUT2
+12V 500 mA(max) OUT1
HIGH CURRENT DRIVER
R/W D0 D2 D4 D6
Vo
K11 +5V UIC-LCD
LCD module connector
K8
VR1 10k Brightness
DIGIT3 DIGIT2 DIGIT1
K7 LED display 4 digit
15 14 13 12 11 10 9 8
R3-R10 220x8 P15 P14 P13 P12 P11 P10 P9 P8 K6
DSP302
DSP301
P7 P6 P5 P4 P3 P2 P1 P0
LED Monitor
Thailand
The manufacturer of en g ineering educational products in Thailand, BASIC Stamp products distributor in
Innovative Experime nt Co.,Ltd.
Design and copyright by
Universal training board for BASIC Stamp 2/2SX microcontroller module Digital circuit experiment Programmable Logic Device experiment and any small/medium microcontroller experiment
NX-1000
DSP303
7 6 5 4 3 2 1 0
R11-R18 220x8
Apéndice A: Hojas de Datos
Manual StampWorks Versión 1.1 • Página 165
Apéndice A: Hojas de Datos
Página 166 • Manual StampWorks Versión 1.1
Apéndice A: Hojas de Datos
Manual StampWorks Versión 1.1 • Página 167
Apéndice A: Hojas de Datos
Página 168 • Manual StampWorks Versión 1.1
Apéndice A: Hojas de Datos
Manual StampWorks Versión 1.1 • Página 169
Apéndice A: Hojas de Datos
Página 170 • Manual StampWorks Versión 1.1
Apéndice A: Hojas de Datos
Manual StampWorks Versión 1.1 • Página 171
Apéndice A: Hojas de Datos
Página 172 • Manual StampWorks Versión 1.1
Apéndice A: Hojas de Datos
Manual StampWorks Versión 1.1 • Página 173
Apéndice A: Hojas de Datos
Página 174 • Manual StampWorks Versión 1.1
Apéndice A: Hojas de Datos
Manual StampWorks Versión 1.1 • Página 175
Apéndice A: Hojas de Datos
Página 176 • Manual StampWorks Versión 1.1
Apéndice B: Manual del BASIC Stamp II, Versión 2.0
Apéndice B: Manual del BASIC Stamp II Versión 2.0 El Manual del BASIC Stamp 2.0 es incluido en este apéndice. El manual completo (y futuras actualizaciones) se pueden comprar o descargar desde www.parallaxinc.com.
Manual StampWorks Versión 1.1 • Página 177