Stampworks Espanol PDF

Experimentos y Cdigo Fuente para el BASIC Stamp
Versin en Castellano 1.1
Sobre la precisin de este texto:

Se realiz un gran esfuerzo para asegurar la precisin de este texto y
los experimentos, pero puede haber errores an. Si usted encuentra
errores o algn tema que requiera informacin adicional, por favor
infrmelo a aalvarez@parallaxinc.com, as podemos continuar
mejorando la calidad de nuestra documentacin.
Garanta
Parallax garantiza sus productos contra defectos en sus materiales o debidos a la fabricacin por un perodo de 90 das. Si usted
descubre un defecto, Parallax segn corresponda, reparar, reemplazar o regresar el valor de la compra. Simplemente pida un
nmero de autorizacin de regreso de mercadera (Return Merchandise Authorization, RMA), escriba el nmero en el exterior de la
caja y envela a Parallax. Por favor incluya su nombre, nmero telefnico, direccin y una descripcin del problema. Nosotros le
regresaremos su producto o el reemplazo, usando el mismo mtodo de correo que usted us para enviar el producto a Parallax.
Garanta de 14 das de regreso de dinero

Si dentro de los 14 das 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 daado.
Derechos de Copia y Marcas Registradas

Esta documentacin 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 pgina web o en material impreso, debe agregar la
aclaracin: BASIC Stamp es una marca registrada de Parallax, Inc. Otros nombres de productos son marcas registradas de sus
respectivos dueos.
Desvinculacin de Responsabilidad
Parallax, Inc. no es responsable de daos por consecuencias, incidentes o daos especiales que resulten de cualquier violacin de la
garanta, bajo cualquier teora legal, incluyendo prdida de beneficio, tiempo, dao 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 dao personal, incluyendo vida o muerte, resultado del uso de cualquiera de nuestros productos.
Usted tiene absoluta responsabilidad por la aplicacin 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 informacin se muestran a continuacin:
E-mail: aalvarez@parallaxinc.com
Web: http://www.parallaxinc.com y http://www.stampsenclase.com
Lista de Discusin de BASIC Stamp en Internet

Mantenemos dos listas de discusin 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 rpida, divertida y gratis de
discutir temas sobre el BASIC Stamp y obtener respuestas a preguntas tcnicas. Para suscribirse a la lista de BASIC Stamp encuentre
la informacin en www.parallaxinc.com. Esta lista genera aproximadamente 40 mensajes diarios.
Tambin 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 discusin en castellano puede encontrarla en http://www.stampsenclase.com.

Contenido
Contenido
Prefacio ............................................................................................................................... 3
Introduccin .............................................................................................................................. 5
Obtenga el Mayor Provecho de las Prcticas de StampWorks ......................................................... 5
Tres Pasos para Tener xito con StampWorks .............................................................................. 5
Prepare su Plaqueta StampWorks....................................................................................... 7

Contenido de este Kit ................................................................................................................. 7
Preparacin de la Protoboard ...................................................................................................... 8
Bases de la Programacin ................................................................................................. 13

Contenido de un Programa ....................................................................................................... 13
Saltos Redireccionando el Flujo de un Programa ...................................................................... 14
Bucles Ejecutando el cdigo una y otra vez.............................................................................. 15
Subrutinas Cdigo reutilizable que ahorra espacio de programa................................................. 17
Estilo de Programacin ............................................................................................................. 17
Plantilla ................................................................................................................................... 18
Convencin sobre Nombres....................................................................................................... 19
Hora de Experimentar ....................................................................................................... 21

Aprendiendo los Conceptos de Programacin.............................................................................. 21
Construccin de Proyectos ........................................................................................................ 21
Que hacer entre proyectos........................................................................................................ 21
Experimento 1: Hacer Titilar un LED .......................................................................................... 23
Experimento 2: Hacer Titilar un LED (Versin 2) ......................................................................... 25
Experimento 3: Contador con LEDs............................................................................................ 29
Experimento 4: Pantalla de LEDs de Ciencia Ficcin .................................................................... 33
Experimento 5: Grficos 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 Dgito ....................................................................................... 51
Experimento 9: Dado Digital ..................................................................................................... 55
Experimento 10: Reloj con Pantalla de LEDs ............................................................................... 59
Manual StampWorks Versin 1.1 Pgina 1

Contenido
Usando LCDs ......................................................................................................................65

Experimento 11: Demostracin Bsica 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 Mgica................................................................................ 85
Avanzando..........................................................................................................................91
Experimento 15: Filtrando Mltiples Entradas ............................................................................. 93
Experimento 16: Contando Eventos ........................................................................................... 97
Experimento 17: Medicin de Frecuencia ................................................................................... 99
Experimento 18: Medicin Avanzada de Frecuencia....................................................................101
Experimento 19: Theremin Controlado por Luz ..........................................................................103
Experimento 20: Efectos de Sonido ..........................................................................................105
Experimento 21: Entrada Analgica con PULSIN ........................................................................109
Experimento 22: Salida Analgica 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: Medicin de Tensin.......................................................................................129
Experimento 28: Medicin 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
Apndice A: Hojas de Datos .............................................................................................163
Apndice B: Manual del BASIC Stamp II, Versin 2.0 .....................................................177
Pgina 2 Manual StampWorks Versin 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 ms duraderos. Y para ser
franco, aprender haciendo es casi siempre la forma ms satisfactoria de aprender; involucra ms 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 teora son
cortas y concisas. Aprender la teora de programacin, ponindola en prctica. No encontrar
muchos rodeos; solamente encontrar trabajo, trabajo divertido que le ensear a programar
microcontroladores con el BASIC Stamp de Parallax.
Por qu tomar el desafo? Por qu aprender a escribir programas para el microcontrolador BASIC
Stamp? La respuesta es simple, sino obvia: los microcontroladores se encuentran por todos lados.
Estn en nuestros televisores, hornos microondas, telfonos celulares e incluso en nuestros autos. El
hecho es que los automviles ms nuevos tienen diez o ms microcontroladores controlando todo,
desde el motor, la climatizacin del habitculo, la rotacin de las ruedas (control de traccin), el
sistema de frenos (ABS) y muchas otras funciones. En resumen, los vehculos modernos son ms
seguros y ms confortables debido, en gran medida, al uso de microcontroladores.
Con microcontroladores podemos construir circuitos y dispositivos inteligentes. En el pasado,

debamos 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 modificacin de
programas y con el Kit de StampWorks qu tan fcil puede ser.
Divirtase con estos proyectos y piense cmo podra aplicar los conceptos aprendidos en cada uno.
Apreciar recibir sugerencias (en Ingls) en cualquier momento por e-mail a jonwms@aol.com.

Introduccin

Introduccin
Introduccin
Obtenga el Mayor Provecho de las Prcticas 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 informacin adicional de la pgina de StampWorks del sitio web
www.parallaxinc.com, incluyendo hojas de datos, actualizaciones y detalles tcnicos generados
despus de emitida esta publicacin.
Tres Pasos para Tener xito con StampWorks:
1. Lea la Seccin 1 del manual del BASIC Stamp II (en Ingls). Esta seccin le explicar el
funcionamiento del BASIC Stamp II y lo guiar en el proceso de instalacin del software de
programacin. Otro recurso til es el captulo 1 de Robtica! (en Castellano) que puede
descargarse por internet de www.stampsenclase.com.
2. Lea la seccin siguiente de este manual, Prepare su Plaqueta de StampWorks para los
Experimentos. Esta seccin describe los pasos necesarios para poner en condiciones la
plaqueta de experimentacin.
3. Realice los experimentos por su cuenta, refirindose a la gua 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 cdigo.
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 indicacin: Divirtase!

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:
Cdigo Descripcin Cantidad

150-01020 resistor 1K ohm, W, 5% 4
150-01030 resistor 10K ohm, W, 5% 8
150-02210 resistor 220 ohm, W, 5% 3
150-04720 resistor 470 ohm, W, 5% 1
200-01040 capacitor 0.1 uF 4
201-01061 capacitor 10 uF 1
251-03230 cristal de 32.768 kHz 1
27000 CD-ROM Parallax 1
27220 Manual StampWorks (en Ingls) 1
27964 Motor paso a paso 12 VDC/75 ohm 1
28135 Plaqueta NX-1000 y LCD 2x16 1
28162 Multmetro Digital 1
350-00009 Fotorresistor 2
451-00303 Conector de 3 pines 1
602-00009 74HC595 1
602-00010 74HC165 1
602-00015 Amp. operacional doble LM358 1
603-00001 MAX2719, driver de LEDs 7 seg. 1
604-00002 Termmetro Digital DS1620 1
604-00005 Reloj de tiempo real DS1302 1
604-00009 Temporizador 555 1
700-00050 Cable rojo 1
700-00051 Cable blanco 1
700-00052 Cable negro 1
700-00065 Juego de herramientas 1
700-00066 Corta / pela cables 1
750-00007 Fuente de alimentacin 12V 1A 1
800-00003 Cable Serial 1
900-00001 Parlante 1
900-00005 Servo comn Parallax 1
ADC0831 Conversor A/D de 8-bits ADC0831 1
BS2-IC Mdulo BASIC Stamp II 1

Para poder realizar los experimentos de StampWorks, necesitar estos componentes:
Mdulo BASIC Stamp II

Plaqueta de laboratorio StampWorks (INEX-1000)
Fuente de alimentacin de 12 V
Cable de programacin
Cables rojo y negro
Corta / pela cables
Empiece quitando la envoltura del mdulo BASIC Stamp II e insrtelo cuidadosamente en el zcalo
de StampWorks. Observar que el mdulo BASIC Stamp II y la plaqueta de laboratorio StampWorks
tienen una marca semicircular. El mdulo BASIC Stamp II debera insertarse en el zcalo de forma
que las marcas queden alineadas.
Use el cable de programacin 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 electrnico, de su
computadora, asegrese de deshabilitar el software de comunicacin antes de intentar programar el
BASIC Stamp. Si an no ha instalado el software de programacin del Stamp, vea la Seccin 1 del
manual de programacin del Stamp II para obtener instrucciones.
Asegrese de que el interruptor de encendido de la plaqueta de laboratorio StampWorks est en OFF.

Conecte la ficha de la fuente de alimentacin de 2.1 mm en la ficha DC INPUT. Conecte la fuente de
alimentacin a un toma (120 VCA o 220 VCA segn 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 cmo trabaja la protoboard. Con un poco
de preparacin, le ser an ms fcil usarla en los prximos experimentos.

La parte central de la protoboard es la que usaremos para conectar nuestros componentes. Esta
seccin consiste en varias columnas de conectores (hay un nmero 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 elctricamente 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 lneas horizontales sern usadas para
suministrar los +5 volts (Vdd) y masa (Vss). Para preparar la protoboard uniremos las filas para que
la alimentacin sea accesible en todos los sectores de la protoboard. As se ve la protoboard desde
el exterior:
Si la viramos con rayos-X, podramos 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 centmetro del aislante del extremo de un cable de interconexin 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
lnea 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, asegurndose de no daar el cable.
Quite el cable de la protoboard y crtelo medio centmetro ms 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 debera poder introducirse fcilmente
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, tambin 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 alimentacin superior e inferior. Estas filas proveern 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 centmetro en ambos extremos.
Doble cada cable con forma de U redondeada. Estos cables no quedarn planos como los
anteriores, para que sean ms fciles 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
podran producir daos al conectar la alimentacin a la plaqueta StampWorks. Cuando termine el
conexionado, la protoboard debera verse as:
Encienda la plaqueta StampWorks moviendo el interruptor de energa a la posicin ON. Debera

encenderse el LED indicador de encendido (ON LED verde). Si no es as, asegrese 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 lnea de cdigo:
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 Ingls).

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 posicin ON? Est encendido el LED verde?
El cable de programacin est conectado entre la PC y la plaqueta StampWorks?
Ha seleccionado (manualmente) un puerto com errneo 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 programacin del Stamp.
Conexin de un Chip
Hay dos formas de dibujar un esquema. Una considerada chip-

cntrica en la cual los pines de E/S del chip aparecen de
acuerdo a su ubicacin fsica. En StampWorks los esquemas se Indicador
dibujaron de forma ms eficiente, poniendo los pines de E/S en
los lugares que hagan el grfico ms 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.

Bases de la Programacin
Contenido de un Programa
En la seccin 1 de BASIC Stamp II manual se introduce el BASIC Stamp, su arquitectura y el

concepto de variables y constantes. En esta seccin, presentaremos varios elementos de un
programa: cdigo lineal, saltos, bucles y subrutinas.
Los ejemplos siguientes usan pseudo-cdigo para demostrar y describir la estructura del programa.
Itlicas se usan para indicar las secciones de pseudo-cdigo que deberan ser reemplazadas por
instrucciones de programacin vlidas para lograr que el ejemplo pueda ser compilado y ejecutado
correctamente. Usted no necesita realizar ninguno de estos ejemplos, ya que todos estos conceptos
sern usados en los prximos 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 especfico de instrucciones.
Este juego de instrucciones se llama programa. Escribirlo es nuestro trabajo. Los programas del
Stamp se escriben en un lenguaje de programacin llamado PBASIC, una versin especfica del
lenguaje de programacin BASIC (Beginners All-purpose Symbolic Instruction Code= Cdigo de
Instrucciones Simblicas Multi-propsito para Principiantes) desarrollada por Parallax. El BASIC es
muy popular debido a su simplicidad y a su sintaxis similar al Ingls.
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 vlida. Lo que encontrar sin embargo, es que
la mayora 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 pequeas
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 desve de su trayectoria lineal. En
otras palabras, cuando el programa encuentra un comando de salto, no ejecutar, en la mayora de
los casos, la siguiente lnea de cdigo. El programa normalmente, se dirigir a otro sector. Hay dos
categoras 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 ubicacin se especifica como parte del comando GOTO y se denomina direccin.
Recuerde que las direcciones estn al principio de una lnea de cdigo y son seguidas por dos puntos
(:). Ver frecuentemente GOTO al final del cuerpo principal del cdigo, haciendo que las instrucciones
del programa se ejecuten nuevamente.
El salto condicional har que el flujo del programa se modifique bajo circunstancias especficas. El
salto condicional ms simple se logra con la funcin IF-THEN. La funcin de PBASIC IF-THEN es
diferente de la original de BASIC. En PBASIC, THEN siempre es seguido por una direccin de
programa (etiqueta), mientras que en el BASIC estndar se permite colocar instrucciones a
continuacin del THEN. Si la condicin que se evala es verdadera, el programa saltar a la direccin
especificada. Caso contrario, continuar en la siguiente lnea de cdigo.
Observe este listado:
Inicio:
instruccion 1
instruccion 2
instruccion 3
IF condicion THEN Inicio
Se ejecutan las instrucciones y se verifica la condicin. Si se evala como verdadera, el programa

saltar hacia atrs a la lnea llamada Inicio. Si la condicin se evala como falsa, el programa
continuar por la lnea que se encuentre a continuacin de la instruccin IF-THEN.

A medida que sus requerimientos se vuelven ms complicados, podra necesitar que su programa
salte a un gran nmero de direcciones, dependiendo de cierta condicin. La primera aproximacin es
usar mltiples instrucciones IF-THEN.
IF condicion_0 THEN Etiqueta_0

Esta aproximacin es vlida 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 mencionbamos, a menudo
proceden de una variable de control. BRANCH es un poco ms sofisticado en su funcionamiento, pero
muy poderoso debido a que puede reemplazar mltiples 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 lnea
de cdigo:
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 cdigo 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 repeticin. 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 repetirn en ciertas condiciones. Los siguientes ejemplos son llamados bucles condicionales.
Estos bucles se ejecutarn bajo ciertas circunstancias. La programacin 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 repeticin, las instrucciones se ejecutarn mientras la condicin se evale
como verdadera. Cuando la condicin se evale como falsa, el programa continuar por la lnea de
cdigo siguiente a la instruccin IF-THEN. Es importante observar que en el listado anterior las
instrucciones siempre se ejecutarn al menos una vez, incluso cuando la condicin sea falsa.
Para evitar que suceda esto, es necesario probar la condicin antes de ejecutar las instrucciones. El
cdigo puede escribirse como se muestra a continuacin para lograr que las instrucciones (1 3)
solamente se ejecuten cuando la condicin sea verdadera. Cuando la condicin es evaluada como
falsa, el programa contina 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 FOR-
NEXT.
FOR controlVar = ValInicial TO ValFinal STEP tamaoPaso

instruccion 1
instruccion 2
instruccion 3
NEXT
La construccin FOR-NEXT es usada para lograr que una seccin de cdigo se ejecute una cantidad
determinada de veces. FOR-NEXT usa una variable de control para determinar la cantidad de
repeticiones. El tamao de la variable determinar la cantidad mxima de repeticiones. Por ejemplo,
la cantidad mxima de repeticiones cuando se utiliza una variable de control tipo byte ser 255.

La opcin STEP de FOR-NEXT es usada cuando se necesita que el incremento de la variable en cada
repeticin sea distinto de uno. Si, por ejemplo, el bucle debe contar en valores pares, el cdigo
podra verse as:
FOR controlVar = 2 TO 20 STEP 2

instruccion 1
instruccion 2
instruccion 3
NEXT
Subrutinas Cdigo reutilizable que ahorra espacio de programa
El ltimo concepto de programacin que discutiremos es la subrutina. Una subrutina es una seccin
de cdigo que puede ser llamada (ejecutada) desde cualquier punto del programa. GOSUB es usado
para redirigir el programa hacia el cdigo de la subrutina. La subrutina termina con el comando
RETURN. Este comando hace que el programa salte hacia la lnea de cdigo 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 cdigo de MySub es ejecutado y luego el programa salta hacia atrs a la lnea
PAUSE 1000.
Estilo de Programacin
El PBASIC es un lenguaje muy flexible. Sus reglas son simples y fciles de aprender. El PBASIC no es
sensible al formato del programa, uso de espacios en blanco (espacios, tabulaciones, lneas en
blanco, etc.) y no detecta diferencias entre maysculas y minsculas; esto quiere decir que dirs,
Dirs y DIRS significan lo mismo en PBASIC as que podremos elegir la opcin que ms nos guste
para trabajar.

Los programadores experimentados tienden a adoptar o desarrollar un estilo (de formato) de

programacin consistente. Ya sea que elija adoptar un estilo o desarrollar uno propio, el hecho de
mantener la coherencia con el mismo simplificar la solucin 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 seccin contiene el nombre del archivo y una corta descripcin de su
funcionamiento. Tambin se registran en este sector las revisiones y actualizaciones que se
realizan a la versin original. En la Versin 1.1 de este libro, tambin hemos agregado la
directiva del compilador que indica el modelo de BASIC Stamp que estamos usando.
Declaraciones: sta seccin contiene la declaracin de los alias para los pines de E/S, valores
constantes y variables. En los ejemplos de programacin de esta gua, las variables PBASIC
siempre tendrn nombres significativos. Los nicos nombres internos que se usarn sern
Outs y Dirs y siempre en la seccin de inicializacin y no en el cdigo principal.
Instrucciones DATA: Algunos programas almacenan informacin adicional en la EEPROM del

BAISC Stamp con instrucciones DATA. Esta seccin provee el espacio para dicho
almacenamiento.
Inicializacin: Esta seccin es usada para inicializar el estado de los pines de E/S, variables
del programa y cuando sea necesario, el hardware externo.
Cdigo: Es donde reside la parte principal del cdigo del programa.
Subrutinas: Las subrutinas estn separadas del cuerpo principal del cdigo debido a que
pueden ser llamadas desde cualquier parte del programa. La separacin entre subrutinas
tambin facilita la portabilidad del cdigo, posibilitando usar la herramienta de edicin 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, asegurndose
de cambiarle el nombre utilizando la opcin Save As (Guardar como) del BASIC Stamp Editor.

' =========================================================================
' Archivo: BLANK.BS2
'
' { descripcin }
'
' {$STAMP BS2}
' =========================================================================
' { pines de E/S }
' { constantes }
' { variables }
' -------------------------------------------------------------------------
' { instrucciones DATA }
' -------------------------------------------------------------------------
' { inicializacin }
' -------------------------------------------------------------------------
' { cdigo }
Principal:
GOTO Principal
END
' -------------------------------------------------------------------------
' { subrutinas }
Convencin sobre Nombres
Como se dijo anteriormente, los programas de los experimentos utilizarn alias (sobrenombres) para
los pines de E/S y variables internas de PBASIC. Se usarn las siguientes convenciones:
Constantes: (incluyendo las etiquetas de direccionamiento a subrutinas) utilizarn mezcla de

maysculas y minsculas, comenzando siempre en mayscula. Ejemplos: LimitSw,
LMotor, DlyTm, InitLCD

Variables: usarn mezcla de maysculas y minsculas, comenzando siempre en minscula.

Ejemplos: lcdChar, hrs, iCount
Palabras reservadas PBASIC: todo en maysculas. Ejemplos: FOR, NEXT, GOSUB, RETURN
Nota del traductor
La traduccin fue realizada por Arstides Alvarez (aalvarez@parallaxinc.com).
Los programas se dejaron en su versin 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 programacin del autor, pero para mantener
la veracidad y equivalencia de la versin en castellano con la versin original en ingls, se mantuvo la
estructura original.
Si tiene comentarios o sugerencias sobre la traduccin, puede enviarlas a aalvarez@parallaxinc.com.

Si quiere opinar sobre el libro en s, puede enviar sus comentarios a Jon Williams, jonwms@aol.com.

Hora de Experimentar
Hora de Experimentar
Aprendiendo los Conceptos de Programacin
Lo que sigue es una serie de experimentos de programacin que usted puede construir y ejecutar en
su plaqueta de laboratorio StampWorks. El propsito de estos experimentos es ensear los conceptos
de programacin y el uso de componentes externos con el BASIC Stamp. Los experimentos fueron
pensados para que gane progresivamente experiencia en programacin. Combinando los conceptos
individuales aprendidos puede producir programas sofisticados.
Construccin de Proyectos
Esta seccin del manual es simple pero importante debido a que aprender lecciones de
programacin y tcnicas de construccin importantes, usando su laboratorio StampWorks. A medida
que avance sobre el manual, observar menos detalles de construccin (ya contar con suficiente
experiencia como para tomar sus propias decisiones) y la explicacin del funcionamiento del
programa ser menos profunda, enfocndose especficamente en las tcnicas especiales o
dispositivos externos conectados al BASIC Stamp.
Qu hacer entre proyectos
El circuito de un proyecto puede no ser elctricamente compatible con el siguiente pudiendo en

algunos casos, causar daos al BASIC Stamp si se ejecuta el programa viejo con el circuito nuevo.
Por esta razn, se debera cargar un programa vaco 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 lnea 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 propsito 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
Construccin del Circuito
Todos los experimentos de StampWorks usan una lnea 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 centmetro 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 ' enciende LED
PAUSE DlyTm ' tiempo encendido
LOW LEDpin ' apaga LED
PAUSE DlyTm ' tiempo apagado
GOTO Principal ' repite todo
END
Descripcin 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 lnea de cdigo:
HIGH 0
Realiza la misma funcin que:
Dir0 = 1 ' hace salida a Pin 0

Out0 = 1 ' pone al Pin 0 en estado alto

Experimento 2: Hacer Titilar un LED (Versin 2)
Experimento 2:
Hacer Titilar un LED (Versin 2)
El propsito de este experimento es hacer titilar un LED con el BASIC Stamp. El mtodo empleado en
este experimento agrega flexibilidad al control del LED.
VAR
Out0 Out15
Dir0 Dir15
Byte
Bit0 Bit15
Construccin del Circuito.
Use el mismo circuito que en el Experimento 1.
' =========================================================================
' Archivo: BLINK2.BS2
'
' Hace titilar un LED conectado al Pin 0. El tiempo de encendido y apagado
' del LED pueden ser distintos.
' =========================================================================
MiLED VAR Out0 ' LED conectado a Pin 0
TiempoEnc CON 1000 ' tiempo encendido en milisegundos

TiempoAp CON 250 ' tiempo apagado en milisegundos
Encendido CON 1
Apagado CON 0
' -------------------------------------------------------------------------
Inicializar:
Dir0 = %1 ' hace salida al pin del LED
' -------------------------------------------------------------------------
Principal:
MiLED = Encendido

PAUSE TiempoEnc ' pausa de encendido

MiLED = Apagado
PAUSE TiempoAp ' pausa de apagado
END
Esta versin de BLINK expone las capacidades tcnicas de los pines de E/S del BASIC Stamp y su
control. Observe cmo usar sobrenombres (o alias) para los pines de E/S, constantes y variables,
logrando que el programa sea fcil de leer. No hay errores en la interpretacin de:
MiLED = Encendido
La ventaja en este programa es la capacidad del pin de E/S del BASIC Stamp I/O de seguir el valor
de una constante o una variable. Cambie el programa para que se vea como el LED puede seguir a
una variable:
' =========================================================================
' Archivo: BLINK2b.BS2
'
' Hace titilar un LED conectado a Pin 0.
' =========================================================================
MiLED VAR Out0 ' LED conectado a Pin 0
TiempoEnc CON 1000 ' tiempo encendido en milisegundos

TiempoAp CON 250 ' tiempo apagado en milisegundos
Encendido CON 1
Apagado CON 0
cntr VAR Byte ' contador para controlar al LED
' -------------------------------------------------------------------------
Inicializar:
Dir0 = %1 ' Hace el pin del LED salida
' -------------------------------------------------------------------------
Principal:
MiLED = cntr ' pone cntr.Bit0 en MiLED
PAUSE TiempoEnc ' pausa de encendido

cntr = cntr + 1 ' incrementa el contador

END
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 nmero par, Bit0 se limpiar (0), haciendo que el LED se apague.

Experimento 3: Contador con LEDs
Experimento 3:
Contador con LEDs
El propsito de este experimento es mostrar el valor de 8 bits (un byte) usando LEDs. Mltiples 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 centmetro 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
ms cables.
' =========================================================================
' Archivo: LEDCNTR.BS2
'
' Muestra un contador binario en los pines 0 - 7
' =========================================================================
LEDs VAR OutL ' LEDs en pines 0 - 7
MinCnt CON 0 ' valor inicial del contador

MaxCnt CON 255 ' valor final del contador
cntr VAR Byte ' contador
' -------------------------------------------------------------------------
Inicializar:
DirL = %11111111 ' hace salidas todos los pines
' -------------------------------------------------------------------------
Principal:
FOR cntr = MinCnt TO MaxCnt ' bucle que genera los nmeros
LEDs = cntr ' muestra el nmero con LEDs
PAUSE DlyTm ' pausa entre nmeros
NEXT

END

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) multipropsito 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.
Desafo
Modifique el programa para que cuente hacia atrs.

Experimento 4: Pantalla de LEDs de Ciencia-Ficcin
Experimento 4:
Pantalla de LEDs de Ciencia-Ficcin
El propsito de este experimento es hacer un ping-pong de luz a travs de los LEDs para crear una
pantalla tipo Sci-Fi (ciencia-ficcin). Circuitos como stos se usan en pelculas 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 VAR OutL ' LEDs se conectan a los pines 0 - 7

' -------------------------------------------------------------------------
Inicializar:
DirL = %11111111 ' configura todos los pines como salidas
LEDs = %00000001 ' comienza con un LED encendido
' -------------------------------------------------------------------------
Adelante:
PAUSE DlyTm ' muestra el LED
LEDs = LEDs << 1 ' desplaza el LED a la izquierda
IF LEDs = %10000000 THEN Atras ' verifica posicin final
GOTO Adelante ' continua en esta direccin
Atras:
PAUSE DlyTm ' muestra el LED

Experimento 4: Pantalla de LEDs de Ciencia-Ficcin
LEDs = LEDs >> 1 ' desplaza el LED a la derecha

IF LEDs = %00000001 THEN Adelante ' verifica posicin final
GOTO Atras ' continua en esta direccin
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 posicin a la izquierda. Con
nmeros 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 cdigo usan IF-THEN para controlar el lmite de la cuenta, haciendo
que el programa salte a la otra seccin cuando llega al valor lmite.
Desafo
Cree un retardo variable y agregue alguna curiosidad al programa (vea PONG2.BS2 por ejemplo).

Experimento 5: Grficos con LEDs (Punto o Barra)
Experimento 5:
Grficos con LEDs (Punto o Barra)
El propsito de este experimento es crear un grfico configurable con LEDs (punto o barra). Este tipo
de grficos es muy comn en equipamiento de audio, especficamente para indicadores de volumen
(VU meters). El valor a graficar en el experimento se tomar de la posicin de un potencimetro.
Word
RCTIME
*/ (operador estrella-barra)
GOSUB-RETURN
DCD
Agregue este circuito al Experimento 4.

1. Usando cable rojo (corte el largo necesario), conecte la pista Vdd (+5) al punto A15.
2. Conecte un capacitor de 0.1 uF (104K) entre los puntos B14 y B15.
3. conecte un resistor de 220-ohm (rojo-rojo-marrn) entre los puntos C10 y C14.
4. Usando cable blanco, conecte A10 al Port 15 del BASIC Stamp.
5. Usando cable blanco, conecte E14 al cursor del potencimetro de 10K
6. Usando cable negro, conecte la pista Vss (masa) al terminal inferior del potencimetro de
10K.
' =========================================================================
' Archivo: LEDGRAGH.BS2
'
' Muestra una barra o un punto en la barra de 8 LEDs
'
' {$STAMP BS2}
' =========================================================================
LEDs VAR OutL ' salidas para LEDs

PotPin CON 15
DotGraf CON 0 ' define tipo de grfico

BarGraf CON 1
GrMode CON BarGraf ' define modo grfico actual
rawVal VAR Word ' valor medido en el potencimetro

grafVal VAR Byte ' valor a graficar
bits VAR Byte ' bit ms alto que se enciende
newBar VAR Byte ' espacio de trabajo para la barra
' -------------------------------------------------------------------------
Inicializar:
DirL = %11111111 ' todas salidas
' -------------------------------------------------------------------------
Principal:
HIGH PotPin ' descarga el capacitor
PAUSE 1 ' durante 1 ms
RCTIME PotPin,1,rawVal ' lee el potencimetro
grafVal = rawVal */ $005F ' escala grafVal (0 - 255)

' equivalente a rawVal * 0.372

GOSUB ShowGraph ' muestra

PAUSE 50
END
' -------------------------------------------------------------------------
ShowGraph:
IF GrMode = BarGraf THEN ShowBar ' salta al cdigo de modo grfico
ShowDot:
LEDs = DCD (grafVal / 32) ' muestra el valor (punto)
RETURN
ShowBar:
bits = DCD (grafVal / 32) ' obtiene el bit ms alto
newBar = 0
BuildBar:
IF bits = 0 THEN BarDone ' se encendieron todos los LEDs?
newBar = newBar << 1 ' no desplazar a la izquierda
newBar.Bit0 = 1 ' enciende el primer LED
bits = bits >> 1 ' desplaza el valor de bits
GOTO BuildBar ' continuar
BarDone:
LEDs = newBar ' mostrar nuevo nivel
RETURN
Despus de inicializar las salidas, este programa lee el potencimetro 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 potencimetro completamente en sentido anti-horario) y 685 (con el
potencimetro 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 mximo valor posible para grafVal) por
685 (mximo valor que entrega rawVal). El resultado es 0.372.
Trabajar con valores fraccionarios dentro del sistema algebraico de nmeros enteros del PBASIC, es
posible gracias al operador */ (estrella-barra). El parmetro para */ es una variable de 16-bit

(word). Los primeros ocho bits (byte superior) se multiplican como un nmero entero. Los ltimos
ocho bits (byte bajo) se multiplican como nmero fraccionario.
Para determinar el valor del byte de la parte fraccionaria, multiplique el valor fraccionario decimal por
255 y convirtalo 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 ms alto de grafVal. Con ocho
LEDs en el grfico, 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 tambin deben encenderse. Esto es realizado por un bucle. El valor de control del
bucle es la variable bits, que tambin se calcula en base a DCD. Este bucle se controla por valor de
bits, saliendo cuando este es igual a cero, mientras que cada iteracin decrementa su valor.
Si bits es mayor que cero, la variable de espacio de trabajo del grfico, 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 vern afectadas en cada iteracin del bucle:
bits newBar
1000 0001
0100 0011
0010 0111
0001 1111
0000 (listo salir del bucle y mostrar el valor)
El propsito de la variable newBar, es evitar que los LEDs parpadeen con cada actualizacin. Esto
permite que el programa comience con una barra grfica vaca que se construye hasta el valor
actual. Con esta tcnica, el programa no debe recordar el valor del grfico anterior.

Experimento 6: Un Juego Simple
Experimento 6:
Un Juego Simple
El propsito 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 piezoelctrico del kit en lugar del de la NX-1000 que parece tener mejor
volumen.
1. Usando cables blancos, conecte los puertos 0 5 del BASIC Stamp a los LEDs 0 5.
2. Usando cable blanco, conecte el puerto 6 del BASIC Stamp al lado + del piezoelctrico.
3. Usando cable negro, conecte el lado del piezoelctrico a masa (ground).
4. Usando un cable negro conecte el puerto 7 del BASIC Stamp al pulsador D0.
' =========================================================================
' Archivo: LASVEGAS.BS2
'
' Mquina tragamonedas basada en un BASIC Stamp
' =========================================================================
LEDs VAR OutL ' salidas LED

Spkr CON 6 ' salida parlante
Swtch CON 7 ' pulsador de entrada
randW VAR Word ' nmero aleatorio

pattern VAR Byte ' patrn de luces
tone VAR Word ' tono de salida
swData VAR Byte ' variable para BUTTON
delay VAR Word ' retardo variable de "giro"
spin1 VAR Byte ' contador bucle
spin2 VAR Byte ' contador bucle
' -------------------------------------------------------------------------
Inicializar:
DirL = %00111111 ' configura LEDs como salidas
' -------------------------------------------------------------------------
Attention:
GOSUB GetRnd ' obtiene nmero aleatorio
FREQOUT Spkr,35,tone ' emite un sonido
PAUSE 100
BUTTON Swtch,0,255,10,swData,1,Spin ' controla el pulsador de juego
GOTO Attention
Spin:
LEDs = %00111111 ' simula un reinicio del juego
PAUSE 750

Experimento 6: Un Juego Simple
LEDs = %00000000
PAUSE 500
delay = 75 ' retardo de inicializacin
FOR spin1 = 1 TO 25 ' gira la rueda

GOSUB GetRnd ' obtiene nmero aleatorio
FREQOUT Spkr,25,425 ' ruido de la rueda
PAUSE delay ' pausa entre ruidos
delay = delay */ $0119 ' multiplica la pausa por 1.1
NEXT
IF pattern = %00111111 THEN YouWin ' si todos se encienden, gana

FREQOUT Spkr,1000,150 ' caso contrario, pierde...
LEDs = %00000000 ' limpia los LEDs
PAUSE 1000
GOTO Attention ' repite todo
YouWin: ' luces y sonidos para indicar que

FOR spin1 = 1 TO 5 gan
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 ' limpia los LEDs

PAUSE 1000
GOTO Attention ' repite todo
END
' -------------------------------------------------------------------------
GetRnd:
RANDOM randW ' obtiene nmero pseudo aleatorio
tone = randW & $7FF ' no deja que el tono sea muy alto
pattern = randW & %00111111 ' borra bits sin uso
LEDs = pattern ' muestra el patrn
RETURN

Este programa demuestra cmo agregar ms aleatoriedad al nmero 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 patrn nuevo en los LEDs.
Al regresar a Attention, se emite el sonido y se revisa si se ha presionado el botn. El programa
repetir el bucle sobre Attention hasta que se presione el botn.
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 botn. 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 mquina tragamonedas. En cada giro, un sonido clic
es generado mientras se aumenta la pausa entre los mismos para simular la desaceleracin natural
de los discos de la mquina.
Si se encienden los seis LEDs antes del ltimo giro, el programa salta a YouWin. Esta rutina usa
LOOKUP para encender un patrn 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.
Desafo
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 propsito de este experimento es crear un pequeo controlador de luces, conveniente para rboles
de navidad y decoraciones externas. Las salidas de este circuito sern solamente LEDs (Para
controlar luces de alta tensin vea el libro de Matt Gilliland, Microcontroller Application Cookbook).
DATA
MIN
// (Operador mdulo)
BRANCH

1. Usando cables blancos, conecte los puertos 0-5 del BASIC Stamp a los LEDs 0 5.
2. Usando cable rojo, conecte la lnea de Vdd (+5) al punto A15.
3. Conecte un capacitor de 0.1 uF (104K) entre B14 y B15.
4. Conecte un resistor de 220-ohm (rojo-rojo-marrn) entre C10 y C14.
5. Usando cable blanco, conecte A10 al puerto 6 del BASIC Stamp.
6. Usando cable blanco, conecte E14 al terminal superior del potencimetro de 10K.
7. Usando cable negro, conecte la lnea de Vss (ground) al cursor (terminal central) del
potencimetro 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 CON 7 ' botn en pin 7

PotPin CON 6 ' pot. control veloc. en pin 6
Lights VAR OutL ' salidas de control de luces
delay VAR Word ' pausa entre patrones

btnVar VAR Byte ' variable para BUTTON
mode VAR Byte ' modo seleccionado
offset VAR Byte ' offset del patrn de luz
randW VAR Word ' variable para RANDOM
' -------------------------------------------------------------------------
SeqA DATA %000001, %000010, %000100, %001000, %010000, %100000

SeqB DATA %100000, %010000, %001000, %000100, %000010
DATA %000001, %000010, %000100, %001000, %010000
SeqC DATA %000000, %001100, %010010, %100001
SeqD DATA %100100, %010010, %001001
SeqE DATA %0
AMax CON SeqB-SeqA ' calcula largo de secuencia

BMax CON SeqC-SeqB
CMax CON SeqD-SeqC
DMax CON SeqE-SeqD
' -------------------------------------------------------------------------

Inicializar:
DirL = %00111111 ' configura LEDs como salidas
' -------------------------------------------------------------------------
Principal:
HIGH PotPin ' descarga el capacitor
PAUSE 1
RCTIME PotPin,1,delay ' lee potencimetro de velocidad
delay = (delay */ $018A) MIN 50 ' calcula retardo (50 ms ~ 1 sec)
PAUSE delay ' espera entre patrones
SwitchCheck:
BUTTON Select,0,255,0,btnVar,0,Show ' nuevo modo?
mode = mode + 1 // 5 ' si, actualizar la var. mode
Show:
BRANCH mode,[ModeA,ModeB,ModeC,ModeD,ModeE]
GOTO Principal
END
' -------------------------------------------------------------------------
ModeA:
offset = offset + 1 // AMax ' actualiza el offset (0 - 5)
READ (SeqA + offset),Lights ' sale nuevo patrn de luces
GOTO Principal ' 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 ' obtiene nmero aleatorio

Lights = randW & %00111111 ' enciende canales aleatorios
GOTO Principal
Este programa es ms simple de lo que parece. El cuerpo principal del programa es un bucle. La
velocidad de ejecucin del bucle principal es controlada por la posicin del potencimetro. RCTIME es
usada para leer el potencimetro y normalmente el nmero mximo que se obtuvo en su lectura fue
648. Multiplicando el mximo valor del potencimetro por 1.54 (delay */ $018A) se obtiene un
mximo de 1000, para producir una pausa de un segundo de duracin. El operador MIN es usado
para garantizar que la pausa ms corta posible sea de 50 milisegundos.
El cdigo SwitchCheck revisa si D7 es presionado. Si es as, la variable mode, es incrementada (en

una unidad). El operador de mdulo (//) es usado para mantener a mode en el rango de cero a
cuatro. Esto funciona debido a que el operador de mdulo entrega el resto de una divisin. Dado que
cualquier nmero 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 cdigo 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 patrn aleatorio de luces.
Mire el cdigo de la subrutina ModeA. Lo primero que se hace es actualizar el valor de la variable
offset, usando la tcnica del operador mdulo. El valor de offset es agregado al principio de la
secuencia de luz especificada, y el patrn de luces actual es obtenido con READ. Observe que las
instrucciones DATA de cada secuencia estn etiquetadas (SeqA, SeqB, etc.). Internamente, cada una
de esas etiquetas es convertida a un valor constante que es igual a la direccin de inicio de cada
secuencia. La longitud de cada secuencia es calculada con esas constantes. Al emplear esta tcnica,
los patrones de luces pueden ser actualizados (alargados o acortados) sin necesidad de modificar el
cdigo llamado por Show. ModeE es muy directo, usando la funcin RANDOM para presentar nuevos
patrones de luces en cada pasada a travs del bucle principal.
Desafo
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 seccin anterior, ya est en condiciones de montar los circuitos
restantes sin instrucciones especficas. Estos proyectos son bastante simples y los encontrar
elctricamente similares a varios de los proyectos que ya construy.
Proceda lentamente y controle dos veces sus conexiones antes de aplicar la alimentacin 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 patrn que se muestra en la Figura 8. Los LEDs tienen un elemento
en comn (nodo o ctodo).
Iluminando combinaciones especficas de LEDs podemos crear los dgitos e incluso algunos caracteres
alfanumricos (letras y smbolos). Los LEDs de siete segmentos normalmente se usan en letreros
numricos.
La plaqueta de StampWorks tiene cuatro displays de siete segmentos de ctodo comn. Los
experimentos de esta seccin le mostrarn como aprovechar al mximo estos componentes tan
verstiles.

Experimento 8: Contador de un Dgito
Experimento 8:
Contador de un Dgito
El propsito de este experimento es demostrar el uso del mdulo de 7 segmentos, creando un
contador decimal simple.
Nib

' =========================================================================
' Archivo: 7SEGS.BS2
'
' Muestra un dgito de 7 segmentos
' =========================================================================
segs VAR OutL ' LEDs del 7 segmentos
cntr VAR Nib ' contador
' -------------------------------------------------------------------------
' Segmentos .abcdefg

' --------
DecDig DATA %01111110 ' 0
DATA %00110000 ' 1
DATA %01101101 ' 2
DATA %01111001 ' 3
DATA %00110011 ' 4
DATA %01011011 ' 5
DATA %01011111 ' 6
DATA %01110000 ' 7
DATA %01111111 ' 8
DATA %01111011 ' 9
' -------------------------------------------------------------------------
Inicializar:
DirL = %01111111 ' configura como salidas los 7 seg.
' -------------------------------------------------------------------------
Principal:
FOR cntr = 0 TO 9 ' cuenta
READ (DecDig + cntr),segs ' muestra el dgito
PAUSE 1000 ' durante un segundo
NEXT

END

Este programa es muy similar al del control de luces: se lee un patrn de la EEPROM y se pone en la
salida de los LEDs. En este programa, el envo de patrones especficos a los LEDs del 7 segmentos,
crea los dgitos del cero al nueve.
Desafo
Actualice el programa para crear un contador hexadecimal de un dgito. Use el patrn que se muestra
a continuacin para generar los ltimos dgitos hexadecimales.

Experimento 9: Dado Digital
Experimento 9:
Dado Digital
El propsito de este experimento es crear un dado digital.
Agregue este pulsador al circuito del experimento anterior.
' =========================================================================
' Archivo: ROLLER.BS2
'
' Dado Digital. Muestra un nmero del 1 al 6 cuando se presiona D7.
' =========================================================================
RollBtn CON 15 ' botn en Pin 7

Segs VAR OutL ' LEDs del 7 segmentos
swData VAR Byte ' datos del comando BUTTON

dieVal VAR Nib ' nuevo valor del dado
spinPos VAR Nib ' posicin de giro
doSpin VAR Nib ' control de actualizacin de giro
' -------------------------------------------------------------------------
' .abcdefg
' --------
DATA %00110000 ' 1
DATA %01101101 ' 2
DATA %01111001 ' 3

DATA %00110011 ' 4

DATA %01011011 ' 5
DATA %01011111 ' 6
DATA %01110000 ' 7
DATA %01111111 ' 8
DATA %01111011 ' 9
Bug DATA %01000000 ' indicador de giro

DATA %00100000
DATA %00010000
DATA %00001000
DATA %00000100
DATA %00000010
' -------------------------------------------------------------------------
Inicializar:
DirL = %01111111 ' define salidas
' -------------------------------------------------------------------------
Principal:
GOSUB GetDie ' obtiene valor del dado
PAUSE 5
' Est presionado el botn?
BUTTON RollBtn,0,255,10,swData,1,ShowDie
GOTO Principal
ShowDie:
READ (DecDig + dieVal),Segs ' muestra el valor
PAUSE 3000 ' durante tres segundos
END
' -------------------------------------------------------------------------
GetDie:
dieVal = dieVal // 6 + 1 ' limita entre 1 y 6
READ (Bug + spinPos),segs ' muestra patrn de giro
doSpin = doSpin + 1 // 7 ' actualiza el indicador de giro?
IF doSpin > 0 THEN GetDieX ' solo si doSpin = 0
spinPos = spinPos + 1 // 6 ' actualiza el indicador de giro
GetDieX:
RETURN

Este programa se basa en todo lo que hemos hecho hasta el momento y debera resultarle fcil de
comprender. Hemos agregado un poco de creatividad en la programacin para lograr que un
programa simple se vea ms interesante.
Hay que remarcar el uso de la variable doSpin. Para crear un valor aleatorio, la variable dieVal es
actualizada rpidamente hasta que el botn es presionado. Esta velocidad de cambio, es demasiado
rpida para usarla en el indicador de giro del dado. La variable doSpin entonces, acta como un
retardo, haciendo que el valor indicado por los LEDs sea actualizado cada sptimo paso por la rutina
GetDie. Esto nos permite ver los nmeros claramente y crea un efecto de display agradable.

Experimento 10: Reloj con Pantalla de LEDs
Experimento 10:
Reloj con Pantalla de LEDs
El propsito de este experimento es crear una pantalla simple de reloj usando cuatro mdulos 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 VAR OutL ' segmentos

digSel VAR OutC ' selector de dgito
tic VAR In15 ' generador de pulsos de 1 Hz
DPoint CON %10000000 ' bit de punto decimal
secs VAR Word ' segundos

time VAR Word ' tiempo con formato
digit VAR Nib ' dgito actual
' -------------------------------------------------------------------------
' .abcdefg
' --------
DATA %00110000 ' 1
DATA %01101101 ' 2
DATA %01111001 ' 3
DATA %00110011 ' 4
DATA %01011011 ' 5
DATA %01011111 ' 6
DATA %01110000 ' 7
DATA %01111111 ' 8
DATA %01111011 ' 9
' -------------------------------------------------------------------------
Inicializar:
DirL = %11111111 ' configura segmentos como salidas
DirC = %1111 ' selector de dgito como salida
digSel = %1111 ' todos los dgitos apagados
' -------------------------------------------------------------------------
Principal:
GOSUB ShowTime ' muestra dgito actual
IF tic = 1 THEN IncSec ' nuevo segundo?

IncSec:
secs = (secs + 1) // 3600 ' actualiza el contador de seg.
Waiting:
GOSUB ShowTime ' muestra dgito actual
IF tic = 0 THEN Principal ' si pas el pulso salta al inicio
' cdigo adicional podra ponerse aqu
GOTO Waiting ' repite

END
' -------------------------------------------------------------------------
ShowTime:
time = (secs / 60) * 100 ' obtiene minutos, en centenas
time = time + (secs // 60) ' obtiene segundos
segs = %00000000 ' pantalla en blanco
' habilita dgito
LOOKUP digit,[%1110,%1101,%1011,%0111],digSel
READ (DecDig + (time DIG digit)),segs ' pone el patrn de segmento
PAUSE 1 ' muestra
digit = (digit + 1) // 4 ' obtiene siguiente dgito
RETURN
Los dos primeros proyectos con los displays de siete segmentos usaron solamente un dgito. Este
proyecto usa los cuatro. Un nuevo problema se presenta; dado que los nodos de los cuatro displays
estn unidos, solamente podemos mostrar uno a la vez. Esto se realiza mediante el patrn de
segmento que determina el dgito que se encuentra activo en cada momento (poniendo en estado
bajo su ctodo).
El objetivo de este programa sin embargo, es crear la pantalla de un reloj, en el cual los cuatro
dgitos deben mostrarse al mismo tiempo. Si bien en la realidad no podemos tener a los cuatro
encendidos a la vez, podemos engaar al ojo humano y hacerle creer que es as.
El ojo humano tiene una propiedad conocida como Persistencia de Visin (POV), que hace que
retenga una imagen durante un breve lapso de tiempo. A mayor brillo de la imagen, ms tiempo
permanece en nuestros ojos. Este fenmeno es el que hace que veamos un punto de luz despus de
observar el flash de una cmara fotogrfica. Podemos usar esta propiedad en nuestro beneficio
haciendo un barrido rpido a travs de cada uno de los cuatro dgitos, mostrando cada dgito en un

segmento durante un corto perodo. Si el ciclo es suficientemente rpido, la POV de nuestros ojos nos
har creer que los cuatro dgitos se encuentran encendidos a la vez. Este proceso se llama
multiplexado.
Multiplexado es el proceso de compartir lneas de datos; es este caso, las lneas de los segmentos de
los displays son compartidas. Si no multiplexramos, se necesitaran 28 lneas de salida para
controlar los cuatro displays de 7 segmentos. Son 12 lneas ms de las que se encuentran disponibles
en un BASIC Stamp.
El verdadero trabajo de este programa lo realiza la subrutina llamada ShowTime. Su propsito es

darle formato de tiempo (MMSS) al contador de segundos y actualizar el dgito actual. Dado que la
rutina solamente puede mostrar un dgito a la vez, debe ser llamada frecuentemente, caso contrario
la pantalla parpadeara. 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, colocndolos
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 prxima actualizacin. 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 dgito actual y
los segmentos que usar ese dgito 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 continuacin del segundo dgito. El paso final es
agregar una pequea pausa mientras est encendido el dgito y se actualiza la variable digit.
El bucle principal de este programa espera la entrada de una seal de onda cuadrada, producida por
el generador de seales del StampWorks. Cuando se fija en 1 Hz, esta seal pasa de LOW (bajo) a
HIGH (alto), una vez por segundo. Cuando se presenta la transicin de bajo a alto, el contador de

segundos es actualizado. El operador de mdulo (//) 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 seal de entrada pase a estado bajo, actualizando la pantalla durante la espera. Si el
programa regresara al principio mientras la seal de entrada estuviese an en estado alto, el
contador de segundos podra actualizarse prematuramente, causando que el reloj corriera ms
rpido. Una vez que la seal de entrada pasa a estado bajo, el programa salta al principio, donde
espera a la siguiente transicin de bajo a alto del pulso del generador.
Desafo
Si se modifica la posicin del punto decimal como se muestra a continuacin, 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 requerirn proveer informacin ms compleja al usuario. Por supuesto, nada supera la
pantalla de video de una PC, pero estos son grandes, caros y casi siempre imprcticos para concretar
proyectos con microcontroladores. Los mdulos LCD de caracteres por otro lado, son ideales para
estas aplicaciones. Estos mdulos econmicos permiten imprimir salidas alfanumricas, usando muy
pocas lneas de E/S y muy poco esfuerzo del BASIC Stamp.
Los mdulos de caracteres LCD estn disponibles en gran variedad de configuraciones: una lnea, dos
lneas y cuatro lneas, son los ms comunes. Tambin es variable el ancho de la pantalla, aunque
normalmente es de 16 o 20 caracteres por lnea.
Mdulo LCD del StampWorks (2 lneas x 16 caracteres).

Se puede bajar la hoja de datos desde www.parallaxinc.com.
El mdulo 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
Inicializacin
El LCD de caracteres debe ser inicializado antes de comenzar a enviarle informacin. Los proyectos
de este libro inicializan el LCD de acuerdo con la especificacin del controlador Hitachi HD44780. El
controlador Hitachi es el que se encuentra comnmente y muchos otros controladores son
compatibles con l.
Modos de Operacin
Hay dos modos principales de operar con LCDs: enviar un caracter y enviar un comando. Cuando se
enva un caracter, la lnea RS est en estado alto y el dato enviado es interpretado como un caracter
que debe ser mostrado en la posicin actual del cursor. El caracter normalmente es enviado en
cdigo ASCII. Tambin se pueden enviar caracteres no ASCII al LCD, as como tambin hasta ocho
caracteres programables personalizados.
Los comandos se envan al LCD luego de poner en estado bajo la lnea RS. Hay varios comandos
estndar para controlar y manipular la pantalla LCD.
Clear $01 Limpia el LCD y mueve el cursor a home o inicio

Home $02 Mueve el cursor a la primer posicin de la primer lnea
Cursor Izq. $10 Mueve el cursor a la izquierda
Cursor Der. $14 Mueve el cursor a la derecha
Display Izq. $18 Desplaza todo el display a la izquierda
Display Der. $1C Desplaza todo el display a la derecha
Conexin 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 conexin de LCD de la plaqueta y presinela hasta que quede
firmemente conectado.

Experimento 11: Demostracin Bsica con LCD
Experimento 11:
Demostracin Bsica con LCD
Este programa demuestra las bases del LCD poniendo a funcionar el mdulo LCD del StampWorks.
PULSOUT
HighNib, LowNib
^ (operador OR Exclusiva)
' =========================================================================
' Archivo: LCDDEMO.BS2
'
' Demostracin Bsica de LCD
' Ver 1.1 Actualizado de acuerdo a las conexiones de LCD del BS2p
' =========================================================================
E CON 0 ' pin habilitacin LCD

RS CON 3 ' Seleccin registro (1 = carac.)
LCDout VAR OutB ' datos de 4-bits del LCD
ClrLCD CON $01 ' limpia el LCD

CrsrHm CON $02 ' mueve el cursor a home

CrsrLf CON $10 ' mueve cursor a la izq.

CrsrRt CON $14 ' mueve cursor a la der.
DispLf CON $18 ' desplaza caracteres a la izq.
DispRt CON $1C ' desplaza caracteres a la der.
DDRam CON $80 ' control RAM de datos
char VAR Byte ' caracter enviado al LCD

index VAR Byte ' contador del bucle
' -------------------------------------------------------------------------
Msg DATA "El BASIC STAMP!",0 ' mensaje pregrabado en EEPROM
' -------------------------------------------------------------------------
Inicializar:
DirL = %11111001 ' configura pines para el LCD
GOSUB LCDinit ' inicializa LCD en modo 4-bits
' -------------------------------------------------------------------------
Principal:
char = ClrLCD ' limpia el LCD
GOSUB LCDcommand
PAUSE 500
index = Msg ' obtiene direccin EE del mensaje
ReadChar:
READ index,char ' obtiene caracter de EEPROM
IF char = 0 THEN MsgDone ' si es 0, mensaje finalizado
GOSUB LCDwrite ' escribe el caracter
index = index + 1 ' apunta al siguiente caracter
GOTO ReadChar ' y lo obtiene
MsgDone: ' mensaje completo
PAUSE 2000 ' espera 2 segundos
char = CrsrHm ' mueve el cursor a home

GOSUB LCDcommand
char = %00001110 ' enciende el cursor

GOSUB LCDcommand
PAUSE 500

char = CrsrRt
FOR index = 1 TO 15 ' mueve el cursor por la pantalla
GOSUB LCDcommand
PAUSE 150
NEXT
FOR index = 14 TO 0 ' regresa el cursor a una

char = DDRam + index ' direccin especfica
GOSUB LCDcommand
PAUSE 150
NEXT
char = %00001101 ' apaga el cursor, enciende blink

GOSUB LCDcommand
PAUSE 2000
char = %00001100 ' apaga blink

GOSUB LCDcommand
FOR index = 1 TO 10
char = char ^ %00000100 ' invierte los bits
GOSUB LCDcommand
PAUSE 250
NEXT
PAUSE 1000
FOR index = 1 TO 16 ' desplaza la pantalla

char = DispRt
GOSUB LCDcommand
PAUSE 100
NEXT
PAUSE 1000
FOR index = 1 TO 16 ' desplaza en sentido contrario
char = DispLf
GOSUB LCDcommand
PAUSE 100
NEXT
PAUSE 1000
END

' -------------------------------------------------------------------------
LCDinit:
PAUSE 500 ' deja descansar el LCD
LCDout = %0011 ' modo de 8-bits
PULSOUT E,1
PAUSE 5
PULSOUT E,1
PULSOUT E,1
PULSOUT E,1
char = %00001100 ' enciende disp y configura
GOSUB LCDcommand
char = %00000110
GOSUB LCDcommand
RETURN
LCDcommand:
LOW RS ' ingresa modo comando
LCDwrite:
LCDout = char.HighNib ' salen los 4 bits altos
PULSOUT E,1 ' pulso en lnea Enable
LCDout = char.LowNib ' salen los 4 bits bajos
PULSOUT E,1
HIGH RS ' regresa al modo caracter
RETURN
Este es un programa muy simple que demuestra las funciones bsicas 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 lneas de E/S del BASIC Stamp
necesarias para controlar el LCD. Si bien es posible conectar y controlar el LCD con ocho lneas de
datos, no se lograra una mejora notable en el rendimiento del programa y se necesitaran cuatro
lneas ms de E/S.

Las bases de la inicializacin son apropiadas para la mayora de las aplicaciones:
Se enciende el display
Se apaga el cursor
Se deshabilita el parpadeo del display
El cursor se incrementa automticamente despus 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 fcil. Cada nibble se enva al LCD con un pulso en la lnea E (habilitacin) con
PULSOUT.
La demo comienza limpiando el LCD y mostrando un mensaje que ha sido almacenado con una
instruccin DATA. Esta tcnica de almacenar mensajes en la EEPROM es muy til y hace que los
programas sean fcilmente actualizables. En este programa, se escriben caracteres hasta que se
encuentra un cero. Este mtodo nos permite modificar la longitud de la cadena de texto, sin tener
que preocuparnos por la configuracin de un bucle FOR-NEXT. Una vez mostrado el mensaje, el
cursor se enva al inicio (primera posicin de la primera lnea) y se enciende (aparece un cursor
subrayado).
El cursor se enva hacia adelante y hacia atrs por el LCD usando dos tcnicas. La primera usa el
comando cursor a la derecha. Para mover el cursor hacia atrs se opt por modificar manualmente
su posicin. Esta ltima tcnica 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 funcin blink (parpadeo). Blink
hace que la posicin actual del cursor alterne entre el caracter y un recuadro negro slido. Esto
puede ser til para llamar la atencin. Otra forma de llamar la atencin es hacer parpadear la
pantalla completa. Esto se logra invirtiendo el estado del bit de habilitacin (enable). El operador OR
exclusiva (^) simplifica esta tarea, debido a que la operacin 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 mtodo para sacar ventaja de esta memoria adicional es
escribir mensajes fuera de la pantalla y luego desplazarlos hasta que estn visibles.

Experimento 12: Creando Caracteres en un LCD
Experimento 12:
Creando Caracteres en un LCD
Este programa demuestra cmo crear caracteres en un LCD, realizar animaciones y la inicializacin
del LCD en modo multi-lnea.
Use el mismo circuito que en el Experimento 11.
' =========================================================================
' Archivo: LCDCHARS.BS2
'
' Animacin usando caracteres personalizados en LCD
' Ver 1.1 Actualizado de acuerdo a las conexiones de LCD del BS2p
' =========================================================================

LCDout VAR OutB ' datos de 4-bits del LCD

CGRam CON $40 ' Caracter creado en RAM
Line1 CON $80
Line2 CON $C0

newChr VAR Byte ' caracter nuevo para animacin
index1 VAR Byte ' contador de bucle
index2 VAR Byte ' contador de bucle
' -------------------------------------------------------------------------
Msg1 DATA "EL BASIC STAMP " ' mensaje pregrabado en EEPROM
Msg2 DATA " ES GENIAL! "

CC0 DATA $0E,$1F,$1C,$18,$1C,$1F,$0E,$00 ' caracter 0

CC1 DATA $0E,$1F,$1F,$18,$1F,$1F,$0E,$00 ' caracter 1
CC2 DATA $0E,$1F,$1F,$1F,$1F,$1F,$0E,$00 ' caracter 2
' -------------------------------------------------------------------------
Inicializar:
DLChars: 'descarga caracteres nuevos al LCD

char = CGRam ' apunta al caracter creado en RAM
GOSUB LCDcommand ' prepara para escribir
FOR index1 = CC0 TO (CC2 + 7) ' arma 3 caracteres
READ index1,char ' obtiene byte de EEPROM
GOSUB LCDwrite ' lo pone en CG RAM del LCD
NEXT
' -------------------------------------------------------------------------
Principal:
GOSUB LCDcommand
PAUSE 250
FOR index1 = 0 TO 15 ' obtiene mensaje de EEPROM

READ (Msg1 + index1),char ' lee un caracter
GOSUB LCDwrite ' lo escribe
NEXT
PAUSE 2000 ' espera 2 segundos
' Animacin por reemplazo de caracteres
FOR index1 = 0 TO 15 ' cubre 16 caracteres

READ (Msg2 + index1),newChr ' obtiene letras del 2 mensaje
FOR index2 = 0 TO 4 ' 5 caracteres en ciclo de animac.
char = Line2 + index1 ' nuevo acceso a DDRAM
GOSUB LCDcommand
LOOKUP index2,[2,1,0,1,newChr],char
GOSUB LCDwrite ' escribe caracter de animacin
PAUSE 50 ' pausa entre caracteres
NEXT
NEXT

PAUSE 1000
END
' -------------------------------------------------------------------------
LCDinit:
PAUSE 500 ' deja reposar el LCD
PULSOUT E,1
PAUSE 5
PULSOUT E,1
PULSOUT E,1
PULSOUT E,1
char = %00101000 ' modo multi-lnea
GOSUB LCDcommand
char = %00001100 ' config. LCD
GOSUB LCDcommand
GOSUB LCDcommand
RETURN
LCDcommand:
LCDwrite:
LCDout = char.HighNib ' salen 4 bits altos
LCDout = char.LowNib ' salen 4 bits bajos
PULSOUT E,1
HIGH RS ' regresa a modo caracter
RETURN

En este programa, el LCD es inicializado en modo multi-lnea. Esto permitir que las dos lneas del
LCD de StampWorks muestren informacin. 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 despus 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 estndar del LCD tiene 5 bits de ancho por 7 bits de alto. Puede crear caracteres
personalizados de 8 bits de alto, pero la octava lnea generalmente es reservada para el cursor de
subrayado. Este es un ejemplo de la definicin 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 posicin, activar ese pxel; 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 mtodo ms comn 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 corazn de este programa es el bucle de animacin. Este cdigo toma un caracter del segundo
mensaje y luego muestra la secuencia de animacin en la segunda lnea del LCD. Una tabla LOOKUP
es usada para llevar a cabo la secuencia de animacin cclica. Al final de la secuencia, se revela el
nuevo caracter.
Desafo
Cree su propia secuencia de caracteres personalizados. Actualice la inicializacin y el cdigo de

animacin 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 segn las conexiones de LCD del BS2p
' =========================================================================

RW CON 2 ' pin leer/escribir del LCD
LCDddir VAR DirB ' direccin del puerto
LCDout VAR OutB ' datos salida de 4-bits del LCD
LCDin VAR InB ' entrada de datos de 4-bits LCD




addr VAR Byte ' direccin lectura/escritura
index VAR Byte ' contador de bucle
rVar VAR Word ' nmero aleatorio
tOut VAR Byte ' valor de prueba a leer del LCD
temp VAR Word ' valor temporal
width VAR Nib ' ancho del nmero a mostrar
' -------------------------------------------------------------------------
Inicializar:
' -------------------------------------------------------------------------
Principal:
GOSUB LCDcommand
FOR index = 0 TO 14 ' crea pantalla

LOOKUP index,["ADDR=?? ???/???"],char
GOSUB LCDwrite
NEXT
Loop:
RANDOM rVar ' genera nmero aleatorio
addr = rVar.LowByte & $3F ' crea direccin (0 a 63)
tOut = rVar.HighByte ' crea valor de prueba (0 a 255)
char = CGRam + addr ' puntero de CGRAM

GOSUB LCDcommand
char = tOut
GOSUB LCDwrite ' mueve el valor a CGRAM
PAUSE 100 ' espera y luego lo obtiene

char = CGRam + addr ' puntero de CGRAM

GOSUB LCDcommand
GOSUB LCDread ' lee valor del LCD
tIn = char
' muestra resultados
char = DDRam + 5 ' muestra direccin en posicin 5

GOSUB LCDcommand
temp = addr
width = 2
GOSUB PutVal
char = DDRam + 8 ' muestra salida en posicin 8

GOSUB LCDcommand
temp = tOut
width = 3
GOSUB PutVal
char = DDRam + 12 ' muestra entrada en posicin 12

GOSUB LCDcommand
temp = tIn
width = 3
GOSUB PutVal
PAUSE 1000
GOTO Loop ' repite todo
END
' -------------------------------------------------------------------------
PutVal:
FOR index = (width - 1) TO 0 ' muestra dgitos de izq. a der.
char = (temp DIG index) + 48 ' convierte dgitos a ASCII
GOSUB LCDwrite ' pone dgito en display
NEXT
RETURN
LCDinit:
LCDout= %0011 ' modo de 8 bits
PULSOUT E,1
PAUSE 5
PULSOUT E,1

PULSOUT E,1
PULSOUT E,1
GOSUB LCDcommand
GOSUB LCDcommand
RETURN
LCDcommand:
LCDwrite:
PULSOUT E,1
RETURN
LCDread:
HIGH RS ' comando de datos
HIGH RW ' leer
LCDddir= %0000 ' hace entradas lneas de datos
HIGH E
char.HighNib = LCDin ' obtiene 4 bits superiores
LOW E
HIGH E
char.LowNib = LCDin ' obtiene 4 bits inferiores
LOW E
LCDddir= %1111 ' lneas de datos como salidas
LOW RW
RETURN

Este programa demuestra la versatilidad de las lneas 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 lneas de E/S del BASIC Stamp deben ser reconfiguradas como
entradas. Esto no representa un problema para el BASIC Stamp. Adems de la reconfiguracin de las
lneas de E/S, para leer valores del LCD se requiere una lnea de control adicional: RW. En la mayora
de los programas, sta lnea puede ser fijada en estado bajo, para poder escribir datos en el LCD.
Para leer desde el LCD la lnea RW se pone en estado alto.
El programa genera datos y una direccin usando la funcin RANDOM. La direccin se mantiene en el
rango de 0 a 63 poniendo una mscara en los bits ms altos de LowByte que entrega la funcin
RANDOM. HighByte representa el dato a ser guardado y ledo 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 direccin y se recuperan
los datos. Para poder hacer esto, las lneas de datos del LCD deben ser reconfiguradas como
entradas. Enviando pulsos en la lnea E (habilitacin) se logra que los datos (de a cuatro bits) estn
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 operacin de lectura.
Cuando todo est listo, la direccin, los datos de salida y los datos de entrada se escriben en el LCD.
La subrutina PutVal, se encarga de escribir valores numricos en el LCD. Para usar esta subrutina,
mueva el cursor a la posicin 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
dgito 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 Mgica
Experimento 14:
Juego de la Bola 8 Mgica
Este programa muestra la capacidad de mostrar fuentes de 8x10 del mdulo LCD del StampWorks.
De esta forma se pueden mostrar correctamente caracteres en minscula que pasan por debajo del
rengln (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 Mgica con BASIC Stamp y LCD
' Ver 1.1 Actualizado de acuerdo con las conexiones de LCD del BS2p
' =========================================================================

LCDout VAR OutB ' datos salida de 4-bits del LCD
AskBtn CON 15 ' pin del botn



NumAns CON 6 ' 6 respuestas posibles
_g CON $E7 ' direcciones DDROM

_j CON $EA
_p CON $F0
_q CON $F1
_y CON $F9

addr VAR Byte ' direccin del mensaje
swData VAR Byte ' variable para BUTTON
answer VAR Nib ' puntero de respuesta
clock VAR Nib ' reloj de animacin
pntr VAR Nib ' puntero al caract. de animacin
' -------------------------------------------------------------------------
Prompt DATA "Pregunte",0
Ans0 DATA "Seguro que SI",0

Ans1 DATA "Posible...",0
Ans2 DATA "Rotundamente NO",0
Ans3 DATA "No es seguro...",0
Ans4 DATA "No se...",0
Ans5 DATA "Tal vez...",0
' -------------------------------------------------------------------------
Inicializar:
' -------------------------------------------------------------------------
Principal:

GOSUB LCDcommand
addr = Prompt
GOSUB ShowMsg ' muestra cursor
Rollem:
GOSUB Shuffle ' Mezcla hasta que se presiona
PAUSE 5 el botn
BUTTON AskBtn,0,255,10,swData,1,ShowAnswer
GOTO Rollem
ShowAnswer:
' obtener direccin de mensaje de respuesta
LOOKUP answer,[Ans0,Ans1,Ans2,Ans3,Ans4,Ans5],addr
char = ClrLCD
GOSUB LCDcommand
GOSUB ShowMsg
PAUSE 2000 ' tiempo para leer respuesta

END
' -------------------------------------------------------------------------
LCDinit:
LCDout= %0011 ' modo de 8 bits
PULSOUT E,1
PAUSE 5
PULSOUT E,1
PULSOUT E,1
PULSOUT E,1
char = %00100100 ' selec. fuente 5x10
GOSUB LCDcommand
GOSUB LCDcommand
GOSUB LCDcommand
RETURN
LCDcommand:

LCDwrite:
PULSOUT E,1
RETURN
ShowMsg:
READ addr,char ' lee un caracter
IF char = 0 THEN MsgDone ' si es 0, mensaje listo
GOSUB Translate ' cambia letras bajo rengln
GOSUB LCDwrite ' escribe el caracter
addr = addr + 1 ' apunta al caracter siguiente
GOTO ShowMsg
MsgDone:
RETURN
' cambia las letras minsculas que pasan por debajo del rengln
' 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 ' actualiza puntero de respuesta
clock = clock + 1 // 15 ' actualiza puntero de reloj
IF (clock > 0) THEN ShuffleDone ' tiempo para actualiz. animacin?
char = DDRam + 15 ' si, escribe en pos. 15
GOSUB LCDcommand
LOOKUP pntr,["-+|*"],char ' carga caracter de animacin
GOSUB LCDwrite ' lo escribe
pntr = pntr + 1 // 4 ' actualiza caracter de animacin
ShuffleDone:
RETURN

Las fuentes comunes de 5x7 de LCD deforman mucho las letras que tienen partes que pasan por
debajo del rengln (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
inicializacin. Para que estos caracteres especiales se vean correctamente sin embargo, hay que
hacer un pequeo truco debido a que fueron mapeados con un desplazamiento con respecto a los
dems caracteres ASCII. Por suerte, el BASIC Stamp tiene un par de comandos para manejo de
tablas que simplifican el proceso de transformacin.
Despus de la inicializacin, se limpia la pantalla y se le indica al usuario que piense una pregunta. La
subrutina ShowMsg muestra un mensaje en la posicin actual del cursor. El mensaje es almacenado
en una instruccin DATA y pasado a la subrutina por su direccin 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 redisear el
caracter para que se vea correctamente en el LCD. Si el caracter no est en la lista, pasar a travs
de Translate sin ser afectado.
El bucle principal del programa espera a que presione un botn, creando una respuesta aleatoria al
llamar continuamente a la subrutina Shuffle. Shuffle actualiza la variable de respuesta y crea una
animacin. La animacin es creada con caracteres comunes y se actualiza cada 15 pasadas por la
subrutina Shuffle. Cuando finalmente se presiona el botn, la direccin de la EEPROM de la
respuesta correspondiente es cargada con LOOKUP y la respuesta mgica es mostrada.
Desafo
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 especficamente con dispositivos de salida,
debido a que estos son crticos para el xito de un proyecto. Hasta ahora, debera sentirse cmodo
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 completarn su educacin como
programador del BASIC Stamp y le darn 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 desafo.
Luego, avance planteando sus propios desafos. Cada vez que modifique un programa aprender
algo. Es normal que sus experimentos no funcionen como se esperaba, debido a que an est
aprendiendo.

Experimento 15: Filtrando Mltiples Entradas
Experimento 15:
Filtrando Mltiples Entradas
El experimento le ensear cmo eliminar el rebote en mltiples entradas del BASIC Stamp. Con
alguna modificacin, se puede eliminar el rebote de cualquier nmero de entradas (entre 2 y 16), con
este cdigo.
~ (operador de complemento a 1)
CLS (modificador de DEBUG)
IBIN, IBIN1 IBIN16 (modificadores de DEBUG)
' =========================================================================
' Archivo: DEBOUNCE.BS2
'
' Eliminacin simultnea del rebote en mltiples entradas.
' =========================================================================

SwIn VAR InA ' entradas pines 0 - 3

swtches VAR Nib ' entradas sin rebote
x VAR Nib ' contador del bucle
' -------------------------------------------------------------------------
Principal:
GOSUB GetSwitches ' obtiene entradas sin rebote
DEBUG CLS, IBIN4 swtches ' muestra en modo binario
PAUSE 100 ' pausa entre lecturas
END
' -------------------------------------------------------------------------
GetSwitches:
swtches = %1111 ' habilita las 4 entradas
FOR x = 1 TO 10
swtches = swtches & ~SwIn ' controla las entradas
PAUSE 5 ' pausa entre controles
NEXT
RETURN
Cuando se quiere filtrar el rebote en una sola entrada, la funcin BUTTON del BASIC Stamp funciona
perfectamente e incluso agrega un par de caractersticas bastante tiles (como auto repetir). Para
filtrar el rebote de dos o ms entradas, necesitamos crear un poco de cdigo. 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 propsito de GetSwitches es asegurarse que las entradas estn 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 posicin.
La rutina GetSwitches comienza asumiendo que todos los interruptores de entrada estn
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 tcnica 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 nmero 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.
Desafo
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 ejecucin del programa al esperar por una cantidad
especfica de eventos
' =========================================================================
E_in VAR In15 ' pin de entrada de eventos
IsLow CON 0
IsHigh CON 1
Target CON 1000 ' cantidad final
eCount VAR Word ' contador de eventos
' -------------------------------------------------------------------------
Principal:
eCount = 0 ' limpia el contador
DEBUG "Iniciado... ", CR
GOSUB WaitForCount ' espera por 1000 pulsos
DEBUG "Cuenta completa."
END
' -------------------------------------------------------------------------
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 ' espera que la ent. pase a bajo
GOTO WaitForCount
WaitDone:
RETURN
El propsito de la subrutina WaitForCount es hacer que el programa espere durante una cantidad
especfica de eventos. En una aplicacin 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 lnea pasa a alto, el contador es incrementado y el programa espera hasta que la
lnea regresa a estado bajo. Cuando esto sucede, el cdigo se repite buscando la siguiente transicin
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 podra causar una cuenta
errnea, anticipando el fin de la subrutina. Un mtodo para tratar una entrada ruidosa (cuando se
conoce de antemano el tiempo estimado entre eventos) es agregar una instruccin PAUSE
inmediatamente despus de cada evento. La idea es hacer una pausa desde que se produce el
evento y finalizarla justo antes de que se produzca el prximo. El cdigo que sigue funciona
correctamente cuando los eventos duran aproximadamente medio segundo y estn 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: Medicin de Frecuencia
Experimento 17:
Medicin de Frecuencia
Este experimento determina la frecuencia de un tren de pulsos usando la funcin COUNT del BASIC
Stamp.
COUNT
Construccin del Circuito (Note que el esquema NO es chip-cntrico)
' =========================================================================
' 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: Medicin de Frecuencia
Principal:
COUNT F_in, 1000, freq ' cuenta pulsos durante 1 segundo
' muestra en la pantalla DEBUG
DEBUG CLS, "Frecuencia: ", DEC freq, " Hz"

END
En el experimento anterior, se usaron varias lneas de cdigo para contar pulsos en un pin de
entrada. Ese mtodo es til cuando se cuenta hasta un valor especfico. Otros programas necesitan
contar la cantidad de pulsos que arriban durante un perodo de tiempo especfico. La funcin COUNT
del BASIC Stamp fue diseada para este propsito.
La frecuencia de una seal oscilatoria representa la cantidad de ciclos por segundo y se expresa en
Hertz. La funcin COUNT del BASIC Stamp controla el pin especificado durante la cantidad de tiempo
dada. Para obtener la medicin de frecuencia, se especific un tiempo de 1000 milisegundos (un
segundo).
Desafo
Mejore la respuesta (que se actualice ms frecuentemente) de este programa modificando el perodo

de COUNT. Qu otro ajuste debe realizarse? Cmo afecta este cambio la capacidad de medir
seales de frecuencias muy bajas?

Experimento 18: Medicin Avanzada de Frecuencia
Experimento 18:
Medicin Avanzada de Frecuencia
Este experimento usa PULSIN para crear un frecuencmetro de respuesta rpida.
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 VAR Word ' ancho de pulso alto

pLow VAR Word ' ancho de pulso bajo
period VAR Word ' perodo (alto+bajo)
freq VAR Word ' frecuencia
' -------------------------------------------------------------------------
Principal:
PULSIN F_pin, 0, pHigh ' obtiene parte alta de la entrada
PULSIN F_pin, 1, pLow ' obtiene parte baja de la entrada
period = pHigh + pLow ' calcula el perodo
freq = 50000 / period * 10 ' calcula la frecuencia
' muestra en la pantalla DEBUG
DEBUG Home
DEBUG "Perodo...... ", DEC period * 2, " uS ", CR
DEBUG "Frecuencia... ", DEC freq, " Hz "

Experimento 18: Medicin Avanzada de Frecuencia

END
En el ltimo experimento, aprendi que la frecuencia de una seal se define como la cantidad de
ciclos por segundo. Cre un frecuencmetro simple contando la cantidad de pulsos (ciclos) durante un
segundo. Este mtodo funciona bien, especialmente para seales de baja frecuencia. Habr veces sin
embargo, que un proyecto necesitar una respuesta ms rpida en la medicin de frecuencia.
La frecuencia de una seal puede ser calculada a partir de su perodo, o el tiempo de un ciclo
completo.
Midiendo el perodo de una seal entrante, su frecuencia puede ser calculada con la ecuacin (donde
el perodo es expresado en segundos):
frecuencia = 1 / perodo
La funcin PULSIN del BASIC Stamp est diseada para medir el ancho de un pulso entrante. Usando
PULSIN para medir las partes en estado alto y bajo de la seal, se pueden determinar el perodo y la
frecuencia. El resultado de PULSIN est expresado en unidades de 2 microsegundos. As, la frmula
para calcular la frecuencia sera:
frecuencia = 500.000 / perodo
Esto representa un inconveniente algebraico para el BASIC Stamp porque solamente puede realizar
clculos con nmeros de 16-bits (el valor mximo es 65.535). Para corregir la frmula, convertimos
500.000 en 50.000 x 10 y la rescribimos as
frecuencia = 50.000 / perodo * 10
Ejecute el programa y ajuste el potencimetro 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
electrnico 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 CON 0 ' salida del piezo

Sensor CON 1 ' entrada del sensor (RCTIME)
Threshold CON 200 ' frecuencia de corte
tone VAR Word ' frecuencia de salida
' -------------------------------------------------------------------------
Principal:
HIGH Sensor ' descarga el cap.
PAUSE 1 ' durante 1 ms

Experimento 19: Theremin Controlado por Luz
RCTIME Sensor,1,tone ' lee el sensor de luz

IF (tone < Threshold) THEN Principal ' saltea por luz ambiental
FREQOUT Speaker,20,tone ' toca el tono
GOTO Principal
END
Un Theremin es un dispositivo musical interesante usado para crear esos sonidos escalofriantes que
se escuchan en las pelculas de terror antiguas. Esta versin 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
ningn sonido. Este valor podra ajustarse para que el Theremin deje de tocar cuando el fotoresistor
recibe la luz ambiente en forma directa.
Desafo
Agregue un segundo circuito RC usando un potencimetro de 10K en lugar de un fotoresistor. Use

este circuito para ajustar el valor de corte para condiciones de iluminacin variables.

Experimento 20: Efectos de Sonido
Experimento 20
Efectos de Sonido
Este experimento usa FREQOUT y DTMFOUT para crear efectos de sonido de telfono.
DTMFOUT
' =========================================================================
' Archivo: PHONE.BS2
'
' Usa FREQOUT y DTMFOUT para crear (US) sonidos telefnicos
'
' {$STAMP BS2}
' =========================================================================
Speaker CON 0 ' piezo en pin 0
R CON 0 ' silencio

C CON 33 ' ideal es 32.703
Cs CON 35 ' ideal es 34.648
D CON 39 ' ideal es 38.891
E CON 41 ' ideal es 41.203
F CON 44 ' ideal es 46.249
G CON 49 ' ideal es 48.999
Gs CON 52 ' ideal es 51.913
A CON 55 ' ideal es 55.000
As CON 58 ' ideal es 58.270
B CON 62 ' ideal es 61.735

N1 CON 500 ' duracin nota completa

N2 CON N1/2 ' media nota
N3 CON N1/3 ' un tercio de nota
N4 CON N1/4 ' un cuarto de nota
N8 CON N1/8 ' un octavo de nota
x VAR Byte ' contador del bucle

note VAR Word ' nota a tocar
octave VAR Nib ' octava de la nota (1 - 7)
dur VAR Word ' longitud de la nota
' -------------------------------------------------------------------------
Principal:
DEBUG CLS, "Sonidos Telefnicos", CR, CR
Dial_Tone:
DEBUG "Tono de Marcado", CR
FREQOUT Speaker,35,35 ' "clic"
PAUSE 100
FREQOUT Speaker,2000,350,440 ' 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 "Seal de Ocupado", CR
FOR x = 1 TO 6
PAUSE 620
NEXT
FREQOUT Speaker,35,35 ' "clic"
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


PAUSE 4000
NEXT
Play_Song:
DEBUG "Pequea meloda", 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) ' frecuencia de nota + octava
FREQOUT Speaker,dur,note ' emite sonido
RETURN
Con un poco de creatividad en la programacin, el BASIC Stamp puede emitir unos efectos de sonido
muy interesantes. Dado que la mayora de los sonidos que escuchamos en el telfono (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 versin especializada de FREQOUT. Su propsito es tocar los tonos
dobles que se requieren para marcar nmeros telefnicos. En lugar de escribir el tono (o tonos),
directamente se usan los nmeros a ser marcados. En verdaderas aplicaciones de marcado, la
duracin y la separacin de los tonos del DTMF puede ser especificada, para ajustarse a la calidad de
la lnea telefnica.
Este programa tambin presenta la habilidad musical bsica del BASIC Stamp tocando una pequea
meloda. Las constantes con las frecuencias de las notas (primer octava) y las duraciones, simplifican
el cdigo operacional. La subrutina PlayNote ajusta la frecuencia de la nota para la octava
especificada. La calidad musical puede verse afectada para octavas ms 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
Desafo
Convierta (una parte de) su cancin favorita para que suene en el BASIC Stamp.

Experimento 21: Entrada Analgica con PULSIN
Experimento 21
Entrada Analgica 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 CON $00C0 ' 0.75

P50 CON $0080 ' 0.50
P25 CON $0040 ' 0.25
rValue VAR Word ' valor directo

sValue VAR Word ' valor suavizado
' -------------------------------------------------------------------------

Experimento 21: Entrada Analgica con PULSIN
Principal:
PULSIN P_pin, 1, rValue ' obtiene parte estado bajo
sValue = (rValue */ P25) + (sValue */ P75)
DEBUG Home
DEBUG "Valor directo... ", DEC rValue, " ", CR
DEBUG "Valor filtrado.. ", DEC sValue, " "

END
En este experimento, el 555 es configurado como un oscilador. Analizando la salida, el ancho de la

porcin de estado bajo es controlado por el valor de la resistencia del fotoresistor. Midiendo la parte
baja de la seal 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 (mtodo iterativo) para obtener un valor suavizado. La relacin entre lectura directa
sobre filtrada de esta ecuacin, determinar la respuesta del filtro. A mayor porcentaje de valor
directo, ms rpidos son los cambios.
Desafo
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 Analgica con PWM
Experimento 22:
Salida Analgica con PWM
Este programa muestra como crear una salida de tensin 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 analgica
level VAR Byte ' nivel analgico
' -------------------------------------------------------------------------

Experimento 22: Salida Analgica con PWM
Principal:
FOR level = 0 TO 255 ' aumenta la tensin del LED
PWM D2Aout,level,25
NEXT
PAUSE 100
FOR level = 255 TO 0 ' disminuye la tensin del LED

PWM D2Aout,level,25
NEXT

END
Mientras que en la mayora de las aplicaciones el BASIC Stamp trabajar con seales digitales, en
algunas necesitarn una salida analgica; una tensin variable entre cero y algn valor mximo. La
funcin PWM del BASIC Stamp est diseada para generar tensiones analgicas cuando se combina
con un filtro RC. La funcin PWM genera una serie de pulsos que tienen una relacin de tiempo de
encendido y apagado programable (ciclo de trabajo). A mayor ciclo de trabajo, mayor tensin de
salida. Un ciclo de trabajo de 255 cargar al capacitor con 5 volts.
En este experimento, se usa medio LM358 como fuente de tensin para el LED. El op-amp
(amplificador operacional) evita que el capacitor se descargue rpidamente bajo condiciones de
trabajo. El brillo del LED vara debido a que la cada de tensin sobre el resistor que est en serie,
modifica la corriente que circula a travs del LED. Observe que el LED se enciende en forma cada
vez ms brillante y luego, se oscurece hasta apagarse. Esto sucede cuando la salida del LM358 cruza
el umbral de tensin de polarizacin directa (la tensin mnima para que el LED se ilumine) del LED
(aproximadamente 1,5 volts).
Usando el Multmetro digital, controle la tensin del Pin 1 del LM358.

Experimento 23: Expandiendo Salidas
Experimento 23:
Expandiendo Salidas
Este experimento demuestra cmo expandir las salidas del BASIC Stamp con un simple registro de
desplazamiento. Se emplean tres lneas para controlar ocho LEDs con un registro de desplazamiento
74x595.
SHIFTOUT

' =========================================================================
' Archivo: 74x595.BS2
'
' Use tres lneas para controlar 8 con un registro de desplazamiento 74x595
' =========================================================================
D_out CON 0 ' salida serial (74x595.14)

Clock CON 1 ' reloj de desp. (74x595.11)
Latch CON 2 ' salida de latch (74x595.12)
DlyTm CON 100
pattern VAR Byte ' patrn de salida
' -------------------------------------------------------------------------
Inicializar:
LOW Latch ' salida en estado bajo
pattern = %00000001
' -------------------------------------------------------------------------
Adelante:
GOSUB Out595
PAUSE DlyTm ' pone patrn en 74x595
pattern = pattern << 1 ' desplaza patrn a la izq.
IF pattern = %10000000 THEN Atras ' comprueba posicin final
GOTO Adelante ' continua en esta direccin
Atras:
GOSUB Out595
PAUSE DlyTm
pattern = pattern >> 1
IF pattern = %00000001 THEN Adelante
GOTO Atras
END
' -------------------------------------------------------------------------
Out595:
SHIFTOUT D_out,Clock,MSBFirst,[pattern] ' enva patrn al 74x595
PULSOUT Latch,3 ' bloquea (latch) las salidas
RETURN

El BASIC Stamp es extraordinariamente flexible en su habilidad para redefinir la direccin (entrada o

salida) de sus pines de E/S, aunque muy pocas aplicaciones requieren tanta flexibilidad. La mayora
de las aplicaciones de microcontroladores definirn los pines como entradas o salidas en la
inicializacin y esta definicin quedar sin cambios durante el resto del programa.
Si hay lneas que solamente se usarn como salidas podemos ahorrar lneas 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 lneas del BASIC Stamp, este programa es
capaz de controlar ocho LEDs a travs del 74x595.
El 74x595 convierte una cadena de datos seriales sincrnicos en ocho salidas paralelas. Los datos
seriales sincrnicos 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 lneas de datos y reloj,
escribiendo los datos en un dispositivo sincrnico, en este caso 74x595. Con el 74x595, los datos
deben ser bloqueados (latch) en las salidas despus del proceso de desplazamiento. El bloqueo se
realiza enviando un breve pulso por la lnea 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 lneas de control. Para conectar varios 74x595s en cascada, las lneas 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.
Desafo
Conecte un segundo 74x595 al primero de forma que las mismas tres lneas del BASIC Stamp puedan
controlar 16 salidas.

Experimento 24: Expandiendo Entradas
Experimento 24:
Expandiendo Entradas
Este experimento demuestra la expansin de entradas del BASIC Stamp con un registro de
desplazamiento. Tres lneas se usan para leer un DIP-switch de ocho posiciones.
SHIFTIN

' =========================================================================
' Archivo: 74x165.BS2
'
' Lea 8 interruptores usando solamente 3 lneas y un registro de desp. 74x165
' =========================================================================
D_in CON 0 ' desplazam. datos (74x165.7)

Clock CON 3 ' reloj (74x165.2)
Load CON 4 ' carga de entrada (74x165.1)
switches VAR Byte ' interruptores de entrada
' -------------------------------------------------------------------------
Inicializar:
HIGH Load ' hace salida en estado alto
' -------------------------------------------------------------------------
Principal:
GOSUB ReadSwitches ' lee 8-pos. del dip switch
DEBUG Home, IBIN8 switches ' muestra en modo binario
PAUSE 100
END
' -------------------------------------------------------------------------
ReadSwitches:
PULSOUT Load,3 ' toma valores interruptores
SHIFTIN D_in,Clock,MSBPre,[switches] ' desplaza valores
RETURN
El experimento demuestra el uso de SHIFTIN, la funcin complementaria de SHIFTOUT. En este

caso, tres lneas 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 lnea 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 posicin ON
se crea una entrada lgica 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).
Desafo
Conecte un segundo registro de desplazamiento 74x165 para leer 16 entradas. Vea las hojas de
datos del 74HC165 para obtener informacin de conexionado.

Experimento 25: Control de un Servo
Experimento 25:
Control de un Servo
Este experimento demuestra cmo controlar un servo comn. Los servos son muy usados en la
robtica amateur.
SDEC, SDEC1 SDEC16 (modificador de DEBUG)
' =========================================================================
' Archivo: SERVO.BS2
'
' Controlador de la posicin de un Servo
'
' {$STAMP BS2}
' =========================================================================
PotCW CON 0 ' entrada pot sentido horario

PotCCW CON 1 ' entrada pot sentido anti-horario

Servo CON 2 ' pin control de servo
rcRt VAR Word ' lectura rc - derecha

rcLf VAR Word ' lectura rc - izquierda
diff VAR Word ' diferencia entre lecturas
sPos VAR Word ' posicin del servo
' -------------------------------------------------------------------------
Principal:
HIGH PotCW ' descarga capacitores
HIGH PotCCW
PAUSE 1
RCTIME PotCW,1,rcRt ' lee sentido horario
RCTIME PotCCW,1,rcLf ' lee sentido anti-horario
rcRt = rcRt */ $0068 MAX 250 ' escala RCTIME a 0-250

rcLf = rcLf */ $0068 MAX 250
sPos = rcRt - rcLf ' calcula posicin (-250 a 250)
PULSOUT Servo,(750 + sPos) ' mueve el servo

PAUSE 15
GOTO Principal
END
Los servos son dispositivos electromecnicos especializados usados frecuentemente para posicionar
los planos de control de aeromodelos. La posicin 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 seal de control es de 1,5 milisegundos. Para
mantener esta posicin, el servo debe ser actualizado constantemente. La frecuencia de actualizacin
tpica 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 potencimetro de 10K. Este circuito y el cdigo pueden ser
usados para determinar la posicin relativa del potencimetro. Las lecturas de cada lado del
potencimetro 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 posicin del servo entre250
y +250.

Este valor se agrega a la posicin 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 posicin 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 cdigo demuestra que el BASIC Stamp trabaja con nmeros negativos. Puede ver el valor de
sPos insertando esta lnea despus del clculo:
DEBUG Home, "Posicin: ", SDEC sPos, " "
Los nmeros negativos son almacenados con el formato de complemento a dos. El modificador SDEC
(decimal con signo) imprime valores decimales con su signo.
Desafo
Reemplace el potencimetro con dos fotorresistores y actualice el cdigo para hacer que el servo se
centre hacia la fuente de luz ms brillante.

Experimento 26: Motor Paso a Paso
Experimento 26:
Motor Paso a Paso
Este experimento demuestra el control de un pequeo motor paso a paso unipolar de 12-volt. Los
motores paso a paso se usan en dispositivos de posicionamiento de precisin en aplicaciones de
control industrial y robtica.
ABS

' =========================================================================
' Archivo: STEPPER.BS2
'
' control de motor paso a paso unipolar
'
' {$STAMP BS2}
' =========================================================================
PotCW CON 0 ' entrada pot. sentido horario

PotCCW CON 1 'entrada pot. sentido anti-horario
Coils VAR OutB ' salida a bobinas del paso a paso
speed VAR Word ' retardo entre pasos

x VAR Byte ' contador de bucle
sAddr VAR Byte ' direccin de EE de datos de paso
rcRt VAR Word ' lectura rc - derecha
rcLf VAR Word ' lectura rc - izquierda
diff VAR Word ' 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 ' config. Pines motor como salidas
speed = 5 ' fija velocidad inicial
' -------------------------------------------------------------------------
Principal:
FOR x = 1 TO 100 ' 1 rev. adelante
GOSUB StepFwd
NEXT
PAUSE 200
FOR x = 1 TO 100 ' 1 rev. atrs

GOSUB StepRev
NEXT
PAUSE 200
StepDemo:
HIGH PotCW ' descarga capacitores
HIGH PotCCW
PAUSE 1
RCTIME PotCW,1,rcRt ' lee sentido horario
RCTIME PotCCW,1,rcLf ' lee sentido anti-horario
rcRt = rcRt MAX 600 ' fija lmites de velocidad

rcLf = rcLf MAX 600
diff = ABS(rcRt - rcLf) ' obtiene dif. Entre lecturas

IF (diff < 25) THEN StepDemo ' zona muerta
IF (rcLf > rcRt) THEN StepCCW
StepCW:
speed = 60 - (rcRt / 10) ' calcula velocidad
GOSUB StepFwd ' da un paso
GOTO StepDemo
StepCCW:
speed = 60 - (rcLf / 10)
GOSUB StepRev
GOTO StepDemo
' -------------------------------------------------------------------------
StepFwd:
sAddr = sAddr + 1 // 4 ' apunta al siguiente paso
READ (Step1 + sAddr),Coils ' datos de paso de salida
PAUSE speed ' pausa entre pasos
RETURN
StepRev:
sAddr = sAddr + 3 // 4 ' apunta al paso anterior
READ (Step1 + sAddr),Coils
PAUSE speed
RETURN

Los motores paso a paso se diferencian de los motores de CC en que no giran libremente cuando se
les aplica la alimentacin. Para que un motor paso a paso gire, la alimentacin debe pulsarse
continuamente en un patrn especfico. La secuencia de pasos (patrn) determina el sentido de
rotacin 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
idntica excepto en que leer el paso anterior. Note el truco con el operador mdulo (//) usado en
StepRev. Agregando el valor mximo de la secuencia al valor actual y luego aplicando el operador
mdulo, la secuencia va a la inversa. Esta el la matemtica involucrada:
0 + 3 // 4 = 3
3 + 3 // 4 = 2
2 + 3 // 4 = 1
1 + 3 // 4 = 0
Este experimento lee ambos lados del potencimetro de 10K para determinar su posicin relativa. El
valor diferencial entre las dos lecturas se mantiene positivo mediante el uso de la funcin ABS. La
posicin es usada para determinar la direccin 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.
Desafo
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: Medicin de Tensin
Experimento 27:
Medicin de Tensin
Este experimento demuestra el uso de un conversor analgico-digital para leer una entrada de
tensin variable.
' =========================================================================
' Archivo: ADC0831.BS2
'
' Leer tensin en el cursor del potencimetro con un ADC-0831
' =========================================================================
ADdata CON 0 ' lnea de datos A/D

ADclock CON 1 ' reloj A/D
ADcs CON 2 ' chip select A/D (act. bajo)
result VAR Byte ' resultado de conversin

mVolts VAR Word ' 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

END
' -------------------------------------------------------------------------
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 analgicos, pero no sirve para leer tensiones. Para medir tensiones el BASIC Stamp la ayuda
de un dispositivo externo. La forma ms simple de medir una tensin variable es con un conversor
analgico-digital.
En este experimento, el National Semiconductor ADC0831 es usado para convertir una tensin (0
5) en una seal serial sincrnica que puede ser leda 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 funcin SHIFTIN permite especificar la cantidad de bits que sern 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 multiplicndolo por 19,6 (result */ $139C). Se usa un truco
interesante con DEBUG para mostrar la variable mVolts. La operacin DIG 3 imprime el valor
entero y el modificador DEC3 la parte fraccionaria.
Desafo
Conecte la salida del Experimento 22 (Pin 1 del LM358) a la entrada del ADC0831. Escriba un
programa que cree una tensin usando PWM y lea el valor resultante con el ADC0831.

Experimento 28: Medicin de Temperatura
Experimento 28:
Medicin de Temperatura
Este experimento demuestra el uso de un sensor de temperatura digital. La medicin de temperatura es
un componente esencial en aplicaciones de control ambiental (calefaccin y aire acondicionado).
' =========================================================================
' Archivo: DS1620.BS2
'
' Lee la temperatura con un Dallas Semiconductor DS1620
' =========================================================================
DQ CON 0 ' DS1620.1 (E/S de datos)

Clock CON 1 ' DS1620.2
Reset CON 2 ' DS1620.3
RdTmp CON $AA ' lee temperatura

WrHi CON $01 ' escribe TH (Temp. alta)
WrLo CON $02 ' escribe TL (Temp. baja)
RdHi CON $A1 ' lee TH
RdLo CON $A2 ' lee TL
StartC CON $EE ' inicia conversin
StopC CON $22 ' detiene conversin
WrCfg CON $0C ' escribe registro config.
RdCfg CON $AC ' lee registro config.
tempIn VAR Word ' temperatura directa

sign VAR tempIn.Bit8 ' 1 = temperatura negativa

tSign VAR Bit
tempC VAR Word ' Celsius
tempF VAR Word ' Fahrenheit
' -------------------------------------------------------------------------
Inicializar:
GOSUB DS1620init ' inicializa el DS1620
' -------------------------------------------------------------------------
Principal:
GOSUB GetTemperature ' lee el DS1620
DEBUG Home
DEBUG "DS1620",CR
DEBUG "------",CR
DEBUG SDEC tempC," C ",CR
DEBUG SDEC tempF," F ",CR

GOTO Principal
END
' -------------------------------------------------------------------------
DS1620init:
HIGH Reset ' activa el DS1620
SHIFTOUT DQ,Clock,LSBFirst,[WrCfg,%10] ' use con CPU; func. Continuo
LOW Reset
PAUSE 10
HIGH Reset
SHIFTOUT DQ,Clock,LSBFirst,[StartC] ' inicia conversiones
LOW Reset
RETURN
GetTemperature:
SHIFTOUT DQ,Clock,LSBFIRST,[RdTmp] ' entrega comando leer Temp..
SHIFTIN DQ,Clock,LSBPRE,[tempIn\9] ' la lee
LOW Reset ' libera al DS1620

tSign = sign ' guarda el bit de signo

tempIn = tempIn/2 ' redondea a grados enteros
IF tSign = 0 THEN NoNeg1
tempIn = tempIn | $FF00 ' extiende bits de signo en neg.
NoNeg1:
tempC = tempIn ' guarda valor Celsius
tempIn = tempIn */ $01CC ' multiplica por 1.8
IF tSign = 0 THEN NoNeg2 ' si negativo, extiende bits signo
tempIn = tempIn | $FF00
NoNeg2:
tempIn = tempIn + 32 ' finaliza conversin C -> F
tempF = tempIn ' guarda valor Fahrenheit
RETURN
El rgano ms grande del cuerpo humano es la piel y es el ms rpidamente afectado por la

temperatura. Esta es la razn por la que se pone tanto esfuerzo en los sistemas de control ambiental
(calefaccin y aire acondicionado).
Este experimento usa el tremostato/termmetro digital Dallas Semiconductor DS1620. Este chip mide
la temperatura y la pone a disponibilidad del BASIC Stamp mediante una interfaz serial sincrnica. El
DS1620 es un dispositivo inteligente y una vez programado, es capaz de operar autnomamente 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
configuracin al DS1620, se necesita un retardo de 10 milisegundos para que la configuracin 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 extensin 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 (centgrados).

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 nmeros mantengan su signo con SDEC (los
nmeros con signo en el BASIC Stamp deben tener una longitud de 16 bits). La temperatura es
convertida a Fahrenheit usando la frmula:
F = (C * 1.8) + 32
Desafo
Rescriba el programa para que muestre los valores de temperatura en el mdulo 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 dgitos son usados frecuentemente en mquinas 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 CON 7 ' pin de datos(MAX7219.1)

Clock CON 6 ' pin de reloj(MAX7219.13)
Load CON 5 ' pin de carga(MAX7219.12)
Coins VAR InL ' entradas de monedas
Decode CON $09 ' decodificador bcd

Brite CON $0A ' registro de intensidad
Scan CON $0B ' reg. De lmite de bsqueda
ShutDn CON $0C ' registro de apagado (1 = enc.)
Test CON $0F ' modo de prueba de display
DecPnt CON %10000000
Blank CON %1111 ' limpia un dgito
Yes CON 1
No CON 0
money VAR Word ' Contador de dinero

deposit VAR Byte ' monedas depositadas
penny VAR deposit.Bit0 ' bits de valores
nickel VAR deposit.Bit1
dime VAR deposit.Bit2
quarter VAR deposit.Bit3
dollar VAR deposit.Bit4
digit VAR Nib ' muestra dgito
d7219 VAR Byte ' datos para el MAX7219
index VAR Nib ' contador de bucle
idxOdd VAR index.Bit0 ' es impar el ndice? (1 = si)
' -------------------------------------------------------------------------
' Segmentos .abcdefg

' --------
Full DATA %01000111 ' F
DATA %00111110 ' U
DATA %00001110 ' L
DATA %00001110 ' 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 parmetro
NoLoad:
NEXT
GOSUB ShowTheMoney
' -------------------------------------------------------------------------
Principal:
GOSUB GetCoins
IF deposit = 0 THEN Principal ' espera monedas
money = money + (penny * 1) ' suma monedas

money = money + (nickel * 5)
money = money + (dime * 10)
money = money + (quarter * 25)
money = money + (dollar * 100)
GOSUB ShowTheMoney ' actualiza el display

PAUSE 100
GOTO Principal
END
' -------------------------------------------------------------------------
GetCoins:
deposit = %00011111 ' habilita todas las entradas
FOR index = 1 TO 10
deposit = deposit & ~Coins ' controla entradas
PAUSE 5 ' retardo entre controles
NEXT
RETURN

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 enva una letra
SHIFTOUT Dpin,Clock,MSBFirst,[index,d7219]
PULSOUT Load,3
NEXT
Multiplexar varios displays de 7 segmentos requiere un gran esfuerzo y la mayora de los recursos de
cmputo del BASIC Stamp. Usando el multiplexor MAXIM MAX7219 solamente son necesarios tres
lneas 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 ctodo
comn. Los pines DIGIT 0 hasta DIGIT 7 se conectan individualmente a los ctodos de cada uno de
los displays. Si usa menos de ocho dgitos, omita los nmeros superiores. Por ejemplo, este
experimento usa cuatro dgitos, numerados de 0 a 3, no de 4 a 7.

El MAX7219 tiene una caracterstica que limita el barrido de displays a los dgitos 0 a n, donde n es el
nmero de dgito ms alto. Esto hace que el chip no pierda tiempo y ciclos de trabajo (perdiendo
brillo) tratando de componer dgitos inexistentes.
Cuando el MAX7219 es usado con displays de 7 segmentos, puede ser configurado para convertir
automticamente valores decimales codificados en binario (BCD) en patrones apropiados de
segmentos. Esto hace que mostrar nmeros decimales sea muy simple. La caracterstica de
decodificacin 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 ms significativo (MSB).

Emita un pulso en la lnea Load para transferir los datos.
Cada paquete de datos de 16-bits consiste en una direccin 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 dgito del display. Si se enciende el decodificador BCD para ese dgito, el nmero 7
aparecer en el display. Si no se enciende la decodificacin, se encendern tres LEDs,
correspondientes a los segmentos G, F y E.
En este experimento, el MAX7219 se inicializa para:
Scan = 3 (Muestra dgitos 0 3)

Brightness = 5 (Brillo)
Decode = $0F (decodificacin BCD 0 3)
Shutdown = 1 (operacin normal)
La inicializacin del MAX7219 es realizada en un bucle. En cada pasada lee una direccin de registro
o valor de datos de la tabla LOOKUP. Despus de que cada valor es enviado, la direccin y el dato son
bloqueados en el MAX7219 mediante un pulso en la lnea Load.
La mayora del trabajo tiene lugar en la subrutina llamada ShowTheMoney. Cuando la cantidad de
dinero es menor que 9999, el valor ser mostrado en los dgitos de 7 segmentos, caso contrario la
pantalla mostrar el mensaje FULL (lleno). La rutina examina cada dgito del dinero y enva la
posicin y el valor (con el operador DIG) al MAX7219. Dado que el display muestra dlares y
centavos, se habilita el punto decimal en el tercer dgito. Cuando el dgito y la posicin han sido
enviados, el display se actualiza enviando un pulso en la lnea 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
decodificacin 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 algn botn con GetCoins y
actualiza los contadores de cada moneda cada vez que se presiona un botn. Este cdigo en
particular es un ejemplo excelente del uso de sobrenombres o alias para las variable para mejorar la
claridad del programa.
Desafo
Modifique el cdigo del Experimento 27 para que muestre la tensin 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 temporizacin RTC es crucial para
aplicaciones que dependen de la hora del da o aquellas que deben medir el tiempo transcurrido.
' =========================================================================
' Archivo: DS1302.BS2
'
' Este programa demuestra las funciones temporales bsicas usando el DS1302
' de Dallas Semiconductor.
' =========================================================================
Dio CON 0 ' DS1302.6

CS_1302 CON 2 ' DS1302.5
BtnsIn VAR InB ' entrada de pulsadores

WrSecs CON $80 ' escribe segundos

RdSecs CON $81 ' lee segundos
WrMins CON $82 ' escribe minutos
RdMins CON $83 ' lee minutos
WrHrs CON $84 ' escribe horas
RdHrs CON $85 ' lee horas
CWPr CON $8E ' reg. de proteccin de escritura
WPr1 CON $80 ' activa protec. de escritura
WPr0 CON $00 ' desactiva protec. de escritura
WrBurst CON $BE ' escribe tren de datos
RdBurst CON $BF ' tren de datos
WrRam CON $C0 ' control de direcciones de RAM
RdRam CON $C1
Yes CON 1
No CON 0
Hr24 CON 0
Hr12 CON 1
ClockMode CON Hr12 ' usa modo AM/PM
index VAR Byte ' contador de bucle

reg VAR Byte ' direccin DS1302 para leer/esc.
ioByte VAR Byte ' datos hacia/desde el DS1302
secs VAR Byte ' segundos

secs01 VAR secs.LowNib
secs10 VAR secs.HighNib
mins VAR Byte ' minutos
mins01 VAR mins.LowNib
mins10 VAR mins.HighNib
hrs VAR Byte ' horas
hrs01 VAR hrs.LowNib
hrs10 VAR hrs.HighNib
day VAR Byte ' da
ampm VAR hrs.Bit5 ' 0 = AM, 1 = PM

tMode VAR hrs.Bit7 ' 0 = 24, 1 = 12
rawTime VAR Word ' valores temporales directos

work VAR Byte ' variable para mostrar salida
oldSecs VAR Byte ' valor de segundos anterior
apChar VAR Byte ' "A" o "P"

btns VAR Nib ' botones entradas

btnMin VAR btns.Bit0 ' actualiza minutos
btnHrs VAR btns.Bit1 ' actualiza horas
btnDay VAR btns.Bit2 ' actualiza da
btnBack VAR btns.Bit3 ' hacia atrs
' -------------------------------------------------------------------------
Su DATA "Domingo", 0
Mo DATA "Lunes", 0
Tu DATA "Martes", 0
We DATA "Miercoles", 0
Th DATA "Jueves", 0
Fr DATA "Viernes", 0
Sa DATA "Sabado", 0
' -------------------------------------------------------------------------
Inicializar:
DirL = %00000111 ' interrup. entradas
reg = CWPr ' deshabilita protec. de escritura

ioByte = WPr0
GOSUB RTC_out
oldSecs = $99 ' habilita la bandera display

hrs = $06 ' fija hora del DS3102 a 6:00 AM
GOSUB SetTime
' --------------------------------------------------------------------------
Main1:
GOSUB GetTime ' lee el DS1302
IF secs = oldSecs THEN CheckButtons ' tiempo para actualizar?
Main2:
GOSUB ShowTime ' si, lo muestra
oldSecs = secs ' lo marca
CheckButtons:
GOSUB GetButtons
IF btns = 0 THEN DoSomeTask ' permite al BS hacer otro trabajo
IF btnBack = Yes THEN GoBack ' botn hacia atrs presionado?

Adelante:
rawTime = rawTime + btnMin ' agrega un minuto
rawTime = rawTime + (btnHrs * 60) ' agrega una hora
day = (day + btnDay) // 7 ' da siguiente
GOTO UpdateClock
GoBack:
IF (btns <= %1000) THEN DoSomeTask ' no se presiona botn actualizar
rawTime = rawTime + (btnMin * 1439) ' resta un minuto
rawTime = rawTime + (btnHrs * 1380) ' resta una hora
day = (day + (btnDay * 6)) // 7 ' da anterior
UpdateClock: ' enva valor actualiz. al DS1302

rawTime = rawTime // 1440 ' limpia modos de tiempo
GOSUB SetRawTime ' conf. Reloj para tiempo directo
GOTO Main2
DoSomeTask: ' trabaja cuando no usa el reloj
' otro cdigo aqu
GOTO Main1
END
' -------------------------------------------------------------------------
ShowTime:
DEBUG Home
LOOKUP day,[Su,Mo,Tu,We,Th,Fr,Sa],work ' obtiene direccin de da
GetDayChar:
READ work,ioByte ' obtiene un caracter
IF ioByte = 0 THEN CheckClockMode ' si 0, da terminado
DEBUG ioByte ' imprime el caracter
work = work + 1 ' apunta al siguiente
GOTO GetDayChar
CheckClockMode:
DEBUG " ", CR ' limpia restos de da 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 ' habilita todas las entradas
FOR index = 1 TO 10
btns = btns & ~BtnsIn ' controla botones
PAUSE 5 ' pausa entre controles
NEXT
PAUSE 200
RETURN
RTC_out: ' enva ioByte al reg. en DS1302

HIGH CS_1302
SHIFTOUT Dio,Clock,LSBFirst,[reg,ioByte]
LOW CS_1302
RETURN
RTC_in: ' lee ioByte del reg. del DS1302

HIGH CS_1302
SHIFTOUT Dio,Clock,LSBFirst,[reg]
SHIFTIN Dio,Clock,LSBPre,[ioByte]
LOW CS_1302
RETURN
SetRawTime: ' convierte rawTime a BCD

hrs10 = rawTime / 600
hrs01 = rawTime // 600 / 60
mins10 = rawTime // 60 / 10
mins01 = rawTime // 10
SetTime: ' escribe datos en modo burst

HIGH CS_1302

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 aplicacin debe llevar registro de la hora y la fecha. La solucin ms 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 lneas para comunicarse con el BASIC Stamp.
Dado que los dos dispositivos son compatibles, el reloj y las lneas 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), da del mes, mes, da de la
semana y ao con compensacin de bisiestos hasta el ao 2100. Como extra, el DS1302 contiene 31
bytes de RAM que podemos usar como queramos. Y para proyectos que usan la alimentacin
principal, el DS1302 tambin tiene un circuito de carga que mantiene cargada una batera 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 (direccin de memoria). Por conveniencia, estn
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 conexin con el DS1302 simple, este experimento solamente usa el modo 24-
horas. 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 matemticamente. En el cdigo, la hora es
manejada como una nica variable tamao word (rawTime) que representa el nmero de minutos
pasada la medianoche. De esta forma se pueden realizar clculos de duraciones y comparar tiempos
de alarmas con la hora actual en forma directa.
Otra buena razn para usar el formato de tiempo directo es que el DS1302 almacena sus registros en
formato BCD (decimal codificado en binario). BCD es un mtodo 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 tamao nibble y ms importante an, permite poner sobrenombres a las
variables.
Este experimento demuestra lo bsico del DS1302 configurando el reloj y luego actualizndolo. Las
conversiones del registro de formato BCD hacia y desde el DS1320 son realizadas por las subrutinas
que envan y reciben datos en el modo burst (completo).
Se usan cuatro pulsadores para fijar el da, horas y minutos del reloj. Normalmente, los botones
incrementan cada valor. Manteniendo presionado el cuarto botn, cada elemento correr hacia atrs.
Mientras no se presiona ningn botn, el programa pasa a una subrutina llamada DoSomeTask. Este
es el sector donde podra poner cdigo adicional (leer un DS1620, por ejemplo).
La salida del programa es mediante una ventana DEBUG. La subrutina ShowTime se encarga de
imprimir el da y la hora en el formato especificado por ClockMode.

Desafo (Avanzado)
Agregue un DS1620 usando las conexiones que se muestran abajo. Escriba un programa que
registre la temperatura actual, la mnima y la mxima 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 travs de cualquiera de sus pines de E/S. Tambin demuestra la capacidad de almacenar
informacin 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 informacin con el BASIC Stamp va
' conexin RS-232
' {$STAMP BS2}
' =========================================================================
LEDs VAR OutA ' salidas LED

DQ CON 4 ' DS1620.1 (a travs de 1K)
Reset CON 6 ' DS1620.3
RxD CON 14 ' entrada serial - a INEX RxD

TxD CON 15 ' salida serial - a INEX TxD
Baud96 CON 84 ' 9600-8-N-1 (compatible DEBUG)
CMenu CON $FF ' muestra menu de comandos

CID CON $F0 ' obtiene ID de cadena
CSet CON $F1 ' fija ID de cadena
CTmp CON $A0 ' DS1620 - display valor directo
CTmpC CON $A1 ' DS1620 - display en C
CTmpF CON $A2 ' DS1620 - display en F
CStat CON $B0 ' estado de salida digital
CLEDs CON $B1 ' config. LEDs salidas
RTmp CON $AA ' lee temperatura

WTHi CON $01 ' escribe TH (reg. Temp. alta)
WTLo CON $02 ' escribe TL (reg. Temp. baja)
RTHi CON $A1 ' lee TH
RTLo CON $A2 ' lee TL
StartC CON $EE ' inicia conversin
StopC CON $22 ' detiene conversin
WrCfg CON $0C ' escribe reg. configuracin
RdCfg CON $AC ' lee reg. configuracin
cmd VAR Byte ' comando de la PC

eeAddr VAR Byte ' puntero de direccin EE
eeData VAR Byte ' dato EE
param VAR Word ' parmetro desde la PC
char VAR param.LowByte ' caracter de la terminal
tmpIn VAR Word ' valor directo del DS1620
halfBit VAR tmpIn.Bit0 ' indicador de 0,5 grados C

sign VAR tmpIn.Bit8 ' 1 = temperatura negativa

tempC VAR Word ' grados C en dcimas
tempF VAR Word ' F en dcimas
potVal VAR Word ' lectura de BSAC
buttons VAR Nib ' botones de entrada
' -------------------------------------------------------------------------
ID DATA "Parallax",CR ' cadena terminada en CR
' -------------------------------------------------------------------------
Inicializar:
DirA = %1111 ' hace salidas los LEDs
GOSUB DS1620init ' 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 invlido: ",HEX2 cmd,CR]
GOTO Principal
END
' -------------------------------------------------------------------------
DS1620init:
SHIFTOUT DQ,Clock,LSBFirst,[WrCfg,%10] ' usa con CPU; modo continuo
LOW Reset
PAUSE 10
HIGH Reset

SHIFTOUT DQ,Clock,LSBFirst,[StartC] ' inicia conversiones

LOW Reset
RETURN
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="] ' etiqueta o rtulo
eeAddr = ID ' puntero al primer caracter de ID
GetEE:
READ eeAddr,eeData ' lee caracter de EEPROM
SEROUT TxD,Baud96,[eeData] ' imprime caracter
eeAddr = eeAddr + 1 ' apunta al siguiente
IF (eeData <> CR) THEN GetEE ' si no CR, lee otro
GOTO Principal
SetID:
eeAddr = ID ' apunta a ubicacin ID
GetC:
SERIN RxD,Baud96,[char] ' obtiene caracter de PC
WRITE eeAddr,char ' escribe caracter en EEPROM
eeAddr = eeAddr + 1 ' apunta a siguiente ubicacin
IF (char <> CR) THEN GetC ' si no CR, espera otro
GOTO ShowID ' confirma nueva ID

ShowTemp:
GOSUB GetTemp
' enva 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 dcimas 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 dcimas 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 ' configura salidas
GOTO ShowStat ' confirma nuevas salidas
GetTemp:
SHIFTOUT DQ,Clock,LSBFirst,[RTmp] ' lee la temperatura

SHIFTIN DQ,Clock,LSBPre,[tmpIn\9] ' obtiene la temperatura

LOW Reset
RETURN
Sin comunicacin serial asincrnica el mundo no sera lo que es hoy. No habra cajeros automticos
para controlar el estado de nuestras cuentas y retirar fondos. No podra haber Internet.
Los experimentos anteriores han usado comunicacin serial sincrnica. En ese esquema, se
necesitaban dos lneas: reloj y datos. El beneficio es la sincronizacin automtica del transmisor y
receptor. El precio que pagamos es que se necesitan al menos dos cables para enviar un mensaje.
La comunicacin serial asincrnica solamente necesita un cable para transmitir un mensaje. En este
caso es necesario que el emisor y el receptor estn de acuerdo en la velocidad de la comunicacin
antes de iniciar la transmisin de datos. Algunos sistemas inteligentes pueden detectar la velocidad
de la comunicacin (baud rate), pero el BASIC Stamp no puede.
En este experimento usamos SEROUT para enviar informacin a una terminal y SERIN para recibir
datos. La entrada normalmente ser un comando y a veces el comando ser acompaado por datos
nuevos.
Despus 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 smbolo de interrogacin, significa que comienza una
pregunta. Una vez que ingresa el signo de interrogacin, el modificador HEX hace que el BASIC
Stamp busque caracteres hexadecimales vlidos (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 contine con el programa.
Lo que en realidad sucede es que el BASIC Stamp ha usado la funcin SERIN para realizar una
conversin de texto a nmero. 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
vlido. Si el comando no es vlido, se muestra un mensaje indicndolo.

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 parmetro y finalmente, un salto de lnea. Cuando usa un
programa terminal, la salida es fcil de leer. Algo as:
ID=Parallax BS2
El salto de lnea al final de la salida nos enva a la lnea 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 mayora de las preguntas son pedidos de informacin. Dos de ellas sin embargo, pueden modificar
la informacin 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
ubicacin 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 cdigo ASCII, no
necesitamos hacer ningn tratamiento especial. Cuando llega un caracter, WRITE es usada para
almacenarlo en la EEPROM y se incrementa el puntero de direccin. Si el ltimo caracter era un salto
de lnea (13), el programa emite la cadena nueva (usando el cdigo de ShowID), caso contrario
repite la secuencia esperando el prximo 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 fcilmente 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 sesin real usando la terminal DEBUG del BASIC Stamp. Para
ejecutar el experimento, siga estos pasos:
1. Quite todos los componentes de los experimentos anteriores.

2. Ingrese y descargue el programa
3. Apague la plaqueta StampWorks y arme el circuito
4. Mueva el cable de programacin al puerto RS-232 Interfacing
5. Abra una ventana DEBUG haciendo clic en el cono DEBUG
6. Encienda la plaqueta StampWorks.
Desafo (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 ayudarn a llevar a la realidad sus
ideas.
Planifique su trabajo, Trabaje segn lo planific
Lo ha escuchado millones de veces: planifique, planifique y planifique. Nada causa ms problemas a

un programador que una planificacin inadecuada. Esto es especialmente cierto con el BASIC Stamp
debido a que los recursos son limitados. La mayora de los programas que hemos reparado haban
fallado debido a falta de planificacin y formato pobre (que los hace difciles de revisar).
Hable
Hable sobre el programa. No solo piense, hable. Hable en voz alta como si estuviese explicando la
operacin del programa a un compaero programador. A menudo, escuchar su propia voz es lo que
marca la diferencia. Mejor an, 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
Disee los detalles de su programa por escrito antes de sentarse en su computadora. Use muchos
colores. Encontrar que al trabajar visualmente en un diseo idear nuevas aproximaciones y el uso
de estos medios le permitir escribir segmentos de programa dentro de sus diagramas funcionales.
Disee con Notas Autoadhesivas
Consiga un bloque de notas autoadhesivas. Escriba los nombres de los mdulos o fragmentos
concisos de cdigo sobre papeles individuales y luego pguelos en la pared. Luego sintese y cheles
una mirada. Luego de un pequeo paseo. Agregue notas, quite algunas; simplemente haga lo que le
parece correcto. Este ejercicio funciona especialmente bien con grupos. Cmo sabe que termin de
disear el programa? Cuando las notas adhesivas dejan de moverse! Es una buena idea escribir la
versin final antes de abrir el editor. Otra idea: esta tcnica funciona mejor si se la mezcla con la
anterior, dibujando lneas que indiquen el flujo del programa. Si se equivoca, borre las lneas o
mueva las notas. Intente esto, realmente funciona.

Vaya ms 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 dnde 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 Khnel y Klaus Zahnert
Getting Started In Electronics por Forrest Mims
Engineers Notebook por Forrest Mims
Nuts & Volts Magazine Stamp Applications column
Sitios Web
www.parallaxinc.com Sitio principal de Parallax

www.stampsinclass.com Sitio educativo de Parallax
www.al-williams.com/awce/index.htm Sitio web de Al Williams
www.seetron.com Sitio web de Scott Edwards Electronics
www.hth.com/losa Fuente de ideas: List of Stamp Applications
www.emesystems.com/BS2index.htm Recursos tcnicos de Tracy Allen
Sitios web en castellano
www.stampsenclase.com Sitio educativo de Parallax en castellano

www.cursoderobotica.com.ar 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.

Apndice A: Hojas de Datos
Apndice A:
Hojas de Datos
Las primeras pginas de las hojas de datos (en Ingls) de los fabricantes se incluyeron en el
Apndice A. Las hojas de datos completas se pueden bajar de la pgina 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
Termmetro digital DS1620 Dallas Semiconductor
Display de cristal lquido 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

LED 7 SEGMENT DISPLAY LED MONITOR 16 CHANNELS
DC DOWNLOAD 15 14 13 12 11 10 9 8
INPUT
BS2-IC/BS2SX-IC
7 6 5 4 3 2 1 0
RESET
7805
BASIC Stamp II Connector DIGIT

POWER
+5V 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 GND a b c d e f g dp 4 3 2 1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
LCD
CONNECTOR
RS

NX-1000 Univeersal training board R/W
E
RS-232 INTERFACING D0
D1
D2
D3
RxD D4
PROTO BOARD AREA D5
D6
D7
TxD
+
GND
PIEZO
VR-10k
1Hz 10Hz 100Hz 1kHz 1 2 3 4 4 CHANNELS

D7
D6
D5
D4
D3
D2
D1
D0
PUSH BUTTON SWITCH DRIVER
PULSE +V 1 2 3 4
FREQUENCY
GENERATOR S1 S2 S3 S4 S5 S3 S4 S5 OUTPUT
BASIC Stamp II Front-end Switch circuit LED Monitor
K3 R3-R10 R11-R18
BASIC Stamp 220x8 220x8
K4 15 P15 7 P7
CONNECTOR PUSH BUTTON
SWITCH 14 P14 6 P6
K1 P15 13 P13 5 P5
P14 D7 S8 12 P12 4 P4
RS-232
+V P13 D6 S7 11 P11 3 P3
DOWNLOAD S6
SK1 P12 D5 10 P10 2 P2
6 P11 D4 S5 9 P9 1 P1
2 1 Sin PWR 24 D3 S4
7 P10 8 P8 0 P0
3 2 Sout GND 23 S3
P9 D2
4 3 ATN RES\ 22 S2 K7 K6
P8 D1
5 4 GND +5V 21 S1
P7 D0
5 P0 P15 20 SW1
P6 LED display 4 digit
6 P1 P14 19 RESET P6
7 P2 P13 18 P5 +5V K8 R19-R26 DSP304 DSP303 DSP302 DSP301
8 P3 P12 17 P4 R2 220x8
9 P4 P11 16 P3 10k*1 a a
10 P5 P10 15 P2 D7 b
D7 b
11 P6 P9 14 P1 D6 D6 c
c
12 P7 P8 13 P0 D5 D5 d
d
D4 D4 e
e
D3 D3 f
f g
D2 D2 g
D1 dp
D1 dp
D0 D0
S9 K9
K5 DIP SW. *8 DIGIT4
DIP SWITCH DIGIT3
DIGIT2
DIGIT1
Power Supply Piezo Speaker VARIABLE LCD module connector

RESISTOR
RS +5V K11 +5V
R/W UIC-LCD NX-1000
+V
J1 D1-D4 ~12V E
DC IN 1N4001 x4 K1 Vo RS Universal training board for
+5V +5V K13 D7
9-12V D6 R/W E BASIC Stamp 2/2SX microcontroller
IC1 + D5 D0 D1
7805 R1 - K14
module
220 D4 VR1 D2 D3
C2
10k Digital circuit experiment
SP1 D3 Brightness D4 D5
220/25V Programmable Logic Device experiment
C1 D2 D6 D7
PIEZO
0.1/50V C3 LED1 and any small/medium microcontroller
K2 SPEAKER VR2 D1
0.1/50V POWER experiment
GND 10k D0
K10
RS-232 INTERFACING PULSE GENERATOR HIGH CURRENT DRIVER

R31 Design and copyright by
4k7 +5V
HERTZ (Hz) K11
+5V C4
RxD 0.1/50V 1k 100 10 1 INPUT Innovative Experime nt Co.,Ltd.
D5 9 +12V
+5V
1N4148 6 11 500 mA(max)
Q1 LED2-LED5 The manufacturer of en g ineering
BC547 1 P1 OUT1
K16 R27 educational products in Thailand,
RS-232 R33 5 12
10k 5 P2 OUT2
R32 4k7 R28-R31 K13 BASIC Stamp products distributor in
1 6 510 X4
6 4k7 TxD 4 IC 3 4 13 DRIVER
2 Q2 7
7 BC557 R34 P GX4100 2 P3 OUT3 OUTPUT Thailand
3 4k7 3
8 S10 3 14
4 D6 R35 C5 P4
9 10/50V FREQ. K12 OUT4
5 1N4148 1k8
8 OUT IC2
GND 8 ULN2003












Apndice B: Manual del BASIC Stamp II, Versin 2.0
Apndice B:
Manual del BASIC Stamp II Versin
2.0
El Manual del BASIC Stamp 2.0 es incluido en este apndice. El manual completo (y futuras
actualizaciones) se pueden comprar o descargar desde www.parallaxinc.com.

Stampworks Espanol PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Stampworks Espanol PDF

Uploaded by

Copyright:

Available Formats

Experimentos y Cdigo Fuente para el BASIC Stamp

Versin en Castellano 1.1

Sobre la precisin de este texto:

Garanta de 14 das de regreso de dinero

Derechos de Copia y Marcas Registradas

Lista de Discusin de BASIC Stamp en Internet

Si busca una lista de discusin en castellano puede encontrarla en http://www.stampsenclase.com.

Prepare su Plaqueta StampWorks....................................................................................... 7

Bases de la Programacin ................................................................................................. 13

Hora de Experimentar ....................................................................................................... 21

Building Circuits On Your Own .......................................................................................... 47

Manual StampWorks Versin 1.1 Pgina 1

Usando LCDs ......................................................................................................................65

Trabajando por su Cuenta................................................................................................161

Apndice A: Hojas de Datos .............................................................................................163

Apndice B: Manual del BASIC Stamp II, Versin 2.0 .....................................................177

Pgina 2 Manual StampWorks Versin 1.1

Con microcontroladores podemos construir circuitos y dispositivos inteligentes. En el pasado,

Manual StampWorks Versin 1.1 Pgina 3

Pgina 4 Manual StampWorks Versin 1.1

Obtenga el Mayor Provecho de las Prcticas de StampWorks

Tres Pasos para Tener xito con StampWorks:

Una ltima indicacin: Divirtase!

Manual StampWorks Versin 1.1 Pgina 5

Prepare su Plaqueta StampWorks

El Kit StampWorks incluye los siguientes componentes de Parallax:

Cdigo Descripcin Cantidad

Manual StampWorks Versin 1.1 Pgina 7

Para poder realizar los experimentos de StampWorks, necesitar estos componentes:

Mdulo BASIC Stamp II

Use el cable de programacin para conectar la plaqueta de laboratorio StampWorks a su PC. Es

Asegrese de que el interruptor de encendido de la plaqueta de laboratorio StampWorks est en OFF.

Pgina 8 Manual StampWorks Versin 1.1

Manual StampWorks Versin 1.1 Pgina 9

Pgina 10 Manual StampWorks Versin 1.1

Encienda la plaqueta StampWorks moviendo el interruptor de energa a la posicin ON. Debera

DEBUG La plaqueta StampWorks est lista!

Manual StampWorks Versin 1.1 Pgina 11

Si ocurre un error, controle los siguientes tems:

Est el BASIC Stamp II conectado correctamente en la plaqueta NX-1000?

Hay dos formas de dibujar un esquema. Una considerada chip-

Pgina 12 Manual StampWorks Versin 1.1

En la seccin 1 de BASIC Stamp II manual se introduce el BASIC Stamp, su arquitectura y el

La gente a menudo piensa en las computadoras y los microcontroladores como dispositivos

Manual StampWorks Versin 1.1 Pgina 13

Saltos Redireccionando el Flujo de un Programa

Este es un ejemplo de salto incondicional usando GOTO:

Observe este listado:

Se ejecutan las instrucciones y se verifica la condicin. Si se evala como verdadera, el programa

Pgina 14 Manual StampWorks Versin 1.1

IF condicion_0 THEN Etiqueta_0

BRANCH controlVar,[ Etiqueta_0, Etiqueta_1, Etiqueta_2]

Cuando controlVar (variable de control) es cero, el programa saltar a Etiqueta_0, cuando

Bucles Ejecutando el cdigo una y otra vez

Manual StampWorks Versin 1.1 Pgina 15

FOR controlVar = ValInicial TO ValFinal STEP tamaoPaso

Pgina 16 Manual StampWorks Versin 1.1

FOR controlVar = 2 TO 20 STEP 2

Subrutinas Cdigo reutilizable que ahorra espacio de programa

Manual StampWorks Versin 1.1 Pgina 17

Los programadores experimentados tienden a adoptar o desarrollar un estilo (de formato) de

Instrucciones DATA: Algunos programas almacenan informacin adicional en la EEPROM del

Cdigo: Es donde reside la parte principal del cdigo del programa.