Experimentos y Código Fuente para el BASIC Stamp

Transcripción

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 [email protected], 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:
[email protected]
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 [email protected].
Introducción
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!
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
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.
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:
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.
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).
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.
Indicador
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á.
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.
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
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.”
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.
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.
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.
'
'
'
'
'
'
'
=========================================================================
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
•
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 ([email protected]).
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 [email protected].
Si quiere opinar sobre el libro en sí, puede enviar sus comentarios a Jon Williams, [email protected].
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.
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
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
' 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.
•
•
•
•
•
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
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
PAUSE TiempoEnc
MiLED = Apagado
PAUSE TiempoAp
GOTO Principal
END
' pausa de encendido
' pausa de apagado
' repite todo
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
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
' pone cntr.Bit0 en MiLED
' pausa de encendido
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.
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.
•
•
•
OutL, OutH
DirL, DirH
FOR-NEXT
Estos LEDs figuran en el sector “LED MONITOR 16 CHANNELS” de la plaqueta NX-1000.
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
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
' bucle que genera los números
' muestra el número con LEDs
' pausa entre números
' repite todo
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.
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.
•
•
•
<< (Operador de desplazamiento de bits hacia la izquierda)
>> (Operador de desplazamiento de bits hacia la derecha)
IF-THEN
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
' ------------------------------------------------------------------------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
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
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).
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.
•
•
•
•
•
Word
RCTIME
*/ (operador estrella-barra)
GOSUB-RETURN
DCD
Agregue este circuito al Experimento 4.
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
' descarga el capacitor
' durante 1 ms
' lee el potenciómetro
' escala grafVal (0 - 255)
' – equivalente a rawVal * 0.372
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
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
(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.
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.
•
•
•
•
•
RANDOM
& (operador And)
FREQOUT
BUTTON
LOOKUP
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
' 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
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.
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).
•
•
•
•
DATA
MIN
// (Operador módulo)
BRANCH
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
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
' -------------------------------------------------------------------------
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:
RANDOM randW
Lights = randW & %00111111
GOTO Principal
' obtiene número aleatorio
' enciende canales aleatorios
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?
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 …
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.
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.
•
Nib
'
'
'
'
'
=========================================================================
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
' cuenta
' muestra el dígito
' durante un segundo
' repite todo
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.
Experimento 9: Dado Digital
Experimento 9:
Dado Digital
El propósito de este experimento es crear un dado digital.
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
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
'
'
'
'
'
limita entre 1 y 6
muestra patrón de giro
¿actualiza el indicador de giro?
solo si doSpin = 0
actualiza el indicador de giro
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.
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.
•
•
•
•
OutA,OutB,OutC,OutD
DirA,DirB,DirC,DirD
In0 - In15
DIG
'
'
'
'
'
=========================================================================
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
' muestra dígito actual
' ¿nuevo segundo?
' repite
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
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
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
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
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.
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.
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.
•
•
•
PULSOUT
HighNib, LowNib
^ (operador OR Exclusiva)
'
'
'
'
'
'
=========================================================================
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
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
char = %00001110
GOSUB LCDcommand
' enciende el cursor
PAUSE 500
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
' ------------------------------------------------------------------------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
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.
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.
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.
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
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
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
'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
'
'
'
'
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
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:
PULSOUT E,1
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
' salen 4 bits altos
' salen 4 bits bajos
' regresa a modo caracter
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.
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.
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.
•
InA, InB, InC, InD
'
'
'
'
'
'
=========================================================================
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
CrsrLf
CrsrRt
DispLf
DispRt
DDRam
CGRam
CON
CON
CON
CON
CON
CON
$10
$14
$18
$1C
$80
$40
'
'
'
'
'
'
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
' ------------------------------------------------------------------------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
' mueve el valor a CGRAM
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
' modo de 8 bits
PULSOUT E,1
LCDout = %0010
PULSOUT E,1
char = %00001100
GOSUB LCDcommand
char = %00000110
GOSUB LCDcommand
RETURN
LCDcommand:
LOW RS
LCDwrite:
PULSOUT E,1
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
' modo de 4-bits
' config. LCD
' config. LCD
' comando de datos
' leer
' hace entradas líneas de datos
' obtiene 4 bits superiores
' obtiene 4 bits inferiores
' líneas de datos como salidas
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.
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).
•
LOOKDOWN
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
CrsrLf
CrsrRt
DispLf
DispRt
DDRam
CGRam
CON
CON
CON
CON
CON
CON
$10
$14
$18
$1C
$80
$40
'
'
'
'
'
'
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
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
' ------------------------------------------------------------------------Principal:
char = ClrLCD
' limpia el LCD
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
' modo de 8 bits
' modo de 4-bits
' selec. fuente 5x10
' config. LCD
' config. LCD
LCDwrite:
PULSOUT E,1
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
'
'
'
'
'
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
'
'
'
'
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
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.
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.
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.
•
•
•
~ (operador de complemento a 1)
CLS (modificador de DEBUG)
IBIN, IBIN1 – IBIN16 (modificadores de DEBUG)
'
'
'
'
'
=========================================================================
Archivo: DEBOUNCE.BS2
Eliminación simultánea del rebote en 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
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.
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.
Experimento 16: Contando Eventos
Experimento 16:
Contando Eventos
Este experimento demuestra un retardo programado por eventos externos.
'
'
'
'
‘
'
=========================================================================
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
Experimento 16: Contando Eventos
WaitLow:
IF E_in = IsHigh THEN WaitLow
GOTO WaitForCount
WaitDone:
RETURN
' espera que la ent. pase a bajo
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
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.
•
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
' -------------------------------------------------------------------------
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
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?
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.
•
PULSIN
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
Experimento 18: Medición Avanzada de Frecuencia
GOTO Principal
END
' repite todo
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.
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.
'
'
'
'
'
'
'
=========================================================================
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
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
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.
Experimento 20: Efectos de Sonido
Experimento 20
Efectos de Sonido
Este experimento usa FREQOUT y DTMFOUT para crear efectos de sonido de teléfono.
•
DTMFOUT
'
'
'
'
'
'
'
=========================================================================
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
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
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
' "clic"
PAUSE 4000
NEXT
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
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
para obtener notas musicales precisas. Tenga en cuenta que cada octava duplica la frecuencia de
una nota.
Octava 2 = Octava 1 * 2
Y así…
Desafío
Convierta (una parte de) su canción favorita para que suene en el BASIC Stamp.
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.
'
'
'
'
'
'
'
=========================================================================
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
' -------------------------------------------------------------------------
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
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.
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.
•
PWM
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
' -------------------------------------------------------------------------
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
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.
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.
•
SHIFTOUT
'
'
'
'
'
=========================================================================
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
' envía patrón al 74x595
' bloquea (latch) las salidas
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.
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.
•
SHIFTIN
'
'
'
'
'
=========================================================================
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
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.
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.
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.
•
SDEC, SDEC1 – SDEC16 (modificador de DEBUG)
'
'
'
'
'
'
'
=========================================================================
Archivo: SERVO.BS2
Controlador de la posición de un Servo
{$STAMP BS2}
=========================================================================
PotCW
CON
0
' entrada pot sentido horario
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
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.
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.
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.
•
ABS
'
'
'
'
'
'
'
=========================================================================
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
' 1 rev. adelante
' 1 rev. atrás
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
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
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.
'
'
'
'
'
=========================================================================
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
' -------------------------------------------------------------------------
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
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.
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).
'
'
'
'
'
=========================================================================
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.
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
' activa el DS1620
' use con CPU; func. Continuo
' inicia conversiones
'
'
'
'
activa el DS1620
entrega comando leer Temp..
la lee
libera al DS1620
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
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).
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.
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.
'
'
'
'
'
'
'
=========================================================================
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
' ------------------------------------------------------------------------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
' habilita todas las entradas
' controla entradas
' retardo entre controles
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
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.
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.
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.
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.
'
'
'
'
'
'
=========================================================================
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
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
'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
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"
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?
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
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
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
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.
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.
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.
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.
•
•
•
•
•
•
SERIN
SEROUT
WAIT (modificador de SERIN)
HEX (modificador de SERIN/SEROUT)
BIN (modificador de SERIN/SEROUT)
WRITE
'
'
'
'
'
'
'
=========================================================================
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
salidas LED
DS1620.1 (a través de 1K)
DS1620.2
DS1620.3
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
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
' 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
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
SHIFTIN DQ,Clock,LSBPre,[tmpIn\9]
LOW Reset
RETURN
' obtiene la temperatura
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.
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>
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.
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.
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.
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
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
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 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.

Experimentos y Código Fuente para el BASIC Stamp

Transcripción

Documentos relacionados