Kit Educativo Propeller

Ki t Educ at i vo Pr opel l er
Fundament os

Ver si n 1.1.1

Por Andy Li ndsay
Tr aduc i do por Osc ar Vi l l ar r eal

GARANTA
Parallax Inc. garantiza sus productos contra defectos en materiales y fabricacin por un periodo de 90 das a partir de la recepcin del
producto. Si el producto tiene un defecto, Parallax Inc. a su conveniencia reparar o remplazar la mercanca o reembolsara el monto de la
compra. Antes de regresar un producto a Parallax se debe llamar a Parallax y obtener un nmero de RMA (Autorizacin de Regreso de
Material). Para regresar la mercanca a Parallax escriba el nmero de RMA es la parte exterior de la caja. Por favor incluya la siguiente
informacin con la mercanca a regresar: Nombre, Nmero de Telfono, Direccin de envo y una descripcin del problema. Parallax
regresara el producto o su reemplazo usando el mismo mtodo de envo que se utilizo para enviar el producto a Parallax.
14-DAS DE GARANTA PARA REGRESO DEL DINERO
Si dentro de los 14 das de haber recibido el producto usted decide que no es til para sus necesidades usted puede regresar el producto y
obtener el un reembolso completo. Parallax Inc. Regresara el precio del producto excluyendo costos de envo y/o manejo. Esta garanta no
es vlida si el producto ha sido alterado o daado. Vea la seccin de Garanta mencionada en el prrafo anterior para instrucciones de
regresar del producto a Parallax.

DERECHOS RESERVADOS Y MARCAS REGISTRADAS
Esta documentacin est protegida bajo derechos reservados 2006-2009 por Parallax Inc. Al obtener una copia electrnica o impresa de
esta documentacin o el software usted est de acuerdo en utilizarla exclusivamente con productos Parallax. Cualquier otro uso no es
permitido y puede representar una violacin a los derechos de autor de Parallax lo cual es legalmente castigable de acuerdo a las reglas
federales de derechos de autor o a las leyes de propiedad intelectual. Cualquier duplicado de esta documentacin para usos comerciales est
expresamente prohibido por Parallax Inc. Duplicados para uso educativo es permitido sujeto a las siguientes condiciones de duplicado:
Parallax Inc. otorga al usuario el derecho condicional de descargar electrnicamente, duplicar y distribuir este texto sin permiso de Parallax
Inc. Este derecho se basa en las siguientes condiciones: el texto o cualquier porcin incluida no puede ser utilizada para fines comerciales,
puede ser duplicada nicamente con fines educativos cuando es utilizado nicamente en conjunto con productos Parallax y el usuario puede
recuperar del estudiante nicamente el costo generado por generar el duplicado.
Este texto est disponible en formato impreso en Parallax Inc. Debido a que los textos son impresos por volumen el precio al consumidor es
comnmente menor al que normalmente se realizan en cualquier otro lugar de copiado.

Propeller, Penguin y Spin son marcas de Parallax Inc. BASIC Stamp, Stamps in Class, Boe-Bot, SumoBot, Scribbler, Toddler y SX-Key
son marcas registradas de Parallax Inc. Si decide utilizar cualquiera de las marcas de Parallax Inc. en tu pgina web o en material impreso se
debe establecer que las marcas son marcas registradas de Parallax Inc. cada vez que se muestre la marca en el documento escrito o en la
pgina web. Otros nombres de productos contenidos en este documento son marcas o marcas registradas de sus respectivos dueos.
ISBN 9781928982555 1.1.0-09.03.06-HKTP
ESTIPULACIONES DE REPONSABILIDAD LEGAL
Parallax Inc. no se hace responsable por incidentes especiales o daos resultantes de cualquier violacin de garanta o cualquier otra teora
legal incluyendo perdidas de ganancias, tiempo perdido, daos o reemplazos de equipo o propiedad, as como cualquier costo de
recuperacin, reprogramacin o reproduccin de cualquier dato almacenado en o usado con los productos Parallax.. Parallax Inc. tampoco
es responsable por daos personales incluyendo vida o salud resultante por el uso de cualquiera de nuestros productos. Usted toma completa
responsabilidad de su aplicacin en los micro controladores Propeller.
LISTAS DE DISCUSIONES EN INTERNET
Mantenemos foros de discusin activos en internet para gente interesada en los productos Parallax. Estas listas son accesibles desde
www.parallax.com a travs de Soporte-Men de Foros de discusin (Support Discussion Forums menu). Estos son foros que operamos
de nuestro sitio web:
Propeller chip Esta lista es especficamente para nuestros clientes que utilizan Propeller chips y productos.
BASIC Stamp Esta lista es utilizada ampliamente por ingenieros, aficionados y estudiantes que comparten sus proyectos
de BASIC Stamp y responden preguntas.
Stamps in Class
Creado para educadores y estudiantes, los suscriptores discuten el uso de la serie de tutoriales Stamps in
Class en sus cursos. Esta lista proporciona una oportunidad para ambos educadores y estudiantes para obtener respuestas de
sus preguntas.
Parallax Educadores Un foro privado exclusivo para educadores y aquellos que contribuyen al desarrollo de materiales
educativos para Stamps in Class y Propeller. Parallax cre este grupo para obtener retroalimentacin de nuestros materiales
educativos y as proporcionar un lugar para educadores que desean desarrollar y compartir recursos de clase.
Robotics Diseado para robots Parallax, este foro tiene la intencin de abrir dilogos para aquellas personas entusiastas
en robtica. Los temas incluyen ensamble, cdigo fuente, expansiones y actualizaciones de manuales. En este foro se
discute acerca del Boe-Bot
, Toddler
, SumoBot
, Scribbler
and Penguin
TM
.
SX Microcontrollers and SX-Key Discusin de la programacin del micro controlador SX con lenguaje ensamblador
Parallax, herramientas SX-Key
y compiladores BASIC y C.
Javelin Stamp Discusin de aplicaciones y diseo usando Javelin Stamp, un modulo de Parallax que se programa usando
un lenguaje una versin de Java de Sun Microsystems
.
ERRATA
A pesar de que se realiz un gran esfuerzo para lograr la precisin de nuestros textos podra existir algn error. Si encuentra un error por
favor envenos la informacin a travs de un correo electrnico a editor@parallax.com. Continuamente mejoraremos nuestros materiales
educativos y la documentacin, de igual forma revisaremos nuestros textos. Ocasionalmente una lista de erratas con la lista de errores para
un documento especifico ser publicada en nuestro sitio web www.parallax.com.
Por favor verifique constantemente las pginas de los productos individuales para encontrar el archivo de erratas correspondiente.
Tabla de Contenidos
Kit Educativo de Practicas Propeller: Fundamentos Pgina 3
ndice
PREFACIO ............................................................................................................................................. 5
1: INTRODUCCIN AL MICRO CONTROLADOR PROPELLER......................................................... 7
El Micro controlador Propeller............................................................................................................ 7
El Kit Educativo Propeller................................................................................................................. 13
Practicas para el Kit Educativo Propeller ......................................................................................... 15
2: PROGRAMAS, DOCUMENTACIN Y RECURSOS....................................................................... 17
Descarga de Software y Documentacin......................................................................................... 17
Instalar la Terminal Serial Parallax .................................................................................................. 18
Sitios Web tiles............................................................................................................................... 18
Recursos y Soporte Tcnico............................................................................................................ 18
3: INICIO Y PRUEBAS PARA PLATAFORMA PE 40-PIN DIP ........................................................... 19
La Plataforma PE............................................................................................................................. 19
Descripcin General......................................................................................................................... 23
Inventario de Equipo y Partes.......................................................................................................... 24
Ensamble de las placas de prueba.................................................................................................. 25
Configuracin y Reguladores de Voltaje de la Plataforma PE ........................................................ 27
Prueba del cableado de la Plataforma PE....................................................................................... 29
Conexin del chip Propeller y la EEPROM...................................................................................... 30
Cargar el programa y probar los pins de E/S................................................................................... 32
Antes de cambiar o ajustar circuitos ................................................................................................ 37
Regulador de Fuente de Poder Propeller Es importante!............................................................ 37
Solucin de problemas para el arranque de la Plataforma PE de 40 pins-DIP............................... 39
4: PRACTICA BSICA DE E/S Y TIEMPO.......................................................................................... 45
Introduccin...................................................................................................................................... 45
Lista de partes y esquemas ............................................................................................................. 45
Nomenclatura del Propeller.............................................................................................................. 46
Luces encendidas con Direcciones y Salidas de Bits de Registro .................................................. 47
Operaciones en grupos de Pins E/S................................................................................................ 49
Leyendo una Entrada, Controlando una Salida............................................................................... 50
Retrasos de tiempo con el reloj del sistema .................................................................................... 51
Configuracin del Reloj del Sistema y Eventos de Tiempo............................................................. 53
Mas Operaciones de Registros de Salida........................................................................................ 55
Comandos condicionales de Repeat ............................................................................................... 57
Operaciones en Posiciones y Pre Post Posiciones de Operadores............................................. 58
Vocabulario de operadores.............................................................................................................. 60
Moviendo el desplegado de LED..................................................................................................... 61
Ejemplo de Variable ......................................................................................................................... 62
Aplicaciones de tiempo .................................................................................................................... 64
Tiempo de Estudio ........................................................................................................................... 66
5: PRACTICAS DE MTODOS Y COGS............................................................................................. 69
Introduccin...................................................................................................................................... 69
Lista de partes y esquemas ............................................................................................................. 69
Definiendo un comportamiento de Mtodo con variables locales ................................................... 70
Llamando un Mtodo........................................................................................................................ 70
Pasando Parmetros........................................................................................................................ 71
Indexando Identificacin del Cog..................................................................................................... 78
Tiempo de Estudio ........................................................................................................................... 80
Tabla de Contenidos
Pagina 4 Kit Educativo de Prcticas Propeller: Fundamentos
6: PRACTICA DE OBJETOS............................................................................................................... 83
Introduccin ..................................................................................................................................... 83
Equipo, Partes y Esquemas ............................................................................................................ 84
Revisin de la llamada a mtodo..................................................................................................... 85
Llamando Mtodos en otros Objetos con la Notacin Dot .............................................................. 85
Objetos que pueden iniciar Procesos en Cogs ............................................................................... 88
Reglas para Mtodos Start y Stop en Libreras de Objetos............................................................ 92
Comentarios de Documentacin ..................................................................................................... 92
Mtodos Pblicos vs. Privados........................................................................................................ 95
Ejemplo de Mltiples Objetos .......................................................................................................... 96
Comunicacin Chip Propeller PC Terminal .................................................................................. 97
FullDuplexSerial y otros objetos de la Librera.............................................................................. 102
Enviando valores de la Terminal Serial Parallax al chip Propeller ................................................ 105
Pantalla de Estado de Pin E/S....................................................................................................... 107
Terminal LED Output Control ........................................................................................................ 109
El Bloque DAT y Paso de Direcciones .......................................................................................... 110
Los Objetos Float y FloatString ..................................................................................................... 112
Objetos que usan Direcciones Variables....................................................................................... 113
Pasando Direcciones de Inicio a Objetos que trabajan con Lista de Variables............................ 116
Tiempo de Estudio......................................................................................................................... 118
7: MDULOS CONTADORES Y APLICACIONES DE CIRCUITOS ................................................ 123
Introduccin ................................................................................................................................... 123
Como trabajan los Mdulos Contadores ....................................................................................... 124
Midiendo Descarga RC con un Detector de Modo Positivo .......................................................... 124
Conversin D/A Controlando luminosidad del LED con Modos DUTY...................................... 133
Registros de Propsito Especial.................................................................................................... 138
Generando Tonos en Piezospeaker con Modo NCO.................................................................... 141
Aplicaciones Objeto IR y Deteccin de Distancia con modos NCO y DUTY................................ 151
Contando Cambios con Modos POSEDGE y NEGEDGE ............................................................ 157
PWM con Modos NCO .................................................................................................................. 160
Prueba y Muestra PWM Agrega un Objeto, Cog y Par de Contadores ..................................... 164
Modos PLL para Aplicaciones de Alta Frecuencia........................................................................ 171
Deteccin de Metal con Modos Detectores PLL, POS y un Circuito LC....................................... 176
Tiempo de Estudio......................................................................................................................... 184
APNDICE A: LISTA DE OBJETOS CDIGO.................................................................................. 191
FullDuplexSerialPlus.spin.............................................................................................................. 191
SquareWave.spin .......................................................................................................................... 198
APNDICE B: SOLUCIONES DE ESTUDIOS.................................................................................. 199
Soluciones de la Practica E/S y Tiempo........................................................................................ 199
Soluciones al Estudio de la Practica Mtodos y Cogs .................................................................. 205
Soluciones al Estudio de la Practica de Objetos........................................................................... 207
Soluciones al Estudio de Mdulos Contadores y Aplicaciones de Circuitos................................. 213
APNDICE C: LISTA DE COMPONENTES KIT PE ......................................................................... 223
APNDICE D: DIAGRAMA DE BLOQUE DEL MICRO CONTROLADOR ....................................... 225
APNDICE E: LM2940CT-5.0 LMITE DE CORRIENTE.................................................................. 226

Prefacio
Prefacio
Debido a que el micro controlador Propeller es un paquete DIP de 40 pins tiene sentido obtener un kit
de componentes para uso con el Propeller en placas de prueba. Los circuitos de soporte para el
Propeller, incluyendo memorias EEPROM, reguladores de voltaje, cristales osciladores, y
herramientas de programacin Propeller se encuentran en versiones que pueden ser conectadas a
Placas de prueba as que porque no?. Tiene sentido desde el punto de vista de colegas y punto de vista
de universidades proporcionar un kit que los estudiantes puedan adquirir, que es reusable, con un
micro controlador que sobresale en una amplia gama de electrnicos, robtica y proyectos de sistemas
integrados. Con esto en mente el PE DIP Plus Kit se ofrece como un paquete que incluye el micro
controlador Propeller mas todos los otros componentes que puedes necesitar para hacerlo funcionar.

El PE DIP Plus Kit tiene sentido para los compaeros que ya han utilizado placas de prueba y tienen
alguna experiencia, pero que pasa con aquellos estudiantes que apenas completaron la clase de Que es
un Micro controlador y su inters es alcanzar tambin el chip Propeller y su kit como tutorial? Con
estos estudiantes en mente otro paquete de partes se ensamblo al igual que una serie de actividades
que se ofrecen para trabajar con el Micro controlador Propeller. El paquete de partes termino con el
nombre de Proyecto PE y las actividades del mismo es el Kit de Practicas PE

El Kit de Prcticas PE se escribi primordialmente para colegas y estudiantes de universidades que
tienen conocimientos previos y experiencia en programacin y electrnica, preferentemente con
micro controladores. Los temas introductorios incluyen:

Bsicos de micro controladores tales como control de Entradas/Salidas y manejo del reloj
Programacin en tpicos como operadores, llamadas y objetos, as como direcciones
variables
Control de Multiprocesadores Programados
Interacciones Micro controlador-Circuitos con luces indicadoras, botones de presin circuitos
sensores de ambiente y que pueden ser medidos con circuitos RC, circuitos de frecuencia y
circuitos selectores de frecuencia
Tpicos avanzados que incluyen utilizacin de mdulos contadores para desarrollar tareas en
el fondo

La intencin de esta coleccin de Kit de Practicas PE es dar al lector un buen comienzo con la
programacin del chip Propeller y el uso en sus proyectos. Sin embargo este libro es solo un
comienzo. Con el Kit de Practicas PE se introduce a todos los aspectos del micro controlador
Propeller, adicionalmente existen practicas disponibles en lnea. Ms practicas y aplicaciones sern
publicadas peridicamente.

Este texto tambin incluye referencias a la riqueza de informacin disponible para el chip Propeller en
el Manual de Propeller, Hoja de Datos Propeller, Foros de Propeller y Cambio de Objetos Propeller
as como ejemplos para utilizar estos recursos. El lector es especialmente alentado a utilizar el
Manual Propeller como una referencia mientras va a travs de estos laboratorios. El contenido del
Manual Propeller y el ndice servirn de referencia para obtener ms informacin acerca de cualquier
tema introducido en estos laboratorios.

Prefacio
Existe un foro para el Kit Educativo Propeller en forums.parallax.com con enlaces a las discusiones
sobre cada laboratorio. Se invita al lector a utilizar este recurso para enviar preguntas sobre temas en
los laboratorios Kit PE, as como comentarios y sugerencias. Parallax recopila estos comentarios y los
incorpora en las futuras revisiones de cada laboratorio. Adems, si usted (o sus alumnos) realizaron
algn buen experimento con el Kit de PE, se publicara su proyecto documentado en los foros para que
otros puedan ver lo que hizo y cmo lo hizo.
Reconocimientos
Parallaxianos:
Autor: Andy Lindsay, Ingeniero de Aplicaciones
Portada: Jennifer Jacobs, Director de Arte
Edicin: Stephanie Lindsay, Editor Tecnico
Ilustraciones: Andy Lindsay, con ayuda de Rich Allred, Gerente de Produccin
Fotografa: Rich Allred
Revisin: Jessica Uelmen, Asociado de Educacin

Comunidad Parallax gracias a:
Aaron Klapheck por sus comentarios en el cdigo ilustrado cog variable bookkeeping en el
tema avanzado: dentro de mtodos Start y Stop en la seccin del laboratorio de objetos.
Estudiantes de la Universidad de California Davis y la Universidad Estatal de California en
Sacramento quienes utilizaron el Kit PE en sus proyectos y propusieron grandes preguntas y
presentaron reportes de errores.
Steve Nicholson por su crtica incisiva y profunda de los primeros borradores del Kit de
Laboratorios PE.
Traduccin al Espaol: Oscar Villarreal FIX Ingeniera

1: Introduccin al Microcontrolador Propeller
1: Introduccin al Micro controlador Propeller

Este captulo proporciona datos generales del micro controlador Propeller y alguna informacin
introductoria a las prcticas de Laboratorio y el Kit Educativo Propeller. Informacin ms detallada
del micro controlador Propeller, su arquitectura y lenguajes de programacin pueden encontrarse en
el Manual de Propeller y la Hoja de Datos del Propeller. Ambos estn disponibles en la liga de
descargas en www.parallax.com/Propeller.
El Micro controlador Propeller
El Micro controlador Propeller mostrado en la Figura 1-1 (a) es un chip sencillo con ocho
procesadores integrados de 32 bits llamados cogs. En otras palabras los cogs pueden funcionar
simultneamente, pero la forma de trabajar ya sea independiente o en conjunto es definida en el
programa. Algunos grupos de cogs pueden ser programados para trabajar juntos, mientras que otros
trabajan en tareas independientes.

Un sistema configurable de reloj proporciona a los cogs la misma seal de reloj (hasta 80MHz). La
Figura 1-1 (b) muestra como cada cog toma su turno en la opcin exclusiva del acceso leer/escribir de
la memoria principal del chip Propeller a travs del Hub. El acceso exclusivo leer/escribir es
importante porque significa que dos cogs no pueden intentar modificar el mismo dato en memoria al
mismo tiempo. Tambin previene que un cog lea una direccin particular de memoria mientras que
otro lo est escribiendo. As el acceso exclusivo asegura que nunca existirn conflictos de acceso que
puedan alterar los datos.

Figura 1-1: Paquete de Micro controlador Propeller e interacciones Hub - Cog

(a) Micro controladores Propeller en paquete
de 40-pins DIP, TSOP y QFN
(b) Extracto del diagrama de bloque del Propeller
que describe la interaccin de Hub y Cog.
Ver Apndice D: Diagrama de Bloque del

32 KB de la memoria principal del chip Propeller es RAM y se utiliza para el programa y
almacenamiento de datos, otros 32KB son ROM y almacena tiles tablas tales como registro, anti
registro, seno y tablas de caracteres grficos. La ROM tambin almacena el cdigo de arranque que es
usado por el Cog 0 al inicializar e interpretar el cdigo que cualquier cog puede usar para buscar y
Generalidades del Microcontrolador Propeller
ejecutar alguna aplicacin de la memoria principal. Cada cog tiene la habilidad de leer los estados de
cualquiera o todos los 32 pins de Entrada/Salida del chip Propeller as como establecer sus
direcciones y estados de salidas en cualquier momento.

El diseo nico de multiprocesamiento del chip Propeller genera una variedad de aplicaciones del
micro controlador relativamente simples que de otra forma serian difciles. Por ejemplo, los
procesadores se pueden asignar a entradas de audio, salidas de audio, ratn, teclado y quiz TV o
Pantalla LCD para crear un sistema de computo basado en micro controladores con procesadores de
sobra para trabajar en tareas ms convencionales tales como el monitoreo de entradas, sensores y
control de salidas y actuadores. La Figura 1-2 (a) muestra un chip Propeller generador de una imagen
de video que podra ser utilizada en algn tipo de aplicacin. El Propeller tambin sobresale como
controlador robtico, con la habilidad de asignar procesadores a tareas tales como control de motores
DC a travs de PWM, video procesador, matriz de sensores de vigilancia y alta velocidad de
comunicacin con robots cercanos y/o Computadoras Personales. La Figura 1-2 (b) muestra un
ejemplo de un Robot Balanceado con sensores de video, el prototipo inicial fue desarrollado con un
Kit Educativo Propeller.

A pesar de que el chip Propeller es muy poderoso no significa que es difcil de usar. El chip Propeller
se presenta de una manera manejable para proyectos simples tales como indicador de luces, botones,
sensores, bocinas, actuadores y pantallas pequeas encontrados en diseos comunes. Usted podr ver
algunos ejemplos de tales circuitos en el siguiente Kit Educacional de Laboratorio Propeller.

Figura 1-2: Ejemplos de Aplicaciones

(a) El Micro controlador Propeller genera graficas para
mostrar en pantalla. Esta aplicacin tambin usa un
ratn estndar PS/2 para controlar las graficas (no
mostrado).
(b) Robot De Balance Hanno Sander, el prototipo
inicial fue desarrollado con el Kit Educativo Propeller y
el programa ViewPort. Foto cortesa de
mydancebot.com.
Aplicaciones con el chip Propeller
Los programas para el Propeller son escritos usando una Computadora para posteriormente cargarlo
en el chip tpicamente a travs de una conexin USB. Los lenguajes que soporta la herramienta de
Programacin incluyen lenguajes de alto nivel llamado Spin y lenguaje ensamblador de bajo nivel.
Las aplicaciones desarrolladas en lenguaje Spin pueden contener opcionalmente cdigo de lenguaje
ensamblador. Estas aplicaciones se guardan en la computadora como archivos .spin

L
Otros lenguajes de programacin han sido desarrollados para programar el chip Propeller. Algunos son
gratuitos y estn disponibles a travs de los recursos como los foros Parallax, otros estn disponibles y
pueden ser comprados o se puede obtener una versin limitada a travs del sitio Parallax o con otras
compaas que venden compiladores.

Antes de que un cog pueda comenzar a ejecutar una aplicacin Spin tiene que cargar un intrprete en
memoria desde la ROM del chip Propeller (Figura 1-3 a). Las aplicaciones Spin son almacenadas en
la memoria RAM principal como fichas lo cual hace que el cog vaya repetidamente a buscar y
ejecutar (Figura 1-3 b & c). Algunos ejemplos de acciones del cog pueden basarse en los valores de
las fichas como se muestra en la Figura 1-3 (c). Incluyen lectura/escritura a los registros de
configuracin, variables y pines de entrada/salida as como lectura de ROM. Los cogs pueden
ejecutar cdigos de maquina generados por lenguaje ensamblador. Como se muestra en la Figure 1-4,
estos cdigos de maquina son cargados en los cogs de 2KB (512 longs) de memoria RAM y
ejecutados en alta velocidad, hasta 20 millones de instrucciones por Segundo (MIPS). La RAM del
cog no utilizado por instrucciones maquina puede proporcionar memoria de alta velocidad para el
cog con cuatro ciclos de reloj (50ns a 80MHz) por lectura/escritura.

Figura 1-3: Cog Interpretando Lenguaje Spin

(a) Interprete cargado en el cog
desde la memoria ROM principal a
travs del Hub
(b) El Cog busca la ficha desde la
memoria RAM principal
(c) El Cog ejecuta la ficha.
Ejemplos incluyen RAM, E/S o
Lectura/Escritura o Lectura ROM

Un Cog Ejecutando lenguaje ensamblador puede accesar de igual forma a la memoria principal del
Propeller a travs del Hub. El Hub garantiza el acceso a la memoria principal a los Cogs cada 16
ciclos de reloj. Dependiendo de cuando el Cog decide verificar la memoria principal el tiempo de
acceso puede ser entre 7 y 22 ciclos de reloj lo cual equivale, al peor escenario de tiempo de acceso a
la memoria, a 275ns a 80 MHz. Despus del primer acceso el lenguaje ensamblador puede
sincronizarse con el Cog alternndose en una ventana de acceso a la memoria principal manteniendo
los subsecuentes accesos a un ciclo fijo de 16 ciclos de reloj (200ns).

E/S
Buscar/Ejecutar
Configuracion
Aplicacion

Pila+ VAR
Conjunto de
Caracteres

Registro,
Antiregistro y
Tablas
Arranque
Interprete
(Hub) Memoria Principal

R
A
M
R
O
M
Configuracion
Aplicacion

Pila + VAR
Conjunto de
Caracteres

Registro,
Antiregistro y
Tablas
Arranque
Interprete

R
A
M
R
O
M
Configuracion
Aplicacion

Pila + VAR
Conjunto de
Caracteres

Registro,
Antiregistro y
Tablas
Arranque
Interprete

32
KB

R
O
M

32
KB

R
A
M
COG
COG COG

Figure 1-4: Cog Ejecutando
Lenguaje Ensamblador

Debido a que cada Cog tiene acceso a la memoria principal RAM del chip Propeller los Cogs pueden
trabajar en conjunto intercambiando informacin. El lenguaje Spin tiene caractersticas incorporadas
para pasar direcciones de una o ms variables usadas en cdigo a otros objetos y Cogs. Esto hace la
cooperacin entre Cogs muy sencilla. El cdigo en un Cog puede ejecutar cdigo en otro Cog y
pasarle una o ms direcciones variables (ver Figure 1-5). Estas direcciones variables pueden ser
utilizadas por dos Cogs para intercambiar informacin.

Figure 1-5: Dos (o ms) Cogs trabajando en
conjunto a travs de memoria compartida.

Los Cogs del chip Propeller estn numerados del Cog 0 al Cog 7. Una vez que la aplicacin se carga
en el chip Propeller este carga un intrprete en Cog 0 y este interprete comienza a ejecutar las fichas
del cdigo Spin almacenadas en la memoria principal. Entonces los comandos en el cdigo Spin
pueden ejecutar bloques de cdigo (que puede ser Spin o Lenguaje Ensamblador) en otros Cogs como
muestra la Figure 1-6. El cdigo ejecutado por otros Cogs puede ejecutar otros Cogs no importando si
es Spin o Cdigo Ensamblador y ambos lenguajes pueden parar otros Cogs para poner fin a procesos
innecesarios o incluso para sustituirlos con otros diferentes.
Configuracion
Aplicacion

Pila + VAR
Conjunto de
Caracteres

Registro,
Antiregistro y
Tablas
Arranque
Interprete

R
A
M

R
O
M
COG
Cog RAM
2 KB
(512 largo)
ASM
4 ciclos
de reloj
7 a 22
Ciclos de
reloj,
16 ciclos
una vez
sincronizado
Configuracion
Aplicacion

Pila + VAR
Conjunto de
Caracteres

Registro,
Antiregistro y
Tablas
Arranque
Interprete
Main (Hub) Memory

R
A
M

R
O
M
COG
COG

Figure 1-6: Arranque de Cogs
El cdigo en un Cog puede poner en marcha otros
Cogs el cual puede poner en marcha otros
Los Cogs tambin pueden parar otros Cogs para
liberarlos y usarlos en otras tareas.
Escribiendo Cdigo de Aplicaciones

Spin es un lenguaje de programacin basado en objetos. Los objetos son diseados para construir
bloques o una aplicacin y cada archivo .spin puede ser considerado un objeto. Mientras que la
aplicacin puede ser desarrollada como un objeto simple (un programa), las aplicaciones son
comnmente una coleccin de objetos. Estos objetos pueden proporcionar una variedad de servicios.
En los ejemplos se incluyen soluciones que de otra forma complicara el cdigo, la comunicacin con
los perifricos, control de actuadores y monitoreo de sensores. Esta construccin de objetos bloque
son distribuidos a travs del objeto de intercambio Propeller (obex.parallax.com) y tambin en el
archivo de librera en la herramienta de programacin Propeller. Incorporando estos objetos pre-
escritos en una aplicacin puede reducir su complejidad y tiempo de desarrollo significativamente.
La Figura 1-7 muestra como los objetos se pueden utilizar como aplicaciones al construir bloques, en
este caso, para un robot que mantiene una distancia entre si y un objeto que esta sensando. El cdigo
de aplicacin en el siguiente objeto Robot.spin hace que el uso de objetos pre-escritos para deteccin
infrarroja (IR Detector.pin) controle los clculos del sistema (PID.spin) y controle el motor (Servo
Control.spin)
Note que estos objetos pre-escritos pueden usar otros objetos por turnos para hacer sus tareas. En vez
de generar objetos para hacer trabajos en tu aplicacin puede tambin escribirlos como borradores y si
se convierten en tiles puede enviarlos para que se publiquen en el Intercambio de Objetos Propeller
en obex.parallax.com.
COG
0 COG
1
COG
2
COG
3
COG
4

Figura 1-7:
Construccin de
Bloques Objetos para
Aplicaciones

En la Figura 1-7, el objeto Following Robot.spin se identifica como archivo objeto inicial. Este
archivo es la primera lnea de cdigo ejecutable donde el chip Propeller comienza cuando la
aplicacin corre. En cada caso el Cog 0 arranca y comienza ejecutando cdigo del objeto superior.
Nuestro objeto superior en el ejemplo Following Robot.spin contiene cdigo que inicializa 3 objetos
debajo del, convirtindolo en objeto padre de los tres. Dos de estos tres bloques en su turno
inicializan un objeto hijo construyendo bloques de s mismos. Dos de los bloques objetos
construidos inicializan Cogs adicionales para hacer sus tareas as que un total de tres Cogs se utilizan
en esta aplicacin. Independientemente de si un objeto padre comienza un Cog en Spin o
Ensamblador los objetos hijos tienen un sistema integrado y documentacin que proporciona una
interface simple con su padre para controlar o monitorear.
A pesar de que no se muestra en la figura recuerde de la Figure 1-6 que un objeto puede inicializar
ms de un Cog. Tambin un objeto puede inicializar un proceso en un Cog y puede terminarlo
nuevamente para dejarlo disponible a otros objetos. A pesar de que cualquier objeto puede inicializar
y detener un Cog es una buena prctica hacer responsable de parar al Cog al Objeto que lo inicializo.
Como se ejecuta el cdigo en el chip Propeller
La herramienta de programacin Parallax puede utilizarse para desarrollar aplicaciones en el chip
Propeller. Cuando una aplicacin se carga en el chip Propeller el cdigo Spin se compila en los
ficheros y el Cdigo Ensamblador opcional se compila en cdigos maquina. La herramienta Propeller
transfiere la aplicacin al chip Propeller tpicamente con una conexin serie USB. El programador
puede escoger cargarlo directamente en la memoria RAM principal del chip Propeller o en una
EEPROM (Memoria de Solo Lectura Elctricamente Borrable Programable por sus siglas en Ingles).
Como se muestra en la Figura 1-8, si el programa se carga directamente en la RAM el chip Propeller
lo ejecuta inmediatamente. Si el programa se carga en la EEPROM el chip copia la informacin a la
RAM antes de comenzar la ejecucin.

Spin + Ensamblador
Arranca un cog
Archivo Objecto
Arranca un cog
Solo Codigo Spin
Figura 1-8: Cargando un Programa en RAM o EEPROM

Cargar programas de una Computadora a la RAM toma alrededor de 1 segundo mientras que la carga
de programas a EEPROM toma algunos segundos (abajo de 10 segundos en la mayora de los casos).
Mientras que cargar programas en RAM puede ser ms rpido para probar resultados de cambios
durante el diseo del cdigo los programas deberan estar cargados en EEPROM cuando la aplicacin
es finalizada o si se espera que comience despus de un ciclo de encendido o re inicializacin. Los
programas cargados en RAM son voltiles, lo que significa que se pueden borrar por una interrupcin
de corriente o reinicializado del chip Propeller. En contraste los programas cargados en EEPROM no
son voltiles. Despus de un ciclo de encendido el chip Propeller copia el programa de la EEPROM
en la RAM y comienza a ejecutarse nuevamente
El Kit Educativo Propeller

El Kit Educativo Propeller (PE) es un sistema de desarrollo completo de micro controlador Propeller
que puede usarse para proyectos y productos prototipo. Este kit incluye partes para proyectos y estn
documentados en el kit de prcticas PE. Estas prcticas le ayudaran a aprender cmo desarrollar
aplicaciones con el micro controlador Propeller.

Figura 1-9: Kit Educativo Propeller
(Versin 40-Pin DIP)
(a) Cargar Programa directo en RAM Propeller (b) Cargar el Programa en EEPROM
Seria
sobre
USB
Copia a
EEPROM
Carga de EEPROM
despus limpia.
Codigo
Propeller
Codigo
Propeller
Serie
sobre
USB
El Kit PE viene en dos versiones diferentes: 40-Pin DIP y PropStick USB. Ambos cuentan con un
sistema para conectar a placas de prueba con las siguientes partes montadas en ellos:

Micro controlador Propeller
Reguladores de Voltaje 5.0 V y 3.3 V
EEPROM para almacenamiento de programas no voltiles
Cristal externo oscilador de 5.00 MHz para seal precisa
Botn de reinicio para arranques manuales
Indicador de Potencia LED
Batera 9 V para conectar a placas de prueba
Conexin USB-Serie para descargas y comunicacin bidireccional con la computadora

En conjunto, las placas de interconexin con el micro controlador Propeller montado se les refieren
en este documento como Plataforma PE. La Plataforma PE con el kit de 40-pins DIP se muestra en la
Figura 1-10 (a). Con esta plataforma, cada parte y circuito en la lista mencionada arriba se conecta
directamente en la placa de prueba. Aunque para esta versin de la plataforma PE se toma un poco de
tiempo construirla y probarla la ventaja es que cualquier parte puede ser reemplazada a un bajo costo.

La Plataforma PE con la Conexin USB se muestra en la Figura 1-10 (a). La conexin USB es un
pequeo circuito impreso con versiones de montaje de superficie de todas las partes y circuitos
listados (excepto el circuito regulador de 5V). La tarjeta tiene pins por lo que puede ser conectada en
la tarjeta de prueba. Mientras que este arreglo hace ms rpida la conexin de la Plataforma PE para
comenzar a trabajar puede ser relativamente costoso reemplazar la conexin USB en vez de los
componentes individuales si alguna vez se daan.

Figura 1-10: Plataformas PE
(a) Versin 40-pin DIP

(b) Versin conexin USB

Practicas para el Kit Educativo Propeller
Las prcticas del Kit Educativo Propeller estn incluidas en este texto y de igual forma existen
prcticas adicionales disponibles para descargar desde www.parallax.com. Las prcticas en este texto
muestran como conectar circuitos al micro controlador Propeller y como escribir programas para
interactuar con los circuitos. Los programas tambin utilizan algunas caractersticas del lenguaje Spin
as como algunas capacidades de multiprocesamiento del micro controlador.
Prerrequisitos
En estas prcticas se asume experiencia previa con micro controlador. A pesar de que las prcticas
incluyen diagramas de conexin para el arranque y prueba el resto no. Como mnimo deber tener
experiencia construyendo circuitos a partir de esquemticos as como experiencia en lenguaje de
programacin de algn micro controlador o computadora.

L
Recursos para principiantes: Para una introduccin de cmo construir circuitos, micro controlador,
programacin y mucho mas antes de una experiencia con micro controladores puede probar el Kit de
actividades BASIC Stamp o el Kit Descubriendo BASIC Stamp. Ambos kits tienen todo lo que usted necesita
para comenzar incluyendo un micro controlador BASIC Stamp 2, tarjeta de prueba, el nivel bsico de Que es
un Micro controlador? y partes para cada actividad. El texto Que es un micro controlador? est disponible
gratuitamente en formato PDF desde www.parallax.com y ambos kits estn disponibles a la venta desde el
sitio web o con algn distribuidor. Para encontrar algn distribuidor cerca de usted verifique la lista de
distribuidores bajo la categora de Compaa en el sitio web de Parallax.
Practicas del Kit PE en este texto

Programas Documentacin y Recursos Descargue la documentacin y el programa,
instale el programa.
Inicio y Pruebas para Plataforma PE 40-Pin DIP Preparacin del equipo. Si usted tiene
la versin USB en el kit PE, utilice el mtodo alternativo. Es gratuito descargndolo de la
pgina de producto en www.parallax.com.
Practica bsica de E/S y tiempo Como configurar las E/S del chip Propeller, seales de
entrada a monitor, seales de transmisin de salida y coordinacin los eventos basado en el
sistema de reloj.
Practicas de Mtodos y Cogs Como escribir mtodos en Spin y arranque de mtodos
opcionales en uno o ms de los chips Propeller (procesadores).
Objectos Como utilizar objetos pre-escritos para simplificar tareas y como escribir objetos.
Mdulos Contadores y Aplicaciones de Circuitos Como emplear los mdulos contadores
generados en cada Cog para desarrollar procesos de control y medicin que requieren tiempo
preciso. (Cada Cog tiene dos mdulos contadores que pueden funcionar en paralelo con la
secuencia del programa).

Las ltimas cuatro practicas (E/S, Tiempo, Mdulos Contadores y Aplicaciones de Circuitos) tienen
preguntas, ejercicios y proyectos al final de cada captulo con respuestas en el Apndice B: ,
empezando en la pagina 199. Para mejores resultados inserte manualmente los ejemplos de cdigo
segn vaya avanzando en las prcticas. Con esto va a darle tiempo a su mente para examinar cada
lnea de cdigo junto con los conceptos y tcnicas introducidas en las diversas secciones de cada
laboratorio.
Mas practicas del Kit PE y aplicaciones en lnea
Para encontrar practicas adicionales y aplicaciones para desarrollar en los conceptos de este libro
visite forums.parallax.com Propeller Propeller Education Kit labs. Usted encontrara ligas a
archivos PDF y discusiones de cada una de las practicas en este texto as como material adicional,
como la practica Extractos de ViewPort mostrada en la Figura 1-11. Algunas de estas prcticas
utilizan partes del Kit PE y otras requieren partes adicionales las cuales puede encontrar en su
mayora en Parallax o con algn otro proveedor de componentes electrnicos.

Figura 1-11: Practica Extractos de ViewPort

Seales de Osciloscopio y Analizador de Espectro generadas por un micrfono mientras alguien esta
silbando. El micro controlador Propeller muestrea estas seales y las enva el programa ViewPort en
la Computadora Personal. Esta es una de las actividades que aparecen en las prcticas de
ViewPort.
2: Programas, Documentacin y Recursos
2: Programas, Documentacin y Recursos

Las herramientas de programacin Propeller y la terminal serial Parallax mostradas en la Figure 2-1
son descargas gratuitas desde www.parallax.com. Usted necesitara estas herramientas para escribir
programas y lograr una comunicacin bidireccional entre la Computadora Personal y el chip
Propeller. En la misma pgina junto con la herramienta de programacin usted encontrara diferentes
documentos de referencia y los programas ejemplos para estas prcticas. Este captulo incluye
instrucciones para descarga e inicializacin de estos productos as como apuntadores a otros recursos
tiles para desarrollar proyectos y prototipos con micro controladores Propeller.

Figure 2-1: Herramienta Propeller y Terminal Serial Parallax

Descarga de Software y Documentacin
En esta prctica usted usara la herramienta de programacin Propeller, la Terminal Serial Parallax y
el Manual de Propeller. Estos elementos junto con la hoja de datos del micro controlador Propeller
estn en una sola pgina en www.parallax.com.
3 Ir a www.parallax.com/go/PEKit Downloads & Resources.
3 Descargar los siguientes componentes y colocarlos en una carpeta adecuada.
o Propeller Tool Software v1.2 o mas nueva. Requerimientos del sistema: Windows
2000/XP/Vista y un puerto USB disponible.
o Programa Parallax Serial Terminal
o Manual Propeller
o Hoja de Datos Propeller
o Cdigo Fuente para Practicas del Kit Educacional Propeller: Fundamentos (.zip)
o Libro Practicas Educativas Propeller: Fundamentos (.pdf)
o Si usted est utilizando la versin PropStick USB del kit de PE, asegrese de
localizar a su instalacin independiente y prcticas en formato PDF
Una de las herramientas Propeller incluida por defecto en el Kit PE es el controlador USB para
programacin/comunicacin/depuracin. Cuando instala la herramienta de programacin
automticamente se instalaran los controladores que necesitara para comunicarse con la herramienta
de programacin Propeller en su Computadora. Estos son controladores FTDIs VCP USB para
Windows 2000/XP/Vista/7. Usted tambin podr obtener los controladores desde www.ftdichip.com.
3 Instale la herramienta de programacin cargando el programa de arranque y siguiendo las
instrucciones. Cuando usted se encuentre en el paso de instalar las opciones de controladores
mostrado abajo asegrese de marcar la casilla Instalar/Actualizar automticamente
controladores.
Programas, Documentacin y Recursos
!
! Deje esta casilla marcada! Usted podr observar este paso durante la instalacin
del Software Propeller. El controlador opcional se requiere para estas prcticas. Es
necesario para los circuitos Serial sobre USB construidos en el Propeller Plug y USB
PropStick

Instalar la Terminal Serial Parallax
La terminal serial Parallax es una aplicacin ejecutable independiente que puede ser utilizada para
intercambiar mensajes con el chip Propeller mientras est corriendo. Adems de mejorar algunos de
los ejemplos del Kit PE con mensajes de texto para indicar el estado y los valores, tambin puede ser
til para registro de datos rudimentarios y la depuracin. A pesar de que es una aplicacin
independiente, es conveniente realizar una sola copia de la misma y colocar un enlace al lado del
programa que va a utilizar para abrir la herramienta de programacin del Propeller.

3 Desempaque la Terminal Serial Parallax en la carpeta donde se instalo la herramienta de
programacin Propeller. La localizacin por defecto en la Versin 1.2 es C:\Program
Files\Parallax Inc\Propeller Tool v1.2.
3 Genere un icono de inicio a la Terminal Serial Parallax junto al icono de inicio de la
herramienta de programacin Parallax.
Sitios Web tiles
Adems de www.parallax.com/go/pekit, hay un par de sitios web donde puede obtener respuestas
tanto a las preguntas como a los objetos para reducir el tiempo de desarrollo en proyectos Propeller.
Pgina principal del Propeller chip: www.parallax.com/Propeller.
Intercambio de Objetos: http://obex.parallax.com
Foro del Chip Propeller: http://forums.parallax.com Propeller
Recursos y Soporte Tcnico
Parallax Inc. ofrece diversos caminos para soporte tcnico:
Correo Electrnico: support@parallax.com
Fax: (916) 624-8003
Telfono: Llame gratis dentro de U.S: (888) 99-STAMP; o (916) 624-8333. Por favor llame
entre 7:00 am y 5:00 pm Hora del Pacifico o en su defecto deje un mensaje.
Foros: http://forums.parallax.com/forums/. Aqu encontrara un foro activo dedicado al chip
Propeller frecuentado por clientes y empleados de Parallax.
3: Configuracin y Prcticas de Laboratorio
3: Inicio y Pruebas para Plataforma PE 40-Pin DIP
Este es el programa de instalacin y Prueba para la versin 40-pin DIP del Kit PE.

3 Si usted tiene la versin del Kit PE 40-Pin DIP (#32305) contine aqu.
3 Si usted tiene la versin PropStick USB del Kit PE (#32306) verifique la versin impresa de
instalacin y pruebas del PropStick USB incluida con su Kit. Tambin existe una descarga
gratuita del producto 32306 en www.parallax.com
La Plataforma PE
El Kit Educativo Propeller (PE) que se muestra en la Figura 3-1 es una gran herramienta prototipo
para proyectos de electrnica y robtica. Es tambin un punto de arranque para aprender los bsicos
de la programacin del micro controlador Propeller para ser integrado como el cerebro de
computadora en su prximo invento. Esta prctica lo introduce a la Plataforma PE, sus componentes y
caractersticas y lo gua a travs del ensamble y prueba de su Plataforma PE.

Figura 3-1: Kit Plataforma PE (Versin 40-Pin DIP)

La Plataforma PE que se muestra en la Figura 3-1 es un arreglo de placas de prueba conectado entre s
con el micro controlador Propeller, circuitos de soporte y componentes montados en el centro. Cada
proyecto construido a la derecha o izquierda ser adyacente a los pins de E/S del Propeller para fcil
acceso. Cada tarjeta de prueba tiene conectores de voltaje en ambos lados por lo que cada punto a
tierra y 3.3 V estn junto a la placa. Este arreglo hace a la mayora de los circuitos sencillos de
conectar y analizar. Tambin minimiza el espagueti de cables y problemas de que pueden ocurrir.
Configuracin y Prcticas de Laboratorio
Componentes de la Plataforma PE y Caractersticas
La Figura 3-2 muestra los mayores componentes de la plataforma de 40-Pin DIP PE incluyendo:

Micro controlador Propeller con calcomana de mapa de pins incluido.
Batera 9 V con conector a placa de prueba
Reguladores 5.0 V y 3.3 V
Indicador LED
Botn para reinicio manual de programa
Cristal Oscilador Externo de 5.00 MHz para seal de reloj preciso
EEPROM de 32 KB no voltil para almacenamiento de programas
Herramienta de conexin Propeller de programacin y comunicacin para descargas y
comunicacin bidireccional con la Computadora Personal.

Figura 3-2: Componentes del Kit de la Plataforma PE

Micro controlador Propeller
Un micro controlador Propeller en un paquete de 40-Pins DIP proporciona un cerebro amigable para
la Plataforma PE. Este increble micro controlador tiene ocho procesadores, llamados Cogs, su
sistema de reloj puede correr hasta 80MHz y cada Cog puede ejecutar hasta 20 millones de
instrucciones por segundo (MIPS). Cada Cog toma su turno de acceso a la memoria principal del chip
Propeller. Este acceso de memoria combinado con los lenguaje Spin (Alto Nivel) y Ensamblador
(Bajo Nivel) creados especialmente para el Propeller hace la escritura de cdigo muy simple y
directa. Si usted ha escrito una subrutina en BASIC y una subrutina Call (o una funcin de C y la
funcin Call, o un mtodo Java y el mtodo Call) hacer que un procesador ejecute esa subrutina,
funcin o mtodo toma solo dos pasos ms. Usted ver muchos ejemplos en estas prcticas del Kit
PE.

L
Hoja de Datos y Manual del Propeller
La hoja de Datos del Propeller proporciona una descripcin completa del micro controlador Propeller y el
Manual explica la programacin del chip y el lenguaje a detalle. Ambos estn disponibles para descarga en
formato PDF desde www.parallax.com La versin impresa del Manual Propeller tambin est disponible a la
venta en el sitio web de Parallax (#122-32000).
Bateria 9V
con
conector a
placa de
prueba
Regulador
de Voltaje
5.0 V
Regulador de
Voltaje 3.3 V
Boton de
Reinicio
Microcontrolador
Propeller +
Calcomania del
Mapa de Pins
Cable USB
Cristal Oscilador de
5 MHz
Herramienta de
Comunicacion y
Programacion
Propeller
EEPROM de 32 KB
Indicador
LED
Botn de Reinicio
El Botn de reinicio se puede presionar y soltar para reiniciar la ejecucin de un programa. Tambin
se puede presionar y sostener para finalizar la ejecucin. Cuando se suelta el chip Propeller cargara el
programa almacenado en la plataforma EEPROM y reiniciara desde el principio.

Batera 9 V para el conector de las placas de prueba
Este pequeo componente proporciona una conexin de la fuente de poder a la tarjeta de prueba. El
voltaje DC recomendado a travs de VIN-VSS es de 6 a 9.5VDC y la fuente de poder recomendada
para VIN-VSS incluye:

Bateras alcalinas de 9 V
Bateras recargables de 9 V (rangos de voltajes incluyen 9V, 8.4V y 7.2 V)

L
Siempre desconecte la batera del conector y almacene por separado. Las Bateras de 9V nunca debern
almacenarse en la caja de plstico del Kit PE ya que las partes sueltas podran causar corto en las terminales.
La Batera de 9V deber desconectarse del conector de la placa de prueba y debe almacenarse donde las
terminales no pueden causar corto a travs de cualquier objeto metlico o algn otro material conductivo.
Wall Warts: Este trmino describe comnmente los transformadores DC que se conectan a travs de
contactos AC y normalmente proporcionan un voltaje mucho ms alto de lo que se menciona. Si va a usar
una conexin de este tipo es conveniente escoger una que esta regulada a 6V DC con una capacidad de
corriente de 500 mA o ms. El Kit PE DIP Plus incluye un capacitor de 47uF que puede ser colocado a travs
de la entrada de la batera en la placa de prueba para proporcionar la capacitancia de entrada requerida por
la el regulador de Voltaje de la Plataforma PE debido a la lnea de suministro de la conexin.

Regulador 5.0 V
El regulador de National Semiconductor LM2940CT-5.0 est incluido en la Plataforma PE para
proporcionar 5V a los componentes tales como detector infrarrojo introducido en los mdulos
contadores y prcticas. Una resistencia en serie (tpicamente 10k) deber estar conectada entre la
salida 5V y el pin de entrada del Propeller el cual es 3.3V. El regulador de 5V tambin sirve como
etapa intermediaria entre la batera y el regulador 3.3V que alimenta al chip Propeller.

El regulador de voltaje LM2940 est diseado para proporcionar 400mA de corriente usando una
batera de 9V en laboratorio (a temperatura ambiente). Este presupuesto de corriente puede variar con
el voltaje y la temperatura. Por ejemplo si el voltaje se reduce de 9V a 7.5V la corriente se incrementa
cerca de los 700mA a temperatura ambiente. Otro ejemplo es si el voltaje es de 9V pero la
temperatura sube a 40 C la corriente caer hasta aproximadamente 350mA.

L
Ms informacin:
Apndice E: LM2940CT-5.0 Lmite de Corriente a partir de la pgina 226 se incluyen ecuaciones que
puede usar para predecir las Corrientes del Regulador de 5V bajo varias condiciones de temperatura y
voltaje.
La hoja de datos del LM2940CT disponible en www.national.com, tiene mucho ms informacin,
incluyendo apuntadores para agregar disipadores de calor para incrementar su funcionalidad mejorando
la habilidad de disipar el calor.

Regulador 3.3 V
Este regulador de National Semiconductor LM2937ET-3.3 puede obtener hasta 400 mA del LM2940
(Regulador 5V) a temperatura ambiente y proporcionar 3.3V al sistema con 360mA de corriente.
Considere que si usted tiene un circuito de 5V que consume potencia, esta se restara de los 400mA de
la salida del regulador el cual otorgara una menor cantidad de corriente al regulador de 3.3V y a su
vez este proporcionara menor corriente al resto del sistema.

Indicador LED
Esta luz se ilumina para indicar que el sistema esta energizado. Tambin puede indicar bateras bajas,
cortos circuitos y hasta puede indicar si la herramienta de comunicacin Propeller est conectada.
Segn conexiones en esta prctica consume hasta 12mA. Despus de completar esta prctica usted
puede usar una resistencia mayor para una menor iluminacin y menor consumo de corriente.

Cristal Oscilador de 5.00 MHz
El cristal oscilador de 5.00 MHz proporciona una seal precisa de reloj al chip Propeller que se puede
usar para aplicaciones sensitivas al tiempo tales como comunicacin serial, mediciones RC y Servo
Control. El chip Propeller tiene un circuito integrado de bucle cerrado que puede utilizar la seal de
reloj de 5MHz para generar frecuencias de 5, 10, 40 y hasta 80MHz

El oscilador de 5MHz puede ser reemplazado con una variedad de otros osciladores. Algunos
ejemplos incluyen un oscilador programable y un cristal de 60MHz. El chip Propeller tiene integrado
un oscilador RC que puede usarse en modo rpido o lento (aproximadamente 12MHz y 20kHz
respectivamente). El oscilador interno no es tan preciso como el de 5MHz as que si su proyecto
contiene tareas sensitivas al tiempo tales como comunicacin serial, modulacin de pulso para servo
control o generacin de seales de TV asegrese de utilizar el oscilador externo.

EEPROM de 32 KB
La plataforma PE de almacenamiento de datos y programa es no voltil, lo cual significa que no
puede borrarse al presionar y soltar el botn de reinicio o desconectando la fuente de poder. Esta
memoria EEPROM no debe tratarse como RAM ya que cada una de sus celdas de memoria es til
solo para 1 milln de ciclos de lecto/escritura. Despus de eso las celdas se desgastan y no sern
confiables para almacenar valores. As que si un programa modifica una EEPROM cada segundo esta
se gastara en tan solo 11.6 das. De otra forma si la celda se modifica cada 10 minutos servir por
hasta 19 aos.

L
EEPROM: Memoria de Solo Lectura Borrable y Programable Elctricamente (Por siglas en ingles)
RAM: Memoria de Acceso Aleatorio.

Tenga en cuenta que su aplicacin puede usar la memoria principal del chip Propeller (de la cual
32KB son RAM) para escribir infinitamente a cualquier frecuencia. Por lo tanto puede usar la
EEPROM como respaldo de datos que la aplicacin necesite posteriormente, especialmente si los
datos se utilizaran despus de reconectar la fuente de poder. La aplicacin de solicitud de registro de
datos EEPROM (disponible en www.parallax.com Propeller Downloads & Articles) presenta
un objeto para respaldar peridicamente los valores almacenados en RAM a la EEPROM.

Herramienta de Programacin y Comunicacin Propeller
El Propeller Plug proporciona una conexin Serial sobre USB entre en chip Propeller y la
Computadora para programar, comunicar y limpiar. El LED azul indica la recepcin de mensajes
desde la Computadora, mientras que el LED rojo indica los mensajes transmitidos a la PC. El chip
FTDI etiquetado como FT232 en el modulo convierte la seal USB de la computadora en seales
seriales de 3.3Vpara el chip Propeller y viceversa.

En el lado de la computadora un controlador de puerto virtual COM proporcionado por FTDI se
incluye con la herramienta de programacin Propeller. Fuera de ser necesario para cargar programas
en el chip Propeller, el puerto virtual hace conveniente la comunicacin con programas seriales tales
como la Terminal Serial Parallax.

L
Ms informacin del Puerto virtual COM
Despus de instalar el Puerto virtual COM de FTDI a travs de la herramienta Propeller cualquier Propeller
Plug que se conecte a uno de los puertos USB aparecer como USB Puerto serie (COMxx) en la lista del
Administrador de Puertos de Windows (COM y LPT). El controlador FTDI convierte los datos colocados en el
puerto serial a USB y lo enva al chip FT232 en el Propeller Plug y los mensajes del FT232 se convierten en
datos seriales y se almacenan en el puerto COM de recepcin. Los programas de comunicacin serial tales
como la Terminal Serial Parallax utilizan esta forma de comunicacin para intercambiar informacin con los
dispositivos seriales perifricos.
Prerrequisitos
Por favor siga las instrucciones en el programa, documentacin y recursos que comienzan en la
pgina 17 antes de continuar aqu.
Descripcin General
En estas prcticas usted ensamblara la plataforma PE Versin 40-Pin DIP) siguiendo los pasos
listados abajo. Es importante seguir las instrucciones en cada paso cuidadosamente, especialmente
porque usted conectara su propia plataforma (en la placa de prueba) en vez de solo conectar el micro
controlador Propeller.

Inventario de Equipo y Partes
Ensamble de las placas de prueba
Configuracin y Reguladores de Voltaje de la Plataforma PE
Prueba del cableado de la Plataforma PE
Conexin del chip Propeller y la EEPROM
Conectar el Propeller Plug a la Computadora y a la Plataforma PE
Conecte la
Prueba de
Cargar el programa y probar los pins de E/S
Solucin de problemas para el arranque de la Plataforma PE de 40 pins-DIP (si es necesario)

Debido a que la Plataforma PE ser el sistema micro controlador en el corazn de las prcticas del Kit
PE, todas las conexiones elctricas debern probarse antes de continuar con las prcticas. Seguir estos
pasos le ayudara a descartar posibles errores de conexiones que pueden pasar fcilmente inadvertidos
durante el ensamble de los circuitos de la Plataforma PE y causar problemas inesperados mas tarde.
Inventario de Equipo y Partes
Requerido:
Computadora con Microsoft Windows 2000, XP, o Vista y un Puerto USB disponible
Batera alcalina de 9V (Para esta configuracin y pruebas utilice una batera alcalina nueva)
Los kits PE que se encuentran listados en las tablas siguientes: Set de Placas de Prueba
(#700-32305), Propeller Plug (#32201), y Kit Propeller DIP Plus (130-32305)

Opcional pero til:
Pinzas pequeas y cortadoras/peladoras de cable
Multmetro (DC + AC Voltmetro y hmetro)
Osciloscopio Digital, similares al Osciloscopio USB de Parallax (#28014)
Brazalete y Tapete antiesttico

!
Precauciones ESD: Las Descargas Electrostticas (ESD) pueden daar los circuitos
integrados (ICs) de este kit. Si usted tiene un brazalete y tapete selo. Si no los tiene
una manera conveniente de eliminar cargas estticas peridicamente es con el chasis
de una Computadora conectada a tierra fsica. La parte del chasis tpicamente expuesta
es la parte trasera. El monitor y equipos perifricos normalmente estn conectados al
marco metlico con tornillos. Toque el marco expuesto (no los puertos) antes de abrir
una bolsa antiesttica y posteriormente hgalo mientras maneja las partes.
Estos son algunos consejos para reducir la posibilidad de una descarga en las partes
del kit PE: Evite tocar los pins en los Circuitos Integrados. Maneje los circuitos en sus
bolsas o cajas. Si usted sabe que su rea de trabajo es propensa a cargas estticas
busque otra rea de trabajo con menos problemas de esttica. De igual forma si usted
observa que un suter genera cargas en una silla no utilice ese suter mientras traba
con la Plataforma PE.

3 Junte los componentes mencionados en la Tabla 3-1, Tabla 3-2, y la Tabla 3-3.
3 Abra la bolsa de partes del Proyecto PE y verifique su contenido contra la lista de partes de la
Tabla C-2 del Apndice C: Lista de Componentes kit PE.

Tabla 3-1: Set de Placas de Prueba (#700-32305)
700-00077 3
Placa de Prueba, 12x30
Conexiones, 3.19" x 1.65"
700-00081 4
Placa de Prueba, 2x24
Conexiones, 3.19" x 0.5"

Tabla 3-2: Propeller Plug (#32201)
32201 1 Propeller Plug
805-0010 1 Cable Retrctil USB A a Mini B

Tabla 3-3: Kit Propeller DIP Plus (130-32305)
Nmero de
Parte
Cantidad Descripcin
571-32305 1 Conexin de Batera 9V
201-01085 2 Capacitor, Electroltico, 6.3 V, 1000 F
201-04740 1 Capacitor, Electroltico, 25 V, 0.47 F
150-01011 1 Resistencia, CF, 5%, 1/4 watt, 100
150-01030 1 Resistencia, CF, 5%, 1/4 watt, 10 k
251-05000 1 Cristal 5.00 MHz, 20 pF, HC-49/s
350-00001 1 LED Verde T1
400-00002 1 Botn normalmente abierto
451-00302 1 Conector 2-pin m/m
451-00406 1 Conector extendido 90 m/m 4 pin espaciado de 0.1
601-00513 1 Regulador 3.3 V, Paquete TO92
601-00506 1 Regulador 5.0 V, Paquete TO92
602-00032 1 EEPROM 32 kB, DIP-8
800-00016 6 Bolsa de 10 cables Puente
P8X32A-D40
120-00003
1
1
Chip Propeller P8X32A - 40 pin DIP Mapa engomado para Propeller DIP

Partes y cantidades sujetas a cambio sin previo aviso.
Ensamble de las placas de prueba
Las tres placas de 12-columnas x 30 renglones mostradas en la Figura 3-3 tienen conexiones y sus
posiciones pueden ser descritas por (letras en columnas, nmeros en renglones). Cada columna tiene
una letra en la parte superior e inferior de la placa y cada rengln tiene un nmero a sus lados. Dos
ejemplos de coordenadas en la placa son (K,3) en el centro y (C,7) en la derecha. Cada placa es
organizada en renglones de 6 conexiones, todas las conexiones en cada rengln de seis estn
conectados por un conductor metlico bajo de ellos. As que para conectar dos cables o ms solo
conctelos en el mismo rengln.
3 Usando los entrelazados conecte las placas de prueba como se muestra en la Figura 3-3.

Figura 3-3: Placas de Prueba

L
Valo a color y acercamiento: Este archivo est disponible gratuitamente en formato PDF en la pgina del
producto Kit Educativo Propeller (32305) en www.parallax.com. Usted tambin puede usar Adobe Acrobat
Reader para realizar acercamientos de las regiones de diagramas y pueden ser tiles para verificar las
conexiones.
Pegamento de soporte no exponer. Las placas tienen un pegamento para soporte cubierto con papel
cera. No despegue el papel encerado a menos que usted vaya a pegar las placas a una superficie
permanente tales como un metal o una caja de proyecto.
VSS y GND; VDD y 3.3V: El pin de tierra del chip Propeller se menciona como VSS en el manual Propeller y
VDD es +3.3V

Cada placa en la Figura 3-3 est alineada en ambos lados por un conector de 2 columnas x 24
renglones. Estas columnas son las conexiones de potencia y estn indicados en Negro y Rojo y los
renglones son identificados por nmeros. Ejemplos de coordenadas son (Negro, 22) en la mitad del
conector de potencia y (Rojo, 28) en la derecha.

En cada conector de potencia en la Figura 3-3 todos los 24 conectores de la lnea vertical negra estas
elctricamente conectados. Estos conectores tpicamente sirven como una tierra comn y cada uno de
estas columnas es conectada a la terminal negativa de la batera. Cada conector de potencia tiene
grupos de 12 conexiones denotados por 2 lneas rojas verticales. Las doce superiores junto a la lnea
roja estn agrupadas en conjunto pero no estn conectadas a las doce bajas de la siguiente lnea roja.
La ruptura en la lnea roja indica la ruptura de continuidad. El diseo de la placa esta de esta forma
Todos las 24 conexiones
de cada linea negra estan
conectados electricamente
Dos grupos de 12
conexiones en cada linea
roja esta conectado
electricamente
Cada grupo de seis esta
conectado electricamente.
Ejemplo de coordenada:
(K, 3) en el centro
(C, 7) en la derecha
(Rojo, 28)a la derecha del
conector de potencia
(Negro, 22) a la mitad del
conector de potencia
para acomodar dos diferentes voltajes en el mismo conector de potencia. Esta caracterstica no se
utiliza por el momento as que se realiza un corto en todos los conectores positivos con cables y luego
se conecta a la salida del regulador de 3.3 V para proporcionar potencia a la Plataforma PE.
Configuracin y Reguladores de Voltaje de la Plataforma PE
El diagrama de la Plataforma PE que se muestra en la Figura 3-4 se ensamblara en partes. En esta
seccin usted lo configurara y probara sin batera, Propeller Plug, chip Propeller o 24LC256
EEPROM. Despus algunas pruebas elctricas para verificar el cableado, usted conectara y probara
cada componente. Siguiendo este procedimiento usted minimizara la posibilidad de daar algn
componente debido a un error de cableado.

Figura 3-4: Diagrama Kit Propeller DIP Plus

La Figura 3-5 muestra el cableado que usara para el diagrama en la Figura 3-5. Note que el chip
Propeller, EEPROM 24LC256, el Propeller Plug y la batera no estn conectados. Note tambin que
la placa en el cableado es justo, con todos los cables cortados a la medida para estar alineados con la
superficie de la placa. Esto har ms fcil de identificar y remover cableado en proyectos sin
necesidad de preocuparse de desconectar una parte o cable que es parte integral de la Plataforma PE

3 Asegrese que la placa est orientada para que los nmeros y letras indicados en la placa
coincidan con las coordenadas de la Figura 3-5.
3 Conecte los cables y componentes exactamente como se muestra en la Figura 3-5. Asegrese
que todos los cables embonan correctamente en las conexiones. Si accidentalmente corto un
cable ms pequeo y tiene un contacto ligero tire el cable y coloque uno Nuevo, usted tiene
que cortar a la medida correcta.
3 El nodo del LED debe estar conectado al (Rojo, 10) y su ctodo a (L,10). El ctodo es el que
est ms cerca de la parte plana en la parte opuesta a la superficie redonda del LED
3 La Resistencia entre (K, 9) y (K, 10) es de 100 (caf-negro-caf) y es una resistencia en
serie con el LED de potencia
3 La Resistencia entre (D, 5) y (D, 9) es de 10 (caf, negro, naranja) y
3 La resistencia entre (D, 5) y (D, 9) es 10 k (caf-negro-naranja), y mantendr en alto uno de
los pins de la EEPROM.

Figura 3-5: Cableado Kit Propeller DIP Plus antes de conectar los ICs

Verificando el cableado
Es importante eliminar cualquier error antes de conectar la fuente de poder a la Plataforma PE.
Verificando dos veces su cableado y haciendo un par de pruebas, usted puede muchas veces observar
algn error que de otra forma puede causar un problema al sistema, no trabajar o incluso daar
algunos componentes. Aunque las partes de la Plataforma PE no son costosas, a menos que tenga ms
a la mano, esperar para obtener nuevas partes puede ser un retraso inconveniente.

3 Haga una impresin de la Figura 3-5 y verifique cada conexin marcando sobre cada punto su
cableado observando que las coordenadas coincidan con las coordenadas para cada conexin
mostrada en la figura.
3 La terminal positiva de la Batera de 9V deber conectarse en el centro de la placa (L, 1) y su
terminal negativa conectarse en (L, 2)
3 El regulador de Voltaje LM2940-5.0 en los sockets (J, 1-3) deber conectarse de tal forma
que la etiqueta en la cara negra este orientado a la izquierda y el disipador de calor de metal
este orientado a la derecha.
3 El regulador de Voltaje LM2937-3.3 en los sockets (H, 3-5) deber conectarse de tal forma
que la etiqueta en la cara negra esta orientada a la izquierda y el metal disipador de calor este
orientado a la derecha.
3 Verifique que la salida del regulador LM2940 5V se conecte al capacitor y que la terminal
negativa del capacitor (vea el signo menos - en el capacitor) est conectada a (Negro, 1) y
que la salida del Regulador LM2937 est conectado al capacitor y la salida del capacitor est
conectado a cualquier posicin en (J, 6) o (J, 7)

!
PRECAUCION: El voltaje invertido en un capacitor electroltico puede causar su
ruptura o en algunos casos explotar. La terminal negativa de un capacitor electroltico
(marcada con un signo negativo) deber estar conectada siempre a un menor voltaje
que el de la terminal positiva.

3 Verifique que el nodo del LED est conectado a (Rojo, 10) y que su ctodo (indicado por un
pin ms corto en la parte plana del encapsulado) se conecta a (L, 10)
Prueba del cableado de la Plataforma PE
Esta seccin muestra una lista de puntos de prueba que con un multmetro puede verificar que:

Los reguladores de voltaje estn cableados correctamente y que trabajan apropiadamente
Los voltajes distribuidos en los rieles son correctos
Los voltajes estn direccionados correctamente a las conexiones para proporcionar potencia
al chip Propeller y al a EEPROM

3 Si usted tiene un multmetro los puntos de prueba se mencionan a continuacin:
Puntos de prueba con batera desconectada

Continuidad
La mayora de los multmetros ofrecen la opcin de continuidad la cual permite probar bajas
resistencias. El smbolo de continuidad es tpicamente un diodo con un punto que emite ondas de
sonido, indicando que si el medidor detecta baja resistencia sonara un timbre. Si su medidor no tiene
el modo de continuidad considere que medidas debajo de 1 es una indicacin de continuidad.

Las medidas de Resistencia tienden a variar con la longitud del cable. Por ejemplo la resistencia entre
(Rojo, 30) en el extremo izquierdo y (Rojo, 30) en el extremo derecho quiz este en el rango de 0.5
, mientras que si mide dos puntos en el mismo conector de potencia quiz no detecte medicin. La
medicin depender de la calibracin de su multmetro y la resistencia de prueba. Usted puede
encontrar el punto de cero ohms juntando las puntas de su multmetro.

Si un punto de prueba falla durante la prueba de continuidad, busque cables faltantes y conexiones
sueltos en el centro de la placa y los rieles.

3 En el conector de la batera de la terminal negativa a las columnas NEGRAS en las cuatro
conexiones. (La terminal negativa en el conector de la batera es la del dimetro ms pequeo
y que est ms cerca de los cables)
3 La terminal positiva del conector de la batera al centro de la placa (G,1)
3 La terminal negativa del conector de la batera a los siguientes puntos: (G,19), (G,20), (F,22),
(D, 4), (G, 6, 7, 8, 9), (G, 2) y (K, 4)
3 (I, 5) a (ROJO, 13) y (Rojo, 18) en las cuatro conexiones de potencia
3 (ROJO, 18) a: (F, 19), (G, 22), (B, 5,), y (B, 6).
Prueba con batera conectada
Si su voltmetro es preciso los voltajes medidos estarn tpicamente en el rango de 0.1 VDC.
Algunos voltmetros ms econmicos tienen menor precisin. Si usted est usando un voltmetro
econmico o uno que desconoce el historial quiz identifique algunas variaciones mayores durante las
mediciones.

L
El Capacitor 0.47 F deber ser colocado en la entrada de 9V si usted est utilizando una fuente de
poder que se conecta a la pared, o cualquier cable que sea ms largo que el adaptador para conectar
la batera de 9V proporcionado en el kit.

3 Conecte una batera alcalina de 9V nueva o una recin cargada al conector de Batera de la
Plataforma PE. El LED deber brillar. Si el LED no brilla o esta naranja en vez de verde
desconecte la batera inmediatamente y revise los pasos de solucin de problemas (2) en la
pgina 39

Voltaje DC
3 Prueba el voltaje entre los cuatro rieles de potencia Rojo/Negro. El voltaje entre (ROJO ,13) y
(NEGRO, 13) deber medir 3.3VDC en cada uno de los cuatro conectores. Si el voltaje por el
contrario esta alrededor de los 4V o mayor desconecte inmediatamente y revise el punto (11)
de la solucin de problemas en la pagina 42. Si el voltaje es incorrecto dirjase a la solucin
de problemas (3) en la pgina 49
3 Repita la prueba para 3.3VDC en (ROJO, 18) y (NEGRO, 13).
3 (I, 1) en centro de la placa a (NEGRO, cualquiera): igual que voltaje en terminales de batera.
3 (G, 3) en el centro de la placa a (NEGRO, cualquiera): 5VDC. Si el voltaje esta alrededor de
los 6V o es mayor desconecte inmediatamente y dirjase a la solucin de problemas (11) en la
pgina 42
Conexin del chip Propeller y la EEPROM
En la Figure 3-6 se muestra el dibujo de la Plataforma PE una vez que el chip Propeller y la
EEPROM han sido conectados.

3 Desconecte la batera del conector para los siguientes pasos.
3 Identifique la muesca de referencia en el chip Propeller y la calcomana del mapa, compare la
orientacin con la muesca entre el chip y el mapa en la Figure 3-6. (La muesca de referencia
es un semicrculo entre el Pin 0 y el Pin 31 en el mapa y deber coincidir con la muesca fsica
en el chip Propeller.)
3 Coloque el mapa del chip Propeller asegurndose que la muesca de referencia en la
calcomana est orientada en la misma direccin que la muesca en el chip.
3 Asegrese que cada pin est alineado con la conexin correcta en la placa de prueba donde
ser instalado.
3 Coloque el chip Propeller en la placa de prueba, verifique su orientacin contra la Figure 3-6.
Presione firmemente con ambos pulgares.
3 Localice la muesca de referencia en la EEPROM 24LC256 y orintelo como se muestra en la
Figure 3-6 y presinelo. La muesca de referencia deber estar entre los Pins que estn entre
los conectores (F, 6) y (G, 6)

Figure 3-6: Dibujo del Cableado Kit Propeller DIP Plus

Conectar el Propeller Plug a la Computadora y a la Plataforma PE
La herramienta de programacin Propeller debe estar cargada en su computadora antes de comenzar.

3 Si usted no ha hecho esto, antes de continuar aqu complete los pasos de Programa,
Documentacin y Recursos comenzando en la pagina 17.

La primera vez que usted conecta el Propeller Plug a su Computadora con el cable USB deben
suceder dos cosas:

1) El Propeller Plug Serial transmite y Recibe, los LED debern titilar brevemente.
2) El sistema operativo Windows deber desplegar el mensaje Encontr Nuevo Dispositivo
USB Puerto Serial seguido por Encontr nuevo dispositivo Su nuevo dispositivo est
instalado y listo para usar.
Cada vez que reconecte su Propeller Plug a la Computadora, los LEDs de comunicacin debern
titilar, pero Windows tpicamente ya no desplegara los mensajes de instalacin del puerto serial.

3 La batera debe estar desconectada
3 Conecte el Propeller Plug a su computadora con el cable USB y verifique que ambos LEDs
de comunicacin (Rojo y Azul) estn titilando brevemente inmediatamente despus de que
usted hizo la conexin.
3 Ahora, Conecte el Propeller Plug al conector de 4 posiciones en su Plataforma PE con las
partes orientadas hacia arriba como se muestra en la Figure 3-6.
3 Verifique que el indicador LED que est conectado en (ROJO, 10) y (L, 10) brilla
ligeramente. Quiz tendr que ver por encima del domo del LED para observar si brilla. Si el
LED no brilla ligeramente no contine con el siguiente paso; en vez de seguir vaya al paso
(5) en la solucin de problemas de la pagina 40.
Conecte la Batera
Cuando usted conecta la batera el LED que brillaba ligeramente cuando usted conecto el Propeller
Plug ahora deber estar brillando. Esto indica que el Regulador 3.3V de la Plataforma PE est
proporcionando potencia al chip Propeller, a la EEPROM y a los conectores que estn junto a las tiras
rojas en los conectores de potencia.

3 Conecte la batera al clip como se muestra en la Figure 3-6. El LED de la Plataforma PE
deber iluminarse brillante. Si no sucede desconecte la batera inmediatamente y vaya a la
solucin de problemas (4) en la pagina 40. Lo mismo aplica si el LED verde obtiene una
tonalidad anaranjada.
3 Si usted tiene un voltmetro, verifique el voltaje en el conector rojo y negro. Deber medir
3.3VDC. Si el voltaje es incorrecto desconecte la batera y vaya a la solucin de problemas
(3) en la pagina 40.
3 Verifique el voltaje AC en los conectores rojo y negro. Deber existir nicamente alrededor
de 50mV de Voltaje AC. Para Voltajes AC mayores de 300mV vaya a la solucin de
problemas (11) en la pgina 42
Prueba de Comunicacin
La caracterstica de identificacin de Hardware en la herramienta de programacin Propeller puede
usarse para verificar la comunicacin entre la PC y el chip Propeller.

3 Asegrese que la batera est conectada.
3 Verifique que el cable de USB conecta la PC al conector del Propeller.
3 Verifique que el conector Propeller est conectado al conector de 4 pins (etiqueta hacia abajo)
3 Abra el programa Propeller, Presione en Men y seleccione Identify Hardware(o F7).
3 Si la herramienta reporta, Propeller Chip versin 1 found on COM, contine a la
siguiente seccin (Cargar el programa y probar los pins E/S) De otra forma vaya a la solucin
de problemas (6) en la pagina 41 y solucin de problemas (1) en la pagina 37.
Cargar el programa y probar los pins de E/S
Estas pruebas son importantes antes de continuar con las prcticas del Kit PE. Un ejemplo de un
problema que estas pruebas pueden interceptar es un pin E/S doblado en el chip Propeller.
Ocasionalmente uno de los pins se dobla debajo del chip en vez de estar conectado en la placa. Puede
ser difcil de identificar visualmente pero si un pin de E/S no identifica entrada o salida de control
esta prueba puede identificar el problema rpidamente. De otra forma podr tomar mucho tiempo
buscar un error en la aplicacin o el cdigo antes de descubrir que el problema es un pin doblado. As
que realice las pruebas. No tomara mucho tiempo y podr ahorrarle mucho tiempo despus.
Partes para el circuito de prueba de pins E/S

3 Abra la bolsa de partes del proyecto PE y verifique su contenido contra la lista de partes en la
Tabla C-2 en el Apndice C: Lista de Componentes kit PE.
3 Para los siguientes circuitos rena las siguientes partes de la bolsa del Proyecto PE

(1) LED Rojo Verde o Amarillo
(1) Resistencia 100 (caf-negro-caf)
(1) Resistencia 10 k (caf-negro-naranja)
(1) Botn pulsador
(4) Alambres de conexin
Construir el circuito de prueba
El circuito que se muestra en la Figure 3-7 y la Figure 3-8 le proporcionara la idea de prueba
para los pins de E/S como entradas y salidas en el chip Propeller. Si alguna de las
instrucciones en la lista de no funciona vaya a la solucin de problemas (9) en la pagina 41.

Comience por verificar que el circuito LED es correcto y que todos los conectores de potencia estn
proporcionando 3.3V como sigue:

3 Desconecte la batera del clip.
3 Construya el circuito que se muestra en la Figure 3-7 y la Figure 3-8.
3 Reconecte la batera al conector.

El circuito del LED puede probarse conectndolo a uno de los conectores de los rieles de potencia
ROJOS, el cual proporcionara 3.3 VDC.

3 Desconecte el alambre del LED de (L, 14) en la Figure 3-8, y conctelo en (ROJO, 13) en el
conector de potencia que est entre el centro y la izquierda de las placas. El LED deber
encender. Si no sucede esto verifique su cableado. Primero asegrese que el LED no est
conectador al revs. Su parte ms corta (nodo) deber estar conectado en el socket siguiente
a la lnea negra en el conector de potencia de la izquierda.

Figure 3-7: Esquema del circuito de
prueba

Figure 3-8: Diagrama del cableado del circuito de prueba

Este circuito del LED puede usarse para probar y asegurarse que todos los rieles ROJOS de potencia
estn conectados a la fuente de 3.3 V. Si usted ya realizo esta prueba con un voltmetro puede
brincarse esta parte.

3 Desconecte el cable de (ROJO, 13) y conctelo en (ROJO, 12) en el conector de potencia de
la izquierda. El LED deber encender nuevamente. Repita para (ROJO, 18) en la izquierda y
(ROJO, 18) en el conector del centro. El LED deber encender en cada punto de prueba. Si
no sucede verifique su placa contra el diagrama de cableado en la Figure 3-8 en busca de
cables faltantes entre los conectores de potencia ROJOS.

Despus de probar los circuitos LED y los conectores de potencia el LED deber reconectarse al pin
I/O del Propeller para que pueda ser utilizado en conjunto con el programa para indicar que los pins
E/S estn funcionando apropiadamente como salidas.

3 Reconecte el circuito LED al chip Propeller P3 E/S pin (L, 14) como en la Figure 3-8.
Programa de prueba PushbuttonLedTest.spin
Como est escrito PushbuttonLedTest.spin hace parpadear en LED conectado a cualquiera de las E/S
en el chip Propeller del lado izquierdo (P0 a P15). El rango de parpadeo del LED depende si el botn
pulsador conectado a P18 se presiona (10Hz) o no (2Hz). El cable que conecta P3 al LED puede
usarse para probar cada pin de E/S. Por ejemplo si ese cable est conectado a (L, 11) confirma que P0
est funcionando como una salida y hace que el LED parpadee. Conecte el cable a (L, 12) y esto
confirma que P1 est funcionando y as hasta P15 (L, 30) Usted puede usar el mapa en el chip
Propeller para identificar rpidamente los pins de E/S.

L
E/S es una abreviatura para Entrada/Salida.
La direccin y el estado de cada E/S son controlados por el programa. En los programas puede
modificarse la direccin y el estado de cada pin individual de E/S as como de grupos de pins en cualquier
momento

Si el LED parpadea a 2 HZ mientras que el botn pulsador se presiona y parpadea a 10 HZ despus
de que se suelta esto confirma que P18 est funcionando como Entrada. El programa puede
modificarse y el cable conectado de P18 al pulsador puede moverse a cada pin de E/S en el lado
derecho del chip Propeller para probar esos pins como Entradas.

Despus de que todas las Salidas en la izquierda del chip Propeller y todas las Entradas del lado
derecho se probaron, el botn pulsador puede moverse a la izquierda y el LED a la derecha. As esta
prueba puede repetirse para verificar que todas las E/S en la izquierda funcionan como Entradas y los
pins de la derecha como Salidas.
Cargar PushButtonLedTest.spin en la EEPROM
Usted puede cargar este programa en la EEPROM de la Plataforma PE presionando el men Run,
seleccionando Compile Current, y luego Load EEPROM (F11). Despus de que se carga el programa
en la EEPROM, el chip Propeller lo copia de la EEPROM en su memoria principal RAM y uno de los
procesadores del chip Propeller lo ejecuta. (Si usted desconecta y reconecta la potencia o presiona y
suelta el botn de arranque de la Plataforma PE el chip Propeller volver a cargar el programa de la
EEPROM a la memoria principal y correr nuevamente desde el principio).
3 Abra el archivo PushbuttonLedTest.spin en la herramienta propeller o escrbalo. Si lo escribe
tenga cuidado de escribir cada lnea exactamente como se muestra.
3 Presione el men Run de la herramienta Propeller y seleccione Compile Current Load
EEPROM (F11).

La ventana de comunicacin Propeller aparecer brevemente y mostrara el progreso de la carga del
programa. Si se cierra despus del mensaje Verifying EEPROM entonces cargo correctamente.

3 Si en cambio se abre una ventana que dice EEPROM programming error... vaya a solucin
de problemas (8) en la pagina 41.
3 Verifique que el LED conectado a P3 parpadea encendido/apagado rpidamente a 10Hz
3 Presione y sostenga el botn pulsador y verifique que el LED parpadea ms lento a solo 2 Hz.
3 Si todo funciono como se anticipaba pase a la prueba de pins E/S mostrada abajo. Si no
funciono vaya a solucin de problemas (9) en la pagina 41.
Prueba de Pins E/S
Use el mapa de pines en el chip Propeller para localizar los pins E/S. Si alguno de estas pruebas
indican que los pins E/S fallan vaya a solucin de problemas (10) en la pagina 42. El primer paso es
usar el circuito LED para verificar que cada pin de E/S en la izquierda del chip Propeller funciona
como salida.

3 Desconecte el final del cable que est en (L, 14) y selo para probar de P0 a P15. De (L, 11) a
(L, 18) y de (L, 23) a (L, 30). Cada pin de E/S deber hacer que el LED parpadee.

Despus, use el botn pulsador para verificar que cada pin de E/S que est al lado derecho del chip
Propeller funciona como entrada.

3 Presione y sostenga el botn pulsador a la derecha de la placa. El circuito LED en la
izquierda de la placa deber parpadear a 2Hz en vez de 10Hz.
3 Desconecte la batera del clip.
3 Desconecte el cable del botn pulsador en (A, 28) en el centro de la placa y conctelo en P16
(A,30)
3 Modifique el programa para monitorear P16 en vez de P18 cambiando la directiva
PUSHBUTTON CON en el objeto PushButtonLedTest.spin de 18 a 16.
3 Reconecte la batera al clip
3 Cargue el programa modificado en la RAM presionando el men Run y seleccionando
Compile Current Load RAM (F10).
3 Verifique que el botn pulsador, ahora conectado a P16, controla la frecuencia del LED.
3 Repita este procedimiento para P17, P19, P20 y as hasta P27.

L
Cargar RAM (F10) vs. Cargar EEPROM (F11): La herramienta de programacin Propeller Cargar RAM es
rpida pero el programa se borra cada que la corriente se corta o el botn de reinicio se presiona. Despus de
un reinicio el chip Propeller cargara el programa que ms recientemente se cargo en EEPROM y comenzara
a ejecutarlo. Los programas cargados en EEPROM no se borran pero toma un poco ms de tiempo
cargarlos. Como la prueba del botn pulsador requiere estar cambiando t recargando el programa en el chip
Propeller ahorra mucho tiempo usar la carga en memoria RAM.
Que sucede con la prueba de P28..P31? Estas E/S del Propeller estn cableados al FTDI USB chip serial y
a la memoria EEPROM. Si usted pudo realizar la carga a la EEPROM significa que estas E/S son funcionales.
Es cierto que estos pins pueden usarse en algunos circuitos usted deber asegurarse que la aplicacin no
daara y no podr ser daada por los otros circuitos conectados a P28P31. Vea la Figura 3-4 en la pagina
27 para detalles. Para la mayor parte las prcticas del kit PE no usaran estas E/S para aplicaciones de
circuitos.

Hasta este punto la mitad de las E/S del chip Propeller se han probado como salidas y la otra mitad se
han probado como entradas. Antes de mover la prueba a circuitos opuestos de la placa es una buena
idea cargar un programa vacio en la EEPROM de la Plataforma PE para que el chip Propeller no
enve seales incorrectas a los pins de E/S. La corriente deber desconectarse cuando se cambia el
circuito. Para asegurarse que el programa vacio corre automticamente cuando la corriente se conecta
deber cargarse en EEPROM usando F11.

3 Cargar este programa (DoNothing.spin) en la EEPROM (F11):
'' File: DoNothing.spin

PUB main ' Mtodo main vaco

Ahora la corriente puede desconectarse, el botn pulsador puede moverse al lado izquierdo de la
placa y el circuito LED puede moverse al lado derecho de la placa de prueba.

3 Desconecte la batera y el cable USB.
3 Mueva el circuito LED a la derecha de la placa de prueba y conctelo a P16.
3 Mueva el botn pulsador del lado izquierdo de la placa de prueba y conctelo a P15.
3 Modifique el objeto PushbuttonLedTest.spin como sigue:
o Cambie la directiva LEDs_START CON de 0 a 16.
o Cambie la directiva LEDs_END CON de 15 a 27.
o Cambie la directiva PUSHBUTTON CON a 15.
3 Reconecte el cable USB y la batera.
3 Cargue el programa objeto modificado PushbuttonLedTest.spin en EEPROM usando F11.
3 Repita las pruebas de salida LED para P16 hasta P27
3 Repita las pruebas de entrada del botn pulsador empezando en P15, luego P14 y as hasta
P0. Recuerde modificar el cdigo y luego cargar la RAM usando F10 entre cada prueba.
Antes de cambiar o ajustar circuitos
El programa DoNothing.spin hace que todas las E/S se programen como entradas asegurando que no
puede enviar inadvertidamente una seal alta (3.3V) a un circuito que est enviando una seal baja
(0V) o viceversa.
Cuando usted ha terminado de probar es una buena idea cargar el programa objeto DoNothing.spin en
la EEPROM as su chip Propeller no puede daar el siguiente circuito que se conecta. De hecho
hgalo un hbito. Siempre cargue DoNothing.spin en EEPROM usando F11 antes de desconectar
la corriente y construir un circuito Nuevo o hacer cambios al existente.

3 Ahora cargue DoNothing.spin en EEPROM (F11).

Cuando usted reconecte la corriente DoNothing.spin se cargara automticamente de la EEPROM a la
memoria principal del Propeller y el chip Propeller lo ejecutara. Esto programara los pins E/S como
entradas por defecto. Entonces cuando el programa termine el chip Propeller se va a modo de bajo
consumo. Esto protege al Propeller y a su circuito al momento de encenderlo nuevamente hasta que
cargue el programa para su nuevo circuito en el chip Propeller
Regulador de Fuente de Poder Propeller Es importante!
Una fuente de poder es importante porque diferentes aplicaciones de circuitos y subsistemas
dependen de ella. Cualquier fluctuacin en la fuente de voltaje se pasar directamente en
fluctuaciones de las seales altas 3.3 V enviadas por los pis E/S del Propeller. Tambin se pasaran en
fluctuaciones en el voltaje de disparo de los pins E/S los cuales son aproximadamente de los 3.3 V
de la fuente de poder. Cuando se aplica un voltaje al pin E/S para activar un pin E/S como Entrada el
Propeller lo interpreta como binario-1 si el voltaje esta por encima del punto de disparo o binario-0 si
esta por debajo. Las seales de los pins E/S del Propeller se usan tambin en una variedad de
aplicaciones anlogo-digital (medidas de voltaje) y digital-anlogo (sntesis de voltaje). As que
cualquier fluctuacin de voltaje que afecte la salida alta y niveles de disparo de entrada reducir la
precisin de medicin y sntesis de voltaje.

Los productos y prototipos de circuitos impresos diseados con chips Propeller tpicamente tienen
varias caractersticas que mejoran la estabilidad del voltaje de entrada. El regulador de voltaje de
salida esta muy cerca de las entradas del chip Propeller, los 3.3V y pins de Tierra. Dependiendo del
diagrama quiz pueda observar las etiquetas Vdd y Vss. Las pistas de metal en la tarjeta que conectan
el regulador de voltaje a las entradas del Propeller son tpicamente ms anchas que otras pistas que
transmiten seales. Ya que los conductores de metal tienen poca resistencia, estas medidas minimizan
la resistencia entre la salida del regulador de voltaje y las entradas del chip Propeller. Esto a su vez
mejora la estabilidad de la fuente de poder minimizando las fluctuaciones de voltaje que pueden
ocurrir si el consumo de corriente en el Propeller cambia, lo cual puede suceder cuando inicia un
procesador y los pins E/S que manejan cargas encienden y apagan. Se pueden conectar capacitores
entre la fuente de entrada del chip Propeller para proporcionar proteccin adicional de fluctuaciones
de voltaje y mejorar aun mas la estabilidad.
Mejore la estabilidad de la Fuente de Poder del Kit
En comparacin con las tarjetas de productos y prototipos, la distancia entre la salida del regulador de
voltaje y las entradas del Propeller es mayor y puede reducir la estabilidad del voltaje proporcionado
a las entradas del chip Propeller. Esto es malo. El remedio es simple y solo requiere dos capacitores y
dos cables. Eso es bueno. Los cables conectan la fuente de entrada en lados opuestos del chip para
asegurar que los niveles de voltaje proporcionados son idnticos en ambas terminales. Los capacitores
se colocan entre las entradas de 3.3 V y la Tierra en ambos lados del chip Propeller para filtrar
cualquier fluctuacin ocasionada por lneas largas de fuentes.

Lista de Partes:

(1) Plataforma construida y probada del Kit PE Versin 40-Pin DIP
(2) Cables Puente
(2) Capacitores 0.1 F

Procedimiento:

La Figura 3-6 muestra los puentes y las conexiones del capacitor. Los pins 3.3 V del chip Propeller
estn conectados entre si con un cable puente y los pins de Tierra estn conectados con otro cable
puente. Capacitores de 0.1 F se conectan entre los pins 3.3 V y Tierra en ambos lados.

3 Desconecte la fuente de poder y el Puerto de programacin
3 Corte los cables puentes para reducir cualquier exceso de longitud cuando se conecten como
se muestra en la Figura 3-6.
3 Use un cable rojo para conectar (J, 22) a (D, 19).
3 Use un cable negro para conectar (J, 20) a (D, 22).
3 Conecte las terminales del capacitor 0.1 F en (K, 22) y (J, 19).
3 Conecte las terminales del otro capacitor 0.1 F en (B, 19) y (B, 22).
3 Verifique sus conexiones.
3 Reconecte la fuente de poder y el Puerto de programacin.

Figura 3-6: Conexin de entrada y capacitores filtro para la Plataforma PE 40-Pin DIP

Solucin de problemas para el arranque de la Plataforma PE de 40 pins-DIP
(1) Conexin de programacin y Puerto Serial
a. Cuando conecte el Propeller Plug al Puerto USB los LED rojo y azul junto al mini USB
del Propeller Plug debern parpadear brevemente. Si no sucede intente un puerto
diferente. Si ninguno de los puertos responde contacte a Soporte Tcnico en Parallax .
(Vea los recursos de Soporte Tcnico en la pgina 18)
b. Corra la herramienta Propeller, presione el men Run y seleccione Identify Hardware
(F7). Si usted obtiene el mensaje que se muestra en la Figura 3-9:
i. Asegrese que el cable USB est conectado al Propeller Plug y al puerto USB de
la computadora.
ii. Verifique las siguientes conexiones en su plataforma PE: (D, 3) a (D, 10), (F, 10)
a (F, 21), (B, 1) a (B, 12), and (C, 2) a (C, 11)
iii. Tambin asegrese que la batera est conectada y que el LED verde de la
Plataforma PE esta brillando ligeramente. Despus presione F7 nuevamente.
iv. Si eso no corrige el problema intente conectar el cable a un Puerto diferente en su
computadora.

Figura 3-9:
Mensaje de error
de comunicacin

c. Si aun tiene el mensaje de la Figura 3-9 despus de asegurarse que el cable del USB est
conectado:
i. Presione el botn Edit Ports en el mensaje de error. La lista de bsqueda de
puerto serial aparecer. Usted puede acezar esta utilidad presionando el men
Edit y seleccionando Preferences (F5). Presione el tabulador Operation y luego
presione el botn Edit Ports.
ii. Deje el cable USB conectado en el Propeller Plug y desconecte y conecte el cable
USB en el puerto de la computadora. Espere 20 segundos entre desconectar y
conectar el cable USB. La lista deber actualizarse y mostrar un nuevo USB
Serial Portcomo el COM46 que se muestra en la Figura 3-10.
iii. Si este aparece en un gris ligero presione el botn derecho y seleccione Include
Port (COMX), o en algunos casos Re-Include Port.

Figura 3-10: Lista de
bsqueda de Puerto
Serial

d. Si la lista de bsqueda del Puerto Serial busca y reconoce ese puerto vaya a
www.parallax.com y presione en la liga del instalador de controladores USB en la parte
de debajo de la pagina despus siga las instrucciones para solucin de problemas.
e. Si la herramienta de programacin Propeller aun despliega el mensaje de No Propeller
chip found utilice el administrador de dispositivos para localizar el puerto serial USB.
i. Para acezar la Lista de Puertos de administrador de dispositivos de Windows,
presione el botn derecho en Mi Computadora y seleccione Propiedades.
Presione la pestaa de Hardware y presione el botn de Administrador de
Dispositivos. En el Administrador de Dispositivos presione el + que esta junto a
Puertos (COM y LPT).
ii. Cada vez que conecte el cable USB deber aparecer una referencia en el Puerto
Serial (COMXX) como se muestra en la Figura 3-11. Cada vez que desconecte
el cable que conecta el Propeller Plug a la Computadora la referencia debe
desaparecer. Por ejemplo el administrador de dispositivos abajo muestra el
Puerto Serial USB (COM46) lo cual indica que el Propeller Plug est conectado a
COM46.


Figura 3-11: Lista de
Puertos en el
Administrador de
Dispositivos

iii. Si el Puerto Serial USB no aparece en la lista de puertos (COM y LPT) pero el
administrador de dispositivos parece refrescarse cada que se conecta o
desconecta el cable USB:
1. Esta indicando que el Propeller Plug se conecto en la computadora y se
hizo un intento de instalar los controladores manualmente antes de que el
la herramienta de programacin y el controlador se instalaran. Busque la
lista para encontrar el controlador que se agrega cada vez que usted
conecta el Propeller Plug. Cuando lo encuentre desinstlelo. Usted puede
hacer esto al presionar el botn derecho mientras esta sobre el
controlador y seleccionando desinstalar.
2. Desconecte el Propeller Plug. Antes de conectarlo nuevamente asegrese
que se instalo el controlador USB FTDI. La manera ms sencilla de
hacerlo es desinstalar y reinstalar la herramienta Propeller.
3. Cuando reinstala la herramienta de programacin Propeller:
a. Asegrese que la instalacin de controladores USB esta
marcado! Para mayor informacin vea la seccin de Descarga de
Programas y Documentacin en la pagina 17.
b. Despus de que reinstalo el programa el controlador correcto se
instalara automticamente cuando conecte el Propeller Plug a la
computadora. Asegrese de dejar la batera desconectada cuando
conecte el Propeller Plug a la computadora con el cable USB por
primera vez.
f. Contacte a Soporte Tcnico de Parallax (Vea pagina 18.)

(2) Si el LED de la Plataforma PE no enciende o si brilla anaranjado cuando la batera se
desconecto:
a. Si el LED se enciende anaranjado:
i. Verifique si hay corto entre el ctodo del LED y tierra. El LED deber tener una
resistencia en serie entre su ctodo (L, 10) y tierra (NEGRO, 9). La resistencia
deber conectar (K, 9) a (K, 10).
ii. Asegrese que el voltaje en el nodo del LED (ROJO, 10) es 3.3V.
b. Si el LED no encendi quiz est conectado al revs. Verifique que el ctodo est
conectado a la resistencia y el nodo conectado a la fuente de 3.3V. En trminos de la
Figura 3-5 en la pgina 28 el pin que sale de la parte plana de la base cilndrica del LED
deber estar conectado en (L, 10). El otro lado (punta nodo) deber estar conectado a
(ROJO, 10). Para detalles vea Verificando Conexiones de Cableado en la pgina 28.
c. Asegrese que la terminal (+) de la batera este conectada a (L, 1) y su terminal (-) est
conectada a (L, 2).
d. Podra existir un error de cableado que ocasione un corto circuito de la fuente de poder a
tierra. Si usted no tiene multmetro comience a verificar visualmente su cableado. Con un
multmetro usted puede verificar resistencia entre la terminal negativa de la batera y las 3
fuentes positivas. Asegrese de desconectar el cable USB y la batera antes de hacer la
prueba de resistencia.
iii. Comience a medir la Resistencia entre la conexin 3.3V y la terminal negativa de
la batera. Por ejemplo pruebe entre los puntos (ROJO, 13) y (J, 4) en el centro de
la placa de prueba.
iv. Repita la medicin de Resistencia entre la terminal negativo (J, 4) y la salida del
regulador de 5V (G, 3) as como (J, 4) y la entrada de la batera (G, 1). Si alguna
de estas resistencias mide menos de 10 , es fuente de voltaje puede estar
hacienda corto a tierra.
v. Contacte a Soporte Tcnico de Parallax (vea pagina 18.)

(3) Si el voltaje entre las conexiones (ROJO-NEGRO) no es 3.3V:
a. Si su medidor es un modelo de baja confiabilidad o se le ha dado uso rudo verifquelo
contra una fuente conocida de voltaje antes de confiar en sus mediciones.
b. Repita la Verificacin de Conexiones de Cables empezando en la pgina 28,
cuidadosamente contine hasta las conexiones de la Batera en la pgina 32, ponga
atencin a los detalles esperando que pueda encontrar a algn error. Estas pruebas pueden
llevar a una variedad de problemas incluyendo cortos entre las fuentes de 5V y/o 9V

(4) Si el LED de encendido no se ilumina cuando conecta la batera despus de conectar el chip
Propeller pero si encenda en pruebas anteriores:
a. Verifique errores en los pins: Si un cable termina en un rengln que se comparte con el
chip Propeller o con el pin de la EEPROM 24LC256 es un punto sospechoso. Asegrese
que las coordenadas son idnticas a la Figura 3-5 de la pagina 28 y la Figure 3-6 de la
pagina 31.
b. Remueva el chip Propeller y la EEPROM 24LC256 de la placa de prueba y repita la
verificacin de cableado de la pagina 28. Contine detalladamente hasta las conexiones
de la batera en la pagina 32 y quiz pueda detectar algn error esta vez.
c. Contacte a Soporte Tcnico de Parallax (vea pagina 18).

(5) Si el LED de encendido no brilla ligeramente despus de conectar el Propeller Plug al
conector de 4 pins en la Plataforma PE y de conectar a la computadora con el cable USB:
a. Verifique que la Resistencia en el circuito LED es de 100 (caf, negro, caf).
b. Verifique que el nodo del LED de encendido est conectado en (ROJO, 10) y el ctodo
conectado a (L, 10). El ctodo es el pin con la parte plana en la base cilndrica del
encapsulado.
d. Intente conectar a otros puertos USB en su computadora.
e. Intente con otro LED verde de las partes de su kit PE. El pin largo (nodo) deber
conectarse a (ROJO, 10) y el pin corto (ctodo) a (L, 10).
f. Verifique el cableado contra la Figura 3-5 de la pagina 28, y la Figure 3-6 de la pagina
31.
g. Remueva el chip Propeller y la EEPROM de la placa de prueba y repita la prueba del
cableado de la Plataforma PE de la pagina 29. Contine hasta la conexin de la batera en
la pagina 32 y quiz usted detecte un problema esta vez.
h. Contacte a Soporte Tcnico de Parallax (vea pagina 18).

(6) Causas comunes del mensaje No Propeller Chip found son:
a. Batera desconectada. Conecte la batera.
b. Batera descargada, la batera tiene que volver a cargarse.
c. El cable USB no est conectando el Propeller Plug a la computadora. Asegrese que
ambas terminales estn conectadas.
d. El Propeller Plug no est conectado al conector de 4 pins o est conectado al revs. La
conexin deber ser con los componentes hacia arriba (etiqueta hacia abajo).
e. Conexin USB daada o gastada. La mayora de las computadoras tienen ms de una
conexin USB, intente con otro puerto.
f. El chip Propeller o la EEPROM 24LC256 no estn conectadas totalmente. La parte de
abajo del chip Propeller y la EEPROM deben estar tocando la placa de prueba. Si no es
as asegrese que todos los pins estn alineados con los hoyos en la placa de prueba y
presione los componentes firmemente.
g. El controlador USB FTDI USB no est instalado. Vea el punto (1) de esta seccin.
h. Fuentes de poder Si usted no verifico los voltajes con un multmetro es hora de hacerlo.
(Vea la prueba de cableado de la Plataforma PE en la pgina 29). Si los voltajes son
incorrectos vea el punto (3).
i. El Propeller Plug esta invertido. El pin 1 y el indicador de semicrculo que est en la
etiqueta del chip Propeller y que se muestra en la Figure 3-6 de la pagina 31 debe estar en
el rengln 11 no en el rengln 30. Verifique tambin que la muesca impresa coincide con
la muesca fsica del chip Propeller, ambos deben estar orientados al rengln 11.
j. Cable USB defectuoso. Use otro cable si usted tiene un cable extra USB A a mini B.

(7) Si la prueba del circuito LED no enciende cuando conecta el puente en (ROJO, 13):
a. La polaridad del LED puede estar invertida. Asegrese que el ctodo del LED esta
conectodo al conector de potencia que esta junto a la lnea negra.
b. Si l LE no encendi cuando probo el conector de potencia en la izquierda asegrese que
el puente conecta la columna roja en el conector de en medio con la columna de potencia
en el conector de la izquierda.

(8) Si usted ve un mensaje EEPROM programming error cuando usa la herramienta de
Load EEPROM en la herramienta Propeller:
a. Observe si el cable USB esta suelto y las conexiones de la batera.
b. Si el problema persiste intente otro Puerto USB
c. Si usted tiene un cable extra USB A a mini B selo.
d. El chip Propeller quiz no est bien conectado. Vea conexin del chip Propeller y
EEPROM en la pagina 30.
e. Verifique las siguientes conexiones: (A, 8) a (A, 14), (A, 9) a (A, 13), (BLACK, 9) a (L,
9), (H, 6) a (H, 7), (I, 7) a (I, 8), (H, 8) a (H, 9), (E, 4) a (E, 7), (RED, 6) a (A, 6), y la
resistencia de 10 k entre (D, 5) y (D, 9). Vea la Figure 3-6 de la pagina 31.
f. Asegrese que la 24LC256 no est invertida. La muesca de referencia en el chip debe
estar entre (F, 6) y (G, 6).
g. Si el problema persiste contacte a Soporte Tcnico de Parallax (Vea pagina 18.)

(9) Si el programa se descarga pero el circuito LED no parpadea:
a. Si ingreso el programa manualmente entonces descrguelo directamente la pagina del kit
Educativo Propeller. bralo con la herramienta de programacin y use F11 para
descargarlo a la EEPROM. Esto eliminara la posibilidad de haber escrito un error.
b. Si el LED no comienza a parpadear asegrese que el oscilador est conectado. (Vea la
Figura 3-2 de la pgina 20 del cristal de 5.00 MHz y verifique que los conectores estn
colocados en las posiciones correctas)
c. Remueva el oscilador y conecte nuevamente para realizar la prueba otra vez.
d. Cambie la lnea de programa en PushButtonLedTestv1.0.spin de _clkmode = xtal1 +
pll16x a _clkmode = xtal1 + pll8x. Si este cambio hace que la luz comience a
parpadear cambie el programa otra vez a pll16x, cargue este programa original en el
chip Propeller para ver que la luz parpadea nuevamente. Si este no es el caso
comunquese a Soporte Tcnico Parallax (Ver pgina 18).

(10) Los pins de E/S del chip Propeller se prueban antes de enviar. Si la prueba de LED o
Botn Pulsador indican que hay un pin daado:
a. Asegrese de verificar que el pin no est doblado debajo del encapsulado y que se
conecto mal a la placa.
b. Intente tocar el pin de E/S con el pin del LED. Si la luz comienza a parpadear con este
contacto elctrico pero no cuando est conectado en el socket:
i. Nuevamente verifique que el pin no est doblado debajo del encapsulado.
ii. Desconecte el chip Propeller y verifique que el pin no est doblado.
iii. Si tiene un multmetro haga la prueba de continuidad entre el conector de E/S
donde estaba conectado y el conector donde el cable estaba conectado. Si no hay
continuidad por favor contacte a Soporte Tcnico Parallax (Ver pgina 18)
c. Si la continuidad en la placa de prueba est bien y el pin no est doblado conecte
nuevamente el chip en la placa y prueba todos los pins de E/S y tome nota de cual
funciona y cual no. Tambin tome notas de cualquier evento que observe durante la
prueba y contacte a Soporte Tcnico Parallax. (Ver recursos en pgina 18)
d. Por favor vea la pliza de garanta en www.parallax.com para ms informacin de
reemplazo del modulo con pins E/S daados.

(11) 4 VDC o mas entre (ROJO, cualquiera) y (NEGRO, cualquiera) o 6 VDC o mas entre
(G, 3) a (Negro, cualquiera).
a. Uno de los capacitores de 1000 F quiz no est bien conectado. Esto lo indican las
mediciones de voltaje DC que estn entre 1 a 2.5V sobre lo que debera estar.
i. Asegrese que las puntas del capacitor estn conectadas en los lugares correctos.
ii. Asegrese que las puntas del capacitor son lo suficientemente largas y estn
haciendo suficiente contacto en los conectores.
b. Si el voltaje entre (G, 3) y (NEGRO, cualquiera) es de 9V quiz hay un corto entre las
terminales positivas (G,,L, 1) y (G..L, 3).
c. Si el voltaje entre (ROJO, cualquiera) y (NEGRO, cualquiera) es 9 V quiz hay un corto
entre las terminales positivas de la batera (G..L, 1) a cualquiera de (G..L, 6) o uno de los
conectores rojos de potencia.
d. Si el problema persiste contacte a Soporte Tcnico de Parallax (Vea pagina 18).
4: Prctica bsica de E/S y tiempo
4: Practica bsica de E/S y tiempo
Introduccin
La mayora de aplicaciones en micro controladores requiere de una lectura de entrada, toma de
decisiones y control de salidas. Tambin hay una tendencia a ser sensibles al tiempo, con el micro
controlador determinando cuando las entradas son monitoreadas y las salidas actualizadas. Los
circuitos de botones pulsadores en esta prctica le darn ejemplos sencillos de aplicaciones que puede
monitorear con los pins de E/S del Propeller. Del mismo mdulos circuitos LED le darn un sencillo
y efectivo significado del monitoreo de pins de E/S en el Propeller y los eventos de tiempo.

Aunque la prctica del botn pulsador y el ejemplo del LED pueden parecer simples, estn hechos
para presentar claramente un nmero importante de tcnicas de cdigo que sern usadas y reusadas en
otras prcticas. Esta es una lista de ejemplos de aplicaciones y de tcnicas de cdigo:

Encender un LED Asignar direcciones de E/S y estados de Salidas
Encender grupos de LEDs Asignar grupos de E/S
Estado de botn pulsador con LED Monitorea una entrada y establece una salida de
acuerdo
Estado de un grupo de botones pulsadores con LED E/S paralelas, monitorear un grupo
de entradas y escribir a un grupo de salidas
Seales sincronizadas Encendido/Apagado de LED Evento de tiempo basado en un
registro que cuenta los segundos del reloj
Configurar el reloj del sistema Propeller Escoger una fuente de reloj y configurar el
multiplicador de de frecuencia Ciclo de Fase Cerrada (Phase Locked Loop) del chip
Propeller.
Desplegar patrones Encendido/Apagado Introduccin a mas operadores Spin que son
usados comnmente en registros de E/S
Desplegar conteos binarios Introduccin a varios tipos de operadores y ejecucin de
bloques de cdigo de ciclos condicionales
Cambiar desplegados de luz Ejecucin de bloques de cdigo y cambio de operaciones
Cambiar desplegados de luz con botn pulsador-rango controlado de refrescado
Variables globales y locales y mas ejecucin de cloques de cdigo
Desplegado de Hora normal en segundos Introduccin a eventos de tiempo sincronizados
que funcionan independientemente de otras tareas dadas a un Cog
Pre requisitos para la practica
Inicializacin y prueba
Lista de partes y esquemas
Esta prctica utilizara seis circuitos LED y tres circuitos de botones pulsadores.

(6) LEDs diversos colores
(6) Resistencia 100
(3) Resistencia 10 k
(3) Botn Pulsador Normalmente abierto
(Miscelneos) cables de unin

3 Construir el circuito que se muestra en la Figura 4-1.
Prctica bsica de E/S y tiempo
Figura 4-1: Circuitos de Botn Pulsador y LED

Nomenclatura del Propeller
La documentacin del micro controlador Propeller frecuentemente hace referencia a Cogs, Spin,
Objetos, Mtodos y variables Globales y Locales. Esta es una breve explicacin de cada trmino:
Cog Un procesador dentro de un chip Propeller. El chip Propeller tiene ocho Cogs, lo que
hace posible que desarrolle diversas tareas en paralelo. El Propeller es como un sper micro
controlador con 8 procesadores de alta velocidad de 32 bits dentro de l. Cada procesador
interno (Cog) tiene acceso a los pins de E/S del chip Propeller y a los 32KB de RAM global.
Cada Cog tiene sus 2KB de RAM que puede usar en cdigo Spin o Ensamblador.
Lenguaje Spin El lenguaje Spin es un lenguaje de programacin de alto nivel creado por
Parallax para el chip Propeller. Los Cogs que ejecutan el cdigo lo hacen cargando un
intrprete Spin de la ROM del chip Propeller. Este interprete obtiene y ejecuta los comandos
Spin que son almacenados en la memoria global RAM del chip Propeller
Los Cogs del Propeller pueden programarse en lenguaje ensamblador de bajo nivel Spin
de alto nivel le dice a un Cog que hacer y Ensamblador de bajo nivel le dice cmo hacerlo. El
lenguaje ensamblador genera cdigo maquina que reside en la RAM del Cog y lo ejecuta
directamente el Cog. Los programas en lenguaje ensamblador hacen posible escribir cdigo
que optimiza el desempeo del Cog, sin embargo requiere un entendimiento profundo de la
arquitectura del chip Propeller. El kit fundamental PE se enfoca en programacin Spin.
Mtodo Un bloque ejecutable de comandos Spin que tiene nombre, regla de acceso y puede
como opcin crear variables locales (temporalmente), recibir parmetros y regresar un valor.
Variables Globales y Locales Las variables Globales estn disponibles para todos los
mtodos en un objeto dado y reservan espacio variable como long en una aplicacin que
est corriendo. Las variables Locales estn definidas en un mtodo, solo puede ser usada
dentro de ese mtodo y solo existe mientras el mtodo ejecuta comandos. Cuando termina, la
memoria de esa variable local queda disponible para otros mtodos y sus variables locales.
Las Variables Globales y Locales se definen con sintaxis diferente.
Objeto Un Bloque de aplicacin de todo el cdigo dado en un archivo .spin. Algunas
aplicaciones Propeller usan solo un objeto pero la mayora usa varios. Los objetos tienen una
variedad de usos dependiendo parcialmente de como se escribieron y parcialmente en cmo
se configuraron y son utilizados por otros objetos. Algunos objetos sirven como objetos de
primera categora que proporcionan un punto de inicio donde el primer comando en una
aplicacin dada se ejecuta. Otros objetos son escritos para proporcionar una librera de
mtodos tiles para objetos iniciales u otros objetos a utilizar.
Los objetos se pueden escribir para usar solo un Cog o puede incluir cdigo que inicializa uno o ms
Cogs. Algunos objetos tienen mtodos que proporcionan datos para intercambiar informacin con
procesos en otros Cogs. Algunos objetos pueden incluso hacer mltiples copias de otros objetos y
darle a cada uno diferentes tareas. Los objetos pueden usar otros objetos los cuales pueden usar
todava otros objetos. En aplicaciones ms complejas un conjunto de objetos forman una relacin
funcional que se ve como una estructura de archivos en la herramienta Propeller.

Los ejemplos en esta prctica solo cubren objetos sencillos usando solo un mtodo. En futuras
prcticas se presentaran varias tcnicas de construccin de bloques para usar en mltiples objetos y
mtodos en una aplicacin as como aplicaciones multiprocesos usando varios Cogs. Como los
objetos en esta prctica son sencillos muchos de ellos se modificaran para construir bloques para otros
objetos en proyectos futuros.
Luces encendidas con Direcciones y Salidas de Bits de Registro
El objeto LedOnP4 que se muestra a continuacin contiene un mtodo llamado LedOn con comandos
que indican al Cog en el chip Propeller para poner el pin P4 E/S en alto. Esto en su momento ocasiona
que el LED en el circuito conectado a P4 emita luz.

3 Cargue LedOnP4 en RAM pulsando Run Compile Current Load RAM (o presione F10).

'' File: LedOnP4.spin

PUB LedOn ' Declaracin de mtodo

dira[4] := 1 ' Asigna P4 a Salida
outa[4] := 1 ' Asigna P4 alto

repeat ' Esta operacin previene que termine el
programa
Como trabaja LedOnP4.spin
La primera lnea en el programa es un comentario de documentacin. Los comentarios de lnea
sencilla se denotan por dos apostrofes (no comillas) a la izquierda del texto de documentacin.

3 Seleccione el botn Documentation sobre el cdigo en el editor Propeller.

Mientras que comandos como dira := y repeat no muestran modo de documentacin, observe que
en el texto a la derecha del doble apostrofe si aparecen. Observe tambin que los comentarios de no-
documentacin en el cdigo es precedido por apostrofes sencillos y no aparecen en modo de
certificacin.

3 Seleccione otras opciones y observe que muestran y que no muestran los elementos del
objeto.
L
Comentarios de bloque: Tambin existen comentarios de documentacin de bloques que pueden
extenderse varias lneas. Estos tienen que comenzar y terminar con dobles llaves como: {{Comentarios de
documentacin del bloque}}. Los comentarios de no-documentacin tambin pueden extenderse varias lneas
comenzando y terminando con llaves sencillas como: {Comentario de bloque de no-documentacin}.

Todos los comandos de lenguaje Spin que ejecuta el chip Propeller tienen que ser controlados con un
bloque mtodo. Cada bloque mtodo tiene que declararse con al menos una regla de acceso y un
nombre. Las reglas de acceso y los nombres de mtodo se revisaran a detalle en otras prcticas, por
ahora solo tenga en mente que PUB LedOn est declarado bloque mtodo con una regla de acceso
pblico (PUB) y el nombre LedOn.
L
Resaltar texto o no? En los prrafos de discusin la fuente usada en la herramienta Propeller se usa
tambin para todo el texto que es parte de un programa. Las porciones de texto que son operadores o
palabras reservadas estarn resaltadas. Las porciones que son definidas por el usuario tales como mtodos,
variables y nombres de constantes y valores no debern estar resaltadas. Esto imita la sintaxis de la
herramienta Propeller al remarcar el esquema Spin. Las listas de cdigo y sobrantes no se les dan el
resaltado. Para ver la versin de sintaxis completa vala en la herramienta Propeller con el Esquema Spin.
Vaya a Edit Preferences Appearance para encontrar el men Syntax Highlighting Scheme.

El registro dira es uno de varios registros de propsito especial en la RAM del Cog; usted puede leer
y escribir al registro dira el cual almacena direcciones de E/S para cada pin de E/S. Un 1 en un
registro dira asigna el pin E/S como salida; un 0 como entrada. El smbolo := es el operador de
asignacin; el comando dira[4] := 1 asigna el valor de 1 al Bit 4 del registro dira lo cual hace P4
una salida. Cuando un pin de E/S es asignado como salida, el valor de su bit en el registro outa
asigna el pin en alto (3.3V) con un 1 o bajo (0V) con un 0. El comando outa[4] := 1 asigna el pin
E/S P4 en alto. Como el circuito LED en P4 termina en tierra el resultado es que el LED emite luz.

L
E/S compartidas entre Cogs? Cada Cog tiene su propia salida E/S (outa) y su registro de direccin E/S
(dira). Debido a que sus aplicaciones usan un solo Cog no tiene que preocuparse por dos Cogs intentando
usar el mismo pin de E/S para diferentes propsitos al mismo tiempo. Cuando varios Cogs se utilizan en una
aplicacin cada direccin de pin E/S y estado de salida es el cableado-OR de los Cogs. Como trabajo esto
lgicamente se describe en la seccin Pin E/S en el Captulo 1 del Manual Propeller.

El comando repeat es uno de los comandos condicionales del lenguaje Spin. Puede hacer que un
bloque de comandos se ejecute repetidamente basado en varias condiciones. Para que repeat afecte
un cierto bloque de comandos tiene que estar debajo de ellos y contener al menos una lnea de
espacio. El siguiente comando despus de repeat que no tiene espacio no es parte del bloque y ser el
siguiente comando a ejecutar despus de que el ciclo repeat se complete.

Como no hay nada debajo del comando repeat en el objeto LedOnP4 solo se repite continuamente.
Este comando se necesita para prevenir que el chip Propeller vaya a modo de bajo consumo despus
de que se queda sin comandos por ejecutar. Si el comando repeat no estuviera ah el LED encendera
muy brevemente como para verlo y despus el chip se pondra en modo de bajo consumo. Para
nuestros ojos parecera que nada sucedi.
Modificando LedOnP4
En una lnea se puede hacer ms de una asignacin:

3 Remplace esto:

dira[4] := 1
outa[4] := 1

...con esto:
dira[4] := outa[4] := 1

Por supuesto usted tambin puede expandir el mtodo LedOn para que corra en ms de un LED.

3 Modifique el mtodo LedOn como se muestra aqu para encender los LEDs en P4 y P5:

PUB LedOn

dira[4] := outa[4] := 1
dira[5] := outa[5] := 1

repeat
Si el comando repeat no estuviera al final del mtodo los LEDs se apagaran tan rpido que no sera
posible verlos en ningn momento. Solo un osciloscopio o ciertos circuitos externos podran observar
el breve estado de Encendido.

3 Intente correr el programa con el comando repeat comentado, colocando un apostrofe a su
izquierda.
3 Si usted tiene un osciloscopio, progrmelo para capturar una seal sencilla y vea como puede
detectar la seal.
Operaciones en grupos de Pins E/S
El lenguaje Spin tiene provisiones para asignar valores a grupos de bits en los registros dira y outa.
En vez de usar un solo digito entre los corchetes seguidos de el comando outa, dos valores separados
por dos puntos pueden usarse para denotar un grupo de bits. El numero binario indicador %
proporciona una forma conveniente de definir el patrn del bit que es asignado al grupo de bits en el
registro outa o dira. Por ejemplo dira[4..9] := %111111 colocara de los bits 4 al 9 en el registro
dira (como salidas). Otro ejemplo outa[4..9] := %101010 activa P4, limpia P5, active P6 y as
sucesivamente. El resultado puede ser que los LEDs conectados a P4, P6, P8 se enciendan mientras
los otros estn apagados.

3 Cargue GroupIoSet.spin en la RAM (F10).
3 Verifique que los LEDs en P4, P6 y P8 encienden.

'' File: GroupIoSet.spin

PUB LedsOn

dira[4..9] := %111111
outa[4..9] := %101010

repeat

Modificando GroupIoSet.spin
Observe que outa[4..9] := %101010 hace que el estado del bit de registro 4 outa se ponga en (1) el
bit 5 limpio (0) y as sucesivamente. Si los valores del grupo de pins inicial y final se cambian el
mismo patrn har que el bit 9 se ponga en (1), el bit 8 limpio (0) y as sucesivamente.

3 Remplace

outa[4..9] := %101010

con esto

outa[9..4] := %101010

3 Cargue el programa en la RAM del chip Propeller y verifique que los LEDs tienen el patrn
inverso.

No importa qu valor esta en el bit de registro outa si su bit de registro dira es cero. Esto es porque
las funciones de los pins E/S estn definidos como entrada en vez de salida cuando el registro dira
est limpio. Un pin de E/S funcionando como entrada detecta una seal alta o baja en vez de
enviarlas. Mientras un pin se configura como salida enva 3.3 o 0V, un pin configurado como entrada
no transmite nada ya que solo esta monitoreando el voltaje aplicado al pin.

Un pin de E/S configurado como salida alta conectado a un LED hace que el LED encienda cuando se
aplica 3.3V al circuito. Como la otra terminal del LED est conectada a tierra (0V) la presin elctrica
a travs del circuito LED hace que la corriente fluya en el circuito lo cual hace que la luz encienda.
Un pin de E/S configurado como salida baja apagara el circuito del LED porque aplica 0 V al circuito.
Con 0 V en ambas terminales del circuito no hay presin elctrica por lo que no fluye la corriente y
las luces se quedan apagadas. La luz se queda apagada tambin cuando el pin E/S se configura como
entrada pero esto sucede por otra razn. Un pin de E/S configurado como entrada no aplica voltaje ya
que esta sensando el voltaje aplicado por el circuito. El resultado es que el LED se queda apagado.

Como un pin de E/S configurado como entrada no aplica ningn voltaje al circuito no importa qu
valor esta en el bit de registro outa correspondiente. El circuito de LED conectado a ese pin se
mantendr apagado. Aqu un ejemplo que configura todos los bits en outa[4..9] pero no en todos los
bits dira[4..9]. El LED conectado a P6 y P7 no prendern porque sus pins E/S se estn configurados
como entradas con ceros en el registro dira.

3 Configurar todos los bits outa[4..9].

outa[4..9] := %111111
3 Limpiar los bits 6 7 7 en dira[4..9].

dira[4..9] := %110011
3 Cargar la modificacin del programa en la RAM del chip Propeller y verificar que los bits
puestos a 1 en outa[6] y outa[7] no pueden prender los LEDs en P6 y P7 porque sus pins
fueron configurados para entradas con ceros en dira[6] y dira[7].
Leyendo una Entrada, Controlando una Salida
El registro ina es un registro de solo lectura en la RAM del cog donde los bits almacenan el estado de
cada pin de E/S. Cuando un pin de E/S es configurado como salida su registro ina reportara el mismo
valor que el registro outa ya que el registro ina indica voltaje alto-bajo con 1 y 0. Si por el contrario
el pin de E/S es una entrada su registro ina se actualiza dependiendo del voltaje aplicado a l. Si en
los pins de E/S hay un voltaje arriba de 1.65 V se observa una entrada lgica y el registro ina
almacena un 1 de otra forma almacena un 0. El registro ina se actualiza con el estado de voltaje de los
pins de E/S cada vez que el comando ina se usa para leer este registro.

El botn pulsador conectado a P21 aplicara 3.3V a P21 cuando se presione o 0V cuando no se
presione. En el objeto ButtonToLed dira[21]es puesto a 0 haciendo el pin E/S P21 una entrada. As
almacenara un 1 si el botn P21 se presiona o un 0 si no se presiona. Asignando repetidamente el
valor almacenado en ina[21] a outa[6] el mtodo ButtonLed hace que el LED en P6 encienda cada
que el botn en P21 se presiona. Note que tambin el comando outa[6] := ina[21] se incluye bajo el
comando repeat lo cual hace que esta lnea se ejecute una y otra vez.

3 Cargue ButtonToLed.spin en la RAM.
3 Presione y suelte el botn conectado a P21 y verifique que el LED conectado a P6 enciende
mientras el botn se mantiene presionado.

'' Archivo: ButtonToLed.spin
'' Led refleja el estado del botn pulsador.

PUB ButtonLed ' Pushbutton/Led Method

dira[6] := 1 ' P6 salida
dira[21] := 0 ' P21 entrada (este comando es redundante)
repeat ' ciclo sin fin
outa[6] := ina[21] ' Copia entrada P21 a P6
Leer Mltiples Entradas, Controlar Mltiples Salidas
Un grupo de bits puede copiarse del registro ina al outa con un comando como outa[6..4] :=
ina[21..23]. El comando dira[6] := 1 tambin tendr que cambiarse a dira[6..4] := %111 antes de
que los botones enciendan los LEDs.

3 Guarde una copia de ButtonToLed y modifquelo para hacer que los botones P23, P22 y P21
enciendan los LEDs P4, P5 y P6 respectivamente. Sugerencia: Usted solo necesita el
comando outa.
3 Intente invertir el orden de los pins en outa[6..4]. Como afecta esto a la forma en que el
botn ingresa al mapa de las salidas de los LEDs? Que sucede si invierte el orden de los bits
en ina[21..23] ?
Retrasos de tiempo con el reloj del sistema
Ciertas operaciones con E/S son mucho ms fciles de estudiar con el cdigo que controla el tiempo
de ciertos eventos como cuando un LED enciende o cunto tiempo se presiono un botn. Los tres
constructores de bloques bsicos para un evento de tiempo en Spin son:

cnt un registro en el chip Propeller que cuenta los ciclos de reloj del sistema.
clkfreq un comando que regresa al chip Propeller la frecuencia del reloj en Hz. Otra forma
til de pensarse es como el valor que almacena el nmero de ciclos de reloj en un segundo.
waitcnt un comando que espera a que el registro cnt tenga un cierto valor.

El comando waitcnt espera a que el registro cnt alcance el valor entre parntesis. Para controlar el
tiempo que waitcnt espera es mejor sumar el numero de ciclos de reloj del sistema que han pasado al
nmero de ciclos de reloj que usted quiere que cnt espere.

El ejemplo suma clkfreq, el nmero de ciclos de reloj en un segundo, al valor actual de cnt. El
resultado de la suma entre parntesis es el valor que el registro cnt alcanzara 1 segundo despus.
Cuando el registro cnt alcanza ese valor waitcnt deja al programa moverse al siguiente comando.

waitcnt(clkfreq + cnt) ' espera por 1 s.

Para calcular retrasos que duran fracciones de segundos simplemente divida clkfreq por un valor
antes de sumarlo al registro cnt. Por ejemplo, aqu est un comando waitcnt que retrasa una tercera
parte de un segundo y otro que retrasa por 1ms.

waitcnt(clkfreq/3 + cnt) ' espera 1/3 s
waitcnt(clkfreq/1000 + cnt) ' espera 1 ms

El objeto LedOnOffP4.spin usa el comando waitcnt para encender P4, esperar s, apagar P4 y
esperar 3/4s. El LED prende y apaga a 1 Hz y estar prendido el 25% del tiempo.

'' Archivo: LedOnOffP4.spin

PUB LedOnOff

dira[4] := 1
repeat
outa[4] := 1
waitcnt(clkfreq/4 + cnt)
outa[4] := 0
waitcnt(clkfreq/4*3 + cnt)

3 Cargue el objeto LedOnOffP4 en la RAM del chip Propeller y verifique que la luz prende y
apaga cada segundo por encendido y apagado.

!
Recuerde que el indentado es importante! La Figura 4-2 muestra un error comn que puede ocasionar
resultados inesperados. En la izquierda las cuatro lneas bajo el comando repeat estn mas indentadas que
repeat. Esto significa que estn anidadas en el comando repeat y los cuatro comandos se repetirn. En la
derecha las lneas bajo repeat no estn indentadas. Estas estn al mismo nivel que el comando repeat. En
este caso el programa nunca llega a ellas porque el ciclo repeat no hace nada.
Note que las lneas sombreadas que conectan la r en repeat a los comandos debajo de ella. Estas lneas
indican los comandos en el bloque en el que opera repeat.
Para habilitar esta funcin en el software Propeller presione Edit y seleccione Preferences. Debajo de la tabla
Appearance seleccione la opcion Show Block Group Indicators o use el acceso rpido Ctrl +I
Figura 4-2: Bloque de Cdigo Repeat
Este ciclo repeat repite cuatro comandos
Los comandos bajo repeat no estn
indentados as que no son parte del ciclo
repeat.

Dentro de waitcnt(clkfreq + cnt)
Cuando se usa Run Compile Current Load para cargar un objeto la herramienta Propeller
examina algunas declaraciones constantes que configuran el sistema de reloj del chip Propeller. Si el
objeto no tiene estas constantes de reloj el software Propeller almacena valores por defecto en el
registro CLK del chip Propeller el cual est programado para usar el oscilador interno RC en modo
rpido (aproximadamente 12 MHz) para el reloj del sistema. Con el reloj de sistema por defecto a
12MHz la instruccin waitcnt(clkfreq + cnt) es equivalente a la instruccin waitcnt(12_000_000 +
cnt).

La Figura 4-3 muestra como waitcnt(12_000_000 + cnt) espera para que el registro cnt acumule 12
millones ms de ciclos de reloj que cuando el comando waitcnt comienza. Tenga en mente que el
registro cnt se ha estado incrementando con cada ciclo de reloj desde que el chip Propeller se re-
encendi. En este ejemplo cnt alcanzo los 50,000,008 ciclos de reloj cuando waitcnt se ejecuto. As
el valor cnt que waitcnt espera es 12,000,000 +50,000,008 = 62,000,008. Por lo tanto el Cog que
ejecuta waitcnt(12_000_000 + cnt) no se le permite moverse al siguiente comando hasta que el
registro cnt alcanza los 62,000,008 ciclos de reloj.

Figura 4-3: El Comando waitcnt y el Registro cnt

Configuracin del Reloj del Sistema y Eventos de Tiempo
Hasta este punto nuestros programas han usado el reloj interno por defecto de 12 MHZ del chip
Propeller. Vamos a modificarlo para usar el oscilador externo de 5 MHz en nuestro circuito de la
Plataforma PE. Ambos, Spin y Ensamblador Propeller tienen provisiones para declarar constantes que
configuran el sistema de reloj y se aseguran que los objetos conozcan cual es su frecuencia de
operacin. El bloque de asignacin CON define una seccin del cdigo para declarar la configuracin
del Propeller as como las smbolos de las constantes globales para usar en el programa.

Declaraciones similares a las del bloque CON pueden agregarse al objeto origen para configurar el
sistema de reloj del chip Propeller. Este conjunto de declaraciones har que el reloj del sistema del
chip Propeller corra a una velocidad lmite de 80MHz

CON
_xinfreq = 5_000_000
_clkmode = xtal1 + pll16x

La lnea _xinfreq = 5_000_000 define la frecuencia esperada del oscilador externo el cual en el caso
de la Plataforma PE es 5.00 MHz. La lnea _clkmode = xtal1 + pll16x hace que el compilador Spin
en la herramienta Propeller programe ciertos bits del registro CLK del chip cuando descarga el
programa. (Vea Manual del Propeller para mayor informacin) El modo de reloj xtal1 configura
ciertos pins XO y XI con caractersticas para trabajar con cristales externos en el rango de 4 a 16
MHz

La frecuencia del cristal externo proporciona la seal de entrada del reloj el cual el circuito PLL
(phase-locked loop) del chip Propeller multiplica por el reloj del sistema. pll16x es un modo de reloj
pre-definido que hace que el circuito PLL multiplique la frecuencia de 5 MHz por 16 para entregar al
sistema una seal de reloj de 80MHz. La constante pll8x puede usarse con el mismo oscilador para
correr el sistema de reloj del chip Propeller a 40MHz. La constante pll4x har que el chip Propeller
corra a 20MHz y as sucesivamente. La lista completa para declaraciones de constantes validas
_clkmode puede encontrarse en el Manual Propeller de Referencia de Lenguaje Spin en la seccin
_CLKMODE.

L
Precisin del Cristal
El reloj interno RC del chip Propeller sirve para aplicaciones no sensitivas al tiempo tales como control de
salidas basadas en entradas y luces parpadeando. Para aplicaciones que son sensitivas al tiempo como
comunicacin serial, generacin de tonos, servo control y temporizadores el chip Propeller puede conectarse
a cristales osciladores y otras seales de alta precisin a travs de sus pins XI y XO.
El oscilador interno del chip Propeller en su modo por defecto RCFAST es el que usa el chip Propeller si el
programa no especifica otra fuente o modo. La frecuencia nominal del oscilador es 12MHz, pero es una
frecuencia actual que puede caer en el rango de 8 a 20 MHz. Esto es un error de +66 a -33%. Nuevamente,
para aplicaciones que no requiere tiempo preciso es suficiente. Por otro lado una aplicacin como
comunicacin serial asncrona puede tolerar nicamente 5% de error y eso es sumando los errores del
transmisor y el receptor. En diseos prcticos ser mejor apostar por un error menor del 1%. Usando un
cristal oscilador externo para la fuente de reloj en el chip Propeller la frecuencia puede estar dentro de esta
tolerancia e incluso en tolerancias de diseos de temporizadores.
La Plataforma PE tiene un cristal de cuarzo de ESC Inc. HC-49US conectado a los pins XI y XO del chip
Propeller que puede usarse en la mayora de aplicaciones sensitivas al tiempo. La hoja de datos para esta
parte menciona una tolerancia de +/- 30 PPM que significa +/- 30 ciclo de reloj en un milln. Eso es un
porcentaje de error de +/- 0.003%. Obviamente es ms que preciso para una comunicacin serial asncrona y
tambin para servo control y generacin de tonos. No es necesariamente ideal para relojes; el error de este
cristal puede hacer que una alarma de reloj gane o pierda 2.808s por da. Esto puede ser suficiente para
relojes que se verifican continuamente con un reloj atmico para actualizarse. Tenga en mente que para
hacer que el chip Propeller funcione con precisin de reloj de pulso solo necesita un oscilador ms preciso
La hoja de datos del HC-49US tambin tiene lmites para temperatura (+/- 50PPM) y desgaste (+/- 5 PPM por
ao). Incluso despus de 5 aos en su rango de -10 + 70C el mximo error podra ser 105PPM lo cual est
todava en control, pero nuevamente, una alarma de reloj podra ganar o perder 9 s por da.

Como clkfreq almacena la frecuencia del reloj del sistema el cdigo objeto puede confiar en l para
el tiempo sin importar la configuracin del reloj del sistema. El comando clkfreq regresa el numero
de ciclos por segundo basado en la configuracin del sistema. Por ejemplo, este bloque CON usa
_xinfreq = 5_000_000 y _clkmode = xtal1 + pll16x, por lo que clkfreq regresa el valor de
5,000,000 16, que equivale a 80,000,000.

ConstantBlinkRate.spin puede configurarse a una variedad de rangos de reloj del sistema para
demostrar como clkfreq mantiene constantes de tiempo sin importar la frecuencia del reloj.

3 Cargue ConstantBlinkRate.spin en la RMA del chip Propeller (F10). El reloj del sistema
correr a 80 MHz.
3 Verifique que rango del parpadeo es de 1 Hz
3 Modifique la declaracin de la constante _clkmode para leer _clkmode = xtal1 + pll8x y
hacer que el sistema corra a 40MHz y cargue el programa en la RAM (F10)

'' File: ConstantBlinkRate.spin

CON

_xinfreq = 5_000_000

PUB LedOnOff

dira[4] := 1
repeat
outa[4] := 1
outa[4] := 0

El reloj de sistema del Propeller trabaja ahora a 40MHz. El LED est parpadeando a 1Hz todava?
3 Repita para pll4x, pll2x, y pll1x. No deber cambiar el rango de parpadeo a ninguna de
estas frecuencias del reloj del sistema.
Temporizar con clkfreq vs. Temporizar con Constantes
Vamos a decir que un valor constante es usado en vez de clkfreq para hacer que el programa trabaje
de una forma a una frecuencia del reloj del sistema particular. Que sucede cuando la frecuencia del
reloj del sistema del chip Propeller cambia?

3 Guarde una copia del objeto ConstantBlinkRate como BlinkRatesWithConstants.spin.
3 Asegrese que el multiplicador PLL est en pll1x para que el reloj corra a 5MHz.
3 Para una seal de encendido/apagado de 1Hz cambie ambas instancias clkfreq/2con
2_500_000. (La herramienta Propeller acepta guin bajo, pero no comas, el nmeros largos
para hacerlos ms legibles)
3 Cargue el objeto en la RAM del chip Propeller y verifique que el LED parpadea a 1 Hz.
3 Despus, cambia el multiplicador PLL a pll2x. Cargue el objeto modificado en la RAM del
Propeller. La luz parpadea dos veces ms rpido? Intente pll4x, pll8x, y pll16x.

Cuando un valor constante se usa en vez de clkfreq un cambio en el reloj del sistema ocasiona un
cambio en el evento del tiempo. Esto es porque los objetos deben usar clkfreq cuando se necesita un
cambio esperado, especialmente para objetos diseados para usarse en otros objetos. De esta forma el
programador puede escoger la mejor frecuencia de reloj para la aplicacin sin tener que preocuparse
acerca si algn objeto de la aplicacin se comportara diferente.
Mas Operaciones de Registros de Salida
En la seccin Operaciones en grupos de Pins E/S, se asignaron valores binarios a los grupos de bits en
los registros dira y outa. Hay muchas formas de recortar y trucos para manipular valores en grupos
de E/S que usted ver en ejemplos de cdigos publicados.
Los Operadores Post-Activo ~~ y Post-Limpio ~
Debajo hay dos ejemplos que hacen lo mismo. Mientras que el objeto a la izquierda usa tcnicas
vistas anteriormente para activar o limpiar todos los bits en dira[4..9]y outa[4..9],el de la derecha
lo hace diferente con los operadores Post-Activo ~~y Post-Limpio ~. Estos operadores son tiles
cuando todos los bits de un cierto rango tienen que activarse o limpiarse.

3 Cargue cada programa en la RAM del chip Propeller y verifique que son idnticos.
3 Analice como el Operador Post-Activo reemplaza := %111111 y el Post-Limpio remplaza :=
%000000.
''Archivo: LedsOnOff.spin
''Todos los LEDs encendidos ''1/4s y
apagados 3/4s.
PUB BlinkLeds

dira[4..9] := %111111

repeat

outa[4..9] := %111111
outa[4..9] := %000000

''Archivo: LedsOnOffAgain.spin
''Todos los LEDs encendidos ''1/4s y
apagados 3/4s con Post ''Activo/Limpio
PUB BlinkLeds

dira[4..9]~~

repeat

outa[4..9]~~
outa[4..9]~
3 Intente modificar ambos programas para que solo afecte P4..P7. Note que los operadores
Post-Activo y Post-Limpio requieren menos mantenimiento ya que automticamente activa o
limpia todos los bits en el rango especificado.
El Operador inteligente NO !
Aqu hay otros dos ejemplos de programas que hacen lo mismo. Esta vez ambos alternan patrones en
los LEDs. El de la izquierda tiene operadores familiares asignados en el ciclo repeat. El de la derecha
inicializa el valor outa[4..9] antes del ciclo repeat. Despus en el ciclo repeat usa el operador NO
! en outa[4..9]. Si outa[4..9] almacena%100001 el comando !outa[4..9] invierte todos los bits
(los 1s se hacen 0s, los 0s se hacen 1s). Por lo que el resultado de !outa[4..9] ser %011110.

3 Cargue cada objeto en la RAM del chip Propeller y verifique que son idnticos.
3 Intente duplicar la frecuencia en cada objeto.

Patrones de Bit de Registro como valor Binario
Un rango de bits en un registro puede escribirse como dgitos o como nmero binario. Por ejemplo en
la instruccin outa[9..4] := %000000 recuerde que % es el indicador de numero binario, %000000
es un numero binario de 6 bits con valor de cero. Se pueden hacer operaciones con este valor y
colocar el resultado nuevamente en el registro. El objeto IncrementOuta agrega 1 a outa[9..4] cada
vez que se repite el ciclo. El resultado ser la siguiente secuencia de valores binarios desplegados en
los LEDs:
Valor Binario Equivalente Decimal
%000000 0
%000001 1
%000010 2
%000011 3
%000100 4
%000101 5
etc
%111101 61
%111110 62
%111111 63
3 Cargue IncrementOuta.spin en la RAM.

''Archivo: LedsOnOff50Percent.spin
''Leds alternan ''encendido/apagado
el 50% del ''tiempo

PUB BlinkLeds

dira[4..9]~~

repeat

outa[4..9] := %100001
outa[4..9] := %011110

''Archivo: LedsOnOff50PercentAgain.spin
''!Leds alternan ''encendido/apagado el
50% del ''tiempo con el operador !

PUB BlinkLeds

dira[4..9]~~
outa[4..9] := %100001

repeat

!outa[4..9]
'' Archivo: IncrementOuta.spin

PUB BlinkLeds

dira[9..4]~~
outa[9..4]~

repeat
waitcnt(clkfreq/2 + cnt) 'cambia a (clkfreq + cnt) para alentar el ciclo
outa[9..4] := outa[9..4] + 1

El ciclo comienza al poner los pins E/S como salida con dira[9..4]~~. Despus outa[9..4]~ limpia
todos los bits en el registro outa rango 9..4 a %000000 cero binario. La primera vez a travs del ciclo
repeat se suma 1, el equivalente a outa[9..4] := %000001, lo cual hace que el LED en P4 se
encienda. Como el ciclo se repite indefinidamente el patrn de LEDs pasa por cada posible
permutacin.
El Operador de incremento ++
El operador de incremento ++puede usarse en vez de + 1 para incrementar un valor. El comando
outa[9..4]++ es equivalente a outa[9..4] := outa[9..4] + 1

3 Modifique el comando outa en el ciclo repeat para usar solo outa[9..4]++.
3 Cargue el objeto modificado en la RAM. Se comportan igual los LEDs?
Comandos condicionales de Repeat
Las opciones de sintaxis para repeat hacen posible especificar el nmero de veces a repetir un bloque
de comandos. Tambin puede repetirse until o while una o ms condiciones existan, incluso
intercambiar un valor variable de un valor from de inicio a un valor final a con la opcion del Delta
step.

3 Lea la explicacin en la seccin REPEAT de la Referencia de Lenguaje Spin del Manual
Propeller si lo encuentra til.

Vamos a modificar IncrementOuta.spin para detenerlo despus que el ltimo valor (%111111 = 63)
ha sido desplegado. Para limitar el ciclo a 63 solo agregue una expresin de conteo al comando
repeat como este:

repeat 63

3 Guarde IncrementOuta.spin como BinaryCount.spin.
3 Agregue el valor de contador 63 despus del comando repeat.
3 Para dejar los LEDs encendidos al terminar el bloque repeat agregue un segundo comando
repeat debajo del bloque. Asegrese que no est ms indentado que el primer repeat.
3 Cargue el objeto BinaryCount en la RAM del chip Propeller y verifique que los LEDs
encienden de acuerdo a la secuencia de valores binarios.

Existen diferentes formas de modificar el ciclo repeat para contar hasta cierto valor y parar. Aqu hay
algunas variaciones de ciclos repeat que cuentan a decimal 20 (binario %010100); el segundo
ejemplo usa el operador igual a ==, el tercero usa en operador menor que <

repeat 20 ' Repite el ciclo 20 veces
repeat until outa[9..4] == 20 ' Repite hasta que outa[9..4] es igual a 20
repeat while outa[9..4] < 20 ' Repite mientras outa[9..4] es menor que 20
Operaciones en Posiciones y Pre Post Posiciones de Operadores
(11 formas diferentes de contar hasta 20)

El comando outa[9..4]++ puede removerse del bloque de cdigo en el ciclo repeat e incrementarse
justo dentro de las condiciones del comando repeat. El objeto IncrementUntilCondition.spin muestra
un ejemplo que cuenta hasta 20 sin incrementar outa[9..4] con el ++ en la condicin del ciclo
repeat.

'' Archivo: IncrementUntilCondition.spin

PUB BlinkLeds

dira[4..9]~~

repeat until outa[9..4]++ == 19


repeat

L
outa y dira inician en cero cuando comienza el programa, as que no se necesita incluir outa[9..4]~.

3 Cargue IncrementUntilCondition.spin en el Propeller y verifique que cuenta hasta 20.

Note que el ciclo se repite hasta 19 pero el programa de cuenta hasta 20. Otra forma de usar ++ en la
condicin del ciclo repeat es ponerlo antes de outa[9..4], como este:

repeat until ++outa[9..4] == 20

Modifique el comando repeat del objeto IncrementUntilCondition con esta condicin hecha until
++outa[9..4] == 20. Verifique que aun para al contar hasta 20.

Cul es la diferencia? Si ++ se pone a la izquierda del outa[9..4], tpicamente se llama Pre-
Incremento y la operacin se desarrolla antes de evaluar la condicin ++outa[9..4] ==. (El operador
-- puesto a la izquierda se llama Pre-Decremento). Igualmente si ++ o -- se coloca a la derecha de
outa[9..4], se llama tpicamente Post-Incremento o Post-Decremento y la operacin se desarrolla
despus de evaluar la condicin.

Con repeat until outa[9..4]++ == 19, el ciclo de retrasa en waitcnt cuando outa[9..4] almacena
0, 1, 219. Cuando outa[9..4] almacena 19, el ciclo no repite el waitcnt. Sin embargo como post-
incremento sucede despus de evaluar la condicin otro uno se agrega al outa[9..4] aun cuando el
ciclo no se repite de nuevo.

Con repeat until ++outa[9..4] == 20 el ciclo se pre-incrementa, as que el primer retraso no
sucede hasta despus de que outa[9..4] brinca a 1. El siguiente retraso sucede despus de 2,
3 y as hasta 19. Cuando outa[9..4] se convierte en 20 el comando ya no se ejecuta por lo
que el ultimo valor en tiene un 20.

En vez de repetir hasta que una condicin es verdadera un ciclo se puede repetir mientras una
condicin es verdadera. Aqu hay ejemplos de conteos hasta 20 usando la condicin while con
operadores Post y Pre Incrementos sumando 1 a outa[9..4]:

repeat while outa[9..4]++ < 19 ' Repite mientras outa[9..4] post-
' incrementado es menor que 19.

repeat while ++outa[9..4] < 20 ' Repite mientras outa[9..4] pre-
' incrementado es menor que 20.

Note que el ciclo post-incrementado cuenta hasta 20, repitiendo mientras outa[9..4] es menor que
19, pero la versin pre-incrementada repite mientras outa[9..4]es menor que 20. Note que con
repeat whileel operador < menor que se usa en vez del operador == igual que. Estas dos
formas demuestran la distincin entre repetir hasta que algo es igual a un valor lo que es diferente a
repetir mientras algo es menor que un valor.

Por supuesto, usted puede usar el operador =< igual o menor que o incluso el operador no igual que
<>. Aqu tenemos ejemplos de esos; en todos los casos los LEDs pararan en binario 20.

repeat while outa[9..4]++ =< 18 'Repite mientras [9..4] post-
'incrementado es menor que o igual a
'18
repeat while ++outa[9..4] =< 19 'Repite mientras outa[9..4] pre-
'incrementado es menor que 19

repeat while ++outa[9..4] <> 20 'Repite mientras outa[9..4] pre-
'incrementado no es igual a 20

Mayor que > o incluso Igual que o Mayor que => pueden usarse tambin con repeat until

repeat until outa[9..4]++ > 18 'Repite hasta que outa[9..4] post-
'incrementado es mayor que 18
repeat until ++outa[9..4] > 19 'Repite hasta que outa[9..4] pre-
'incrementado es mayor que 19
repeat until ++outa[9..4] => 20 'Repite hasta que outa[9..4] pre- es
'incrementado es igual que o mayor a '20
repeat until outa[9..4]++ => 19 'Repite hasta que outa[9..4] post-
'incrementado es igual que o mayor a '19

3 Analice cada uno de los comandos repeat y pruebe cada uno en al objeto
IncrementUntilCondition.

Si usted todava tiene preguntas acerca de esto, no se preocupe por el momento. El punto de esta
seccin es demostrar que hay una variedad de formas para hacer comparaciones e incrementar
valores. Otras prcticas incluirn mejores formas de desplegar cada ciclo para que usted pueda probar
en cada intento.
Mas variaciones Repeat con From...To...
(Otras 3 formas de contra hasta 20)

Aqu hay una condicin mas para repeat, repitiendo outa[9..4] de un valor a otro valor. Con cada
repeticin del ciclo, esta forma de repeat automticamente suma 1 a la cuenta cada vez. Fjese en el
fragmento de abajo. La primera vez a travs del ciclo outa[9..4] empieza en 0. La segunda vez se
suma automticamente 1 y la condicin se verifica para asegurarse que outa[9..4] es mayor que o
igual a 0 o menos que o igual a 19. Se suma 1 cada vez que se repite el ciclo. Despus del ciclo donde
outa[9..4] es igual a 19 se suma 1 a outa[9..4] hacindolo 20. Como 20 no est en el rango de 0 a
19 el cdigo en el ciclo no se ejecuta.

repeat outa[9..4] from 0 a 19 'Suma 1 a outa[9..4] con cada
'repeticin, empieza en 0 y cuenta 'hasta 19.

Aqu se muestra un comando repeat que ofrece una funcin similar usando and. Prueba dos
condiciones, ambas deben ser verdaderas para que el ciclo se repita. Aqu necesitamos incrementar
con el ciclo bloque:

repeat while (outa[9..4] => 0) and (outa[9..4] =< 19)
outa[9..4]++

Otra punto importante de la forma repeatfroma es que usted puede usar un argumento step.
Por ejemplo si usted quiere repetir el ciclo con outa[9..4] a todos los valores pares y salir del ciclo
dejando outa[9..4] en 20, aqu tiene una forma de hacerlo:

Repeat outa[9..4] from 0 a 18 step 2

3 Pruebe las variaciones de los comandos repeat en esta seccin para el objeto
IncrementUntilCondition.
Vocabulario de operadores
Los operadores Unarios tienen un operando. Por ejemplo el operador - en la expresin -1 es un
operador unario y 1 es el operando. Los operadores binarios tienen dos operandos; por ejemplo el
operador menos - en la expresin x - y es un operador binario y x y y son operandos.

Operadores normales tales como suma + opera en sus operandos y proporciona un resultado para el
resto de la expresin sin afectar a los operandos. Algunos operadores que hemos utilizado como :=,
~~, ~, y ! son operadores de asignacin. Los operadores unarios de asignacin tales como ~ , ~~, y ++
escriben el resultado de la operacin de regreso al operando mientras que los operadores binarios de
asignacin tales como := asignan el resultado al operando de la izquierda inmediata. En ambos casos
el resultado est disponible para uso en el resto de la expresin.

Los operadores de transferencia a la derecha >> y transferencia a la izquierda<< toman el patrn
binario del valor en el primer operando y lo mueven a la derecha o izquierda por el numero de bits
especificado en el Segundo operando y regresa el valor creado por el nuevo patrn de bit. Si una
forma de asignacin (>>= o <<=) se usa, el valor original es sobrescrito con el resultado. Los
operadores de transferencia son parte de un grupo ms grande, el de Operadores de Bits Inteligentes
el cual realiza diversas manipulaciones de bits. El operador inteligente NO ! que vimos
anteriormente es un ejemplo.

Algunos operadores normales y de asignacin tienen caractersticas adicionales de ser Operadores de
Comparacin. Un Operador de Comparacin regresa verdad (-1) si los valores en ambos lados del
operador hacen la expresin verdadera o falso (0) si los valores en ambos lados hacen la expresin
falsa. (Estos operadores de comparacin binaria tambin se les llama Operadores Booleanos; tambin
hay un operador booleano unario, NOT)

Bloques condicionales con if
Como muchos lenguajes de programacin, Spin tiene un comando if que permite ejecutar un bloque
de cdigo condicionalmente, basado en el resultado de una prueba. Un comando if puede usarse por
s mismo o como parte de una serie ms compleja de decisiones cuando se combina con elseif,
elseifnot y else. Los Operadores de Comparacin son tiles para probar condiciones en una
declaracin.

if outa[9..4] == 0
outa[9..4] := %100000


Si la condicin es verdadera el bloque de cdigo debajo (una lnea en este caso) se ejecutara. De otra
forma el programa se brincara hasta el siguiente comando que este en el mismo nivel de indentacion
que la declaracin if (aqu es waitcnt).
Moviendo el desplegado de LED
El siguiente objeto ejemplo ShiftRightP9toP4.spin, usa diferentes tipos de operadores para producir
eficientemente el movimiento de un patrn de luces con nuestro circuito de 6 LED.

3 Cargue ShiftRightP9toP4 en la RAM del chip Propeller.
3 Oriente su plataforma para que parezca que las luces se mueven de izquierda a derecha una y
otra vez.
3 Verifique que el patrn empieza en P9 y termina en P14 antes de repetir.

'' Archivo: ShiftRightP9toP4.spin
'' Demuestra el operador de movimiento a la derecha y la declaracin if

PUB ShiftLedsLeft

dira[9..4] ~~

repeat

if outa[9..4] == 0
outa[9..4] := %100000

outa[9..4] >>= 1

Cada vez que pasa el ciclo repeat, el comando if [9..4] == 0 usa el operador == para comparar
contra el valor 0. Si la expresin es verdadera el resultado de la comparacin es -1. Si es falsa el
resultado es 0. Recuerde que por regla outa[9..4] inicializa en cero as que outa[9..4] == 0 se
evala como verdadero la primera vez que pasa por el ciclo repeat. Esto hace que la sentencia if
ejecute el comando outa[9..4] := %100000, el cual enciende el LED en P9.

Despus de la pausa de 1/10s, >>= (el operador de asignacin mover a la derecha) toma el bit en
outa[9..4] y lo mueve a su derecha un bit con la siguiente instruccin: outa[9..4] >>= 1. El bit de la
derecha que estaba en outa[4] se elimina y la vacante que se crea en outa[9] se llena con un 0. Por
ejemplo si outa[9..4] almacena %011000 antes de outa[9..4] >>= 1, almacenara %001100 despus.
Si el comando fuera outa[9..4] >>= 3, el resultado sera %000011

Cada vez que el ciclo se repite el comando outa[9..4] >>= 1 mueve el patrn a la derecha,
generando un ciclo %100000. %010000, %001000,%000001, %000000. Cuando outa[9..4] tiene
%000000 el comando if ve que outa[9..4] almacena un 0, por lo que almacena %100000 en
outa[9..4] y el movimiento de la luz en el LED se repite.

3 Pruebe al cambiar el Segundo operando en la operacin de mover a la derecha de 1 a 2 para
hacer que el patrn en outa[9..4] se mueva dos bits a la vez. Usted deber estar viendo
parpadear cada dos LED de izquierda a derecha.
Ejemplo de Variable
El objeto ButtonShiftSpeed que se muestra abajo es una versin extendida de ShiftRightP9toP4 que le
permite usar los botones para controlar la velocidad a la cual el LED cambiara su posicin a la
derecha. Si usted sostiene el botn P21 la velocidad baja; si sostiene el botn en P22 la velocidad
sube. El control de velocidad se hace posible al almacenar un valor en una variable. El patrn que se
mueve tambin es almacenado en una variable, haciendo posible un numero de patrones que no se
pueden alcanzar desarrollando operaciones de movimiento en los bits en outa[9..4].

3 Cargue ButtonShiftSpeed.spin en la RAM.
3 Intente presionar P22 y observe el cambio en el comportamiento del LED, despus presione
el botn P21.

'' Archivo: ButtonShiftSpeed.spin
'' El LED se mueve de izquierda a derecha a velocidad variable presionando los botones.

VAR

Byte pattern, divide

PUB ShiftLedsLeft

dira[9..4] ~~
divide := 5

repeat

if pattern == 0
pattern := %11000000

if ina[22] == 1
divide ++
divide <#= 254
elseif ina[21] == 1
divide --
divide #>= 1

waitcnt(clkfreq/divide + cnt)
outa[9..4] := pattern
pattern >>= 1

ButtonShiftSpeed tiene un bloque variable (VAR) que declara dos variables de un byte, pattern y
divide. La variable pattern almacena el patrn del bit que se manipula y se copia a outa[9..4], y
divide almacena un valor que divide a clkfreq para un retraso de longitud variable

Byte es una de las tres opciones para declarar variables y puede almacenar un valor desde 0 hasta 255.
Otras opciones son word (0 a 65535) y long (-2,147,483,648 a 2,147,483,647). Pueden declararse
arreglos de variables especificando el nmero de elementos en corchetes a la derecha del nombre de
la variable. Por ejemplo myBytes[20] ser un arreglo de 20 elementos de nombre myBytes. Esto pone
a disposicin las variables myBytes[0], myBytes[1], myBytes[2],, myBytes[18], y myBytes[19].

El primer bloque if en el ciclo repeat se comporta similar al del objeto ShiftRightP9toP4. En vez de
outa[9..4], la sentencia if examina el contenido de la variable pattern y si es cero la siguiente lnea
reasigna a pattern el valor de %11000000.
Los operadores Limite Mnimo #> y Limite Mximo <#
Spin tiene operadores Limite Mnimo #> y Limite Mximo <# que pueden usarse para mantener
el valor de variables dentro de un rango deseado ya que son redefinidas por otras expresiones. En
nuestro objeto ejemplo, la segunda sentencia if en el ciclo repeat es parte de una sentencia
ifelseif que verifica el estado del botn pulsador. Si el botn P22 se presiona divide se
incrementa en 1 con divide ++, y divide est limitado a 254 con <#=, la forma de asignar el operador
de lmite mximo. Si el resultado de divide ++ es 255 la siguiente lnea divide <#= 254 reduce su
valor nuevamente a 254. Esto previene que el valor de divide pase a 0 lo cual es importante porque
divide tiene que dividirse entre clkfreq en el comando waitcnt posteriormente en el ciclo repeat. Si
P21 se presiona en vez de P22 la variable divide se decrementa con --, la cual resta 1 de divide. El
operador de asignacin #>= se usa para asegurarse que divide nunca ser menor que 1, nuevamente
previniendo de llegar al 0.

Despus de que la sentencia ifelseif verifica el estado del botn y decrementa o incrementa la
variable divide si alguno de los botones se presiono se ejecuta la funcin waitcnt(clkfreq/divide +
cnt) para esperar un tiempo. Note que conforme divide es mayor waitcnt es menor. Despus de que
el retraso waitcnt, que es controlado por la variable divide, pattern se almacena en outa con
outa[9..4] := pattern. Por ltimo la variable pattern se mueve a la derecha en 1 la siguiente vez
que se realiza el ciclo.
Comparacin entre Operaciones y Condiciones
Los operadores de comparacin regresan un verdadero (-1) o falso (0). Cuando se usa en los bloques
if y repeat el cdigo especificado se ejecuta s la condicin en no-cero. Siendo este el caso puede
usarse if ina[22] en vez de if ina[22] == 1. El cdigo funciona igual pero con menos
procesamiento ya que se salta la operacin de comparacin.

Cuando se presiona el botn la condicin en if ina[22] == 1 regresa un -1 ya que ina[22] almacena
un 1 haciendo la comparacin verdadera. Usando solo if ina[22] aun se ejecuta el bloque de cdigo
cuando se presiona el botn ya que ina[22] almacena 1, el cual es no-cero, haciendo que el bloque de
cdigo se ejecute. Cuando el botn no se presiona ina[22] almacena un 0 y ina[22] == 1 regresa un
falso (0). En cualquiera de los casos la condicin de if es 0 as que el cdigo debajo de if ina[22] ==
0 o if ina[22] se salta.

3 Cambie if ina[22] == 1elseif ina[21] == 1 a if ina[22]elseif ina[21], y
verifique que el programa modificado todava funciona.
Variables Locales
Mientras que todos los ejemplos de objetos en estas prcticas usan solo un mtodo, los objetos
frecuentemente tienen ms de un mtodo y las aplicaciones tpicamente son colecciones de diversos
objetos. Los mtodos en las aplicaciones de paso de control de programa y parmetros opcionales van
y vienen entre otros mtodos del mismo objeto y tambin en otros mtodos en otros objetos. Para
preparar el trabajo con mtodos mltiples en las siguientes prcticas veamos como un mtodo puede
crear una variable local.
Las variables declaradas en la seccin VAR de un objeto son globales para el objeto, lo que significa
que todos los mtodos en un objeto pueden usarlas. Cada mtodo en un objeto tambin puede declarar
variables locales para uso propio. Estas variables locales duran mientras se ejecuta el mtodo. Si el
mtodo corre fuera de sus comandos y pasa el control del programa al comando que lo llamo, el
nombre de la variable local y la memoria quedan disponibles para usarse por otras variables.

Las dos variables globales en el objeto ButtonShiftSpeed se pueden reemplazar con variables locales
como sigue:

3 Remueva el bloque VAR (incluyendo su declaracin de byte variable).
3 Agregue el smbolo pipa a la derecha del bloque de declaracin de mtodo seguido por los
dos nombres de variables separados por comas, pruebe si el programa funciona igual.

PUB ShiftLedsLeft | pattern, divide
Las variables pattern y divide ahora son locales, lo que significa que otros mtodos en el objeto no
pueden usarlas; ya que nuestro objeto aqu solo tiene un mtodo no hay consecuencias. Hay otra
diferencia. Cuando usbamos la sintaxis del bloque VAR, tenamos la opcion de definir nuestras
variables globales como byte, Word o Long. Sin embargo las variables locales se definen
automticamente como Long y no hay opcion para tamaos de byte o Word en variables locales.
Aplicaciones de tiempo
Para aplicaciones de reloj y tiempo es importante eliminar todos los errores posibles excepto por la
precisin del cristal oscilador. Observe los dos objetos que desarrollan tareas de reloj. Asumiendo que
usted tiene un cristal muy preciso el programa a la izquierda tiene un serio problema! El problema es
que cada vez que se repite el ciclo, el ciclo de reloj transcurrido durante la ejecucin de los comandos
en el ciclo no se cuentan, y esto retraso desconocido se acumula junto con clkfreq + cnt. As que el
numero de segundos de la variable seconds estar desfasada y crecer significativamente cada da
mucha ms que el solo error inducido por el rango del cristal +/- PPM.

El programa a la derecha resuelve el problema agregando dos variables: T and dT. Un incremento de
tiempo se coloca con dT := clkfreq lo cual hace que dT iguale el numero de ciclos en un segundo. Un
tiempo particular de inicio se marca con T := cnt. Dentro del ciclo el siguiente valor de cnt que
waitcnt tiene que esperar se calcula con T += dT. (Usted puede usar T := T + dT) sumando dT a T al
pasar por el ciclo genera una diferencia precisa del valor original marcado en el valor de T. Con este
sistema cada nuevo valor para waitcnt es exactamente el valor de 1 segundo. No importa cuntas
tareas se ejecuten entre las ejecuciones del comando waitcnt, siempre y cuando se complete en
menos de un segundo. As que el programa de la derecha nunca perder ciclos de reloj y mantendr
''Archivo: TimekeepingBad.spin

CON

_xinfreq = 5_000_000

VAR

long seconds

PUB BadTimeCount

dira[4]~~

repeat
waitcnt(clkfreq + cnt)
seconds ++
! outa[4]

''Archivo: TimekeepingGood.spin

CON

_xinfreq = 5_000_000

VAR

long seconds, dT, T

PUB GoodTimeCount

dira[9..4]~~

dT := clkfreq
T := cnt

repeat
T += dT
waitcnt(T)
seconds ++
outa[9..4] := seconds
una constante de 1 s basado en que ser tan bueno como la seal que el chip Propeller obtiene de su
cristal oscilador externo.

L
Consejo:
En TimeKeepingGood.spin, dos lneas:
T += dT
waitcnt(T)
Pueden reemplazarse con esta lnea:
waitcnt(T += dT).

3 Pruebe ambos objetos. Sin un osciloscopio no deber observar una diferencia notable.
3 Agregue un retraso de .7 s al final de cada objeto (dentro de caca ciclo repeat). El objeto en la
izquierda ahora repetir cada 1.7 s; el de la derecha deber repetir aun cada 1 s.

En vez de un retraso imagine cuantas otras tareas puede realizar el chip Propeller en cada Segundo y
aun mantener una base de tiempo precisa!
Varios mltiplos de un tiempo dado pueden tener diferentes usos en diferentes aplicaciones. Por
ejemplo estos objetos tienen segundos como tiempo base, pero quiz estamos interesados en minutos
y horas. Hay 60 segundos en un minuto, 3,600 segundos en una hora y 86,400 segundos en un da.
Vamos a decir que la aplicacin corre al conteo de seconds. Una forma de determinar si ha
transcurrido un segundo es dividir seconds por 60 para ver si hay algn recordatorio. El operador
Modulus // regresa un recordatorio de problemas de divisin. Conforme pasa el segundo, el
resultado de seconds // 60 es 0 cuando seconds es 0, 60, 120, 180, y as sucesivamente. El resto del
tiempo Modulus regresa el sobrante. Por ejemplo, cuando seconds es 121 el resultado de seconds //
60 es 1. Cuando seconds es 125 el resultado de seconds // 60 es 5 y as sucesivamente.

Siendo este el caso tenemos una expresin que incrementa la variable minutes cada que otros 60
segundos transcurren:

if seconds // 60 == 0
minutes ++

Otro ejemplo con hours:

if seconds // 3600 == 0
hours ++

Por cada hora que pasa minutes se deber poner en cero cada que llegue a 60. Un ejemplo de un if
anidado que expande el clculo previo de minutes:

minutes ++
if minutes == 60
minutes := 0

El objeto TimeCounter mostrado abajo usa tiempo sincronizado y corre segundos totales con el
operador Modulus para rastreo de segundos, minutos, horas y das basado en el contador seconds. El
valor de seconds se despliega en binario con los 6 circuitos LED. Estudie este programa
cuidadosamente porque contiene las claves para esta prctica que incrementa un tiempo basado en
presionar un botn por diferente duracin. Tambin tiene la clave para otro proyecto en el cual los
LEDs parpadean a diferente ritmo usando Cogs mltiples. (Cuando use Cogs mltiples en otras
prcticas ser mucho ms fcil!)

3 Cargue TimeCounter.spin en la EEPROM, y verifique que el incremento del conteo LED es
cada 1 s.
3 Modifique el cdigo para que el ultimo comando copie el valor que tiene minutes en
outa[9..4], y verifique que el LED incrementa cada minuto.

''Archivo: TimeCounter.spin

CON

_xinfreq = 5_000_000

VAR

Long seconds, minutes, hours, days, dT, T

PUB GoodTimeCount

dira[9..4]~~

dT := clkfreq
T := cnt

repeat

T += dT
waitcnt(T)
seconds++

minutes++
if minutes == 60
minutes := 0
if seconds // 3600 == 0
hours++
if hours == 24
hours := 0
if seconds // 86400 == 0
days++

outa[9..4] := seconds

Eventualmente la variable seconds alcanzara la limitacin de almacenamiento. Por ejemplo cuando
llegue a 2,147,483,647, el siguiente valor ser -2,147843,648, y despus -2,147,843,647, -
2,147,843,646, y as hasta -2, -1. As que cuanto tardara el contador seconds en llegar a
2,147,483,647? La respuesta es 68 aos. Si esto es aun un problema para su aplicacin considere
limpiar el contador seconds cada ao.
Tiempo de Estudio
Preguntas
1) Cuantos procesadores tiene el micro controlador Propeller del kit PE?
2) Cuanta memoria global RAM tiene el micro controlador Propeller?
3) Cul es el suministro de voltaje del chip Propeller? Como se relaciona esto al estado alto o
bajo de los pins de E/S?
4) Donde almacena el cdigo Spin el chip Propeller y como se ejecuta?
5) Cules son las diferencias entre ejecutar cdigo Spin y cdigo Ensamblador?
6) Cul es la diferencia entre un mtodo y un objeto?
7) Que es un objeto tope?
8) Que determinan los bits en los registros dira y outa?
9) Sin argumentos especiales el comando repeat repite un cloque de cdigo indefinidamente.
Que tipos de argumentos opcionales se usaron en esta prctica y como limitaban el nmero de
repeticiones?
10) Cual comando Spin usado con waitcnt hace posible controlar el tiempo sin conocer la
frecuencia del chip Propeller por adelantado?
11) Si los comandos estn bajo el comando repeat, como determina si se repetirn o no en el
ciclo?
12) Cual fue el significado ms frecuente de calcular un valor para el comando waitcnt y con
cual registro hace que el comando waitcnt que compare este valor?
13) Cul es la diferencia entre _xinfreq y _clkmode?
14) Que hace el circuito de fase cerrada a la seal de reloj del cristal?
15) Por qu es tan importante usar fracciones de clkfreq y no un valor constante para retrasos?
16) Cual seal de reloj es ms precisa, el reloj RC interno del chip Propeller o un cristal externo?
17) Que registros controlan la direccin y salida de los pins E/S? Si un pin E/S se coloca como
entrada, que valor de registros cambiaran mientras corre la aplicacin y como son los valores
que regresa determinados por el Propeller?
18) Cul es la diferencia entre la sintaxis dira/outa/ina que se refiere a un bit sencillo en el
registro y la sintaxis que denota un grupo de bits?
19) Que indicador proporciona una forma conveniente de asignar un grupo de valores de bits a un
grupo de bits en el registro dira/outa/ina?
20) Como responde un pin E/S si hay un 0 en su bit de registro dira y un 1 en su bit de registro
outa?
21) Si los bits en dira o outa no son inicializados cual es su valor inicial por defecto?
22) Que operadores de asignacin se presentaron en esta prctica?
23) Que operadores de comparacin se usaron en esta prctica?
24) Cul es la diferencia entre los operadores := y ==?
25) Son necesarios los operadores de comparacin para las condiciones if?
26) Cules son los dos diferentes alcances que una variable puede tener en un objeto?
27) Cules son los tres tamaos de variables que pueden declararse? Que rango de nmeros
puede tener cada una? Se ve afectado el tamao de la variable debido a su alcance?
28) Como se declara una variable local en un mtodo? Qu carcter se necesita para declarar ms
de una variable local?
Ejercicios
1) Escriba una sola lnea de cdigo que programe P8 a P12 como salida alta.
2) Escriba comandos para programar P9 y P13 a P15 como salidas. P9 deber ser salida alta y
P13 a P15 deber ser baja.
3) Escriba un comando nico de inicializacin para programar P0 a P2 como salida y P3 a P8
como entrada.
4) Escriba un bloque repeat que cambie el estado de P8 y P9 cada 1/100 s. Cada que P8 est
encendido P9 deber estar apagado y viceversa.
5) Escriba un ciclo repeat que programe P0 a P7 al estado opuesto censado por P8 a P15.
Puede consultar el manual Propeller para ver cul es la mejor opcion de operadores de
asignacin.
6) Escriba un bloque CON para hacer que el reloj del sistema del chip Propeller corra a 10MHz
7) Escriba un cdigo para un retraso de 5 segundos.
8) Escriba un cdigo que programe P5 a P11 alto por 3 segundos, despus programe P6, P8 y
P10 bajo. Asuma que los bits dira han sido programados
9) Escriba un mtodo llamado LightsOn con un ciclo repeat que encienda P4el primer segundo,
P5 el segundo, P6 el tercero y as hasta P9. Asuma que las direcciones de los pin E/S no han
sido programados. Asegrese que las luces se vayan quedando encendidas.
10) Escriba un mtodo que encienda un LED conectado a P27 por 5 s si se presiona un botn
conectado a P0, incluso si el botn se suelta antes de 5 s. No asuma que las direcciones E/S
han sido programadas. Asegrese de apagar P27 despus de los 5 s.
11) Escriba un mtodo de conteo regresivo de 1 segundo que se despliegue de P4 a P9. Deber
contar de 59 a 0 en binario.
12) Escriba un mtodo de conteo regresivo de 1 segundo que se despliegue de P4 a P9. Deber
contar de 59 a 0 en binario una y otra vez indefinidamente.
13) Escriba un mtodo llamado PushTwoStart que requiere que presione los botones conectados a
P21 y P23 al mismo tiempo para empezar la aplicacin. Por ahora la aplicacin puede al
menos encender un LED y dejarlo encendido.
14) Escriba un mtodo llamado PushTwoStart que requiere que presione los botones conectados a
P21 y P23 al mismo tiempo para empezar la aplicacin. La aplicacin deber contar
regresivamente de 59 a 0 usando P9 a P4.
Proyectos
1) Conecte LED rojos a P4 y P7, Amarillos en P5 y P8 y verdes en P6 y P9. Asuma que un set
de LED est apuntando en ambas direcciones en la calle norte-sur y el otro est apuntando en
la calle este-oeste. Escriba un objeto controlador no-activado (uno que siga un patrn sin que
verifique si hay carros en las intersecciones).
2) Repita el objeto previo pero asuma que la calle norte-sur est muy transitada y colquelo en
verde mientras que la calle este-oeste tiene un sensor que se activa para que la luz cambie.
3) Use un Cog sencillo para hacer que el LED parpadee a diferentes rangos (esto es ms sencillo
con mltiples Cogs como pudo observar en las ltimas prcticas). Haga que P4 parpadee a 1
Hz, P5 a 2 Hz, P6 a 3 Hz, P7 a 7Hz, P8 a 12 Hz y P9 a 13 Hz.
4) Los botones que programan una alarma de reloj tpicamente incrementan o decrementan el
tiempo despacio hasta que usted ha detenido el botn por un par de segundos; despus de eso
el tiempo se incrementa/decrementa mas rpido. Los botones de la alarma de reloj tambin lo
dejan incrementar/decrementar si presiona y suelta rpidamente el botn. Escriba una
aplicacin que lo deje incrementar o decrementar un contador binario de minutos (de o a 59)
con los botones P21 y P23. Si usted detiene el botn, los primeros diez minutos
incrementa/decrementa cada s pero si continua presionando el botn los minutos se
incrementaran 6 veces ms rpido. Use P9 a P4 para desplegar el conteo binario de los
minutos.
5) Extienda el proyecto 4 modificando el objeto para que tenga un contador regresivo que se
programe con P21 y P23 y se inicie con el botn P22.

5: Prcticas de Mtodos y Cogs
5: Practicas de Mtodos y Cogs
Introduccin
Los objetos son organizados en bloques de cdigo llamados mtodos. En Spin se pueden usar
nombres de mtodos para pasar el control de programa y opcionalmente valores de parmetros de un
mtodo a otro. Cuando un mtodo usa otro nombre de mtodo para pasarle el control de programa se
llama llamada mtodo. Cuando el mtodo llamado corre los comandos automticamente regresa el
control del programa y un resultado a la lnea de cdigo en el mtodo que se le llamo. Dependiendo
de cmo se escribe el mtodo tambin puede recibir uno o ms parmetros cuando se llama. Usos
comunes para valores de parmetros incluyen configuracin, definir el comportamiento de los
mtodos y valores de entrada para clculos.

Los mtodos tambin pueden iniciarse en Cogs separados para que sus comandos se procesen en
paralelo con comandos en otros mtodos. El lenguaje Spin tiene comandos para iniciar mtodos en
Cogs, identificar Cogs y detener Cogs. Cuando los mtodos se inician en Cogs se tienen que declarar
variables globales para asignar memoria para los mtodos y almacenar direcciones de regreso, valores
de regreso, parmetros y valores usados en clculos. Esta memoria normalmente se conoce como
espacio de pila.

Esta prctica muestra tcnicas para escribir mtodos, llamar mtodos, pasar parmetros a mtodos y
regresar valores de mtodos. Tambin muestra cmo usar llamadas a mtodos en comandos que
inician instancias de mtodos en Cogs separados as como una introduccin a que tanto espacio de
pila se necesita para uno o ms mtodos Spin que se ejecutan por un Cog.
Prerrequisitos para la Prctica
Configuracin y Prueba
Bsicos de E/S y tiempo
Lista de partes y esquemas
Esta prctica usa seis circuitos LED y tres circuitos de botones pulsadores

(6) LEDs diferentes colores
(6) Resistencias 100
(3) Resistencias 10 k
(3) Botones Pulsadores normalmente abierto
(misc) cables puente

3 Construir el circuito mostrado en la Figura 5-1.

Prcticas de Mtodos y Cogs
Figura 5-1: Esquema de botones pulsadores LED

Definiendo un comportamiento de Mtodo con variables locales
El objeto AnotherBlinker muestra el uso de tres variables, pin, rate, y reps, para definir el
comportamiento encendido/apagado de su ciclo repeat de LED. Con las variables actuales
programadas hace que P4 parpadee a 3 Hz por 9 repeticiones encendido/apagado. Como el ciclo
repeat solo cambia el estado del LED (en vez de un ciclo completo) el objeto necesita dos veces ms
el numero de estados de cambio y la mitad del retraso especificado entre cada cambio de estado. As
la variable reps se multiplica * 2 en vez de solo reps y tambin el comando waitcnt utiliza rate/2 en
vez de rate para el rango de parpadeo de 3Hz.

3 Corra el objeto AnotherBlinker.spin y verifique que hace que el LED P4 parpadee a 3Hz por
9 repeticiones.
3 Pruebe una variedad de valores para pin, rate y reps y verifique que definen correctamente
el comportamiento del ciclo repeat.

'' AnotherBlinker.spin

PUB Blink | pin, rate, reps

pin := 4
rate := clkfreq/3
reps := 9

dira[pin]~~
outa[pin]~

repeat reps * 2
waitcnt(rate/2 + cnt)
!outa[pin]

Llamando un Mtodo
El mtodo Blink se usa nuevamente en el siguiente objeto ejemplo CallBlink, junto con otro mtodo
llamado Main. La Figure 5-2 muestra como el mtodo Blink se llama desde el mtodo Main. La
ejecucin del programa comienza en Main, en el primer bloque PUB. Cuando el programa llega a la
lnea Blink en el mtodo Main el control del programa pasa al mtodo Blink. Esta es una versin
pequea de una llamada de mtodo. Cuando el mtodo Blink termina de parpadear el LED 9 veces el
control del programa regresa al mtodo Blink en el mtodo Main. Eso es el regreso de mtodo o
simplemente regreso. Vamos a dar un vistazo al mtodo Main del objeto CallBlink. Comienza por
encender el LED en P9 para hacer saber al usuario que puede presionar el botn P23. El ciclo repeat
until ina[23] se repite hasta que P23 se presiona y el programa se mueve apagando el LED P9 con
outa[9] := 0. Entonces llama al mtodo Blink el cual hace parpadear P4 a 3Hz 9 veces y luego
regresa. El siguiente comando es waitcnt(clkfreq/2*3 + cnt) el cual detiene por 3/2 s. Despus el
otro ciclo repeat comienza su siguiente iteracin. A ese punto el LED P9 se enciende nuevamente
indicando que el botn P23 puede disparar nuevamente la secuencia de 9 repeticiones a 3 Hz en P4.

3 Cargue el objeto CallBlink.spin en el chip Propeller.
3 Cuando el LED P9 se enciende presione/suelte el botn en P23.
3 Espere a que P9 encienda nuevamente despus de que P4 ha parpadeado 9 veces.
3 Presione/Suelte el botn P23 para reiniciar la secuencia otra vez.

Figure 5-2: Llamando un Mtodo

Pasando Parmetros
El mtodo Blink que acabamos de usar programa los valores de sus variables locales pin, rate, y reps
con instrucciones individuales var :=. Para hacer mtodos ms flexibles y eficientes de usar el valor
de sus variables locales pueden definirse en la llamada de mtodo en vez del mtodo mismo.

La Figura 5-3 muestra cmo funciona el objeto BlinkWithParams. La declaracin del mtodo
modificado Blink ahora es: Blink( pin, rate, reps). El grupo de variables locales entre parntesis
se llama lista de parmetros. Note como el mtodo Blink llamado en el mtodo BlinkTest tambin
tiene su lista de parmetros. Estos valores de parmetros se pasan a las variables locales en la
declaracin de la lista de parmetros del mtodo BlinkTest. En este caso el BlinkTest pasa 4 a pin,
clkfreq/3 a rate y 9 a reps. El resultado es el mismo que en el objeto AnotherBlinker, pero ahora
el cdigo en un mtodo puede pasar valores a variables locales en otro mtodo.

3 Cargue BlinkWithParams.spin en el chip Propeller y verifique que el resultado es el mismo
que el objeto previo AnotherBlinker.
3 Ajuste valores de parmetro en la llamada a mtodo para ajustar el comportamiento de Blink
'' CallBlink.spin

PUB Main

repeat
outa[9] := dira[9] := 1
repeat until ina[23]
outa[9] := 0
Blink

PUB Blink | pin, rate, reps

pin := 4
rate := clkfreq/3
reps := 9

dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]
Llamada de
Mtodo
Regreso de
Mtodo
Siguiente
Comando

Figura 5-3: Pasando Parmetros

Los mtodos pueden reusarse con diferentes valores de parmetros en cada llamada de mtodo; aqu
se llama Blink tres veces con diferentes parmetros y una pausa de 1 s en medio.

PUB BlinkTest

Blink(4, clkfreq/3, 9)

Aqu hay otro ejemplo en el que prende un LED diferente cada que se presiona y suelta en botn. Esta
es una variacin del mtodo Main del objeto CallBlink, con una variable local llamada led y un ciclo
repeat que programa la variable a 4, 5, , 8, 9, 4, 5, 8, 9, . Una llamada de mtodo actualizada
Blink pasa el valor en la variable al parmetro pin del mtodo Blink. Como led cambia con cada
iteracin del ciclo repeat, la variable pin recibir un valor diferente cada que se llama a Blink. El
resultado? Cada vez que se presiona en botn (despus que enciende P9) un LED diferente
parpadeara a 3 Hz 9 veces.

PUB BlinkTest | led
repeat
repeat led from 4 a 9
outa[9] := dira[9] := 1
repeat until ina[23]
outa[9] := 0
Blink(led, clkfreq/3, 9)

La variable local led del mtodo BlinkTest se pudo haber llamado pin porque es una variable local
ya que solo el mtodo BlinkTest la usa. El cdigo en el mtodo Blink tiene tambin una variable
local pin, pero nuevamente, solo el cdigo en el mtodo Blink estar pendiente del valor de la
variable pin.

3 Pruebe las dos versiones modificadas BlinkTest en discusin y asegrese que hace sentido.
3 Intente cambiar los parmetros para que el LED P4 parpadee 4 veces, P5 5 veces y as
sucesivamente.
'' BlinkWithParams.spin

PUB BlinkTest


PUB Blink(pin,rate,reps)

dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]

Arrancando mtodos en los Cogs
Todos los mtodos en los objetos hasta este punto se han ejecutado en un solo Cog del chip Propeller,
el Cog 0. Cada vez que el mtodo Blink se llamaba, era llamado en secuencia, por lo que solo un
LED parpadeaba a la vez. El mtodo Blink puede arrancar en diferentes Cogs, cada uno con
diferentes parmetros para hacer que los LEDs parpadeen simultneamente. El objeto BlinkWithCogs
mostrado en la Figura 5-4 muestra cmo hacer esto con los 3 comandos cognew.

El primer mtodo en el objeto superior automticamente arranca en el Cog 0 por lo que el mtodo
Blink del objeto BlinkWithCogs arranca en el Cog 0. Se ejecutan 3 comandos cognew y se queda sin
instrucciones por lo que el Cog 0 se apaga. Mientras tanto los otros 2 Cogs se iniciaron cada uno
correo por 3 segundos. Despus de que el ltimo Cog se queda sin instrucciones el chip Propeller se
va a bajo consumo.

Figura 5-4: Arrancando mtodos en Cogs con pase de parmetros

Mientras que el Cog 0 accesa RAM global no usada que viene despus del cdigo de programa para
almacenar direcciones de regreso en llamadas de mtodo, variables locales y clculos de expresiones
intermedias, otros Cogs que ejecutan mtodos Spin deben tener variables para ellos. Tal espacio
variable reservado en RAM global para esas actividades temporales se llama espacio de pila y los
datos almacenados en cualquier momento es la pila. Note que el objeto BlinkWithCogs en la Figura
5-4 tiene una declaracin variable de pila long stack[30]. Esto declara un arreglo de variables long
llamadas stack con 30 elementos [0], stack[1], stack[2], , stack[28], stack[29].

El comando cognew(Blink(4, clkfreq/3, 9), @stack[0])llama al mtodo Blink en el siguiente Cog
disponible con los parmetros 4, clkfreq/3, y 9 lo cual sucede en el Cog 1. El argumento @stack[0]
pasa la direccin del arreglo stack[0] al Cog 1. As el Cog 1 inicia ejecutando Blink(4, clkfreq/3,
9) usando stack[0] y hacia arriba el regreso de direccin, variables locales y clculos intermedios. El
comando cognew(Blink(5, clkfreq/7, 21), @stack[10]) inicia Blink(5, clkfreq/7, 21) en el
Cog 2 con un apuntador a la direccin stack[10] en RAM para usar desde stack[10] hacia arriba.
Luego cognew(Blink(6, clkfreq/11, 39), @stack[20]) hace lo mismo con diferentes parmetros de
mtodo y diferente direccin en el arreglo stack.
'' BlinkWithCogs.spin

VAR
long stack[30]

PUB LaunchBlinkCogs

cognew(Blink(4, clkfreq/3, 9), @stack[0])

PUB Blink( pin, rate, reps)

dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]

Arranque en
Cog 2
Arranque en
Cog 1
Arranque en
Cog 3
Cog 1
Blinker(4, clkfreq/3, 9)
RAM @stack[0]
Cog 2
RAM @stack[10]
Cog 3
RAM @stack[20]
Cog 0
Comandos LaunchBlinkerCogs
3 Cargue el objeto BlinkWithCogs en el chip Propeller y verifique que los tres LED parpadean
a diferentes frecuencias al mismo tiempo (en vez de secuencialmente)
3 Examine el programa y haga notas de los nuevos elementos.

La RAM no usada que el Cog 0 usa para su pila puede verse en la ventana de Informacin del Objeto
mostrado en la Figura 5-5 (F8 muestra Hex). El color gris en la parte superior muestra cdigos de
inicializacin que inician el Objeto superior en un Cog, programa el registro de reloj del chip
Propeller y otras tareas. La memoria roja almacena el cdigo de programa Spin, el amarillo indica el
espacio global variable (el arreglo de 30-variables long). Lo que sigue en azul es RAM no usada de la
cual puede usarse para la pila del Cog 0. La direccin inicial RAM del Cog 0 es hexadecimal 00F0.

Figura 5-5: Ventana de Informacin del Objeto

Parando Cogs
Con el comando cognew, el chip Propeller siempre busca el siguiente Cog disponible y lo empieza
automticamente. En el objeto BlinkWithCogs el patrn de asignacin de Cogs es predecible: el
primer comando cognew inicia Blink(4, clkfeq/3, 9)en el Cog 1 Blink(5, clkfreq/7, 21) en el
Cog 2, y Blink(6, clkfreq/11, 39) en el Cog 3.

L
Elija su Cog: En vez de usar el siguiente Cog disponible usted puede especificar cual Cog desea usar para
inicializar usando el comando coginit en vez de cognew. Por ejemplo, este comando iniciara el mtodo en el
Cog 6:
coginit(6, Blink(4, clkfreq/3, 9), @stack[0])

El comando cogstop puede usarse para parar cada uno de los Cogs. Un ejemplo con cada parmetro
programado para que el objeto mantenga parpadeando el LED hasta que se repita un milln de veces.
Despus de 3 segundos de retraso el comando cogstop apagara cada Cog en intervalos de un segundo
usando el numero de Cog, as ninguno de los mtodos se cierra hasta ejecutarse un milln de veces.

Primera direccin RAM
no usada para la pila
del Cog 0
PUB LaunchBlinkCogs

cognew(Blink(4, clkfreq/3, 1_000_000), @stack[0])
waitcnt(clkfreq * 3 + cnt)
cogstop(1)
cogstop(2)
cogstop(3)

Con algunos trucos de indexacin, los Cogs pueden incluso iniciarse y apagarse con ciclos repeat.
Abajo se muestra un ejemplo que usa una variable local index en un ciclo repeat para definir los pins
E/S, un arreglo stack e identificacin de Cogs. Hace lo mismo que la versin modificada del mtodo
LaunchBlinkCogs. Note que la variable local index se declara con el smbolo de pipa. As
repeat index from 0 to 2 incrementa index cada vez que pasa por los tres comandos cognew.
Cuando index es 0 el parmetro de pin del mtodo Blink es 0 + 4, pasando 4 al parmetro de pin del
mtodo Blink. En la segunda vez index es 1, por lo que pin se convierte en 5, y la tercera vez pin es
6. Para la secuencia clkfreq de 3, 7, 11 con valores de index de 0, 1, y 2 (index * 4) + 3 llena la
ecuacin. Para 0, 10 y 20 como elemento de arreglo, index * 10 completa la ecuacin. Para detener
los Cogs 1, 2 y 3 el segundo ciclo repeat cambia index de 1 a 3. La primera vez es index es 1 as que
se cogstop(index) se convierte en cogstop(1). La segunda vez index es 2, as cogstop(2), y la
tercera vez index es 3 resultando en cogstop(3).

PUB LaunchBlinkCogs | index

repeat index from 0 to 2
cognew(Blink(index + 4, clkfreq/((index*4) + 3), 1_000_000), @stack[index * 10])


cogstop(index)

3 Pruebe las versiones modificadas de los mtodos LaunchBlinkCogs.

Los objetos pueden escribirse para monitorear que Cog se est ejecutando en un cierto mtodo. Un
avance es discutido en la seccin Indexacin de Identificaciones de Cogs en la pgina 78. Otros
avances se mostraran en futuras prcticas de objetos.
Cunto espacio de Pila para iniciar un Mtodo en un Cog?
Abajo se muestra una lista del numero longs de que cada mtodo agrega a su pila cuando se llama.

2 direcciones de regreso
1 regreso de resultado
Numero de parmetros del mtodo
Numero de variables locales
Espacio de trabajo para expresiones de clculo intermedias

Asuma que tiene un objeto con tres mtodos: A, B y C. Cuando el mtodo A llama al mtodo B la pila
crecer conteniendo dos grupos de longs, uno para el mtodo A y otro para el mtodo B. Si el mtodo B
llama al mtodo C habr un tercero. Cuando el mtodo C regresa la pila se reducir a dos grupos.

El rea de trabajo es para almacenar valores que existen durante ciertas tareas y evaluaciones de
expresiones. Por ejemplo el mtodo de Blink repeat reps * 2 usa el rea de trabajo de dos formas.
La primera en la expresin reps * 2 empuja dos elementos a la pila: el valor almacenado por reps y
2. Despus del clculo * el 2 sale de la pila y el resultado del clculo se almacena en un elemento
sencillo. Este elemento se queda en la pila hasta que se termina el ciclo repeat. Dentro del ciclo
repeat reps * 2 ocurren dos expansiones y contracciones similares de la pila con
waitcnt(rate/2 + cnt), el primero con rate/2 y nuevamente cuando el resultado de rate/2 se
suma a cnt.

En el caso del mtodo Blink lo ms que usa de rea de trabajo y clculos de expresiones intermedias
es 3 longs: uno para detener el resultado de reps * 2 hasta que el ciclo repeat se completa, y dos ms
para los diversos clculos con operadores binarios como multiplicar (*) y dividir (/). Conociendo esto
podemos verificar el nmero de variables long que el Cog necesita en la pila para ejecutar el mtodo
listado abajo. As el total de espacio de pila (ej., nmero de variables long) que necesita un Cog para
ejecutar el mtodo Blink es 10.

2 Regresos de direcciones
1 Resultado variable (cada mtodo tiene esto incluido, aun cuando no se especifica un valor
de regreso. (Esto se analizara en la siguiente seccin)
3 Parmetros pin, freq, y reps
1 Variable local time
3 reas de espacio para clculo.
------------------------------------------------
10 Total

Como se menciono anteriormente un Cog necesita suficiente espacio para toda la memoria que puede
usar junto con el espacio de pila que cualquier mtodo llama. Algunos mtodos tendrn llamadas de
mtodos anidados donde un mtodo A llama a un mtodo B que a su vez llama un mtodo C. Todos
esos mtodos necesitan memoria de pila asignada si el mtodo A es el que se inicio en el Cog.

L
Errar en el lado de la precaucin: La mejor forma de asignar espacio de pila para el Cog que inicia un
mtodo Spin es tener precaucin y declarar mucho ms memoria de lo que piensa que necesitara. As usted
puede usar un objeto en la librera de la herramienta Propeller (la carpeta donde se localiza el archivo
Propeller.exe) que se llama Stack Length.spin para encontrar cuantas variables esta actualmente usando el
mtodo. La prctica de objetos revisara un proyecto que usa el objeto Stack Length para verificar el nmero
de variables Long requeridas por un mtodo Spin que se inicia en un Cog.

Declarar un arreglo variable long llamado stack en un bloque de cdigo de objeto VAR es una forma
de asignar extra RAM para el Cog que correr el interprete Spin. El nombre del arreglo no tiene que
ser stack; solo tiene que ser un nombre que el lenguaje Spin pueda usar como nombre de variable.
Los nombres blinkStack o methodStack tambin funcionan, siempre y cuando el nombre que se
escoge es aquel cuya direccin se pasa al Cog por el comando cognew. Recuerde que el operador @ a
la izquierda del nombre de variable es el que especifica la direccin RAM de la variable global.

L
Acerca de _STACK: El lenguaje Spin tiene tambin una constante _stack opcional que puede usarse en un
bloque CON. Es una constante programable de una sola vez para especificar el espacio de pila de la
aplicacin. Lea ms acerca de esto en la seccin de referencia de Lenguaje Spin en el manual del Propeller.
Llamada de Mtodo y el Resultado Variable
Cada mtodo pblico y privado tiene integrada una local variable predefinida llamada result. Cada
vez que se llama un mtodo su result variable se inicializa a cero. Luego, el valor de result puede
definirse por el cdigo en el mtodo. Cuando ese mtodo termina de ejecutarse se regresa el valor
actual de result. A este punto esa llamada de mtodo puede usarse como un valor (siendo el valor de
result) en expresiones. Cuando una llamada de mtodo aparece en una expresin el mtodo se
ejecuta para obtener el valor de result antes de que la expresin es evaluada.

L
Acerca de llamada de mtodo en Expresiones: Una llamada de mtodo puede usarse en expresiones al
igual que un valor, incluyendo condiciones, comparaciones y operadores normales. Sin embargo esto excluye
operaciones que intentan cambiarlo. Por lo tanto una llamada a mtodo no puede usarse con operadores de
asignacin unarios o como operando objetivo del lado izquierdo de n operador de asignacin binario.

Una forma prctica de usar esta caracterstica nos permite tomar un valor definido por un proceso en
un mtodo y tenerlo disponible para uso por otros mtodos. Nuestro ejemplo ButtonBlink.spin usa
tres mtodos para demostrar Main, Blink, y ButtonTime. En esta aplicacin presionando y soltando un
botn en P23 har que un LED en P4 parpadee 10 veces (usando el mtodo Blink) y la frecuencia se
determina por cunto tiempo se presiona el botn usando el mtodo ButtonTime.

Figura 5-6: Usando un Resultado de Mtodo Variable

Observe la Figura 5-6. el mtodo Main de ButtonBlink declara solo una variable, time. Contiene solo
dos llamadas de mtodos en el ciclo repeat. En el primero ButtonTime(23) llama al mtodo
ButtonTime y pasa el valor 23 a su parmetro pin (Paso 1). El cdigo en ButtonTime define el valor de
su variable result, la cual representa que tanto tiempo se presiono P23. Este valor se regresa al punto
de la llamada de mtodo (Paso 2). La expresin time := ButtonTime(23) asigna el valor regresado
por la llamada de mtodo ButtonTime a la variable time del mtodo Main (Paso 3). Luego time est
listo para usarse en la siguiente llamada de mtodo Blink (4, time, 10) (Paso 4) como el valor a
pasar al parmetro rate del mtodo Blink (Paso 5).

3 Cargue ButtonBlinkTime en el chip Propeller.
'' ButtonBlink.spin

PUB Main | time

Repeat

time := ButtonTime(23)
Blink(4, time, 10)

PUB Blink(pin, rate, reps)

dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]

PUB ButtonTime(pin) | t1, t2

repeat until ina[pin]
t1 := cnt
repeat while ina[pin]
t2 := cnt
result := t2 - t1
(Paso 1) La llamada
de mtodo
ButtonTime pasa 23
al parmetro pin
de ButtonTime
(Paso 2) El mtodo
ButtonTime define la
variable result y
regresa este valor a la
llamada de mtodo
(Paso 3) El resultado
del mtodo ButtonTime
se asigna a la variable
time del mtodo
principal
(Paso 4) time se usa en
lallamada a mtodo
Blink
(Paso 5) El mtodo
Blink recive time como
valor a usar en su
parmetro rate
3 Presione y suelte el botn y observe que el LED parpadea 10 veces a una frecuencia
determinada por el tiempo que se sostiene el botn.
3 Despus de que el LED termina de parpadear presione y suelte el botn en un tiempo
diferente.
3 Intente varios tiempos desde presionar y soltar rpidamente hasta presionar por varios
segundos.
Especificando Valores de Regreso
Declaraciones de mtodos pblicos y privados ofrecen la opcion de nombrar el valor de regreso
(Definiciones en el Manual Propeller Rvalue en el PUB y Sintaxis PRI). Cuando se especifica un valor
de regreso solo proporciona un alias a la variable result del mtodo. Este nombre alias es practico
especialmente para documentar el cdigo pero no es requerido.

A continuacin hay una versin modificada del mtodo ButtonTime que demuestra cmo se puede
usar regresar un valor en vez de una variable result. Aqu se agrego :dt a la declaracin del mtodo
y en la ltima lnea ahora dice dt := t2 t1en vez de result := t2 t1. Tenga en mente que dt
es solo un alias de la variable local result. As desde el punto de vista de la llamada de mtodo este
mtodo aun funciona idnticamente que el objeto original ButtonBlink.

PUB ButtonTime(pin) : dt | t1, t2 ' Alias opcional especificado para el valor de
regreso

t1 := cnt
t2 := cnt
dt := t2 - t1 ' Automticamente se regresa el valor almacenado por dt

3 Haga una copia del objeto ButtonBlink en un nuevo tabulador.
3 Substituya esta versin modificada del mtodo ButtonTime en la copia del objeto ButtonBlink
y verifique que trabaja igual.
3 Utilice el sumario y vistas de documentacin para comparar los dos objetos

En la versin modificada de ButtonBlink usted debe ver el valor de regreso dt incluido en el sumario
y la vista de documentacin. Hacer un hbito en definir valores de regreso cuando se declaran
mtodos que pueden llamarse dentro de la expresin har ms fcil entender y reusar sus objetos.
Indexando Identificacin del Cog
Como se menciono anteriormente los objetos no pueden predecir necesariamente cual Cog ser
iniciado en un mtodo. El comando cognew regresa la identificacin del Cog donde se ejecuta un
mtodo. Cada vez que un mtodo se inicia en un Cog nuevo la identificacin del Cog que regresa el
comando cognew puede almacenarse en una variable. Esto hace posible rastrear que hace cada Cog.

El objeto CogStartStopWithButton demuestra como rastrear los Cogs con un arreglo variable en una
aplicacin que inicia un Nuevo Cog cada vez que el botn se presiona y se suelta. Usa el mismo
mtodo ButtonTime del objeto ejemplo anterior para medir el tiempo que el botn se presiono. Luego
inicia el mtodo Blink en un nuevo Cog con la medida time determinando la frecuencia de parpadeo.
El resultado es una aplicacin donde cada vez que se presiona y se sultale botn otro LED comienza
a parpadear a la frecuencia que coincide con el tiempo que se presiono el botn. Despus de seis
veces que se presiona/suelta las siguientes seis veces apagaran los Cogs en sentido contrario. Como el
arranque y paro esta anidado en un ciclo repeat sin condiciones cuando se presione el botn P23 13
veces el ciclo comenzara con el mismo efecto que el de la primera vez.
3 Cargue CogStartStopWithButton.spin en el chip Propeller y use el botn P23 para iniciar el
mtodo Blink en los otros seis Cogs.
3 Presione por diversos tiempos para que el LED obviamente parpadee a diferente frecuencia
3 Asegrese de presionar/soltar el botn P23 al menos 12 veces para iniciar y despus apagar
los Cogs del 1 al 7.

'' Archivo: CogStartStopWithButton.spin
'' Inicia mtodos en Cogs y detiene Cogs en las estructuras de ciclo que
'' avanzan por pulsacin de botn

VAR

long stack[60]

PUB ButtonBlinkTime | time, index, cog[6]

repeat

cog[index] := cognew(Blink(index + 4, time, 1_000_000), @stack[index * 10])

ButtonTime(23)
cogstop(cog[index])


dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]

PUB ButtonTime(pin) : delta | time1, time2

repeat until ina[pin] == 1
time1 := cnt
time2 := cnt
delta := time2 - time1

Dentro de ButtonBlinkTime
El mtodo ButtonBlinkTime del objeto CogStartStopWithButton se declara con ocho variables
locales: time, index, y un arreglo llamado cog con seis elementos. El comando repeat bajo la
declaracin del mtodo repite el resto de los comandos en el mtodo ya que estn indentados. Debido
a que este comando repeat no tiene condiciones el resto de los comandos en el mtodo se repiten
indefinidamente.

PUB ButtonBlinkTime | time, index, cog[6]

repeat

El primer ciclo anidado repeat incrementa la variable index de 0 a 5 cada vez. El primer comando
que repite es time := ButtonTime(23), el cual tiene un nuevo lapso de tiempo por la presin del botn
cada vez que se llama. La siguiente lnea cog[index] := cognew inicia Blink(index + 4, time,
1_000_000) en un nuevo Cog. El comando cognew regresa el numero de Cog, el cual se almacena en
cog[index]. La primera vez index es igual a 0 as el comando se hace cog[0] := cognew(Blink(4,
time, 1_000_000), @stack[0]). La segunda vez cog[1] := cognew(Blink(5, time, 1_000_000),
@stack[10]). La tercera cog[2] := cognew(Blink(6, time, 1_000_000), @stack[20]), y as
sucesivamente. As cog[0], cog[1], hasta cog[5], cada uno almacena la identificacin del Cog para
cada Cog en la cual se inician diferentes versiones de Blink.

cog[index] := cognew(Blink(index + 4, time, 1_000_000), @stack[index * 10])

Despus de presionar/soltar seis veces entra a este ciclo repeat. Observe como se llama al mtodo
ButtonTime, pero su valor de regreso no se almacena en la variable time. Eso es porque el mtodo se
usa nicamente para esperar por la siguiente vez que se presiona/suelta el botn para poder apagar el
siguiente Cog. Como no se hace nada con su valor de regreso entonces no necesita almacenarse en la
variable time. Este ciclo repeat va de 5 a 0. La primera vez que hace el ciclo apagara el Cog que
tiene su identificacin almacenada en cog[5]. La segunda vez apagara el Cog con la identificacin en
cog[4], y as sucesivamente hasta el cog[0],.

ButtonTime(23)
cogstop(cog[index])

Tiempo de Estudio
Preguntas
1) Qu sucede si un mtodo que fue llamado se queda sin comandos?
2) Cuntos parmetros se pueden pasar a un mtodo?
3) Cuntos valores tiene un regreso de mtodo?
4) Cmo se determina el valor que regresa un mtodo?
5) Cuales dos argumentos necesita cognew para iniciar un mtodo en un nuevo cog?
6) Cul es la diferencia entre la Pila del Cog 0 y las pilas de otros Cogs?
7) Cul es la diferencia entre cognew y coginit?
8) Cmo puede detener un Cog?
9) Cuando se llama un mtodo que valores se copian a la pila del Cog?
10) Qu puede suceder en la pila conforme se ejecutan los comandos en un mtodo?
11) Qu le pasa a la Pila durante las llamadas de mtodos anidados?
12) Cul es la mejor forma de evitar problemas con la pila cuando estas iniciando un mtodo
prototipo que corre en un Cog?
13) Qu caracterstica del comando cognew hace posible que el programa pueda rastrear que
proceso est corriendo en un Cog?
14) Es posible iniciar Cogs sucesivos en un ciclo?
Ejercicios
1) Escriba una declaracin pblica para un mtodo de nombre SquareWave que espera
parmetros de nombre pin, tHigh, y tCycle, regresa success y tiene variables locales tC and
tH.
2) Escriba una llamada al mtodo del ejercicio #1. Programe el Pin a 24, el tiempo en alto de
1/2000 de la frecuencia del sistema de reloj y el tiempo de ciclo 1/100 de la frecuencia del
reloj. Almacene el resultado en una variable de nombre yesNo.
3) Aparte 40 nombres long en un Cog separado de nombre swStack para prototipo del mtodo
SquareWave.
4) Declare una variable de nombre para almacenar la identificacin del Cog donde se corre el
mtodo SquareWave.
5) Inicie el mtodo SquareWave en un Cog Nuevo y almacene la identificacin del Cog en la
variable swCog con la direccin de arranque de la variable swStack.
6) Corra el mtodo SquareWave en el Cog 5.
7) Modifique la declaracin de la variable swStack para iniciar tres copias del mtodo
SquareWave en Cogs separados. Recuerde esto es para prototipo y el espacio de pila no
requerida ser acomodado despus (En la prctica de objetos)
8) Modifique la declaracin de la variable swCog para almacenar tres identificaciones de Cogs
diferentes,
9) Inicie tres copias del mtodo SquareWave en Cogs separados. Aqu hay una lista de
parmetros para cada mtodo SquareWave: (1) 5, clkfreq/20, clkfreq/10, (2) 6,
clkfreq/100, clkfreq/5, (3) 9, clkfreq/1000, clkfreq/2000.
Proyectos
1) Haga el prototipo del mtodo SquareWave descrito en la seccin de ejercicios. Asegrese de
incorporar las tcnicas de cdigo para prevenir inexactitudes debido al tiempo de ejecucin
de comandos de los cuales se hablo en la prctica de E/S y tiempo. (Tenga en cuenta que hay
mejores formas de desarrollar ondas cuadradas que sern revisadas en prcticas de
Contadores y Lenguaje Ensamblador)
2) Escriba un programa para probar el mtodo SquareWave usando diversas caractersticas de la
seccin de ejercicios.
3) Ms experimentos: Quiz haya notado que el Pin 9 brilla poco. Si usted decrementa el
trmino tHigh incrementando el denominador ser ms bajo. Si incrementa el trmino tHigh
decrementando el denominador entonces brillara mas. Asegrese que tHigh es ms pequeo
que tCycle, de otra forma el programa no trabajara como se pretende. Intntelo.


6: Prctica de Objetos
6: Practica de Objetos
Introduccin
En prcticas anteriores todas las aplicaciones de ejemplos de cdigo eran para objetos individuales.
Sin embargo las aplicaciones son organizadas en colecciones de objetos. Cada aplicacin tiene un
objeto superior, el cual es donde se inicia la ejecucin del cdigo. Los objetos superiores pueden
declarar y llamar a mtodos en uno o ms objetos. Esos objetos pueden en su turno declarar y llamar
mtodos en otros objetos y as sucesivamente

Muchos objetos son incorporados en aplicaciones diseadas para simplificar desarrollos. Algunos de
estos objetos son colecciones de mtodos prcticos que han sido publicados por lo que tareas
comunes de cdigo no tiene que ser hechas desde el principio. Otros objetos administran procesos que
son iniciados en Cogs. Estos usualmente cubren las tareas observadas en la prctica de mtodos y
Cogs, incluyendo declaracin de valores de pila y rastreo de en que cog se inicio el proceso. Estos
objetos que administran Cogs tambin tienen mtodos de arranque y paro de procesos.

Hay diferentes fuentes donde puede obtener objetos tiles que pueden ser incorporados en su
aplicacin, incluyendo la librera de la herramienta Propeller. El intercambio e objetos en
obex.parallax.com y el foro del chip Propeller en los foros forums.parallax.com. Cada objeto tiene
documentacin tpicamente que explica como incorporarlo en su aplicacin junto con uno o ms
ejemplos de archivos superiores que demuestran como declarar el objeto y llamar su mtodo. Adems
de usar los objetos pre-escritos usted querr modificar un objeto existente para usarlo de acuerdo a su
aplicacin o incluso escribir un objeto particular. Si usted escribe un objeto que soluciona un
problema o desarrolla una tarea que no est disponible en otro lado considere publicarla en el
Intercambio de Objetos Propeller.

Esta prctica lo gua a travs de escrituras de varios objetos y la incorporacin de ellos es sus
aplicaciones. Algunos objetos son solo colecciones de mtodos tiles mientras que otros administran
procesos iniciados en Cogs. Algunos de los objetos sern escritos desde el principio y otros usaran la
librera Propeller como recurso. Los ejemplos de aplicaciones lo guiara a travs de:

Llamar mtodos en otros objetos
Usar objetos que inician procesos en Cogs
Escribir cdigo que llama un mtodo de un objeto basado en su documentacin
Escribir documentacin de objetos y esquemticos
Usar objetos de la Librera Propeller de Objetos
Accesar valores y variables por su direccin de memoria
Usar objetos para iniciar Cogs que leen y/o actualizan las variables de los objetos padre
Prerrequisitos para la Practica
Configuracin y Prueba
E/S y Tiempo
Mtodos y Cogs
Prctica de Objetos
Equipo, Partes y Esquemas
Aun cuando el circuito es el mismo que se uso en prcticas anteriores hay algunos cambios. Primero,
el esquemtico mostrado en la Figura 6-1 se dibujo usando la fuente Parallax y la tabla de caracteres
de la herramienta Propeller, lo cual es un importante componente en la documentacin de objetos.
Segundo, algunos de los ejemplos de cdigo le permiten monitorear y controlar elementos del
circuito desde su PC con el programa incluido en esta prctica que se llama Terminal Serial Parallax
(PST.exe). Las aplicaciones Propeller que se comunican serialmente con la Terminal Serial Parallax
lo harn con la ayuda de un objeto llamado FullDuplexSerial.spin.

3 Usted puede accesar la tabla de caracteres presionando Help y seleccionando View Character
Chart.

Figura 6-1: Esquemtico (Dibujado con el Programa de la Herramienta Propeller)

Revisin de la llamada a mtodo
El objeto ButtonBlink de abajo es un ejemplo de la prctica de Mtodos y Cogs. Cada vez que
presiona y suelta el botn conectado a P23 el objeto mide el tiempo aproximado que se presiono y usa
este valor para determinar el periodo completo de encendido/apagado, despus el LED parpadea diez
veces. (El botn de eliminacin de rebotes no se requiere con los botones del PE kit). El objeto
cumple estas tareas llamando otros mtodos en el mismo objeto. El cdigo en el mtodo Main llama al
mtodo ButtonTime para medir el tiempo que se presiono el botn. Cuando ButtonTime regresa un
valor el mtodo Blink se llama, con uno de los parmetros siendo el resultado de la medicin de
ButtonTime.

3 Cargue ButtonBlink.spin en el chip Propeller y prubelo para asegurarse que puede usar el
botn en P23 para programar el periodo de parpadeo del LED

'' ButtonBlink.spin

PUB Main | time

Repeat

Blink(4, time, 10)


dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]

PUB ButtonTime(pin) : dt | t1, t2

t1 := cnt
t2 := cnt
dt := t2 - t1

Llamando Mtodos en otros Objetos con la Notacin Dot
Los mtodos ButtonTime y Blink del objeto ButtonBlink nos dan un ejemplo simple del cdigo que
puede ser til en diferentes aplicaciones. Estos mtodos pueden almacenarse en archivos objetos
separados y despus cualquier objeto que lo necesite para hacer parpadear un LED o medir una
pulsacin de un botn puede accesar estos mtodos siguiendo estos dos pasos:

1) Declarar el objeto en un cdigo de bloque OBJ, y dar un apodo al archivo del objeto.
2) Use ObjectNickname.MethodName para llamar al mtodo del objeto.

L
Lo que se llama Notacin Dot aqu se refiere como referencia mtodo-objeto en el Manual Propeller.

Prctica de Objetos
La Figura 6-2 muestra un ejemplo de cmo funciona. Los mtodos ButtonTime y Blink se movieron a
un objeto llamado ButtonAndBlink. Para tener acceso a los mtodos pblicos del objeto
ButtonAndBlink el objeto DotNotationExample tiene que empezar declarando el objeto
ButtonAndBlink y darle un apodo. Estas declaraciones de objetos se hacen en el cdigo de bloque OBJ
del objeto DotNotationExample. La declaracin PbLed : "ButtonAndBlink" le da un apodo PbLed al
objeto ButtonAndBlink.

La declaracin PbLed hace posible para el objeto DotNotationExample llamar mtodos en el objeto
ButtonAndBlink usando la notacin ApodoObjeto.Nombre Mtodo. As DotNotationExample usa
time := PbLed.ButtonTime(23) para llamar el mtodo ButtonTime de ButtonAndBlink, pasa el
parmetro 23 y asigna el resultado regresado a la variable time. DotNotationExample tambin usa el
comando PbLed.Blink(4, time, 20) para pasar 4, el valor almacenado en la variable time y 20 al
mtodo Blink de ButtonAndBlink.

L
Ubicacin de archivos: Un objeto tiene que estar ya sea en el mismo archivo con el objeto que lo est
declarando o en el mismo archivo que el archivo Propeller Tool.exe. Los objetos almacenados con la
herramienta Propeller comnmente se refiere como librera de objetos.

Figura 6-2: Llamando Mtodos en otros Objetos con la Notacin Dot

3 Cargue el objeto DotNotationExample en el chip Propeller. Si usted est ingresando el cdigo
manualmente asegrese que ambos archivos estn en el mismo directorio. Tambin el nombre
del archivo del objeto ButtonAndBlink debe ser ButtonAndBlink.spin.
3 Verifique que el programa hace lo mismo que el objeto del ejemplo anterior (ButtonBlink).
3 Siga los pasos en la Figura 5-4 y asegrese que est claro como ButtonAndBlink obtiene un
apodo en la seccin OBJ y como se usa ese apodo por DotNotationExample para la llamada de
mtodo en el objeto ButtonAndBlink.
3 Compare DotNotationExample.spin con el objeto ejemplo anterior (ButtonBlink).
Organizacin de Objetos
Los objetos pueden declarar objetos que pueden a su vez declarar otros objetos. Es importante
examinar las relaciones entre objetos padres con sus hijos, nietos y as sucesivamente. Hay un par de
formas para examinar esos rboles familiares de objetos. Primero vamos a ver las relaciones en la
ventana de Informacin del Objeto con la caracterstica Compilar de la Herramienta Propeller:
'' Archivo: ButtonAndBlink.spin
'' Objeto Ejemplo con dos metodos
PUB ButtonTime(pin): delta | time1, time2

time1 := cnt
time2 := cnt


dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]
'File: DotNotationExample.spin

OBJ

PbLed : "ButtonAndBlink"

PUB Main | time

repeat

time := PbLed.ButtonTime(23)

PbLed.Blink(4, time, 20)

Llamada a mtodo con
ApodoObjeto.NombreMetodo
Declaracion
de Objeto
3 En men Run de la herramienta Propeller seleccione Compile Current View Info (F8).

Observe que la cadena de comando se muestra en la ventana de la informacin del objeto en la
esquina superior izquierda. En esta ventana puede hacer click en cada carpeta para ver cuanta
memoria ocupa en la memoria RAM global. Tambin puede presionar dos veces en la carpeta para
abrir el archive Spin que contiene el cdigo. Como la aplicacin DotNotationExample declaro a
ButtonAndBlink el cdigo ButtonAndBlink ahora es parte de DotNotationExample por lo que este
parece tener ms cdigo que ButtonAndBlink en la ventana de informacin, aun cuando tiene mucho
menos cdigo escrito.

Figura 6-3: Ventana de Informacin del Objeto

Despus de cerrar la ventana de informacin la misma vista del objeto se podr ver en la esquina
izquierda superior de la herramienta Propeller (ver Figura 6-4). El objeto se puede abrir presionando
sobre l. Tambin puede ver un objeto en modo de documentacin al presionar el botn derecho del
ratn sobre la carpeta. Puede presionar el botn izquierdo para regresar al modo de vista completa.

Figura 6-4: Herramienta Propeller con Vista del Objeto (Ventana Superior Izquierda)

Prctica de Objetos
Objetos que pueden iniciar Procesos en Cogs
En la prctica de mtodos nos tomo varios pasos para escribir un programa que inicia un mtodo en
un Cog. En primer lugar tenan que declararse variables adicionales para darle al Co su memoria de
pila y rastrear cual Cog corra un proceso antes de poder usar los comandos cognew o cogstart.
Tambin se requera una variable que almacena la identificacin de los Cogs para escoger el Cog
apropiado por si el programa tena que parar un proceso despus de iniciarlo. Los objetos que inician
procesos en los Cogs pueden cuidar todos los detalles por usted. Por ejemplo tenemos un objeto
superior que declara dos hijos de nombre Button y Blinker. El objeto Blinker tiene un mtodo Start
que inicializa el mtodo Blink en un Cog nuevo y todas las variables que las acompaa. De esta
forma todo lo que tiene que hacer el objeto superior es llamar al mtodo Start del objeto Blinker.

{{
Archivo superior: CogObjectExample.spin
Parpadea un LED 20 veces. El periodo de parpadeo del LED se determina
Por qu tanto tiempo se presiono el botn en P23
}}

OBJ

Blinker : "Blinker"
Button : "Button"

PUB ButtonBlinkTime | time

repeat

time := Button.Time(23)
Blinker.Start(4, time, 20)

A diferencia del objeto DotNotationExample usted no tendr que esperar a que el LED parpadee 20
veces antes de presionar el botn nuevamente para cambiar el periodo (para las siguientes 20 veces).
Hay dos razones. La primera porque el objeto Blinker automticamente inicia el proceso de parpadeo
del LED en un Cog nuevo. Esto libera al Cog 0 para que siga monitoreando el botn mientras que el
Cog 1 hace parpadear el LED. La segunda el mtodo Start del objeto Blinker automticamente para
cualquier proceso que este corriendo antes de iniciar uno nuevo. De esta forma tan pronto como se
toma el tiempo con Button.Time(23) el mtodo Blinker.Start para cualquier proceso (Cog) que
pudiera estar corriendo antes de iniciar el nuevo proceso.

3 Si est usando archivos .spin pre-escritos disponibles para este texto (ver la pagina 17) todos
estn en la misma carpeta. Si usted est escribiendo el cdigo asegrese de guardar los tres
archivos en la misma carpeta. Los objetos que tiene que guardar son CogObjectExample
(arriba), Blinker, y Button (ambos abajo).
3 Cargue CogObjectExample en el chip Propeller.
3 Intente presionar y soltar el botn en P23 para que haga parpadear el LED despacio.
3 Antes del parpadeo 20 presione y suelte rpidamente el botn en P23. El LED deber
parpadear ms rpido inmediatamente.
Dentro del Objeto Blinker
Construir cloques de objetos que inician procesos en Cogs se escriben tpicamente para cuidar la
mayora de los detalles de grabacin del Cog. Todos los objetos padres es declarar el objeto y luego
inicializar el objeto llamando el mtodo Start del objeto o detenerlo llamando el mtodo Stop. Por
ejemplo el objeto Blinker, mostrado abajo, tiene el arreglo de variables necesarias en la pila del Cog
para las operaciones mientras se ejecuta el mtodo Blink en otro Cog. Tambin tiene una variable
llamada cog para mantener el historial de en cual Cog se inicio el mtodo Blink.

El objeto Blinker tiene los mtodos Start y Stop para iniciar el ahora mtodo familiar Blink en un
nuevo Cog y detenerlo nuevamente. Cuando el mtodo Start inicia el mtodo Blink en un nuevo Cog
toma la identificacin del Cog que regresa cognew, agrega 1 y copia el valor del resultado en la
variable cog. El valor que regresa el mtodo Start en la variable success tambin es cog ID + 1 el
cual el objeto padre trata como un valor booleano. Al final como este valor es no-cero significa que el
proceso se inicio con xito. Si el valor es cero significa que el Cog no se inicializo. Esto sucede
tpicamente cuando los ocho Cogs del chip Propeller estn en uso. El mtodo Stop del objeto Blinker.
Spin puede llamarse para detener el proceso. Cuando se llama usa el valor almacenado en la variable
cog (menos 1) para obtener la identificacin correcta del Cog que detendr el Cog donde el mtodo
Start inicio el mtodo Blink.

{{ Archivo: Blinker. Spin
Ejemplo de administracin del Cog para el proceso de parpadeo de LED.
SCHEMATIC

100 LED
pin -/|!
~
GND

}}
VAR
long stack[10] 'Espacio de Pila del Cog
byte cog 'Identificacin del Cog

PUB Start(pin, rate, reps) : success
{{Inicia nuevo proceso blinking en Cog Nuevo; regresa True si tiene xito.
Parmetros:
pin La E/S conectada al circuito LED ver esquemtico
rate Ciclo encendido/apagado definido por el numero de ciclos de reloj
reps El numero de ciclos de encendido/apagado
}}
Stop
success := (cog := cognew(Blink(pin, rate, reps), @stack) + 1)

PUB Stop
''Detiene el proceso blinking, si existe.

if cog
cogstop(cog~ - 1)

{{Parpadea un circuito LED conectado al pin a una frecuencia dada por reps.

Parmetros:
pin La E/S conectada al circuito LED ver esquemtico
rate Tiempo de ciclo de encendido/apagado definido por ciclo de reloj
reps el nmero de ciclos de encendido/apagado
}}
dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]
Prctica de Objetos
Los mtodos Start y Stop mostrados en este objeto es el alcance recomendado para objetos que
administran Cogs. La lista de parmetros del mtodo Start debera tener todos los parmetros que el
proceso necesita para iniciarse en un Cog. Note que esos valores se pasan al mtodo del objeto Blink
a travs de la llamada en el comando cognew.

Los mtodos Start y Stop se usan por convencin en objetos que inician procesos en nuevos Cogs.
Si est usando un objeto con mtodos Start y Stop puede esperar que el mtodo Start del objeto
inicie el proceso en un nuevo Cog por usted y que el mtodo Stop detenga el proceso y libere un Cog.
Si est escribiendo cdigo que depende de objetos construidos en bloques con mtodos Start y Stop
su principal problema ser llamar al mtodo Start desde un objeto padre y pasar los parmetros
correctos. Estos parmetros se explican en los comentarios de documentacin los cuales se revisaran
en la seccin de Comentarios de en la pgina 90.

Los mtodos Start y Stop tambin rastrean en cual Cog se inicio el proceso (el mtodo Blink en el
caso de Blinker. Spin). Si todos los Cogs estn en uso el mtodo Start regresa un 0; de otra forma
regresa la identificacin del Cog + 1 lo cual es un no-cero. Esto simplifica el trabajo del de verificar y
encontrar si el mtodo Start inicio correctamente el proceso en el nuevo Cog. Especialmente si el
objeto padre ha llamado a mtodos Start de otros objetos, todos los cogs del chip Propeller pueden
estar trabajando en otras tareas al mismo tiempo. Por ejemplo el objeto padre puede verificar si el
mtodo Start del objeto Blinker se desempeo correctamente como:

if Blinker.Start
'Inserte el cdigo si se inicio correctamente
else
'Inserte cdigo aqu si fallo la inicializacin

El cdigo indexado debajo de la sentencia if se ejecuta si Blinker.Start indica que se inicio
exitosamente el cog al regresar un no-cero. Si el mtodo Blinker.Start regresa un cero indica que no
fue posible iniciar el cog, lo cual puede suceder si todos los Cogs estn ocupados. En este caso el
cdigo debajo de la condicin else indentada se ejecutara.

Una prctica comn entre autores de bloques de objetos es copiar y pegar el ejemplo y Stop de los
mtodos del Manual Propeller o de este texto en los objetos que escriben. Despus ajustan la lista de
parmetros del mtodo Start y la documentacin necesaria. No solo hacen los ejemplos de los
mtodos Start y Stop de acuerdo a la convencin de los mtodos Start y Stop en la librera de
objetos discutidos en la pgina 90, ellos combinan la correcta contabilidad con valores de regreso no-
cero para indicar el progreso. Si est interesado en como ellos hacen esto ponga atencin a la
siguiente seccin. De otra forma brnquese la seccin El Objeto Button que empieza en la pagina 89.
rea Avanzada: Dentro de los mtodos Start y Stop
Cuando un mtodo Spin se inicia desde otro Cog, adems del arreglo de pila necesita declarar una
variable cog en el objeto Blinker. Esta variable global es accesible para todos los mtodos en el
objeto, as el mtodo Start puede almacenar un valor en esta variable que corresponde al Cog que fue
ejecutado, y el mtodo Stop puede accesar esta variable si necesita saber cual Cog detener.

VAR
long stack[10] 'Cog stack space
byte cog 'Cog ID

El comando cognew en el mtodo Start regresa la identificacin del Cog. El valor del Cog puede ser
de 0 a 7 si se inicia adecuadamente y -1 si falla al iniciar. Como -1 es un no-cero los mtodos Start y
Stop tienen que hacer ms trabajo de administracin para rastrear el numero de Cog que est
corriendo el proceso (en caso de que su cdigo decida parar despus) mientras aun regresa valores
que indican la inicializacin del Cog (no-cero) o el fallo de inicio (0).

En caso de que el objeto padre llame al mtodo Start dos veces seguidas sin llamar al mtodo Stop la
primer cosa que hace el mtodo Start es llamar al mtodo Stop. Despus el mtodo Start usa el
comando cognew para iniciar el mtodo Blink en un nuevo Cog. El comando cognew regresa el valor
del Cog o -1 si no hay Cogs disponibles. En la extrema derecha se suma 1 al valor de regreso cognew
y este valor se almacena en ambas variables cog y success. Recuerde que en este punto cog y success
almacenan la Identificacin de Cog + 1, lo cual es 0 si el mtodo Blink no se inicio en un Cog y un
no-cero si el comando cognew tuvo xito.

{{...}}
Stop
' | | |
' Cog ID (0 a 7) o -1 si fallo iniciar Cog
' Cog ID + 1 (1 a 8) o 0 (-1 + 1) Si fallo iniciar Cog
' Mismo valor del Cog, usado para que el objeto superior pueda usar el comando :

Lo primero que hizo el mtodo Start fue llamar al mtodo Stop. Recuerde: La variable del Cog
almacena 0 si su proceso (El mtodo Blink) no est corriendo en otro Cog, o Identificacin del Cog +
1 si el proceso de administracin del objeto esta activo. Si el Cog no se inicio o si el mtodo Stop se
llamo la variable cog almacenara un 0. En este caso se saltara el cdigo debajo de la condicin if y el
mtodo Stop regresara sin tomar otra accin. Si en vez de esto la variable cog almacena la
Identificacin + 1 la condicin if empieza restando 1 de la variable cog de esta forma regresamos al
valor de Identificacin del Cog. El comando cogstop usa este valor para detener el Cog adecuado, el
cual es el que se inicio por el mtodo Start en un tiempo anterior. La ltima cosa que el mtodo Stop
hace es usar el operador Post-Limpiar ~ para dejar Cog en cero para que todo funcione correctamente
la prxima vez que se llame a un mtodo Start o Stop.

Pub Stop
'' ...
' 0 si no se ha iniciado un cog por el mtodo start,
' | 1 a 8 si se inicio un Cog por el mtodo Start
if cog
cogStop(cog~ - 1)
' |
' Orden de operaciones:
' 1. cog (Cog ID + 1) - 1 = Cog ID.
' 2. Detiene el cog con el Cog ID.
El Objeto Button
CogObjectExample tambin usa el objeto Button el cual hasta el momento tiene solo un mtodo, pero
puede expandirse en una coleccin de mtodos tiles. Note que esta versin del objeto Button no
inicia ningn proceso nuevo en Cogs as que no tiene un mtodo Start o Stop. Todo lo que hace el
objeto Button se hace en el mismo Cog del objeto que lo llama. Este objeto podra modificarse en
diversas formas. Por ejemplo se podra agregar otro mtodo relacionado con botn. El objeto podra
modificarse para trabajar con un botn o grupo de botones. Podra agregarse un mtodo Init o Config
para programar el objeto y monitorear automticamente un botn o grupo de botones. El objeto
podra tambin modificarse para monitorear estos botones en un Cog separado, pero en ese caso se
deberan agregar los mtodos Start y Stop.

Prctica de Objetos
'' Archivo: Button.spin
'' Comienza un objeto til.

PUB Time(pin) : delta | time1, time2

time1 := cnt
time2 := cnt

Reglas para Mtodos Start y Stop en Libreras de Objetos
Si un objeto se disea como bloque de construccin para iniciar otros objetos en un Cog este deber
tener mtodos Start y Stop. El mtodo Start cuidara de iniciar el Cog. Si inicia un mtodo spin en un
Cog nuevo el mtodo Start usa el comando cognew para pasar la llamada a mtodo y la direccin de
la variable global del arreglo de pila del objeto al Cog. Tambin graba el Cog en el que el mtodo se
inicio con una de las variables globales del objeto, tpicamente un byte variable de nombre cog. El
mtodo Stop encuentra cual Cog necesita detenerse verificando la misma variable cog.

La regla del mtodo Start y Stop en objetos de construccin de bloques que inician Cogs fue
establecida por Parallax para mantener una lnea de usuario simple y consistente. Tambin ofrece al
diseador del objeto un lugar para cuidar del espacio de pila y numero de Cog para el objeto. Si usted
usa un objeto de la librera Parallax o del intercambio de Objetos Propeller que inicia un Cog, este
deber tener los mtodos Start y Stop que cuidan de estos detalles. As todo lo que sus aplicaciones
tienen que hacer es llamar al mtodo Start del objeto y pasar los parmetros que necesita. La librera
de objetos cuida de lo dems y debe proporcionar mtodos y comentarios de documentacin que
simplifiquen el monitoreo y control del proceso que est ocurriendo en el Cog que se inicio.

L
Nunca use cognew o coginit para iniciar un mtodo que est en otro objeto. Los comandos connew y
coginit solo pueden iniciarse en un mtodo spin en un nuevo cogsi est en el mismo objeto que el comando.
Esta es otra razn por la cual construir objetos de construccin de bloques que inician cogs deber contener
siempre los mtodos start y stop. El comando cognew se localiza en el mtodo start del objeto asegurndose
que est en el mismo objeto que el metodo que se iniciara en otro cog.

Muchos objetos tiles no necesitan iniciar un cog. Cuando el objeto padre llama a su mtodo solo
hacen algo til en el mismo cog. En algunos casos estos objetos tienen variables que necesitan ser
configuradas antes de que el objeto pueda proporcionar servicio. El nombre de mtodo recomendado
para configurar variables de objetos si no inicia un cog es Init o Config. No use el nombre de mtodo
start en este tipo de objetos porque podra llevarlo a pensar que inicia un cog. Del mismo modo no
use start como nombre de mtodo al principio del cdigo de su aplicacin. En su lugar utilice en
mtodo Go si nada ms descriptivo viene a su mente.
Comentarios de Documentacin
La Figura 6-5 muestra la primera parte del objeto Blinker desplegado en vista de documentacin. Para
ver el objeto en esta modalidad asegrese que est en el tabulador activo (presione el tabulador con el
nombre de archivo Blinker), despus presione el botn de radio Documentation justo arriba del
cdigo. Recuerde de la practica E/S y tiempo que una lnea sencilla de comentarios de documentacin
es precedida por dos apostrofes: ''comment, y que los comentarios de documentacin que ocupan ms
de una lnea se inician y terminan con dobles llaves: {{comments}}. De un vistazo a los comentarios
de documentacin en modo de fuente completa y comprelos con los comentarios en modo de
documentacin.
La vista en modo de documentacin agrega automticamente alguna informacin que est en los
comentarios de documentacin. Primero est la lnea de informacin del objeto, el cual es una lista de
las declaraciones del mtodo pblico del objeto incluyendo el nombre del mtodo, lista de parmetros
y valores de regreso. Esto le da al programador una vista d los mtodos del objeto. Con esto en mente
es importante escoger nombres descriptivos para un mtodo de objeto, parmetros de mtodo y
valores de regreso. El modo de documentacin tambin proporciona cuanta memoria agregara el
objeto a un programa y cuanto toma para las variables. Estas por supuesto son importantes para
caractersticas de vista rpida.

Figura 6-5: Vista de Documentacin

El modo de vista de documentacin tambin inserta cada declaracin de mtodo (sin variables locales
no se usan como parmetros o variables de regreso). Note como tambin aparecen los comentarios de
documentacin debajo de la declaracin del mtodo y lo que hace el mtodo, que informacin
debern recibir sus parmetros y que regresar. Cada documentacin de mtodo pblico deber tener
suficiente informacin para un programador sin tener que mover de regreso a la vista completa y
hacer ingenieria inversa al mtodo y tratar de adivinar que es lo que hace. Esta es otra buena razn
para escoger los nombres de mtodos y parmetros cuidadosamente ya que ayudara a hacer los
comentarios ms concisos. Con los comentarios de documentacin debajo de cada declaracin de
mtodo pblico explique qu hace el mtodo. Explique cada parmetro, empiece con su nombre e
incluya cualquier informacin adicional acerca de los valores que el parmetro tiene que recibir. Haga
lo mismo para valores de regreso.

3 Intente agregar un comentario de documentacin de bloque justo abajo del mtodo
ButtonBlinkTime del objeto CogObjectExample y verifique que la documentacin aparece
debajo de la declaracin del mtodo en el modo de vista de documentacin.

Figura 6-6: Mas vista de documentacin

Prctica de Objetos
Dibujando esquemticos
La fuente Parallax tiene smbolos para dibujar esquemticos y debern usarse para documentar los
circuitos para los que los objetos fueron diseados. La herramienta de caracteres se muestra en la
Figura 6-7. Adems de los smbolos para dibujar esquemticos tiene smbolos para diagramas de
tiempo )`{{`, operadores matemticos + - = , y smbolos griegos para
cantidades y medidas .

3 Presione Help y seleccione View Character Chart.
3 Presione el botn symbolic Order
3 Coloque el curso en un rea de comentario en el objeto
3 Presione varios caracteres en la grafica y observe que aparecen en el objeto.

Figura 6-7: Herramienta
Propeller Mapa de
Caracteres

Los archivos que involucran circuitos debern tener esquemticos para que tambin el circuito pueda
hacerse y probarse. Por ejemplo el esquemtico mostrado en la Figura 6-8 puede agregarse para
CogObjectExample. El botn puede ser engaoso. La grafica que se muestra en la Figura 6-8,
muestra el orden regular (presione el botn Standard Order). En este orden el carcter 0 es el superior
izquierdo, carcter 1 el siguiente y as sucesivamente hasta llegar al carcter 255 en la inferior
derecha. Esta es una lista de los caracteres que necesitara:

Botn: 19, 23, 24, 27, 144, 145, 152, 186, 188
LED: 19, 24, 36, 144, 145, 158, 166, 168, 169, 189, 190

3 Intente agregar el esquemtico mostrado en la Figura 6-8 a su copia de CogObjectExample.


Figura 6-8: Dibujando
esquemticos con el
mapa de caracteres

Mtodos Pblicos vs. Privados
El objeto Blinker est escrito para que su objeto padre pueda llamar al mtodo Start o Blink. Para
este objeto particular es til porque hay veces que el programador puede no querer permitir que el
parpadeo de 20 LED se interrumpa. En este caso en vez de llamar al mtodo Start el objeto padre
llama al mtodo Blink directamente.

3 Modifique una copia de CogObjectExample para que llame al mtodo Blink del objeto
Blinker en vez del mtodo Start.

La versin modificada no lo dejara interrumpir el parpadeo del LED para reiniciar una nueva
frecuencia. Esto porque todo el cdigo se ejecuta en el mismo Cog mientras que la versin no
modificada le permite llamar al mtodo Start en cualquier momento ya que el parpadeo del LED
sucede en otro Cog. As mientras el Cog est ocupado parpadeando el LED no se monitorea el botn.

Algunos objetos se escriben para tener mtodos pblicos (PUB) que pueden llamarse por otros objetos
y mtodos privados (PRI) que solo pueden llamarse por otro mtodo en el mismo objeto. Los mtodos
privados tienden a ser los que ayudan al objeto a hacer su trabajo, pero no son hechos para llamarse
por otros objetos. Por ejemplo algunas veces una tarea compleja se separa en diversos mtodos. Un
mtodo pblico puede recibir parmetros y luego llamar mtodos privados en una cierta secuencia.
Especialmente si llamando a esos mtodos en la secuencia incorrecta podra llevar a resultados
indeseables, esos otros mtodos deberan ser privados.
Prctica de Objetos
Con el mtodo Blink del objeto Blinker no hay razn actual para hacerlo privado fuera de examinar
que sucede cuando un objeto padre intenta llamar otro mtodo privado de objeto.

3 Cambie el mtodo Blink del objeto Blinker de PUB a PRI.
3 Intente correr la copia modificada de CogObjectExample y observe los mensajes de error.
Esto demuestra que el mtodo Blink no puede accesarse por otro objeto ya que es privado.
3 Corra la copia no modificada (la cual solo llama al mtodo publico Start, no al mtodo
privado Blink) y verifique que aun trabaja apropiadamente. Esto demuestra como el mtodo
privado Blink aun puede ser accesado del mismo objeto (Blinker) por su mtodo Start.
Ejemplo de Mltiples Objetos
Los objetos Spin que inician y administran uno o ms cogs para un proceso dado son escritos
tpicamente para una sola copia del proceso. Si la aplicacin necesita ms de una copia de los
procesos corriendo actualmente simplemente se puede declarar ms de una copia del objeto. Por
ejemplo el chip Propeller puede controlar una pantalla de TV con un cog, pero cada objeto TV solo
controla una pantalla de TV. Si la aplicacin necesita controlar ms de una TV entonces se declaran
ms de una copia del objeto TV.

L
Copias mltiples de Objetos? No hay Problema!
No hay penalizaciones para el espacio de cdigo por declarar mltiples objetos. El compilador de la
herramienta Propeller los optimiza as que solo se ejecuta el cdigo una vez por todas las copias de los
objetos. La nica penalizacin para declarar ms de una copia del mismo objeto es que habr ms de una
copia de variables globales que declara el objeto, un paquete por cada objeto. Como ms o menos se
necesitan el mismo nmero de variables extras por una aplicacin dada para hacer el mismo trabajo sin
objetos, realmente no es una penalizacin.

El objeto MultiCogObjectExample demuestra cmo se pueden iniciar mltiples copias de un objeto
que administra un proceso con un arreglo de objeto. Al igual que las variables, los objetos pueden
declararse como arreglos. En este ejemplo seis copias del objeto Bliker se declaran en el bloque OBJ
con Blinker[6] : Blinker. Las seis copias de Blinker pueden indexarse tambin de la misma forma
que los arreglos de variables con Blinker[0], Blinker[1], y as sucesivamente hasta Blinker[5]. En
MultiCogObjectExample un ciclo repeat incrementa una variable index, por lo que
Blinker[index].Start llama sucesivamente cada mtodo Start del objeto.

El objeto MultiCogObjectExample es funcionalmente equivalente al objeto CogStartStopWithButton
de la practica Mtodos y Cogs. Cuando el programa corre cada vez que se presiona/suelta el boton en
P23 inicia un nuevo Cog que hace parpadear sucesivamente los LEDs (conectados de P4 a P9) a
rangos determinados por la duracin del tiempo que se presiona el botn. De la primera a la sexta vez
que se presiona el botn inicia el proceso de parpadeo de LED en nuevos cogs, de la sptima a la
decimo segunda detiene cada cog en sentido contrario al que se arrancaron.

3 Cargue el objeto MultiCogObjectExample.spin en el chip Propeller
3 Presione y suelte el botn P23 seis veces sucesivas (cada una con diferente duracin) y
verifique que los seis cogs se iniciaron correctamente.
3 Presione y suelte el botn en P23 seis veces ms y verifique que cada proceso de parpadeo se
detiene en orden inverso.
''Archivo superior: MultiCogObjectExample.spin

OBJ

Blinker[6] : "Blinker"
Button : "Button"

PUB ButtonBlinkTime | time, index

repeat

time := Button.Time(23)
Blinker[index].Start(index + 4, time, 1_000_000)

Button.Time(23)
Blinker[index].Stop

Comunicacin Chip Propeller PC Terminal
Es realmente conveniente para diversas aplicaciones poder intercambiar caracteres y valores con el
micro controlador utilizando el programa PC terminal. Algunos ejemplos incluyen monitoreo de la
computadora y circuitos controlados, mediciones de sensores y enviar y recibir informacin de
diagnsticos para pruebas de sistemas y depurado.

La comunicacin Terminal/Chip Propeller involucra un programa en la Computadora y el cdigo del
micro controlador. Para la computadora utilizaremos el programa Parallax Serial Terminal el cual se
ver a continuacin. Para el cdigo del micro controlador haremos uso de objetos que atienden
seales elctricas y conversiones entre valores binarios y sus representaciones en carcter para poder
enfocarnos en aplicaciones de escritura.

Conforme desarrolle aplicaciones que hagan uso de objetos de comunicacin serial considere como
esos objetos disponibles simplifican la escritura de programas. Se da un ejemplo de cmo usando
objetos de la Librera Propeller, Intercambio de Objetos Propeller y el foro del Chip Propeller hace
posible hacer mucho con unas pocas lneas de cdigo.
Terminal Serial Parallax
El programa de la terminal serial Parallax (PST.exe) mostrado en la Figura 6-9 es una herramienta
adecuada para la comunicacin chip Propeller/Computadora. Muestra texto y mensajes numricos del
chip Propeller y tambin permite enviar mensajes similares al chip Propeller.

3 Si aun no lo ha hecho vaya a Programas, Documentacin y Recursos (pgina 17) Y siga las
instrucciones para descargar y preparar la Terminal Serial Parallax.

Este programa tiene una ventana de transmisin que enva los caracteres que usted teclea al chip
Propeller y una ventana de recepcin que muestra los caracteres que son enviados por el chip
Propeller. Tiene mens para el Puerto de Comunicacin y la Velocidad de Transmisin as como
indicadores de actividad y selectores de controles para los diversos canales (TX, RX, etc). Tambin
hay un selector Echo On que esta seleccionado automticamente para que los caracteres que ingresan
a la ventana de transmisin tambin aparezcan en la ventana de recepcin.

Prctica de Objetos
En la parte derecha inferior de la ventana de la Terminal Serial Parallax hay botones de control que:

Muestran y editan preferencias (Prefs)
Limpian la ventana de la terminal (Clear)
Detienen el desplegado de datos de entrada (Pause)
Habilitan o Deshabilitan la conexin al Puerto serial Parallax (Disable/Enable)

Figura 6-9: Terminal Serial Parallax

El botn para habilitar/deshabilitar en la Terminal Serial Parallax en la parte inferior derecha es
importante. (Vea la Figura 6-10). Cuando despliega Disable significa que la terminal est conectada
al puerto serial. Cuando presiona el botn Disable la terminal serial Parallax libera el puerto serial
para que la herramienta lo pueda usar y cargar un programa en el chip Propeller. Mientras que la
Terminal Serial esta deshabilitada el botn muestra Enable. Despus que cargo el programa usted
puede presiona el botn Enable para regresar a la comunicacin entre la Terminal y el chip Propeller.

L
Programar automticamente Habilitar/Deshabilitar
En Prefs Serial Port Selection por defecto las opciones Automatically Disable y Wait for Busy estn
seleccionadas. Con estos parmetros usted puede presionar en el programa de la herramienta Propeller,
cargar un programa e inmediatamente presionar el botn Enable para reconectar. No hay necesidad de
presionar Disable antes de cambiar la herramienta a carga de programa porque la Terminal Parallax se
desconectara automticamente tan pronto como usted presione otra ventana. De igual forma usted no tiene
que esperar a terminar de cargar el programa antes de presionar Enable. Usted puede presionarlo tan pronto
ha comenzado a cargar el programa y la Terminal Serial Parallax detecta que el puerto serial aun est
ocupado y espera a que la herramienta Propeller termine de cargar el programa antes de reconectarse.

Figura 6-10: Conectado vs. Desconectado (al/del el Puerto de Comunicacin)

Conectado al Puerto serial y
comunicandose con el chip
Propeller.
Desconectado del Puerto
Serial para que la
herramienta Propeller pueda
cargar el programa.
Ventana de
Transmision
Ventana de
Recepcion
Usted puede presionar en el botn Prefs de la terminal serial Parallax para ver la apariencia y
tabuladores mostrados en la Figura 6-11. Las preferencias Appearance le permiten definir los colores,
letras y otros formatos. Las preferencias Fuction le permiten seleccionar funciones especiales para
caracteres ASCII no imprimibles. Deje todo seleccionado para estas prcticas ya que los usaremos
para limpiar pantallas, mostrar regresos, etc

Figura 6-11: Preferencias de Apariencia y Funciones

Lo mejor es dejar todo seleccionado en ambas categoras. La caracterstica Automatically Disable
hace que la Terminal Parallax este deshabilitada automticamente para liberar el puerto serie para
cargar el programa cada vez que presione la herramienta Propeller. Wait for busy port hace que la
Terminal Parallax espere hasta 10 segundos si presiona el botn Enable antes de que la herramienta
Propeller haya terminado de cargar el programa. (No hay problema con Load RAM (F10) pero Load
EEPROM (F11) puede tomar algunos segundos). Si estas caractersticas no fueron seleccionadas
usted tendr que presionar manualmente Disable antes de cargar un programa y esperar a que el
programa termine de cargar antes de presionar Enable para reconectar.

L
Cuando deshabilitar el parmetro Automatically disable:
El parmetro Automatically disable es muy conveniente para modificar el cdigo con la Herramienta
Propeller y observar los resultados en la Terminal Serial Parallax. EL evento que dispara el automtico
Disable es el hecho de que usted presione en otra ventana
Digamos que en vez de estar cambiando de ida y vuelta entre la Terminal Parallax y algn otro programa tal
como una hoja de datos para anlisis de medicin de un sensor con el parmetro Automatically disable
cada vez que presione en otra ventana la Terminal Serial automticamente se desconecta del puerto serial y
cualquier mensaje enviado por el chip Propeller no se mantendr o mostrara.
Para hacer que la Terminal Parallax mantenga la conexin del Puerto serial mientras usted trabaja con otra
ventana deshabilite el parmetro Automatically disable As la terminal Parallax se mantendr conectada
puerto serial y continuara mostrando los mensajes actualizados independientemente de en que ventana este
trabajando. Tenga en cuenta que con este parmetro no seleccionado usted tendr que presionar
manualmente el botn Disable antes de cargar un programa y Enable despus de que el programa se cargo.

El botn de edicin de puertos en la Figura 6-11 abre la lista de puertos serial. Usted puede mover
entradas en la lista arriba y abajo para cambiar el orden en el que aparecen en el men de la terminal
Parallax. Usted tambin puede presionar con el botn derecho para incluir o excluir la entrada o
incluso crear reglas para incluir o excluir puertos basado en el texto de la columna de descripcin.
Prctica de Objetos
Mensajes de Prueba en la Terminal Serial Parallax
La Figura 6-12 muestra la aplicacin HelloFullDuplexSerial en la izquierda y los mensajes repetidos
que enva a la Terminal Serial Parallax en la derecha. El programa HelloFullDuplexSerial declara el
objeto FullDuplexSerial y usa sus metodos para enviar mensajes a la terminal Parallax. Primero llama
al mtodo start del objeto FullDuplexSerial con start y luego repetidamente llama el mtodo str
(string) con Debug.str en un ciclo repeat. Vamos a probar primero y luego ver ms de cerca al objeto
FullDuplexSerial, sus caractersticas y mtodos.

Figura 6-12: Usando el objeto FullDuplexSerial para mostrar mensajes en la terminal Parallax

La primera vez que abre la Terminal Serial Parallax (PST.exe) necesitara programar (Com Port) igual
que el utilizado por la herramienta Propeller para cargar programas en el chip Propeller. Tambin
tendr que seleccionar el Baud Rate igual al que usa el programa Spin. Despus de eso solo cargue la
caracterstica Load EEPROM de la herramienta Propeller para cargar el programa en la EEPROM del
chip Propeller y presione el botn Enable de la Terminal Serial Parallax para ver los mensajes

3 Abra HelloFullDuplexSerial.spin con la Herramienta de Programacin Propeller
3 Abra la Terminal Serial Parallax (presione dos veces en PST.exe para correrlo)
3 Conecte la batera a su Plataforma PE y verifique que est conectada a la computadora con el
cable USB.
3 En la herramienta Propeller presione Run, y seleccione Identify Hardware (F7). Tome nota
del COM port donde se encontr el chip Propeller.
3 Introduzca el COM port en el campo de la izquierda inferior de la Terminal Parallax,
asegrese que es el mismo que encontr en el paso anterior.
3 Verifique el parmetro baudrate en la llamada a mtodo Debug.start para encontrar la
velocidad de transmisin (Actualmente es 57600).
3 Coloque la velocidad de transmisin en la terminal Parallax para que sean iguales (a 57600).
3 En la herramienta Propeller use F11 para cargar HelloFullDuplexSerial.spin en la EEPROM
del chip Propeller.
3 En la Terminal Parallax presione el botn Enable para iniciar el desplegado de mensajes del
chip Propeller.

''HelloFullDuplexSerial.spin
''Prueba de mensaje a la Terminal Serial Parallax.

CON

_xinfreq = 5_000_000

OBJ

Debug: "FullDuplexSerial"

PUB TestMessages

''Envia mensajes de prueba a la Terminal Serial Parallax.

Debug.start(31, 30, 0, 57600)

repeat
Debug.str(string("This is a test message!", 13))

!
NOTA IMPORTANTE CUANDO EL CHIP PROPELLER NO ESTE CONECTADO A LA COMPUTADORA!
Si el chip Propeller est corriendo una aplicacin pero no est conectado a la Computadora el cdigo que
intenta enviar mensajes a la Computadora puede ocasionar que el chip se reinicie por el convertidor Serial a
USB
El convertidor USB serial normalmente toma su corriente del Puerto USB. Si el convertidor USB-Serial esta
desconectado del puerto USB su chip convertidor FTDI USB-serial deber estar apagado. Sin embargo si el
Propeller intenta enviar mensajes a la Computadora la seal de voltaje puede proporcionar suficiente
potencia para alimentar el chip FTDI brevemente. Cuando esto sucede una de las primeras cosas que hace
es activar la lnea DTR que en su turno reinicia el chip Propeller.
La solucin para la versin DIP 40-Pin del kit PE es simple. Solo desconecte el Propeller de su conector de 4
pins para remover el convertidor serial del sistema. Esto previene la intencin de enviar cualquier mensaje
inadvertidamente a una Computadora ocasionando que el chip FTDI reinicie el chip Propeller.
Debido a que el modulo PropStick USB tiene su convertidor USB-Serial FTDI integrado requiere de una
solucin diferente. Antes de correr alguna aplicacin que no est conectada a la Computadora con el cable
USB asegrese de remover todo el cdigo que intente enviar mensajes a la Computadora. Esto previene que
la aplicacin misteriosamente se reinicie cuando la Plataforma PE no est conectada a la Computadora.
Cambiando Velocidad de Transmisin
Si la velocidad de transmisin es la misma usted puede seleccionar la velocidad que mejor funcione
para su aplicacin. Por ejemplo usted puede cambiar la velocidad de 57.6 a 115.2 kbps como sigue:

3 En la herramienta Propeller modifique la llamada a mtodo start del objeto
HelloFullDuplexSerial para que pase el valor de 115200 al parmetro baudrate del mtodo
start del objeto FullDuplexSerial como sigue:

Debug.start(31, 30, 0, 115200)

3 Cargue la versin modificada de HelloFullDuplexSerial en el chip Propeller.
3 Escoja 115200 en la Terminal Serial Parallax del men Baud Rate.
3 Presione el botn Enable en la Terminal Serial Parallax
3 Verifique que con la nueva velocidad los mensajes aun se muestran en pantalla.
3 Asegrese de cambiar los parmetros de regreso a 57600 en ambos programas y antes de
continuar asegrese que aun trabajan.
Prctica de Objetos
FullDuplexSerial y otros objetos de la Librera
El objeto FullDuplexSerial simplifica mayormente el intercambio de datos entre el Propeller y
componentes Perifricos que se comunican con protocolos seriales asncronos como RS232. Solo
unos ejemplos de equipos que pueden conectarse al Propeller incluyen Computadoras, otros micro
controladores, mdems, el LCD Parallax y el modulo Pink Ethernet.

L
Comunicacin Serial: Para mayor informacin acerca de comunicacin serial asncrona vea los artculos de
Comunicacin Serial y RS232 en Wiki peda.
Serial-sobre-USB: Para mayor informacin acerca de la forma en la que el chip FT232 en el Propeller Plug y
el ProStick USB enva datos seriales sobre una conexin USB vea la versin de Programacin y Prueba del
PropStick USB.

Como se menciono anteriormente un cdigo en un objeto puede declarar otro objeto si:

Los dos objetos estn en la misma carpeta
El objeto a ser declarado esta en la misma carpeta que la Herramienta Propeller

El objeto en la misma carpeta con la herramienta Propeller es llamado Liberia de objetos. Para ver el
contenido de la librera Propeller:

3 Presione en el men entre la esquina superior izquierda y la mitad la ventana como se
muestra en la Figura 6-13 y seleccione Propeller Library. Los objetos de la librera propeller
aparecern en la ventana baja de la izquierda.

Note que en la Figura 6-13 el icono siguiente a FullDuplexSerial en la herramienta esta de color azul
en vez de amarillo. Esto indica que es un archivo residente de la librera Propeller. Usted tambin
puede ver estos archivos usando el Explorador de Windows. Asumiendo una instalacin por defecto
la ruta deber ser C:\Program Files\Parallax Inc\Propeller Tool v1.2.

Figura 6-13: Cdigo que declara una Librera
Objeto

Cuando usa una librera objeto la primera tarea es examinar sus lineamientos para saber acerca de sus
mtodos y que puede hacer.

3 Presione dos veces sobre FullDuplexSerial en la herramienta propeller localizado en la parte
baja izquierda, con esto usted podr ver el contenido de la librera Propeller
3 Cuando la herramienta Propeller abre el objeto FullDuplexSerial presione el botn de
Documentacin para ver lo mostrado en la Figura 6-14.

3 Verifique la lista de mtodos en la seccin Interface del objeto FullDuplexSerial
3 Baje el cursor y encuentre la documentacin para el mtodo start y str y examnelos. Se
usaran en el siguiente ejemplo.

Figura 6-14: Vistas de Documentacin del Objeto FullDuplexSerial

El objeto HelloFullDuplexSerial en la Figura 6-13 declara el objeto FullDuplexSerial dndole el
apodo Debug. Entonces llama el mtodo start del objeto FullDuplexSerial con el comando
Debug.start(31, 30, 0, 57600). De acuerdo a la documentacin programa los parmetros de E/S
rxpin al pin 31, txpin al 30, mode en 0, y baudrate a 57600. Despus de eso un ciclo repeat enva el
mismo mensaje de texto a la Terminal Parallax cada segundo. El mtodo Debug.str es el que
transfiere la cadena "This is a test message!" a la memoria temporal. Despus de eso
FullDuplexSerial se encarga de enviar cada carcter sucesivamente en la cadena del chip FT232 el
cual lo reenva a la computadora a travs del USB.

Veamos ms de cerca Debug.str(string("This is a test message!", 13)). Primero Debug.str
llama al mtodo str del objeto FullDuplexSerial. La declaracin del mtodo para el mtodo str
indica que el parmetro esperado deber ser un puntero de cadena. Al compilar la directiva
string("This is a test message!") almacena el valor que corresponde a los caracteres en el
mensaje de texto en la memoria de programa del chip Propeller y los anexa con un cero para terminar
la cadena. Aun si la documentacin del mtodo str no lo incluye (En realidad debera!) espera un
cero para terminar la cadena para que pueda obtener y transmitir caracteres hasta encontrar un cero.
Mientras est corriendo la directiva string regresa la direccin de inicio de la cadena. Debug.str pasa
este parmetro al mtodo str del objeto FullDuplexSerial. Entonces el mtodo str enva caracteres
hasta que ve un cero que lo finaliza.

Prctica de Objetos
L
Que hace el 13? El 13 en Debug.str(String("This is a test message!", 13)) es un caracter especial que
hace que la Terminal Parallax coloque un salto. Es por eso que This is a text message! aparece cada vez
en su propia lnea ya que el mensaje previo fue enviado con un salto. Vea la Figura 6-11 para ver la lista de
caracteres de control de la Terminal Serial Parallax.

Usted puede ver dnde queda almacenada la cadena en el programa con ayuda de la ventana de
Informacin de la herramienta Propeller.

3 Mientras ve el objeto HelloFullDuplexSerial con la herramienta Propeller presione Run y
luego Compile Current y seleccione View Info (F8). Debe aparecer la ventana de informacin
que se muestra en la Figura 6-15.
3 Observe el texto en la columna de la derecha en la lnea 4 y 5. El cdigo hexadecimal ASCII
ocupa las direcciones de memoria 0038 a 004F con el terminador 0 en la direccin 50.

Figura 6-15: Encontrando una Cadena de Texto en Memoria

Desplegando valores
Observe nuevamente el objeto FullDuplexSerialen modo de documentacin. (Vea la Figura 6-14 en
la pgina 101). Observe que tambin tiene un mtodo dec para mostrar nmeros decimales. Este
mtodo toma un valor y lo convierte al carcter que representa el valor antes de transmitirlos
serialmente a la Terminal Parallax. Es usado especialmente para mostrar lecturas de sensores y
valores almacenados por variables para depurar programas.

3 Modifique la declaracin del mensaje del objeto HelloFullDuplexSerial agregando una
declaracin local variable:

PUB TestMessages | counter

3 Modifique el ciclo repeat del objeto HelloFullDuplexSerial como se muestra:

repeat
Debug.str(String(13, "counter = "))
Debug.dec(counter++)

3 Use la herramienta Propeller para cargar la versin modificada de HelloFullDuplexSerial en
la EEPROM del chip Propeller (F11).
Vista amplia
debajo.
3 Presione en el botn Enable de la Terminal Serial Parallax y verifique que el valor
actualizado de counter se muestra varias veces cada segundo. Usted puede presionar y soltar
el botn de reinicio para empezar a contar desde 0 nuevamente.
Enviando valores de la Terminal Serial Parallax al chip Propeller
El objeto FullDuplexSerial no tiene un mtodo equivalente GetDec para complementar dec. As que
no se puede usar FullDuplexSerial para recibir un valor de la Terminal Parallax. Junto con los
archivos .spin est incluida una versin modificada de FullDuplexSerial con el nombre de
FullDuplexSerialPlus. El objeto FullDuplexSerialPlus tiene los mismos mtodos que
FullDuplexSerial y otros mas como GetDec, GetBin, y GetHex. Los mtodos adicionales pueden
utilizarse para recibir la representacin de caracteres decimales, hexadecimales y nmeros binarios
desde la Terminal Serial Parallax, convertirlos a sus valores numricos y almacenarlos en variables.
Como FullDuplexSerialPlus tambin tiene los mismos mtodos que FullDuplexSerial llamadas como
Debug.start, Debug.str, y Debug.dec siguen dando el mismo resultado.

L
FullDuplexSerialPlus Est incluido en la descarga de Practicas PE (Ver pgina 17) y una lista completa del
cdigo se proporciona en el apndice A: Lista de Cdigos de Objetos en la pgina 191.

Recuerde que un objeto puede declararse siempre y cuando este en la misma carpeta de los objetos a
los que se est referenciando o en la misma carpeta que se encuentra la Herramienta Propeller. En
este caso el objeto FullDuplexSerialPlus est en la misma carpeta con los objetos de esta prctica.
As, puede ser declarado en el bloque de objetos padres OBJ casi de la misma forma que se declaro
FullDuplexSerial. La nica diferencia es que el objeto padre usa un nombre diferente. As que en vez
de usar la declaracin Debug : FullDuplexSerial se usa Debug : FullDuplexSerialPlus.

3 Abra ambos objetos FullDuplexSerial y FullDuplexSerialPlus en modo de documentacin.
3 Use la lnea para observar cuales mtodos se agregaron hay 6 y los nombres de mtodos
estn en maysculas.
3 Verifique la documentacin para los nuevos mtodos. Los comentarios para los otros
mtodos se extendieron tambin, obsrvelos tambin.
Aplicacin de prueba EnterAndDisplayValues.spin
El objeto EnterAndDisplayValues espera para que usted introduzca un valor en la ventana de
transmisin de la terminal Parallax. Convierte el carcter a su valor equivalente numrico y lo
muestra en formatos decimal, hexadecimal y binario.

Figura 6-16: Probando Valores de
Entrada

La Figura 6-16 muestra un objeto de prueba EnterAndDisplayValues con la Terminal Parallax. El
objeto hace que el chip Propeller enve un cursor que se muestra en la ventana de recepcin de la
Prctica de Objetos
Terminal. Despus de teclear un valor decimal en la ventana de transmisin y presionar Enter el chip
Propeller convierte la cadena de caracteres su valor correspondiente, lo almacena en una variable y
luego usa el objeto FullDuplexSerialPlus para enviarlo de regreso en su representacin decimal,
hexadecimal y binaria.

3 Cargue EnterAndDisplayValues.spin en la EEPROM (F11) e inmediatamente presione el
botn Enable de la Terminal Propeller.
3 La aplicacin de dar dos segundos para conectar la Terminal Parallax al presionar el botn
Enable. Si usted no ve el mensaje Enter a decimal value: quiz no presiono a tiempo el
botn Enable. Usted puede reiniciar la aplicacin presionando el botn de reinicio de la
plataforma PE. Usted tambin puede reiniciar el chip Propeller al seleccionar y deseleccionar
la lnea DTR.
3 Haga lo que pide el mensaje de la terminal Propeller. Comience con 131071 y verifique que
muestra los valores que ve en la Figura 6-16.

El Propeller representa nmeros negativos con complementos dos de 32 bits. Las variables long del
chip almacenan 32 bits como valores enteros de -2,147,483,648 a 2,147,483,647.

3 Ingrese estos valores: 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, y discierna el patrn de complemento dos.
3 Intente ingresar 2,147,483,645, 2,147,483,646, y 2,147,483,647 examine los valores de sus
equivalentes en valores hexadecimales y binarios.
3 Tambin intente con -2,147,483,646, -2,147,483,647, y -2,147,483,648.

'' Archivo: EnterAndDisplayValues.spin
'' Mensajes de/al chip Propeller con Terminal Serial Parallax. Pide que ingrese un valor
y muestra el valor en formatos decimal, binario y hexadecimal.

CON

_xinfreq = 5_000_000

OBJ

Debug: "FullDuplexSerialPlus"

PUB TwoWayCom | value

''Prueba la Terminal Serial Parallax ingresa un numero y muestra.

Debug.start(31, 30, 0, 57600)
waitcnt(clkfreq*2 + cnt)
Debug.tx(16)

repeat

Debug.Str(String("Enter a decimal value: "))
value := Debug.getDec
Debug.Str(String(13, "You Entered", 13, "--------------"))
Debug.Str(String(13, "Decimal: "))
Debug.Dec(value)
Debug.Str(String(13, "Hexadecimal: "))
Debug.Hex(value, 8)
Debug.Str(String(13, "Binary: "))
Debug.Bin(value, 32)
repeat 2
Debug.Str(String(13))

Debug.dec vs. Debug.getDec
El mtodo GetDec del objeto FullDuplexSerialPlus guarda los caracteres que recibe de la Terminal
Serial Parallax hasta que presiona la tecla Enter. Convierte el carcter en su correspondiente valor
decimal y regresa ese valor. El comando del objeto EnterAndDisplayValues value := Debug.GetDec
copia el resultado de la llamada de mtodo GetDec a la variable value. El comando Debug.Dec(value)
muestra el valor en formato decimal. El comando Debug.Hex(value, 8) muestra el valor en formato
hexadecimal de 8 caracteres y el comando Debug.Bin(value, 32) lo muestra en formato binario de
32 caracteres.
Conteo de Caracteres Hex y Bin
Si solo va a mostrar palabras positivas o variables de tamao byte, no hay razn para mostrar todos
los 32 bits de valores binarios. Como las palabras variables tienen 16 bits y las variables byte solo
tienen 8 bits no tiene sentido mostrar los 32 bits cuando se examinan esas variables ms pequeas.

3 Haga una copia de EnterAndDisplayValues y cambia el comando Debug.Bin(value, 32) a
Debug.Bin(value, 16).
3 Remueva la variable local | value de a declaracin del mtodo TwoWayCom (recuerde que las
variables locales son arreglos de 32 bits, las variables globales pueden ser declaradas como
long, Word o byte).
3 Agregue un bloque VAR al objeto y declare value como palabra (Word) variable.
3 Corra el programa ingresando los valores de 0 a 65535.
3 Que sucede si ingresa 65536, 65537 y 65538? Intente repetir esto con el objeto no modificado
para ver los bits faltantes.

Cada digito hexadecimal toma 4 bits. De esta forma tomara 4 dgitos mostrar todos los valores
posibles en una palabra variable (16 bits).

3 Modifique la copia EnterAndDisplayValues para que solo muestre 4 dgitos hexadecimales.
Pantalla de Estado de Pin E/S
La pantalla de la Terminal Serial Parallax proporciona un medio conveniente para probar sensores y
asegurarse que el programa y cableado estn correctos. El objeto DisplayPushbuttonsmuestra los
valores almacenados en ina[23..21] en formato binario como muestra la Figura 6-17. Un 1 en una
ranura especial indica que se presiono un botn; un 0 indica que no se presiono. La Figura 6-17
muestra un ejemplo donde P23 y P21 se presionan.

Figura 6-17: Pantalla
del estado del Botn en
la Terminal Serial

El objeto DisplayPushbuttons utiliza el comando Debug.Bin(ina[23..21], 3) para mostrar el estado
del botn. Recuerde de la prctica de E/S y tiempo que ina[23..21] regresa el valor almacenado en
bits de los registros ina 23 al 21. Este resultado pasa como un parmetro al mtodo bin del objeto
Prctica de Objetos
FullDuplexSerialPlus con el comando Debug.bin(ina[23..21], 3). Note que como solo hay 3 bits
para mostrar el parmetro bits del mtodo bin es 3 lo que en su turno hace que el mtodo muestre
solo 3 dgitos binarios.

El objeto FullDuplexSerialPlus est corriendo en un controlador serial en otro cog y es posible
transferir mensajes ms rpido de lo que se le permite. El comando waitcnt(clkfreq/100 + cnt)
marca el paso al actualizar los valores cada 1/100 de segundo para evitar el sobre flujo.

3 Use la herramienta Propeller para cargar el objeto DisplayPushbuttons.spin en EEPROM
(F11) e inmediatamente presione el botn Enable. Nuevamente, si usted no lo presiona en los
2 segundos despus de la descarga solo presione el botn de reinicio de la plataforma PE para
reiniciar el programa.
3 Presione y suelte varias combinaciones de P23..P21 y verifique que se actualiza el valor en
pantalla cuando se presionan.

{{ DisplayPushbuttons.spin
Muestra el estado del botn en la Terminal Serial Parallax.

Botones

3.3 V 3.3 V 3.3 V

Botn Botn Botn

P21 P22 P23

- 10 k - 10 k - 10 k

~ ~ ~
GND GND GND

}}

CON
_xinfreq = 5_000_000

OBJ

PUB TerminalPushbuttonDisplay

''Lee el estado de los botones P23 a P21 y los muestra en la Terminal Serial Parallax.

Debug.start(31, 30, 0, 57600)
Debug.tx(Debug#CLS)
Debug.str(String("Pushbutton States", Debug#CR))
Debug.str(String("-----------------", Debug#CR))

repeat
Debug.tx(Debug#CRSRX)
Debug.tx(0)
Debug.Bin(ina[23..21], 3)

Accesando constantes en objetos con ObjectNickname#OBJECT_CONSTANT
Quiz ha notado que la expresin Debug#CR reemplaza el numero 13 para enviar un salto. (Vea el lado
izquierdo de la Figura 6-18). Eso es porque los caracteres constantes de control para la Terminal
Serial Parallax son declarados en el objeto FullDuplexSerialPlus. Usted puede verlos en la
documentacin del objeto FullDuplexSerialPlus en la derecha de la Figura 6-18. En vez de usar los
nmeros o declararlos por segunda vez en el objeto superior DisplayPushbuttons usa el registro
ObjectNickname#OBJECT_CONSTANT para especificar caracteres de control que se envan a la
Terminal Serial Parallax.

3 Examine el objeto FullDuplexSerialPlus en ambos modos; documentacin y fuente completa.
3 Tome nota de como se declaran las constantes y como son documentadas con comentarios de
doble apostrofe.

Figura 6-18: DisplayPushbuttons Completa (izq.), DisplayPushbuttons Documentacin (der.)

Terminal LED Output Control
Es importante durante los prototipos probar varios actuadores. El objeto TerminalLedControl
demuestra que es conveniente probar varios estados de salidas para probar diferentes circuitos. (Ver
Figura 6-19). Mientras este ejemplo usa indicadores LED, los pins de seales de salida pueden as de
fcil enviarse a otros pins de entrada de chips, salidas a circuitos que controlan salidas de alta
corriente tales como solenoides, relevadores, motores DC, calentadores, lmparas, etc.

Figura 6-19: Ingresando patrones
binarios que controlan estados de E/S

El comando outa[9..4] := Debug.GetBin llama al mtodo GetBin del objeto FullDuplexSerialPlus.
EL mtodo regresa el valor correspondiente a los caracteres binarios (unos y ceros) que usted ingreso
en la ventana de transmisin de la Terminal Parallax. El valor que el mtodo GetBin regresa se asigna
a outa[9..4], lo cual hace encender el LED correspondiente.
Prctica de Objetos
3 Cargue TerminalLedControl.spin en la EEPROM (F11) e inmediatamente presione el botn
Enable de la Terminal Parallax.
3 Intente ingresar los valores mostrados en la Figura 6-19 en la ventana de transmisin y
verifique que el LED correspondiente se enciende.

{{
TerminalLedControl.spin

Ingresa el estado del LED en la Terminal Parallax. El Propeller chip recibe el estado y
enciende las luces del LED correspondiente.

LED SCHEMATIC

(todos)
100 LED
P4 -/|!

P5 -/|!

P6 -/|!

P7 -/|!

P8 -/|!

P9 -/|!
~
GND

}}

CON

_xinfreq = 5_000_000

OBJ

Debug : "FullDuplexSerialPlus"

PUB TerminalLedControl

''Limpia o Activa el estado del Pin de salida basado en patrones binarios
''ingresados en la Terminal Serial Parallax.

Debug.start(31, 30, 0, 57600)
Debug.tx(Debug#CLS)
dira[4..9]~~

repeat

Debug.Str(String("Enter 6-bit binary pattern: "))
outa[4..9] := Debug.getBin

El Bloque DAT y Paso de Direcciones
Uno de los usos de bloque DAT es para almacenar secuencias de valores (incluyendo caracteres).
Especialmente para mensajes ms largos y diseos de mens, manteniendo todos los mensajes en un
bloque DAT puede hacer ms conveniente que usar string("...")en el cdigo.
L
El Bloque DAT puede usar separa almacenar lenguaje ensamblador que se inicializa en un cog. Por ejemplo
observe FullDuplexSerial en vista de modo completo.

Debajo del bloque DAT del siguiente ejemplo, TestMessages note como cada lnea tiene una etiqueta,
un tamao y una secuencia de valores (caracteres en este caso)

DAT

MyString byte "Este es un mensaje de prueba numero:", 0
MyOtherString byte ", ", Debug#CR, "y este es otro mensaje de lnea de texto.",
0
BlankLine byte Debug#CR, Debug#CR, 0

Recuerde que la directiva string regresa la direccin inicial de la cadena as que el mtodo str del
objeto FullDuplexSerial puede comenzar a enviar caracteres y luego terminar cuando encuentra un
cero que lo termina. Con los bloques DAT el carcter de terminacin tiene que ser ingresado
manualmente. El nombre de una directiva de bloque DAT hace posible pasar la direccin inicial de la
secuencia usando el operador @. Por ejemplo @MyString regresa la direccin del primer carcter en la
secuencia MyString. Por lo que Debug.str(@myString) comenzara a obtener y transmitir caracteres a
la direccin del primer caracter en MyString, y se detendr cuando obtenga el 0 que sigue de los
caracteres "number: ".

3 Cargue el objeto TestMessages.spin en la EEPROM (F11), y presione inmediatamente el
botn Enable en la Terminal Serial Parallax
3 Verifique que los tres mensajes se muestran cada segundo.

'' TestMessages.spin
'' Enva mensajes de texto almacenados en el bloque DAT de la Terminal.

CON
_xinfreq = 5_000_000

OBJ

PUB TestDatMessages | value, counter

''Enva mensajes almacenados en el bloque DAT.

Debug.start(31, 30, 0, 57600)
Debug.tx(Debug#CLS)

repeat
Debug.Str(@MyString)
Debug.Dec(counter++)
Debug.Str(@MyOtherString)
Debug.Str(@BlankLine)

DAT
MyString byte "Este es el mensaje de prueba: ", 0
MyOtherString byte ", ", Debug#CR, "y esta es otra lnea de texto.", 0
BlankLine byte Debug#CR, Debug#CR, 0
Expandiendo la seccin DAT y Accesando sus Elementos
Aqu hay una seccin DAT modificada. El mensaje de texto tiene diferente contenido y diferentes
etiquetas. Adems hay un ValueList con elementos long en vez de elementos byte.
Prctica de Objetos
DAT

ValTxt byte Debug#CR, "El valor es: ", 0
ElNumTxt byte ", ", Debug#CR, "y su elemento #: ", 0
ValueList long 98, 5282, 299_792_458, 254, 0
BlankLine byte Debug#CR, 0

Usted puede accesar elementos individuales en la lista con long, Word, o byte. Por ejemplo,
long[@ValueList] regresara el valor 98, el primer long. Hay tambin una contraparte que puede
agregarse en un segundo corchete para accesar elementos sucesivos en la lista. Por ejemplo:

value := long[@ValueList][0] ' copia 98 a la variable value
value := long[@ValueList][1] ' copia 5282 a la variable value
value := long[@ValueList][2] ' copia 299_792_458 a la variable value

L
Las palabras long, Word, y byte tienen diferentes usos en diferentes tipos de bloques.
En bloques VAR, long, Word y byte pueden usarse para declarar tres tamaos diferentes de variables. En
bloques DAT, long, Word, y byte pueden usarse para declarar el elemento de tamao de la lista. En mtodos
PUB y PRI, long, Word, y byte se usan para recuperar valores de ciertas direcciones.

3 Haga una copia del objeto TestMessages y reemplace la seccin DAT con la mostrada arriba.
3 Reemplace la seccin PUB con la mostrada abajo.

PUB TestDatMessages | value, index

Debug.start(31, 30, 0, 57600)
Debug.tx(Debug#CLS)

repeat
Debug.Str(@ValTxt)
value := long[@valueList][index]
Debug.Dec(value)
Debug.Str(@ElNumTxt)
Debug.Dec(index)
Debug.Str(@BlankLine)

3 Pruebe el objeto modificado con el chip Propeller y la Terminal Serial Parallax. Note como
una variable index se usa en long[@ValueList][index] para regresar elementos sucesivos en
ValueList.
Los Objetos Float y FloatString
Floating-point es la forma corta para punto decimal flotante y se refiere al valor que puede contener
un punto decimal, precedido o seguido por nmeros o dgitos. El formato de precisin (32-bit) punto
flotante IEEE754 es soportado por la herramienta Parallax y por los objetos de las libreras Propeller
Float y FloatString. Este formato usa un cierto nmero de bits en una variable de 32-bit para un
nmero significativo, otros bits para almacenar exponente y otro para almacenar el valor del signo.
Mientras los clculos involucran dos valores de punto-flotante precisin-simple los valores no son tan
precisos como los que involucran dos variables de 32-bit, es excelente cuando se tienen valores
fraccionales a la derecha del punto decimal, incluyendo magnitudes de nmeros grandes y pequeos.
Por ejemplo variables long pueden manejar enteros de -2,147,483,648 a 2,147,483,647, los valores de
punto-flotante precisin-simple pueden representar valores de entre 3.40310
38
y 1.17510
38
.

Para esta prctica solo es importante conocer que la librera Propeller tiene objetos que pueden usarse
para procesar valores de punto flotante. TerminalFloatStringTest demuestra algunas operaciones
bsicas de punto flotante. Primero a := 1.5 y b := pi usan la habilidad del programa Propeller para
reconocer los valores de punto flotante para pre-asignar de 1.5 a la variable a y pi (3.141593) a b. Se
usa el objeto FloatMath para agregar los valores de punto flotante almacenados por las variables a y b.
Finalmente usa el objeto FloatString para mostrar el resultado que queda almacenado en c.

3 Cargue el objeto FloatStringTest.spin en la EEPROM (F11), e inmediatamente despus
presione el botn Enable de la Terminal Propeller.
3 Verifique que la ventana de recepcin de la Terminal Parallax muestra 1.5 + Pi = 4.641593.

''FloatStringTest.spin
''Resuelve problema matemtico de punto flotante y muestra el resultado
''en la Terminal Serial.

CON

_xinfreq = 5_000_000

OBJ

fMath : "FloatMath"
fString : "FloatString"

PUB TwoWayCom | a, b, c

''Resuelve problema matemtico de punto flotante y muestra el resultado

Debug.start(31, 30, 0, 57600)
Waitcnt(clkfreq*2 + cnt)
Debug.tx(Debug#CLS)

a := 1.5
b := pi

c := fmath.FAdd(a, b)

Debug.str(String("1.5 + Pi = "))

debug.str(fstring.FloatToString(c))

Objetos que usan Direcciones Variables
Igual que los elementos en los bloques DAT las variables tambin tienen direcciones en RAM. Ciertos
objetos son diseados para iniciar con parmetros de direcciones variables. Frecuentemente corren en
Cogs separados y actualizan su salida basndose en un valor almacenado en variables del objeto
padre, o actualizan la variable del objeto padre basados en mediciones de datos de entrada, o ambos.

AddressBlinker es un ejemplo de objeto que toma valores de las variables de su objeto padre. El
mtodo Start tiene parmetros para dos valores de direcciones, pinAddress y rateAddress. El objeto
padre tiene que pasar al mtodo Start del objeto AddressBlinker la direccin de una variable que
almacena el numero de pin de E/S y otro que almacena el tiempo. El mtodo Start transmite estos
parmetros al mtodo Blink a travs de la llamada de mtodo en el comando cognew. As cuando el
Prctica de Objetos
mtodo Blink se inicia en un nuevo Cog tambin recibe copia de sus direcciones. Cada vez que el
ciclo repeat del mtodo Blink verifica los valores almacenados en las variables de su objeto padre
con pin := long[pinAddress] y rate := long[rateAddress]. Observe que como pinAddress and
rateAddress almacena la direccin el operador @ ya no se necesita.

L
Variables Globales vs. Locales : En este programa las variables pinAddress y rateAddressse pasan al
mtodo Start por el objeto padre como parmetros. EL mtodo Start transmite estos valores al mtodo Blink
como parmetros tambin. Ambos mtodos Start y Blink terminan con sus propias variables locales
pinAddress y rateAddress porque las variables locales solo son accesibles por el mtodo que las declara.
Otra prctica comn en hacer que el mtodo Start copie parmetros que recibe de variables globales
declaradas en el bloque de objeto VAR. Otros mtodos en el objeto pueden leer de y escribir a estas variables
globales segn se necesite. Tenga en cuenta que diferentes Cogs pueden ejecutar cdigo en diferentes
mtodos. Aun as ambos mtodos pueden trabajar con variables globales de objetos. N ejemplo de esta
prctica importante se demuestra en la siguiente practica Dentro del Objeto MonitorPWM en la pagina 167.

3 Examine el objeto AddressBlinker.spin y ponga atencin a las relaciones que acabamos de
discutir.

'' Archivo: AddressBlinker.spin
'' Ejemplo de administracin de Cog que ve variables en su objeto padre

VAR
byte cog 'Cog ID

PUB Start(pinAddress, rateAddress) : success
''Inicia un Nuevo proceso en un Cog Nuevo. Regresa True si tiene xito.
''Parmetros: pinAddress - long direccin de la variable que almacena el pin E/S
'' rateAddress - long direccin de la variable que almacena el tiempo
Stop
success := (cog := cognew(Blink(pinAddress, rateAddress), @stack) + 1)

PUB Stop
''Detiene el proceso blinking, si existe.

if Cog
cogstop(Cog~ - 1)

PRI Blink(pinAddress, rateAddress) | pin, rate, pinOld, rateOld

pin := long[pinAddress]
rate := long[rateAddress]
pinOld := pin
rateOld := rate

repeat
pin := long[pinAddress]
dira[pin]~~
if pin <> pinOld
dira[pinOld]~
!outa[pin]
pinOld := pin
rate := long[rateAddress]

El objeto AddressBlinkerControl demuestra una forma de declarar variables asignando sus valores y
pasando sus direcciones a un objeto que lo estar monitoreando, el objeto AddressBlinker en este
caso. Despus de pasar la direccin de sus variables pin y rateDelay al mtodo Start de
AddressBlinker el objeto AddressBlinker verifica estas variables entre cada cambio de estado de
LED. Si el valor de pin o rateDelay ha cambiado, AddressBlinker detecta esto y actualiza de acuerdo
a esto el pin LED o el tiempo de parpadeo.

3 Cargue el objeto AddressBlinkerControl.spin en la EEPROM (F11), y presione
inmediatamente el botn Enable de la Terminal Parallax.
3 Ingreso los nmeros de pins y retrasos de ciclos de reloj mostrados en la Figura 6-20 en la
ventana de transmisin de la Terminal y verifique que la aplicacin selecciona correctamente
el LED y determina la frecuencia de parpadeo.

Tan pronto como presione Enter el objeto AddressBlinker se actualizara basado en el nuevo valor
almacenado en las variables pin o rateDelay del AddressBlinkerControl.

Figura 6-20: Ingresando Pin y Tiempo en
la Terminal Serial

'' AddressBlinkerControl.spin
'' Ingresa el estado del LED en la Terminal Parallax y lo enva al chip '' Propeller a
travs de la Terminal Serial Parallax

CON

_xinfreq = 5_000_000

OBJ

AddrBlnk: "AddressBlinker"

VAR

long pin, rateDelay

PUB UpdateVariables

'' Actualiza variables que son observadas por el objeto AddressBlinker.

Debug.start(31, 30, 0, 57600)
Debug.tx(Debug#CLS)

pin := 4
Prctica de Objetos
rateDelay := 10_000_000

AddrBlnk.start(@pin, @rateDelay)

dira[4..9]~~

repeat

Debug.Str(String("Enter pin number: "))
pin := Debug.getDec
Debug.Str(String("Enter delay clock ticks:"))
rateDelay := Debug.getDec
Debug.Str(String(Debug#CR))

Mostrando Direcciones
En AddressBlinkerControl los valores de pin y rateDelay pueden mostrarse con Debug.Dec(pin) y
Debug.Dec(rateDelay). Las direcciones de pin y rateDelay pueden mostrarse con Debug.Dec(@pin)
y Debug.Dec(@rateDelay).

3 Inserte comandos que desplieguen las direcciones de las variables pin y rateDelay en la
Terminal Parallax justo antes de que comience el ciclo repeat y muestre el valor de esas
variables cada vez que se ingresan. Nota: El punto de este ejercicio en reforzar la distincin
entre un contenido de variable y su direccin.
Pasando Direcciones de Inicio a Objetos que trabajan con Lista de Variables
Algunos objetos monitorean o actualizan listas de variables long de otro cog, en este caso,
tpicamente tienen documentacin que explica el orden y tamao de cada variable que el objeto padre
necesita declarar. Este tipo de mtodos Start de objetos tpicamente solo esperan un valor, la
direccin de inicio de la lista de variables en el objeto padre. El objeto hijo toma esa direccin y la
usa para accesar el resto de la variables en el objeto padre.

AddressBlinkerWithOffsets es un ejemplo de un objeto del que el mtodo start espera la direccin
de inicio de una lista de variables. Diferente a AddressBlinker su mtodo Start solo recibe la
direccin de la variable del objeto padre que almacena el valor pin. Su documentacin requiere que la
variable almacene el retraso de la frecuencia de parpadeo para ser declarada, sin variables extra.

Como el parmetro baseAddress almacena la direccin de la variable de los objetos padre que
almacena el numero de pin, long[baseAddress][0] almacenara este valor. En cambio
long[baseAddress][1] accesara la variable que almacena la frecuencia de parpadeo. As es como el
programa obtiene ambos valores de variables con solo un parmetro de direccin.

3 Examine el objeto AddressBlinkerWithOffsets.spin. Note como su mtodo start necesita un
baseAddress que lo usa para encontrar variables en sus objetos padre que determinan el pin y
el retraso en el parpadeo.
3 Considere como esto puede ser aplicado a listas ms grandes de variables usando
considerando direcciones.

'' Archivo: AddressBlinkerWithOffsets.spin
'' Ejemplo de cog que observa variables en sus objetos padres
'' Objeto padre para declarar un long que almacena E/S LED y numero de pin
'' seguido por un long que almacena el numero de ciclos de reloj entre
'' cada cambio de estado de LED. Debe pasar la direccin del long que
'' almacena el numero de pin E/S de LED al mtodo Start.

VAR
byte cog 'Cog ID

PUB Start(baseAddress) : success
''Inicia un nuevo parpadeo en un cog Nuevo; regresa True si tiene xito.
''baseAddress...la direccin de la variable long que almacena el numero de pin LED.
''baseAddress + 1...la direccin de la variable long que almacena la frecuencia de
parpadeo.

Stop
success := (cog := cognew(Blink(baseAddress), @stack) + 1)

PUB Stop
''Detiene el proceso de parpadeo, si existe.

if Cog
cogstop(Cog~ - 1)

PRI Blink(baseAddress) | pin, rate, pinOld, rateOld

pin := long[baseAddress][0]
rate := long[baseAddress][1]
pinOld := pin
rateOld := rate

repeat
pin := long[baseAddress][0]
dira[pin]~~
if pin <> pinOld
dira[pinOld]~
!outa[pin]
pinOld := pin
rate := long[baseAddress][1]

Tenga en cuenta que el punto de este ejemplo es demostrar como un objeto padre puede pasar una
direccin base a su hijo y la documentacin requiere una lista de variables de tamao especifico que
tiene ciertos valores y son declarados en cierto orden. El objeto AddressBlinkerControlWithOffsets
trabaja con el objeto AddressBlinkerWithOffsets de esta forma para desarrollar la misma aplicacin
que en el ejemplo previo, seleccin de LED y Frecuencia por Terminal. Manteniendo la
documentacin del objeto AddressBlinkerWithOffsets, AddressBlinkerControlWithOffsets declara
una variable long para almacenar pin y la siguiente variable declara rateDelay. As pasa la direccin
de su variable pin al mtodo Start del objeto AddressBlinkerControl.

En este objeto la declaracin de variables es long pin, rateDelay crucial. Si el orden de estas dos
variables se intercambia la aplicacin no trabaja bien. Esto es, nuevamente, porque el objeto
AddressBlinkerWithOffsets espera recibir la direccin de una variable long que almacena el valor
pin, y espera la siguiente variable long consecutiva para almacenar la variable rateDelay. Ahora, est
bien declarar variables long antes y despus de estas dos. Es solo que pin y rateDelay tienen que ser
variables long y tienen que declararse en orden especfico por AddressBlinkerWithOffsets. La
direccin de inicio de la lista variable tambin tiene que pasarse al mtodo start del objeto hijo, en
este caso con AddrBlnk.start(@pin). Ponga atencin en este alcance de los objetos que son
diseados para trabajar con listas de variables long en sus objetos padre.

Prctica de Objetos
3 Prueba AddressBlinkerControlWithOffsets y verifique que es idnticamente funcional a
AddressBlinkerControl.
3 Examine como AddressBlinkerControlWithOffsets se disea de acuerdo de la documentacin
del objeto AddressBlinkerWithOffsets.

'' Archivo: AddressBlinkerControlWithOffsets.spin
'' Otro ejemplo de administrador de cog que se basa en un objeto que
'' observa variables en su objeto padre
''
'' Este mtodo Start solo pasa una direccin variable pero la usa como su
'' ancla para dos variables que se monitorean por ''AddressBlinkerWithOffsets.

CON

_xinfreq = 5_000_000

VAR

long pin, rateDelay

OBJ

AddrBlnk: "AddressBlinkerWithOffsets"

PUB TwoWayCom

''Enva mensajes de prueba y valores la Terminal Serial Parallax.

Debug.start(31, 30, 0, 57600)
Debug.tx(Debug#CLS)

pin := 4
rateDelay := 10_000_000

AddrBlnk.start(@pin)

dira[4..9]~~

repeat

Debug.Str(String("Ingrese el numero de pin: "))
pin := Debug.getDec
Debug.Str(String("Ingrese el retraso para 'rate':"))
rateDelay := Debug.getDec
Debug.tx(Debug#CR)

Tiempo de Estudio
Preguntas
1) Cules son las diferencias entre llamar un mtodo en el mismo objeto y llamar un mtodo en
otro objeto?
2) Llamar a un mtodo en otro objeto afecta la forma en que se pasan los parmetros y valores
de regreso?
3) Cules son los requerimientos de archivos que se tienen que satisfacer antes de que un
objeto pueda declarar exitosamente otro objeto?
4) Donde se puede ver la cadena de comando en la aplicacin?
5) Cmo se incluyen los comentarios en un objeto?
6) Cmo puede ver los comentarios de documentacin del objeto mientras filtra el cdigo?
7) Por regla, Que nombres de mtodos se usan para iniciar mtodos en nuevos cogs y detener
los cogs?
8) Qu puede hacer si un objeto administra un proceso en un cog nuevo pero usted quiere
iniciar ms de una ocurrencia de ese proceso en cogs mltiples?
9) Cul es el efecto neto de un mtodo Start de objeto llamando su mtodo Stop?
10) Cmo se ingresan caracteres especiales para esquemticos, medidas, expresiones
matemticas y diagramas de tiempo en los comentarios de objeto?
11) Cules son las diferencias entre mtodo pblico y privado?
12) Cmo se declaran mltiples copias de un objeto?
13) Donde se almacenan los objetos de Libreras Propeller?
14) Cmo se puede ver la informacin de un objeto?
15) En qu parte de RAM la directiva String hace que se almacene un cdigo de carcter?
16) Por qu un cero de terminacin de cadena es importante para el objeto FullDuplexSerial?
17) Que debe explicar el comentario de documentacin de un objeto acerca de un mtodo?
18) Cmo se pueden almacenar cadenas de caracteres aparte de la declaracin String
19) Cules son los tres diferentes usos de las palabras clave long, Word y byte en el lenguaje
Spin
20) Qu mtodo usa el objeto Float para sumar dos nmeros de punto flotante?
21) Qu mtodo se usa para mostrar nmeros de punto flotante como cadena de caracteres?
22) Es el comando a := 1.5 procesado por el objeto FloatMath?
23) Cmo se pasa una direccin de variable a un parmetro en un mtodo de otro objeto?
24) Cmo puede pasar una direccin a un mtodo de objeto reducir el nmero de parmetros?
25) Dada una direccin de variable Cmo un mtodo de objeto accesa valores almacenados en
esa variable y variables declaradas posteriormente?
26) Dada una direccin Puede un objeto monitorear un valor variable?
27) Dada una direccin Puede un objeto actualizar la variable en otro objeto usando esa
direccin?
Ejercicios
1) Dado el archive MyLedObject.spin, escriba una declaracin para otro objeto la misma carpeta
para que pueda usar sus mtodos. Use el apodo led.
2) Escriba un comando que llame un mtodo llamado on en un objeto apodado led. Este mtodo
requiere el parmetro pin (use 4).
3) Liste los valores decimales de los caracteres de la fuente Parallax que se requieren para
escribir esta expresin en un comentario de documentacin f = T.
4) Declare un mtodo privado llamado calcArea que acepte parmetros height y width y regrese
rea.
5) Declare cinco copias de un objeto llamado FullDuplexSerial (el cual podra ser usado para
cinco conexiones de comunicacin seriales simultaneas bidireccionales) Use el apodo uart.
6) Llame el tercer mtodo str del objeto FullDuplexSerial y enve la cadena Hola!!!. Asuma
el apodo uart.
7) Escriba un bloque DAT e incluya una cadena etiquetada Hi con la terminacin de cadena cero
Hola!!!.
8) Escriba un comando que calcule la circunferencia (c) de un crculo dado el dimetro (d).
Asuma que el objeto FloatMath ha sido apodado f.
9) Dada la variable c, la cual almacena un valor de punto flotante pase esto a un mtodo en
FloatString que regresa la direccin de la representacin de una cadena almacenada de un
valor de punto flotante. Almacene esta direccin en la variable address. Asuma el apodo fst.
Prctica de Objetos
Proyectos
1) TestBs2IoLiteObject usa llamadas de mtodo similares a los comandos del lenguaje de
programacin del micro controlador BASIC Stamp. Este objeto necesita un objeto Bs2IoLite
con mtodos como high, pause, low, in, y toggle. Escriba un objeto que soporte estas
llamadas a mtodos usando las descripciones en los comentarios

''Archivo superior: TestBs2IoLiteObject.spin
''Enciende LED en P6 por 1 s, despus parpadea LED P5 a 5 Hz cada ''que el botn
P21 se mantiene presionado.

OBJ

stamp : "Bs2IoLite"

PUB ButtonBlinkTime | time, index

stamp.high(6) ' Programa P6 como salida-alta
stamp.pause(1000) ' Retraso 1 s
stamp.low(6) ' Programa P6 como salida-baja
stamp.low(5) ' Programa P5 como salida-baja
repeat ' Repite (como DO...LOOP en PBASIC)
if stamp.in(21) ' Si se presiona P21
stamp.toggle(5) ' Cambia el estado de salida P5
else
stamp.low(5)
stamp.pause(100) ' Retrasa 0.1 s antes de repetir

2) Examine la longitud de de pila en la Librera Propeller, la longitud de pila en la carpeta Demo
de la Librera Propeller. Haga una copia de longitud de pila Demo.spin, y modifquela para
probar el espacio de pila requerido para iniciar el mtodo Blink del objeto Blinker (del inicio
de sta prctica) en un cog. Genere la conexin a la Terminal Serial Parallax basado en la
documentacin de StackLenthDemo para mostrar el resultado. NOTA: Las instrucciones para
usar el objeto Stack Lenght estn ocultas en los comentarios de TEORIA DE OPERACIN,
los cuales son visibles en modo de vista.

3) Algunas aplicaciones tendrn un reloj corriendo en un cog para mantener el tiempo. Abajo
esta una pantalla que se actualiza cada que el botn P23 de la plataforma PE se presiona y
suelta

La Terminal Parallax se actualice por el objeto de abajo TerminalButtonLogger.spin. Hay dos
llamadas al objeto TickTock. La primer llamada es Time.Start(0, 0, 0, 0), que inicia las
variables del objeto de TickTock day, hour, minute, y second. La segunda llamada de mtodo
es Time.Get(@days, @hours, @minutes, @seconds). Esta llamada de mtodo pasa la direccin
del objeto TickTock de las variables days, hours, minutes, y seconds del objeto
TerminalButtonLogger. El objeto TickTock actualiza estas variables con el tiempo actual.

La tarea en este proyecto es escribir el objeto TickTock que trabaje con el objeto
TerminalButtonLogger. Asegrese de usar la segunda tcnica de conteo del mtodo
GoodTimeCount de la prctica de E/S y Tiempo.

'' TerminalButtonLogger.spin
'' Graba las veces que el botn conectado a P23 se presiona/suelta
'' en la Terminal Serial Parallax.

CON
_xinfreq = 5_000_000

OBJ
Button : "Button"
Time : "TickTock"

VAR
long days, hours, minutes, seconds

PUB TestDatMessages

Debug.start(31, 30, 0, 57600) 'Inicia objeto FullDuplexSerialPlus.
waitcnt(clkfreq*3 + cnt) 'Espera tres segundos.
Debug.tx(Debug#CLS)

Time.Start(0, 0, 0, 0) 'Comienza objeto TickTock e
'inicializa el da, hora,
'minuto y Segundo.
Debug.Str(@BtnPrompt) 'Muestra instrucciones en
'La Terminal Serial Parallax
repeat

if Button.Time(23) ' Si se presiona el botn.
' Pasa variables al objeto
' TickTock para actualizar
Time.Get(@days, @hours, @minutes, @seconds)
DisplayTime ' Muestra el tiempo actual.

PUB DisplayTime

Debug.tx(Debug#CR)
Debug.Str(String("Day:"))
Debug.Dec(days)
Debug.Str(String(" Hour:"))
Debug.Dec(hours)
Debug.Str(String(" Minute:"))
Debug.Dec(minutes)
Debug.Str(String(" Second:"))
Debug.Dec(seconds)

Prctica de Objetos

DAT

BtnPrompt byte Debug#CLS, "Press/release P23 pushbutton periodically...", 0

7: Prctica de Mdulos Contadores y Aplicaciones de Circuitos
7: Mdulos Contadores y Aplicaciones de Circuitos
Introduccin
Cada Cog Propeller tiene dos Mdulos Contadores y cada modulo contador puede configurarse para
desarrollar tareas repetitivas independientemente. As que el chip Propeller no solo tiene la habilidad
de ejecutar cdigo simultneamente en cogs separados sino que cada cog puede tambin orquestar
hasta dos procesos adicionales con mdulos contadores mientras el cog contina ejecutando
comandos de programa. Los contadores pueden proporcionar una variedad de servicios como:

Medir Pulsos y Tiempo de Decadencia
Contar ciclos de seales y Medir Frecuencia
Enviar seales de oscilador numricamente controladas (NCO). Por ejemplo ondas cuadradas
Enviar seales de ciclos de fase cerrada (PLL) las cuales pueden ser tiles para ondas
cuadradas de mayor frecuencia
Deteccin de limite de seal
Conversiones Anlogo Digital (A/D)
Conversiones Digital Anlogo (D/A)
Proporcionar seales internas para generacin de video

Como cada modulo contador puede configurarse para desarrollar muchas de estas tareas en un tipo de
programe y olvide, es posible para un Cog ejecutar un programa mientras al mismo tiempo hace
cosas como generar tonos de bocina, controlar motores y servos, contar frecuencias de entrada y
transmitir y/o medir voltajes anlogos.

Esta prctica proporciona ejemplos de cmo usar 10 de 32 modos contadores diferentes para
desarrollar variaciones de 8 diferentes tareas:

Medicin de tiempo en Decadencia RC para potencimetros y foto resistores.
Conversin Digital Anloga para controlas luminosidad de LED
Seales NCO para enviar tonos de bocina
Seales NCO para IR modulada para objetos y deteccin de distancia
Contar ciclos de tonos de bocina
Detectar una transicin de seal
Control de Amplitud de Pulso
Generar seales de alta frecuencia para deteccin de metal

Un cog no tiene necesariamente que programar y olvidar un modulo contador. Tambin puede
dedicarse a procesar envolviendo mdulos contadores haciendo cosas increbles, incluyendo un
nmero de aplicaciones de audio y video. Esta prctica incluye un ejemplo que demuestra este tipo de
relacin cog-contador aplicada a enviar mltiples seales PWM.
Prerrequisitos de la Prctica

Configuracin y Pruebas
E/S y Tiempo
Mtodos y Cogs
Objetos
Prctica de Mdulos Contadores y Aplicaciones de Circuitos
Como trabajan los Mdulos Contadores
Cada cog tiene dos mdulos contadores, Contador A y Contador B. Cada cog tiene tambin tres
registros de propsito especial de 32-bit para cada uno de sus mdulos contadores. Los registros
especiales del contador A son phsa, frqa, ctra, y el B phsb, frqb y ctrb. Note que cada nombre de
contador es tambin una palabra reservada en Spin y Ensamblador Propeller. Si esta prctica esta
refirindose a un registro generalmente pero no importa si es contador A o B usara nombres genricos
PHS, FRQ, y CTR.

Aqu se muestra como cada uno de los tres registros trabaja en un modulo contador:

PHS El registro Fase se actualice cada ciclo de reloj. Un modulo contador puede tambin
configurarse haciendo que ciertos bits de registros PHS afecten pines de E/S.
FRQ El registro Frecuencia es condicionalmente agregado al registro PHS cada ciclo de
reloj. El modo del modulo contador determina que condiciones ocasionan que FRQ se
agregue a PHS. Las opciones de Modo incluyen always, never y opciones condicionales
basadas en estados de pin de E/S o transiciones
CTR El registro Control configure ambos modos, el modulo contador y Pins de E/S que
son monitoreados y/o controlados por el modulo contador. Cada modulo contador tiene 32
modos diferentes, dependiendo del modo puede monitorear y/o controlar hasta dos pin de E/S
Midiendo Descarga RC con un Detector de Modo Positivo
La descarga Resistor-Capacitor (RC) es til para una variedad de mediciones de sensores. Algunos
ejemplos incluyen:

Posicin de perilla o joystick con uno o ms potencimetros
Niveles de ambientacin de luces con Resistencia dependiente o fotodiodo
Reflectividad de superficie infrarroja con un LED infrarrojo y fototransistor
Presin con platos capacitivos y
Presin con placas del capacitor y un dielctrico compresibles
Salinidad de un liquido con puntas de metal
Circuito de Descarga RC
Las mediciones de descarga RC se desarrollan tpicamente cargando un capacitor (C) y despus
monitoreando el tiempo que tarda el capacitor en descargarse a travs de una resistencia (R). En la
mayora de los circuitos de descarga RC uno de los valores es fijo y el otro vara con la variable
ambiental. Por ejemplo el circuito en la Figura 7-1 se usa para medir la posicin de una perilla. El
valor de C es fijo a 0.01 F, y el valor de R vara con la posicin del potencimetro al ajustar la perilla
(la variable ambiental)

3 Construya el circuito mostrado en la Figura 7-1 es la Plataforma PE. Este circuito y otros en
esta prctica son adicionales al circuito bsico construido en Configuracin y Prueba.

Figura 7-1: Descarga RC Partes y Circuito
Lista de Partes Esquemtico

(1) Potencimetro 10 k P17
(1) Capacitor - 0.01 F
(misc) Cables - R 0.01 F
~ ~
GND GND

Midiendo Descarga RC
Antes de tomar la medicin de descarga RC, el chip Propeller necesita programar el pin E/S
conectado al circuito en Salida Alta. Esto carga el capacitor hasta 3.3 V como se muestra en el lado
izquierdo de la Figura 7-2. De esta forma el chip Propeller inicia la medicin de descarga al
programar el pin E/S a entrada, como se muestra en la derecha de la Figura 7-2. Cuando el pin E/S
cambia a Entrada el capacitor se carga y comienza a descargar a travs de la resistencia variable. El
tiempo que le toma al capacitor para descargarse de 3.3V hasta el punto de cambio del pin 1.65 V es:

t = 0.693 C R

Como 0.693 y C son constantes el tiempo t que le toma para descargar el circuito es directamente
proporcional a R, la resistencia variable.

Figura 7-2: RC Carga y Descarga Circuitos y Voltajes

Carga Circuito Descarga Circuito
(I/O pin = output-high) (I/O pin = input)

3.3 V
Vc Vc
i
I/O Pin

ir| ic| | i |
- R C - R C

~ ~ ~ ~
GND GND GND GND

3.3 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

1.65 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

|
0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Vc (V) t, (s) t t = 0.693 C R

L
Dnde est la resistencia en serie de limitadores de corriente?
El pin E/S del chip Propeller puede controlar circuitos que no necesitan protegerse de un pico de corriente
inicial que resulte cuando el pin E/S est tomando su salida baja o entrada alta. La capacidad de salida del
pin E/S y lmite de corriente previene de cualquier dao.
Si usted trata de usar este circuito con otro micro controlador, probablemente necesitara incluir una
resistencia limitadora de corriente entre el pin E/S y el circuito RC. Asegrese que sea lo suficientemente
grande para prevenir daos del pin E/S.
Detector Positivo de Modos
Hay dos opciones de detectores positivos de Modo, regular y con retroalimentacin. El modo
regular el modulo contador del chip Propeller monitorea un pin E/S y agrega FRQ a PHS por cada
ciclo de reloj en el cual el pin esta en alto. Para hacer que el registro PHS acumule el numero de
ciclos de reloj en el cual el pin esta en alto solo programe el registro del contador de modulo a 1. Para
medir la descarga RC el modulo contador deber comenzar a contar (sumando FRQ = 1 para PHS)
tan pronto como el pin E/S se cambia de salida alta a entrada. Despus que la seal de descarga esta
debajo de 1.65V el modulo ya no agrega FRQ a PHS y lo que se almacena en PHS es el tiempo de
descarga medida en ciclos de reloj.

Una ventaja significativa para usar el modulo contador para medir descarga RC es que el cog no tiene
que esperar a que termine la descarga. Como el contador automticamente incrementa PHS con cada
ciclo de reloj en el cual el pin esta en alto el programa est libre para moverse en otra tareas. El
programa puede obtener el valor del registro PHS en cualquier momento que sea conveniente.

Configurando un Modulo Contador para Detector Positivo de Modo
La Figura 7-3 muestra extractos de la Tabla de Modo de Contadores del Objeto CTR de la Librera
Propeller. El Objeto CTR tiene informacin de un modulo contador y un ejemplo de cdigo que
genera onda cuadradas. La Tabla de Modo del objeto CTR lista las 32 opciones de modo, siete de las
cuales se muestran abajo. El modo que usaremos para la descarga RC es Detector Positivo (sin
retroalimentacin), mostrado como POS detector en los extractos de la tabla.

Figura 7-3: Extractos de la Tabla de Modos Contadores en CTR.spin
Acumula APIN BPIN
CTRMODE Descripcin FRQ to PHS output* output*

%00000 Counter disabled (off) 0 (never) 0 (none) 0 (none)

.
.

%01000 POS detector A 0 0
%01001 POS detector w/feedback A 0 !A
%01010 POSEDGE detector A & !A 0 0
%01011 POSEDGE detector w/feedback A & !A 0 !A

.
.

%11111 LOGIC always 1 0 0

* Debe programar el correspondiente bit DIR para afectar el PIN

A = APIN entrada retrasada por 1 clock
A = APIN entrada retrasada por 2 clocks
B = BPIN entrada retrasada por 1 clock

Note como cada modo contador en la Figura 7-3 tiene un correspondiente cdigo de 5-bit
CTRMODE. Por ejemplo el cdigo para POS detector as %01000. Este valor tiene que copiarse a
un campo de bit con el registro CTR del modulo contador para hacer su funcin en modo POS
detector. La Figura 7-4 muestra el mapa de registro para los registros ctra y ctrb. Note como el
mapa de registro nombra los bits 31..26 CTRMODE. Estos son los bits del cdigo 5-bit de
CTRMODE en la Figura 7-3 que tienen que copiarse para operar un modulo contador en un modo
particular.

Figura 7-4: Mapa de Registro CTRA/B de CTR.spin

bits 31 30..26 25..23 22..15 14..9 8..6 5..0

Name CTRMODE PLLDIV BPIN APIN

Al igual que los registros dira, outa e ina los registros ctra y ctrb son bit-direccionales, as el
procedimiento para asignar y limpiar en este registro es el mismo que seria para un grupo de
operaciones de pins E/S con dira, outa, o ina. Aqu se muestra un ejemplo para hacer Counter A un
POS detector:

ctra[30..26] := %01000

L
La Tabla de Modos Contadores y el Mapa de Registro aparecen en el Objeto CTR de la Librera Propeller
y tambin en el Manual Propeller en la seccin CTRA/B localizada en el captulo de Referencia Spin. APIN y
BPIN son pins de E/S que el modulo contador puede controlar, monitorear o no usar dependiendo del modo.

Note tambin en la Figura 7-4 como hay campos de bits para PLLDIV, BPIN, y APIN. PLLDIV es el
nombre corto para ciclo divisor de fase cerrada y es usado solo para modo contador PLL el cual
puede sintetizar ondas cuadradas de alta frecuencia. APIN (y BPIN para modo de dos pins) tienen que
almacenar los nmeros de pins E/S que el modulo contador va a monitorear o controlar. En el caso
que el contador A coloque a modo POS frqa se suma a phsa basado en el estado del APIN durante el
reloj anterior. (Vea referencia A y pie de nota en la Figura 7-3). As el bit de campo APIN tiene que
almacenar el valor 17 ya que P17 va a monitorear el circuito RC. Este es un comando que programa
los bits 5..0 del registro ctra a 17:

ctra[5..0] := 17

Recuerde que frqa se agrega a phsa con cada ciclo de reloj donde APIN est en alto. Para hacer que
el contador identifique cuantos ciclos de reloj el pin esta en alto simplemente programe frqa a 1:

frqa := 1

En este punto se le agrega 1 al registro phsa por cada ciclo de reloj en el cual el voltaje que se le
aplica a P17 est por encima del disparo lgico 1.65V. La nica cosa que tiene que hacer antes de
comenzar la medicin de la descarga es limpiar el registro phsa.

En suma, configurar el modulo contador para que cuente los ciclos de reloj cuando un pin E/S esta en
Alto toma 3 pasos:

1) Almacenar %01000 en el campo de bit CTRMODE del registro CTR :

ctra[30..26] := %01000

2) Almacenar en el campo APIN del registro CTR el numero de pin E/S que quiere monitorear:

ctra[5..0] := 17

3) Almacenar 1 en el registro FRQ para que el registro phsa agregue un 1 por cada ciclo del
reloj en el que P17 est en alto:

frqa := 1

1 no es el nico valor til para el registro FRQ. Otros valores de registro FRQ pueden usarse para
medir el sensor de entrada para clculos o incluso para activar actuadores. Por ejemplo FRQ puede
programarse como clkfreq/1_000_000 para contar la descarga en microsegundos.

frqa := clkfreq/1_000_000

Esta expresin trabaja para el sistema de reloj del chip Propeller en frecuencias que normalmente son
mltiplos de 1MHz. Por ejemplo trabajar bien con una entrada de cristal de 5 MHz pero no con una
de 4.096 MHz ya que los resultados de la frecuencia del reloj no sern mltiplos exactos de 1 MHz.

Una desventaja de valores muy grandes de FRQ es que el programa no pude necesariamente
compensar el numero de ciclos de reloj entre la limpieza del registro y poner la entrada del pin E/S a
1. Un comando que compensa esta fuente de error se puede agregar despus que el ciclo de reloj se
termino y puede continuarse con un comando que convierte a una medida conveniente tal como
microsegundos.

L
Midiendo seales de entrada o salida. Este modo contador puede usarse para medir la duracin en la cual
un pin E/S enva una seal alta y su duracin en la que esa seal se aplico a la entrada E/S. La nica
diferencia es la direccin del pin E/S cuando se toma la medida.
Contando la Medida de Descarga RC
Antes de la medicin de descarga RC el capacitor deber estar cargado. Aqu hay una pieza de cdigo
que pone P17 como salida alta luego espera 10s lo cual es ms que suficiente para cargar el
capacitor en la red RC de la Figura 7-1.

dira[17] := outa[17] := 1
waitcnt(clkfreq/100_000 + cnt)

Para empezar la medicin de la descarga limpie el registro PHS y luego ponga el pin E/S que est
cargando el capacitor como entrada:

phsa~
dira[17]~

Despus de limpiar phsa y dira, el programa queda libre para desarrollar otras tareas durante la
medicin. En algn tiempo el programa puede regresar y copiar el contenido del registro phsa a una
variable. Por supuesto el programa deber asegurarse de esperar suficiente tiempo para que se
complete la medicin. Esto se puede hacer al muestrear el reloj, esperando a que el pin de descarga
pase a bajo o desarrollando una tarea conocida que es mayor que el tiempo de descarga.

Para completar la medicin copie el registro phsa a otra variable y reste 624 de esta para contar el
numero de ciclos de reloj entre phsa~ y dira[17]~. El resultado de esta resta puede programarse a un
mnimo de 0 con #> 0. Esto tendr mayor sentido que -624 cuando la resistencia es tan baja que jala
la salida del pin E/S de salida alta a baja.

time := (phsa 624) #> 0

L
De donde viene 624?
El numero de ciclos de reloj entre phsa~ y dira[17]~ se determine reemplazando 0.01 F capacitor con un
capacitor de 100 pF y encontrando el valor ms bajo antes de que un cero se regresara. En el programa de
prueba time := phsa reemplaza time := (phsa 624) #> 0, y el valor medible ms bajo fue 625.
Ejemplo de Objeto que mide el Tiempo de Descarga RC
El objeto TestRcDecayaplica la tcnica que acabamos de discutir para medir la descarga RC en un
circuito con Resistencia variable controlada por la posicin de una perilla de ajuste de potencimetro.
Como se muestra en la Figura 7-5, el programa muestra un mensaje working on other tasks
despus de iniciar la medicin de descarga para demostrar que el modulo contador automticamente
incrementa el registro phsa hasta que el voltaje aplicado a P17 se descarga debajo de 1.65 V. El
programa puede entonces verificar despus para encontrar el valor almacenado en phsa.

Figura 7-5: Tiempos de Descarga RC

L
La mayora de los ejemplos en esta prctica son objetos superiores que demuestran detalles de trabajo en los
mdulos contadores. Si usted planea incorporar estos conceptos en una librera de objetos diseados para
ser usados por otras aplicaciones asegrese de poner atencin en la seccin titulada: Prueba y Muestra PWM
Agrega un Objeto, Cog y Par de Contadores
que comienza en la pagina 162.

3 Abra el objeto TestRcDecay.spin. Llamara mtodos en FullDuplexSerialPlus.spin, asegrese
de que estn grabados en la misma carpeta.
3 Abra la Terminal Serial Parallax y programe su Puerto COM para usar el mismo Puerto que
la Herramienta Propeller usa para cargar programas en el chip Propeller.
3 Use la herramienta Propeller para cargar TestRcDecay.spin en el chip Propeller.
3 Presione el botn Enable inmediatamente. (No espere a que el programa termine de cargar.
De hecho puede presionar el botn inmediatamente despus de presionar F10 o F11 en la
herramienta Propeller)
3 Pruebe ajustando el potencimetro a varias posiciones y note los valores del tiempo. Estos
debern variar en proporcin a la posicin de la perilla.

'' TestRcDecay.spin
'' Prueba mediciones de descarga Circuito RC

CON

_clkmode = xtal1 + pll16x ' Reloj de Sistema 80 MHz
_xinfreq = 5_000_000

CR = 13

OBJ

Debug: "FullDuplexSerialPlus" ' Use con la terminal Serial
' Parallax para desplegar valores

PUB Init

'Inicia comunicacin serial y espera 2 s para conexin a la Terminal Serial Parallax.

Debug.Start(31, 30, 0, 57600)

' Configura el Modulo Contador.

ctra[30..26] := %01000 ' Modo a "POS detector"
ctra[5..0] := 17 ' Pone APIN a 17 (P17)
frqa := 1 ' Incrementa phsa 1 por cada ciclo de reloj

main ' Llama al mtodo Main

PUB Main | time
'' Repetidamente toma y despliega las mediciones de descarga de P17

repeat

' Charge RC circuit.

dira[17] := outa[17] := 1 ' Pone pin a salida alta
waitcnt(clkfreq/100_000 + cnt) ' Espera a cargar circuito

' Inicia medida descarga RC. Automticamente despus esto...

phsa~ ' Limpia el registro phsa
dira[17]~ ' Pin a entrada detiene carga

' Opcional Hacer otras cosas durante la medicin.

Debug.str(String(CR, CR, "Working on other tasks", CR))
repeat 22
Debug.tx(".")

' Medicin lista hace tiempo. Ajusta ciclos entre phsa~ y dira[17]~.

time := (phsa - 624) #> 0

' Display Result

Debug.Str(String(13, "time = "))
Debug.Dec(time)

Dos mediciones simultaneas de descarga RC
Como un modulo contador rastrea el tiempo en alto despus de que empieza la descarga y como cada
Cog tiene dos mdulos contadores es posible tomar mediciones simultaneas de descarga RC en pins
diferentes con un solo Cog. La Figura 7-6 muestra un ejemplo de un Segundo circuito conectado a
P25 para medir descargas simultneamente. En vez de un potencimetro para medir la posicin de la
perilla este circuito tiene un fototransistor para medir el nivel de luz en interiores. El monto de
corriente del fototransistor permite pasar en su terminal colectora (C) y de regreso en su terminal
Emisora (E) es controlada por la intensidad de luz brillando en su base (B). Si la luz es ms brillante
el fototransistor permite pasar ms corriente lo que resulta en una descarga ms rpida del capacitor.
Si la luz es menos brillante el fototransistor permite el paso de menor corriente resultando en tiempo
de descargas ms lentas.
3 Localice el fototransistor en las partes del Kit PE. Hay tres partes con encapsulado
transparente que se parecen al fototransistor infrarrojo de la derecha de la Figura 7-6. Las dos
partes idnticas son diodos emisores de luz infrarroja. La tercer parte tiene un encapsulado
ligeramente ms pequeo, ese es el fototransistor infrarrojo.
3 Construya el circuito mostrado en la Figura 7-6.

Figura 7-6: Segunda Descarga RC Partes y Circuito
Lista de Partes Esquematico

100
(1) Resistencia - 100 P25 /
(1) Fototransistor
(1) Capacitor - 0.1 F Foto- ' 0.1 F
(misc) cables transistor ~ ~
GND GND

L
La Resistencia en serie de 100 en la Figura 7-6 previene sobrecargas en el capacitor cuando el pin E/S
cambia de entrada a salida alta. Tenga en cuenta que el fototransistor conduce ms corriente cuando la luz es
ms brillante. De forma que bajo condiciones de luz brillante, la resistencia en serie reduce la carga del
fototransistor de lo contrario se pondra en el pin E/S como se carga en el capacitor.
Con un fototransistor en el circuito, la resistencia de 100 no previene al capacitor de cargarse a 3.3 V antes de
la medicin de descarga. Si el fototransistor fuera reemplazado por un sensor resistivo de luz, menores
resistencias podran terminar en voltajes iniciales menores antes de que la medicin de descarga inicie.

TestRcDecay.spin puede modificarse para usar el contador B para medir niveles de luz durante un
periodo paralelo a la medicin de descarga de la perilla del potencimetro en el contador A. Como un
Cog controla ambas mediciones, las inicia secuencialmente- una despus de la otra. Sin embargo
como ambos contadores pueden rastrear el tiempo de descarga independientemente el cdigo del Cog
no tiene que esperar a que termine la primera medicin antes de comenzar la segunda. Puede iniciar
ambas, una inmediatamente despus de la otra, moverse a otras tareas y revisar los resultados en los
registros de fase posteriormente. Un enfoque para modificar TestRcDecay.spin par alas dos
mediciones podra ser comenzar convirtiendo ka variable time a dos arreglos de elementos as cada
medicin se almacena en un elemento diferente.

PUB Main | time[2]

Cada modulo contador puede programarse a detector de modo positivo, con uno monitoreando P17 y
el otro monitoreando P25, como esto:

' Configurar mdulos contadores.

ctra[30..26] := %01000 ' Modo a "POS detector"
ctra[5..0] := 17 ' Activa APIN en 17 (P17)
frqa := 1 ' Incrementa phsa 1 por cada ciclo de
reloj

ctrb[30..26] := %01000 ' Modo a "POS detector"
ctrb[5..0] := 25 ' Activa APIN en 25 (P25)
frqb := 1 ' Incrementa phsb 1 por cada ciclo de
reloj

Ambos pins E/S pueden activarse a salida alta para cargar ambos capacitores antes de comenzar la
medicin de descarga. El capacitor en el circuito fototransistor es 10 veces mayor que el del circuito
del potencimetro y hay tambin una resistencia limitando la corriente de carga del capacitor, as que
C E
B
tomara quiz un poco mas de tiempo para cargar. El retraso antes de comenzar la medicin puede
incrementarse de 10 s a 100 s cambiando clkfeq/100_000 a clkfreq/10_000.

' Carga Circuitos RC.

dira[17] := outa[17] := 1 ' Activa pin a salida-alta
dira[25] := outa[25] := 1 ' Activa pin a salida-alta
waitcnt(clkfreq/10_000 + cnt) ' Espera a cargar el circuito

Como los mdulos contadores estn midiendo el tiempo de descarga el Cog puede empezar cada
medicin en sucesin rpida sin esperar a que termine la primera antes de comenzar la segunda. La
medicin del potencimetro empieza al limpiar phsa y dira[17]. Cuando se limpia dira[17] el pin
E/S se convierte en entrada. Como entrada no entrega ninguna carga al capacitor y comienza la
descarga. Posteriormente la medicin del fototransistor comienza limpiando phsb y dira[25]:

' Comienzan mediciones de descarga RC...

phsa~ ' Limpia registro phsa
phsb~ ' Limpia registro phsb

Despus de que ha pasado suficiente tiempo el contenido de un registro de fase puede copiarse en la
variable time[0] y el otro en la variable time[1]:

' Mediciones listas por largo tiempo. Ajuste ciclos entre phsa~
' y dira[17]~. Repita para phsb.

time[0] := (phsa - 624) #> 0
time[1] := (phsb - 624) #> 0

Al final pero no menos importante despliegue ambos resultados:

' Despliega Resultados

debug.Str(String(13, "time[0] = "))
debug.Dec(time[0])
debug.Str(String(13, "time[1] = "))
debug.Dec(time[1])

3 Haga una copia de TestRcDecay.spin.
3 Use el enfoque discutido para modificar la copia y medir el circuito de la Figura 7-1 y la
Figura 7-6 al mismo tiempo.

El cdigo no tiene que esperar por un periodo fijo de tiempo antes de verificar los registros. Puede
encontrar si se realizo una medicin verificando el estado del pin E/S. Despus de que la medicin de
descarga comenz si ina[17] almacena un 1 significa que la descarga aun est en proceso por lo que
no se debe verificar phsa todava. Si en cambio almacena un 0 la medicin se complet. Igualmente si
ina[25] almacena un 1 la medicin de la luz aun esta en proceso y no se tiene que verificar phsb
todava. Hay una modificacin sencilla que hace que el Cog espere a que terminen ambas mediciones
antes de copiar el contenido de los registros a las variables time:

' Espera a que terminen ambas mediciones. Estonces ajusta los ciclos
' entre phsa~ y dira[17]~. Repite para phsb.

repeat until ina[17] == 0 and ina[25] == 0

time[0] := (phsa - 624) #> 0
time[1] := (phsb - 624) #> 0

Con todos los retrasos en el cdigo no hay una diferencia apreciable. Se hace ms evidente cuando se
comenta el cdigo que ocasiona los retrasos (excepto el waitcnt que da a los capacitores el tiempo de
carga). Tambin ayuda declarar una variable para contar la repeticiones del ciclo repeat y mostrar su
valor entre cada medicin. Con este arreglo se podr observar cuantas mediciones se toman por
segundo.

3 Intntelo.
Conversin D/A Controlando luminosidad del LED con Modos DUTY
Hay dos opciones de modos DUTY, terminacin sencilla y diferencial. Un modulo contador en
terminacin sencilla permite controlar una seal que puede ser usada por conversin digital a anloga
con el registro FRQ. Aun si la seal cambia rpidamente entre alto y bajo el tiempo promedio que
esta alto (duty) es determinada por la proporcin del registro FRQ a 2
32
.

pin high time FRQ
duty = =
time 4_294_967_296

Eq. 1

Para conversin D/A vamos a decir que el programa tiene que enviar una seal 0.825 V. Eso es 25%
de 3.3 V por lo que se requiere 25% de una seal duty. Calcular el valor a almacenar en el registro
FRQ es simple. Solo coloque duty = 0.25 y resuelto para FRQ.

FRQ
0.25 = FRQ = 1_073_741_824
4_294_967_296

Tambin puede usar la Eq 1 para calcular que seal de tarea est enviando un objeto. Vamos a decir
que el valor 536,870,912 es almacenado en un registro de modulo contador y su registro CTR lo ha
configurado a modo DUTY de terminacin sencilla.

536_870_912
duty = = 0.125
4_294_967_296

En una escala de 3.3 V eso resultara 0.4125 V. Nuevamente el gran detalle de los contadores es que
pueden hacer sus tareas sin atar un cog. As el cog gestara libre para continuar ejecutando comandos
mientras el contador cuida de mantener la seal de tarea de la conversin D/A.
Como trabaja el modo DUTY de terminacin sencilla
Cada vez que FRQ se suma a PHS el sumador de fase del modulo contador (que suma FRQ a PHS
con cada ciclo reloj) activa o limpia una bandera de acarreo. Esta operacin de acarreo es similar a la
operacin de acarreo de la suma decimal. Vamos a decir que est permitido 3 posiciones decimales y
se intenta agregar dos valores que suman ms de 999. Algn valor normalmente no sera acarreado de
los cientos a los miles. La versin binaria de la suma con acarreo se aplica cuando el registro FQR se
suma al registro PHS cuando el resultado es mayor que 2
32
1. Si el resultado excede este valor la
bandera de acarreo del sumador PHS se activa.

Lo interesante es que la bandera de acarreo es que, el tiempo en el que es 1, es proporcional al valor
almacenado en el registro FRQ dividido por 2
32
. En modo DUTY de terminacin sencilla el bit de
acarreo del sumador de fase del modulo contador controla el estado de salida de un pin de E/S. Como
el tiempo en el cual el bit de acarreo del sumador de fase es 1 es proporcional a FRQ/2
32
es lo mismo
para el estado de salida del pin E/S. El pin E/S puede cambiar rpidamente entre alto y bajo pero el
promedio en el que el pin esta en alto es determinado por FRQ-to-2
32
mostrado en la ecuacin Eq. 1.

Partes y Circuitos
Si, de regreso a LEDs por un poco ms y despus nos moveremos a otros circuitos. Prcticas previas
usan LEDs para indicar el estado de pins E/S y tiempo. Esta porcin de la prctica usara modo DUTY
de terminacin sencilla para conversin D/A para controlar el brillo de un LED.

Figura 7-6: Circuito LED para control de iluminacin con seales Duty


(4) Resistencia 100 verde
(2) LEDs - verde 100 LED
(2) LEDs - amarillo P4 -/|!
(misc) cables verde
100 LED
P5 -/|!
amarillo
100 LED
P6 -/|!
amarillo
100 LED
P7 -/|!
~
GND

3 Agregue el circuito mostrado en la Figura 7-6 a la Plataforma PE, deje el circuito de descarga
RC en su lugar.
Configurando un Contador para modo DUTY
La Figura 7-7 muestra ms entradas del objeto CTR en la tabla del Modo Contador del Manual
Propeller. Como se menciono previamente los dos tipos de modos DUTY son terminacin sencilla y
diferencial.
Con modo DUTY de terminacin sencilla el APIN es un espejo del estado del bit de acarreo. As que
si FRQ es programado a un valor de 1,073,741,824 calculado anteriormente el APIN deber estar alto
del tiempo. Un circuito LED recibiendo esta seal parecer que brilla a de su brillo total.

Con modo DUTY de terminacin sencilla el APIN es un espejo del estado del bit de acarreo del bit de
acarreo, mientras BPIN es el valor opuesto. As que cada que el bit de acarreo del sumador de fase (y
APIN) son 1, BPPIN es 0 y viceversa. Si FRQ se programa a 1,073,741,824, APIN debera hacer que
un LED brille a de luminosidad mientras BPIN brilla a .

Figura 7-7: Mas extractos de la Tabla de Modo de Contadores CTR.spin

Acumulado APIN BPIN
CTRMODE Descripcin FRQ to PHS salida* salida*

%00000 Contador deshabilitado(off) 0 (never) 0 (none) 0 (none)

.
.
.

%00110 DUTY terminacin sencilla 1 PHS-Carry 0
%00111 DUTY diferencial 1 PHS-Carry !PHS-Carry

.
.
.

%11111 LOGIC siempre 1 0 0

* debe programar el bit DIR para afectar el pin


La Figura 7-8 es una repeticin de la Figura 7-4. De la Figura 7-4 sabemos que el valor almacenado
en el campo del bit CTRMODE del registro CTR es %00110 (DUTY terminacin sencilla) o %00111
(DUTY diferencial). Entonces el bit APIN (y opcionalmente BPIN) tienen que activarse como pins
E/S que transmitirn las seales DUTY.

Figura 7-8: CTRA/B Mapa de registro de CTR.spin

bits 31 30..26 25..23 22..15 14..9 8..6 5..0

Nombre CTRMODE PLLDIV BPIN APIN

La aplicacin de descarga RC activa el registro FRQ a 1 y el resultado fue que se sumo 1 a PHS por
cada ciclo de reloj en el cual el pin monitoreado estaba alto. En esta aplicacin el registro FRQ est
programando valores que controlan el tiempo en alto de una seal DUTY aplicada a un pin E/S. No
hay condicin para sumar con modo duty; FRQ se suma a PHS cada ciclo de reloj.
Activando una seal Duty
Aqu tiene unos pasos para activar una seal duty tambin con un contador:

(1) Active el campo de bit CTRMODE del registro CTR para escoger el modo.
(2) Active el bit APIN del registro CTR para escoger el pin.
(3) Si usted est usando modo DUTY diferencial active el campo BPIN del registro CTR.
(4) Active el pin(s) E/S a salida.
(5) Active el registro FRQ a un valor que le de el porcentaje de la seal duty que desea

Ejemplo Enviar una seal duty de 25% a P4 usando el contador A.

(1) Active el campo de bit CTRMODE del registro CTR para escoger el modo. Recuerde que los bits
30..26 del registro CTR (mostrado en la Figura 7-8) tienen que activarse al patrn seleccionado de la
lista CTRMODE en la Figura 7-7. Por ejemplo aqu hay un comando que configura el modulo
contador para operar en modo DUTY de terminacin sencilla

ctra[30..26] := %00110

(2) Active el bit APIN del registro CTR para escoger el pin. La Figura 7-8 indica que APIN es los
bits 5..0 en el registro CTR. Un ejemplo que activa los bits APIN del registro ctra a 4, el cual
controla el LED verde conectado a P4.

ctra[5..0] := 4

Nos saltaremos el paso (3) ya que el modulo contador se configure como modo DUTY de
terminacin sencilla.

(4) Active el pin(s) E/S a salida.

dira[4]~~

(5) Active el registro FRQ a un valor que le de el porcentaje de la seal duty que desea. Para de
brillo, use duty 25%. Active el registro frqa a 1_073_741_824 (calculado anteriormente).

frqa := 1_073_741_824
Claves para activar DUTY con el Registro FRQ
Como los registros de propsito especial inicializan a cero, frqa es 0 as que 0 es repetidamente
sumado al registro PHS resultando en no cambios de estado del LED. Tan pronto como el programa
activa el registro FRQ a alguna fraccin de 2
32
el pin E/S y el LED comenzara a enviar la seal duty,

Teniendo 2
32
diferentes niveles de iluminacin no es prctico, pero 256 diferentes niveles trabajaran
bien. Un forma simple de llegar a esto es declarando una constante que es 2
32
256.

CON

scale = 16_777_216 ' 2
32
256

Ahora el programa puede multiplicar la escala constante por un valor entre 0 y 255 para tener 256
niveles de iluminacin. Si se quiere de brillo multiplique la escala por de 256.

frqa := 64 * scale

L
Variacin de Tiempo D/A y Filtro: Cuando se modula el valor de frqa para enviar seales de variaciones de
tiempo un circuito RC filtran la seal tpicamente. Es mejor usar una fraccin ms pequea que la seal de
uso, decir 25% a 75% o 12.5% a 18.75%. Manteniendo la seal en este rango el D/A ser menos ruidoso y
resistencias y capacitores ms pequeos se pueden usar para respuestas ms rpidas. Esto es importante
para seales que varan rpidamente tales como audio, lo cual ser visto en otra practica.
R
Seal duty -/ voltage
C
~
GND

Cdigo Ejemplo de Modo DUTY de Terminacin Sencilla
El objeto LedDutySweep.spin demuestra los pasos para configurar un contador DUTY terminado
sencillo y transmisin de una seal duty con un pin E/S. Tambin cambia una variable duty de 0 a
255 repetidamente provocando que el LED en P4 incremente gradualmente en brillo y se apague.

3 Cargue el objeto LedDutySweep en el chip Propeller y observe el efecto.

''LedDutySweep.spin
''Ciclo de LED P4 de apagado, brillo parcial, brillo complete.

CON

scale = 16_777_216 ' 2 256

PUB TestDuty | pin, duty, mode

'Configura el modulo contador.

ctra[30..26] := %00110 ' Activa ctra a modo DUTY
ctra[5..0] := 4 ' Activa APIN de ctra
frqa := duty * scale ' Activa registro frqa

'Usa contador para tomar un LED de apagado a brillo completo repitiendo a 2 Hz.

dira[4]~~ ' Activa P5 como salida

repeat ' Repite indefinidamente
repeat duty from 0 to 255 ' Cambia duty de 0 a 255
frqa := duty * scale ' Actualiza registro frqa
waitcnt(clkfreq/128 + cnt) ' Retrasa por 1/128 s

Modos Duty de Terminacin Sencilla vs. Diferencial
Diferencial es la segunda opcin para modos DUTY, al igual que muchos otros modos contadores.
Las seales diferenciales son tiles para obtener seales a travs de lneas de transmisin ms largas
y se usan en Ethernet cableado, RS485 y ciertas seales de audio.

Cuando un modulo contador funciona en modo diferencial usa un pin E/S para transmitir la misma
seal que transmite la terminacin sencilla junto con un segundo pin E/S que transmite la seal de
polaridad opuesta. Por ejemplo un modulo contador activado para modo diferencial puede enviar la
seal opuesta que P4 transmite en P5 o algn otro pin. Cada que la seal en P4 es alta la de P5 es baja
y viceversa. Intente modificar una copia de LedDutySweep.spin para que enve la seal diferencial en
P5. As en cuanto P4 se empieza a iluminar ms P5 ira bajando de intensidad. Aqu estn los pasos:

3 Guarde una copia del objeto LedDutySweep que modificara.
3 Para activar el modulo contador a modo DUTY diferencial cambie ctra[30..26] := %00110 a
ctra[30..26] := %00111.
3 Active el campo BPIN agregando un comando ctra[14..9] := 5
3 Active P5 a salida para que la seal se transmita por el pin E/S con el comando dira[5]~~.
Usando ambos mdulos contadores A y B
Usando ambos contadores para mostrar la intensidad del LED tambin es un ejercicio valioso. Para
obtener dos mdulos contadores enviando seales duty en pins separados intente estos pasos:

3 Guarde otra copia del objeto original, no modificado LedDutySweep objeto.
3 Agregue ctrb[30..26] := %00110.
3 Asuma que ctrb controlara P6, agregue ctrb[5..0] := 6.
3 Tambin asumiendo que ctrb controlara P6, agregue dira[6]~~.
3 En el ciclo repeat duty from 0 to 255, haga frqb dos veces el valor de frqa con el
comando frqb := 2 * frqa. Esto ocasiona que el LED P6 brille dos veces ms rpido que
el LED P4.
Dentro del Modo DUTY
Vamos a observar cmo trabaja examinando la versin 3-bit. Como el denominador de la fraccin es
2 de exponente de bits en el registro una versin 3-bit de FRQ seria dividida por 2
3
= 8:

pin high time frq
duty = = (3-bit example)
time 8

Vamos a decir que el bit de acarreo necesita estar en alto 3/8 del tiempo. La versin 3-bit del registro
FRQ deber almacenar 3. El ejemplo de abajo desarrolla ocho sumas de 3-bi-FRQ a 3-bitPHS usando
sumas long-hand. El bit de acarreo (que deber ser acarreado en el bit 4) es marcado con el smbolo
cada que es 1. Note que de las ocho sumas PHS = PHS + FRQ tres resultados acarrean bits. Por lo
que el bit de acarreo esta, de hecho, activo 3/8 del tiempo.

carry flag set

3-bit frq 011 011 011 011 011 011 011 011
3-bit phs(previous) +000 +011 +110 +001 +100 +111 +010 +101

3-bit phs(result) 011 110 001 100 111 010 101 000

L
La Suma binaria trabaja igual que la suma decimal cuando se hace long hand. En vez de acarrear un digito
de 1 a 9 cuando los dgitos en una columna particular suman un valor mayor a 9 en la suma binaria acarrea
un 1 si el resultado en una columna excede 1.
Binary Result
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10 (0, carry the 1)
1 + 1 + 1 = 11 (1, carry the 1)
Registros de Propsito Especial
Cada cog tiene un arreglo de registro de propsito especial (SPR) del cual los elementos pueden
accesar con spr[index]. El valor index lo deja escoger un registro dado de propsito especial. Por
ejemplo usted puede activar el valor de ctra asignando un valor a spr[8], o ctrb asignando un valor
para spr[9]. Igualmente puede asignar valores a frqa y frqb asignando valores a spr[10] y spr[11],
o phsa y phsb asignando valores a spr[12] y spr[13]. Se puede encontrar una lista completa de
arreglos de elementos SPR en el Manual Propeller.

3 Observe SPR en la seccin de referencia de Lenguaje Spin del Manual Propeller y revise la
explicacin de SPR y la tabla de arreglo de elementos SPR.

La ventaja de usar arreglos SPR es que son accesibles por los valores index. Tambin ctrb, frqb, y
phsb son elementos todo in uno sobre ctra, frqa, y phsa. Esto hace posible escoger entre registros de
contador A y B con tan solo agregar 1 a (o substraer 1 de) el valor del ndice usado para accesar un
registro SPR dado. Esto en su momento hace posible eliminar la declaracin de condiciones para
decidir cual modulo contador usar y tambin hace posible inicializar y actualizar mdulos contadores
con estructuras cclicas.

Una desventaja de los registros de propsito especial es que no son bit-direccionales. Por ejemplo los
comandos ctra[30..26] := %00110 and ctra[5..0] := 4 tienen que codificarse diferente para
spr[8], el cual es el elemento del arreglo de propsito especial ctra. El mejor modo de escribir estos
dos comandos en lenguaje Spin con el arreglo SPR es como esto:

spr[8] := (%00110 << 26) + 4

En el comando de arriba el patrn de bit %00110 se mueve a la izquierda por 26 bits, lo cual tiene el
mismo alcance que ctra[30..26] := %00110, y sumando 4 a l sin mover tiene el mismo efecto que
ctra[5..0] := 4. Aqu est la suma:

%00110 << 26 %00011000000000000000000000000000
+ 4 %00000000000000000000000000000100

spr[8] %00011000000000000000000000000100

Vamos a decir que la aplicacin enviara seales duty en P4 y P5. Un ciclo que podra activar estos
pins de E/S para seales duty se vera as:

repeat module from 0 to 1 ' 0 es modulo A, 1 es modulo B.
spr[8 + module] := (%00110 << 26) + (4 + module)
dira[4 + module]~~

La primera vez en el ciclo module es 0, as el valor 4 se almacena en los bits 5..0 de spr[8] y dira[4 +
module]~~ se convierte en dira[4]~~. La segunda vez module es 1, as 5 se almacena en los bits 4..0
de spr[9], y dira[4 + module]~~ se convierte en dira[5]~~.

Cuando se usan contadores en objetos los pins probablemente pasaran como parmetros. Si los
parmetros sostienen el valor del pin quiz no estarn juntos o ligados por alguna relacin
matemtica. Una manera de mantener una lista de pins no ligados si no est esperando que vengan de
otro lado podra ser un comando lookup o lookupz. Dando un valor index ambos lookup y lookupz
regresan un elemento en una lista. Por ejemplo el comando value := lookup(index: 7, 11, 13, 1)
almacenara 7 en value si index es 1, 11 en value si index is 2, y as. Si index excede la longitud de la
tabla el comando lookup almacena0 en value. El mismo comando con lookupz almacenara7 en value
si index es 0, o 11 en value si index es 1, y as sucesivamente. Al igual que lookup, lookupz regresa 0
si index excede la longitud de la lista.

Abajo hay una versin del ciclo repeat que usa lookupz para almacenar una lista de pins no ligados y
los carga en los bits 5..0 de los registros de propsito especial A y B del cog (spr[8] and spr[9]).
Note como el comando lookupz almacena 4 y 6. En el primer ciclo module es 0 por lo que se
almacena 4 en apin, el cual se almacena en los bits 5..0 de spr[8] y activa el bit 4 en el registro dira.
La segunda vez en el ciclo module is 1, as 6 se almacena en apin, el cual a su vez se almacena en los
bits 5..0 de spr[9] y el bit 6 de dira queda activado.

repeat module from 0 to 1 ' 0 es modulo A, 1 es B.
apin := lookupz (module: 4, 6)
spr[8 + module] := (%00110 << 26) + (apin)
dira[apin]~~
El objeto LedSweepWithSpr hace el mismo trabajo que el cdigo LedDutySweep modificado en la
seccin Usando ambos Mdulos Contadores. La diferencia es que desarrolla todas las operaciones
de modulo usando el arreglo SPR en vez de referirse a los registros CTR, FRQ y PHS de los mdulos
A y B.

3 Compare la copia de LedDutySweep que mueve ambos contadores contra el cdigo en
LedSweepWithSpr.spin.
3 Corra LedSweepWithSpr y use LEDs para verificar que controla dos seales duty separadas.

''LedSweepWithSpr.spin
''Ciclo P4 y P5 LEDs de apagado hasta brillo mximo en diferentes rangos.

CON

scale = 16_777_216 ' 2 256

PUB TestDuty | apin, duty[2], module

'Configura ambos mdulos contadores con un ciclo repeat que indexa elementos SPR.

repeat module from 0 to 1 ' 0 es modulo A, 1 es B.
apin := lookupz (module: 4, 6)
spr[8 + module] := (%00110 << 26) + apin
dira[apin]~~

'Repite cambios duty indefinidamente.

repeat
duty[1] := duty[0] * 2 ' duty[1] dos veces ms rpido
repeat module from 0 to 1
spr[10 + module] := duty[module] * scale ' Actualiza reg frqa
waitcnt(clkfreq/128 + cnt) ' Detiene por 1/128 s

Modificando LedSweepWithSpr para Seales Diferenciales
Intente actualizar el objeto LedSweepWithSprpara que haga dos seales diferenciales, una en P4 y P5
y la otra en P6 y P7.

3 Haga una copia de LedSweepWithSpr.spin.
3 Agregue una variable bpin a la lista de variables locales del mtodo TestDuty.
3 Agregue el comando bpin := lookupz(module: 5, 7) justo debajo del comando que asigna
el valor apin con un comando lookup.
3 Cambie spr[8 + module] := (%00110 << 26) + apin a
spr[8 + module] := (%00111 << 26) + (bpin << 9) + apin.
3 Agregue dira[bpin]~~ inmediatamente despus de dira[apin]~~.
3 Cargue la copia modificada de LedSweepWithSpr.spin en el chip Propeller y verifique que
enva dos seales diferenciales duty.
Generando Tonos en Piezospeaker con Modo NCO
NCO significa Oscilador Controlado Numricamente. Al igual que DUTY hay dos modos NCO,
terminacin sencilla y diferencial. Si un modulo contador se configura para modo NCO terminacin
sencilla har que un pin E/S enve una onda cuadrada. Asumiendo que clkfreq es constante, la
frecuencia de su onda cuadrada es numricamente controlada por un valor almacenado en un
registro FRQ del modulo contador en un cog dado.

3 Construya el esquemtico mostrado en la Figura 7-9.

Figura 7-9: Rango de Audio NCO Lista de Partes y Circuitos


(2) Piezospeakers Piezospeakers
(misc) cables
\+ +/
((( - P3 P27 - )))
/ \
~ ~
GND GND

Modulo Contador en Modo NCO de Terminacin Sencilla
Cuando se configura a modo NCO de terminacin sencilla el contador hace dos cosas:
El registro FRQ se suma al registro PHS cada ciclo de reloj
El bit 31 del registro PHS controla el estado de un pin E/S.

Cuando el bit 31 del registro PHS es 1, el pin E/S que controla enva una seal alta y cuando es 0 una
seal baja. Si clkfreq se mantiene igual el hecho de que FRQ se suma a PHS cada ciclo de reloj
determina el rango al cual el bit 31 del registro se activara. Esto a su vez determina la frecuencia de
onda cuadrada transmitida por el pin controlado por el bit 31 del registro PHS.
Dada la frecuencia del reloj del sistema y una frecuencia NCO deseada para transmitir en el Propeller
se puede calcular el valor de registro FRQ con esta ecuacin:

2
32

FRQ register = PHS bit 31 frequency
clkfreq
Eq. 2

Ejemplo:

Qu valor tiene que almacenar frqa para hacer que el modulo contador transmita a 2093 Hz de onda
cuadrada si el sistema de reloj est corriendo a 80MHz? (Si esto fuera una onda senoidal seria Do7
una nota Do en la 7ma Octava)

Para la solucin empiece sustituyendo 80,000,000 en Eq. 2 para clkfreq y 2093 para frequency.

frqa = 2,093 2
32
80,000,000
frqa = 2,093 53.687
frqa = 112,367

La Tabla 7-1 muestra otras notas en la 6a octava y su valor de registro FRQ a 80 MHz. Las notas
agudas estn para que se calculen. Tenga en cuenta que estas son las versiones de onda cuadrada. En
otra prctica usaremos objetos que digitalmente sintetizan ondas senoidales en tonos.
Tabla 7-1: Notas, Frecuencias, y Valores de Registro FRQA/B para 80 MHz
Nota Frecuencia (Hz) FRQA/B Registro Nota Frecuencia (Hz) FRQA/B Registro
Do 6 1046.5 56_184 Sol 6 1568.0 84_181
Do 6# 1107.8 Sol 6# 1661.2
Re 6 1174.7 63_066 La 6 1760.0 94_489
Re 6# 1244.5 La 6# 1864.7
Mi 6 1318.5 70_786 Si 6 1975.5 105_629
Fa 6 1396.9 74_995 Do 7 2093.0 112_367
Fa 6# 1480.0

La Eq. 3 puede tambin reacomodarse para calcular la frecuencia transmitida por un objeto dando un
valor que el objeto almacena en su registro FRQ:

clkfreq FRQ register
PHS bit 31 frequency =
2
32

Eq. 3

Ejemplo:

Un objeto tiene su contador B del cog operando en modo NCO terminacin sencilla y almacena
70,786 en su registro frqb. El sistema de reloj corre a 80 MHz. Cul es la frecuencia que transmite?

Sabemos la respuesta por la Tabla 7-1, pero aqu est con la Eq. 3

80,000,000 70,786
PHS bit 31 frequency = = 1318 Hz
2
32

Configurando un Modulo Contador para Modo NCO
La Figura 7-10 muestra entradas de modo NCO en la tabla de Modo de Contadores del Objeto CTR.
Note que se llama modo NCO/PWM en la tabla, usted ver eso ocasionalmente. PWM es una
aplicacin del modo NCO que ser explorado en la seccin PWM en la pgina 158. Como se
menciono el modo NCO tiene opciones de terminacin sencilla y diferenciales. Modo NCO de
Terminacin Sencilla hace que iguala el bit 31 del registro PHS sea transmitida por el APIN. Modo
diferencial enva la misma seal en APIN junto con la seal invertida en BPIN.

Recuerde que con modos DUTY la bandera de acarreo del sumador de fase (bit 32 del registro PHS)
determinado por el estado del pin E/S que resultaba en la seal que variaba con el valor almacenado
por el registro FRQ. Sin embargo con modo NCO es el bit 31 del registro PHS el que controla el pin
E/S lo cual resulta en una onda cuadrada cuya frecuencia es determinada por el valor almacenado en
el registro FRQ.
Figura 7-10: Extractos de la Tabla de Modo de Contadores del Objeto CTR

Acumulado APIN BPIN
CTRMODE Descripcin FRQ to PHS salida* salida*

%00000 Counter desactivado (off) 0 (never) 0 (none) 0 (none)

.
.
.

%00100 NCO/PWM term sencilla 1 PHS[31] 0
%00101 NCO/PWM diferencial 1 PHS[31] !PHS[31]

.
.
.


debe activar el correspondiente bit DIR para afectar al pin

A = APIN input delayed by 1 clock
A = APIN input delayed by 2 clocks
B = BPIN input delayed by 1 clock

Los pasos para configurar el modulo contador para modos NCO son similares a los pasos para los
modos DUTY. Los campos de bits CTRMODE, APIN (y BPIN para modo diferencial) del registro
CTR deben activarse. Luego el registro FRQ da un valor que activa la frecuencia NCO. Como en
otros ejemplos de salida los pins E/S usados por el modulo contador tienen que activarse como salida.

Aqu estn los pasos para configurar el modulo contador a modo NCO:

(1) Configure el registro CTRA/B
(2) Active el registro FRQA/B
(3) Active el pin E/S como salida

(1) Configure el registro CTRA/B: Se muestra un ejemplo que active el contador A para modo NCO
de terminacin sencilla con envo de seal por P27. Para hacer esto active ctra[30..26] a %00100, y
ctra[5..0] a 27.

ctra[30..26] := %00100
ctra[5..0] := 27

(2) Active el registro FRQA/B Active el Registro FRQA/B: Se muestra un ejemplo para la versin de
onda cuadrada de la nota Do 7:

frqa := 112_367

(3) Active el pin E/S a salida: Como es P27 el que est enviando la seal convirtalo en salida:

dira[27]~~

Despus de iniciar el modulo contador corre independientemente. El cdigo en el cog puede olvidarse
y hacer otras cosas, o monitorear/controlar/modificar el comportamiento del contador si se necesita.
Ejemplo de Onda Cuadrada
El objeto SquareWaveTest.spin de abajo toca una onda cuadrada de la versin de onda cuadrada de
Do en la 7ma octava por un Segundo.

Examine el objeto SquareWaveTest, comprelo con los pasos 1 a 3 que acabamos de discutir.
Cargue el objeto SquareWaveTest en el chip Propeller. Crralo y verifique que toca un tono.
Cambie frqa := 112_367 a frqa := 224_734. Eso es Do 8, la nota Do en la siguiente octava
ms alta.
Cargue el objeto modificado en el chip Propeller. Esta vez la nota deber sonar a un tono ms
agudo.

''SquareWaveTest.spin
''Enva onda cuadrada de 2093 Hz a P27 por 1 s con el modulo contador.

CON

_clkmode = xtal1 + pll16x ' Programa clkfreq = 80 MHz.
_xinfreq = 5_000_000

PUB TestFrequency

'Configura modulo ctra
ctra[30..26] := %00100 ' Activa ctra for "NCO sencillo"
ctra[5..0] := 27 ' Activa APIN a P27
frqa := 112_367 ' Activa frqa a 2093 Hz (Do)
usando:
' FRQA/B = frecuencia (2^32 clkfreq)
'Transmite la seal por 1 s
dira[27]~~ ' Activa P27 a salida
waitcnt(clkfreq + cnt) ' Espera por tono para tocar 1 s
Deteniendo (y reiniciando) la Seal
En el objeto SquareWaveTest el cog se queda sin comandos, as el tono se detiene porque el
programa termina. En muchos casos se quiere detener y reiniciar la seal. Los 3 caminos ms
sencillos de detener (y comenzar) la seal de transmisin son:

1) Cambien la direccin del pin E/S a entrada. En el objeto SquareWaveTest esto podra
hacerse con dira[27] := 0 o dira[27]~ cuando el programa est listo para detener la seal.
(Para reiniciar la seal use dira[27] := 1 o dira[27]~~.)
2) Detenga el contador limpiando los bits CTR 30..26. En el objeto SquareWaveTest se
puede hacer con ctra[30..26] := 0. Otra forma de hacerlo es activando todos los bits en el
campo de bits CTRMODE del registro ctra con ctra[30..26]~. En cualquiera de los casos
el pin E/S es aun una salida y su estado de salida puede ser alto o bajo. Despus
examinaremos una forma de asegurarse que la seal termina cuando el pin E/S est
transmitiendo una seal baja. (Para reiniciar copie %00100 nuevamente en ctra[30..26]).
3) Detenga la suma a PHS al activar FRQ a 0. En el objeto SquareWaveTest se puede hacer
con frqa := 0 o frqa~. El contador podra correr pero como agregara un cero a phsa con cada
el bit 31 de phsa no cambiara, as el pin E/S tambin dejara de cambiar. Igual de detener el
contador el pin E/S detendr el estado de salida que tena en el momento que se limpio frqa.
(Para reiniciar la seal use frqa := 112_367).

El objeto Staccato cambia el pin E/S entre salida y entrada para iniciar el tono 2.093 Khz y detener a
15Hz for 1 s. Se usa el mtodo 1 para iniciar y detener la seal. Su trabajo ser modificar dos copias
del cdigo para hacerlo a travs de las opciones 2 y 3.
3 Cargue Staccato.spin en el chip Propeller y verifique que suena a 15 Hz por 1 s.
3 Haga dos copias del programa.
3 Modifique una copia para que utilice el mtodo 2 para iniciar y detener la seal.
3 Modifique la otra copia para usar el mtodo 3 para iniciar y detener la seal.

''Staccato.spin
''Enva 2093 Hz sonidos en sucesiones rpidas (15 Hz por 1 s).

CON

_xinfreq = 5_000_000

PUB TestFrequency

'Configure ctra module
ctra[30..26] := %00100 ' Activa ctra para "NCO terminacin sencilla"
frqa := 112_367 ' Activa frqa para 2093 Hz (Nota Do):

'Diez timbres encendido/apagado en 1 segundo.
repeat 30
!dira[27] ' Activa P27 a Salida
waitcnt(clkfreq/30 + cnt) ' Espera por tono para tocar por 1 s
'Termina programa, tambin detiene el modulo contador.

L
Use F10 y F11 para comprara programas fcilmente:
Es conveniente colocar el original Staccato.spin en EEPROM con F11, luego usar F10 cuando pruebe las
modificaciones. Despus de correr el programa nuevo puede presionar y soltar el botn de reinicio de la
Plataforma PE para tener una comparacin de audio inmediata.
Tocando una Lista de Notas
DoReMi.spin Es un ejemplo del modulo contador donde se toca una serie de notas. Como no se
necesita nada ms por el momento el pin E/S que enva la onda cuadrada al piezospeaker esta activo
como entrada durante el que detiene entre notas. El bit 31 del registro phsa aun cambia a una
frecuencia dada durante el cuarto detenido, pero la pseudo nota no suena.

Los valores del registro frqa se almacenan en un bloque DAT con la instruccin:

DAT
...
notes long 112_367, 126_127, 141_572, 149_948, 168_363, 188_979, 212_123, 224_734

Un ciclo repeat que mueve una variable index de 0 a 7 se usa para obtener y copiar cada una de las
notas al registro frqa. El ciclo copia cada valor sucesivo de la secuencia notes al registro frqa con
este comando:

'Set the frequency.
frqa := long[@notes][index]
...

3 Cargue el objeto DoReMi.spin en el chip Propeller y observe el efecto.

''DoReMi.spin
''Toca Do6, Re6, Mi6, Fa6, Sol6, La6, Si6, Do7 como cuartos y detiene cuartos en medio.

CON

_clkmode = xtal1 + pll16x ' Reloj de sistema 80 MHz
_xinfreq = 5_000_000

PUB TestFrequency | index

'Configure ctra module
ctra[30..26] := %00100 ' Activa ctra para "NCO Terminacin sencilla"
frqa := 0 ' No toca notas todava


frqa := long[@notes][index] ' Asigna la frecuencia.

'Transmite la seal por 1/4 s
dira[27]~~ ' Activa P27 a salida
waitcnt(clkfreq/4 + cnt) ' Espera por tono para tocar por s/

dira[27]~ ' Detiene 1/4 s

DAT
'Valores 80 MHz frqa para onda cuadrada de aproximaciones de la nota musical con el modulo
contador
'configurado a NCO:
' Do6 Re6 Mi6 Fa6 Sol6 La6 Si6 Do7
notes long 56_184, 63_066, 70_786, 74_995, 84_181, 94_489, 105_629, 112_528

Ejemplo de Contador Modo NCO con bit 3 en lugar de bit 31
En modo NCO el estado de salida del pin E/S es controlado por bit 31 del registro PHS. Sin embargo
la frecuencia encendido/apagado para cualquier bit en una variable o registro puede calcularse usando
la Eq. 4 y asumiendo que un valor es sumado repetidamente a un rango dado:

frequency = (value rate) 2
bit + 1

Eq. 4

El siguiente ejemplo se puede hacer en papel y puede ayudar a clarificar como funciona

Ejemplo Bit 3: A qu frecuencia cambia el bit 3 en una variable si se le agrega 4 ocho veces cada
Segundo? Aqu value es 4, rate es 8 Hz, y bit es 3, as

frequency = (value rate) 2
bit + 1

= (4 8 Hz) 2
3 + 1

= 32 Hz 16
= 2 Hz

La Tabla 7-2 muestra cmo trabaja. Cada 1/8 de segundo el valor 4 se suma a una variable. Como
resultado el bit 3 de la variable cambia dos veces cada segundo a 2 Hz.

Tabla 7-2: Ejemplo Bit 3
Bit 3 en Variable
Tiempo
(s) Valor Variable
7 6 5 4 3 2 1 0
0.000 0 0 0 0 0 0 0 0 0
0.125 4 4 0 0 0 0 0 1 0 0
0.250 4 8 0 0 0 0 1 0 0 0
0.375 4 12 0 0 0 0 1 1 0 0
0.500 4 16 0 0 0 1 0 0 0 0
0.625 4 20 0 0 0 1 0 1 0 0
0.750 4 24 0 0 0 1 1 0 0 0
0.875 4 28 0 0 0 1 1 1 0 0

1.000 4 32 0 0 1 0 0 0 0 0
1.125 4 36 0 0 1 0 0 1 0 0
1.250 4 40 0 0 1 0 1 0 0 0
1.375 4 44 0 0 1 0 1 1 0 0
1.500 4 48 0 0 1 1 0 0 0 0
1.625 4 52 0 0 1 1 0 1 0 0
1.750 4 56 0 0 1 1 1 0 0 0
1.875 4 60 0 0 1 1 1 1 0 0
Mtodo Calculador NCO FRQ
El objeto TerminalFrequencies.spin le permite ingresar frecuencias de onda cuadrada en la Terminal
Serial Parallax y calcula y muestra el valor de registro FRQ y tambin toca el tono en el piezospeaker
de P27 (ver Figura 7-11). El mtodo NcoFrqReg del objeto es una adaptacin del mtodo fraction del
objeto CTR de la Librera Propeller. Dando una frecuencia de onda cuadrada calcula:

frqReg = frequency (2
32
clkfreq)

Eq. 5

...y regresa frqReg. As, por una frecuencia de onda cuadrada simplemente iguala el registro FRQ a
result que regresa la llamada a mtodo NcoFrqReg.

Figura 7-11: Calculando frqa dando una
frecuencia en HZ

Ventana de
Transmision
Ventana de
Recepcion
El mtodo NcoFrqReg usa clculos binarios para lograr obtener el valor que fue generado por Eq. 5.
Tambin sera posible usar la librera FloatMath para desarrollar estos clculos. Sin embargo el
mtodo NcoFrqReg necesita mucho menos espacio de cdigo que la librera FloatMath. Tambin toma
menos tiempo completar los clculos, as que lo hace buen candidato para un objeto contador
matemtico.

3 Cargue TerminalFrequencies.spin en EEPROM (F11) a inmediatamente despus presione el
botn Enable de la Terminal Serial Parallax. (Recuerde, no necesita esperar a que termine de
cargar el programa)
3 Cuando muestre el cursor ingrese la porcin integra de cada valor de frecuencia (no los
valores de registro FRQ) de la Tabla 7-1 en la pagina 139 en la ventana de transmisin de la
Terminal Serial Parallax mostrada en la Figura 7-11.
3 Verifique que los clculos del mtodo NcoFrqReg coinciden con los valores de registro FRQ
en la Tabla
3 Recuerde presionar el botn Disable de la Terminal Serial Parallax antes de cargar el
siguiente programa.

''TerminalFrequencies.spin
''Ingresa frecuencias para tocar en el piezospeaker y mostrar los valores ''de registro
frq con la Terminal Serial Parallax

CON

_xinfreq = 5_000_000

CLS = 16, CR = 13 ' Caracteres de control
' Terminal Serial Parallax

OBJ

Debug : "FullDuplexSerialPlus" ' Terminal Serial Parallax
' muestra objeto

PUB Init

'Configure ctra module.
ctra[30..26] := %00100 ' Activa ctra para "NCO terminacin sencilla"
frqa := 0 ' No enva tono aun.
dira[27]~~ ' pin E/S a salida

'Inicia FullDuplexSerialPlus y limpia la Terminal Serial Parallax.
Debug.start(31, 30, 0, 57600)
Debug.tx(CLS)

Main

PUB Main | frequency, temp

repeat

Debug.Str(String("Enter a frequency: "))
frequency := Debug.getDec
temp := NcoFrqReg(frequency)
Debug.Str(String("frqa = "))
Debug.Dec(temp)
Debug.tx(CR)

'Transmite la seal por 1 s
frqa := temp
frqa~

PUB NcoFrqReg(frequency) : frqReg
{{
Regresa frqReg = frequency (2 clkfreq) calculado por divisin long binaria. Esto es
ms rpido que la librera de punto flotante y toma menos espacio de cdigo. Este mtodo
es una adaptacin del mtodo fraction del objeto CTR.
}}

repeat 33
frqReg <<= 1
if frequency => clkfreq
frequency -= clkfreq
frqReg++
frequency <<= 1

Use Dos Mdulos Contadores para Tocar Dos Notas
El objeto TwoTones demuestra como ambos contadores pueden usarse para tocar dos ondas
cuadradas diferentes en bocinas diferentes. En este ejemplo todo lo que hace el programa es esperar
por un cierto tiempo para pasar antes de ajustar los valores de registro frqa y frqb. El programa
podra desarrollar otras tareas antes de regresar y esperar por el registro CLK para obtener el siguiente
incremento.

3 Cargue el objeto TwoTones.spin en el chip Propeller.
3 Verifique que toca la onda cuadrada de la aproximacin de Do6 en la bocina P27 por un
segundo, luego detiene por s y toca Mi6 en la bocina de P2 detiene por otro s y toca
ambas notas en ambas bocinas al mismo tiempo.

''TwoTones.spin
''Toca notas individuales con cada bocina luego toca las notas con ambas ''al mismo tiempo

CON

_xinfreq = 5_000_000

OBJ

SqrWave : "SquareWave"

PUB PlayTones | index, pin, duration

'Inicializa mdulos contadores
pin := byte[@pins][index]
spr[8 + index] := (%00100 << 26) + pin
dira[pin]~~

'Busca tonos y duraciones en la seccin DAT y los toca.
frqa := SqrWave.NcoFrqReg(word[@Anotes][index])
frqb := SqrWave.NcoFrqReg(word[@Bnotes][index])
duration := clkfreq/(byte[@durations][index])
waitcnt(duration + cnt)
DAT
pins byte 27, 3

'index 0 1 2 3 4
durations byte 1, 2, 1, 2, 1
anotes word 1047, 0, 0, 0, 1047
bnotes word 0, 0, 1319, 0, 1319

Dentro de TwoTones.spin
El objeto TwoTones declara el objeto SquareWave (ver apndice A) en su bloque OBJ y le da el apodo
SqrWave. Este objeto tiene un mtodo con el mismo nombre y funcin que NcoFrqReg en el objeto
TerminalFrequencies, pero el cdigo se basa en mtodos adaptados del objeto CTR de la Librera
Propeller para desarrollar el clculo

El primer ciclo repeat en el mtodo PlayTones se inicializa el mtodo counter creando los elementos
8 y 9 del arreglo spr, los cuales son los registros ctra y ctrb. La variable index en ese ciclo es usada
para ver los nmeros de pin listados en a secuencia Pins del bloque DAT usando pin :=
byte[@pin][index]. El segundo ciclo repeat ve elementos en las secuencias durations, anotes y
bnotes del bloque DAT. Cada secuencia tiene cinco elementos as el ciclo repeat cataloga de 0 a 4 para
obtener cada elemento en cada secuencia.

Observe el comando frqa := SquareWave.NcoFrqReg(word[@Anotes][index]) en el segundo ciclo
repeat del objeto TwoTones. Primero word[@Anotes][index] regresa el valor de index elementos a la
derecha de la etiqueta anotes. El primer ciclo index es 0 as que regresa 1047. La segunda, tercera y
cuarta vez index es 1, 2 y 3. Regresa 0 cada vez. La quinta vez index es 4 as que regresa 1047 otra
vez. Cada uno de estos valores regresados por word[@Anotes][index] es un parmetro en la llamada
de mtodo SquareWave.NcoFrqReg. Finalmente el valor regresado por SquareWave.NcoFrqReg se
almacena en la variable frqa. El resultado? Un valor de una frecuencia dada en la secuencia anotes
se convierte al valor correcto por frqa para hacer que el modulo contador toque una nota.
Control de Contador con un Objeto
Si examina el objeto SquareWave quiz note que tiene un mtodo Freq que permite escoger el
modulo contador 0 o 1 para contador A o Contador B), un pin y una frecuencia. El mtodo Freq
considerablemente simplifica el objeto TwoTones.

3 Compare TwoTonesWithSquareWave (abajo) con el objeto TwoTones (arriba).
3 Cargue TwoTonesWithSquareWave en el chip Propeller y verifique que se comporta igual
que el objeto TwoTones.

''TwoTonesWithSquareWave.spin
''Toca notas individuales con cada bocina, luego toca notas con ambos al ''mismo tiempo.

CON

_xinfreq = 5_000_000

OBJ


PUB PlayTones | index, pin, duration

'Busca tonos y duraciones en la seccin DAT y los toca.
SqrWave.Freq(0, 27, word[@Anotes][index])
SqrWave.Freq(1, 3, word[@Bnotes][index])
duration := clkfreq/(byte[@durations][index])
waitcnt(duration + cnt)

DAT
pins byte 27, 3

'index 0 1 2 3 4
durations byte 1, 2, 1, 2, 1
anotes word 1047, 0, 0, 0, 1047
bnotes word 0, 0, 1319, 0, 1319

Aplicaciones Objeto IR y Deteccin de Distancia con modos NCO y DUTY
Cuando apunta el control remoto a la TV y presiona un botn el remoto parpadea un LED IR
rpidamente para enviar mensajes al receptor en la TV. EL rango al cual parpadea el LED IR coincide
con el filtro dentro del recibidor de la TV. Frecuencias comunes son 36.7, 38, 40, y 56.9 kHz.
Estas frecuencias y sistemas de filtro se usan para distinguir mensajes remotos Infra Rojos de Infra
Rojos tales como luz solar y la seal de 120Hz que se transmite por la luz de su hogar.

L
La longitud de onda usada de IR por Control Remoto esta tpicamente en el rango de 800 a 940 nm.

El remoto transmite la informacin modulando la seal IR. El tiempo que se enva la seal puede
contener informacin tal como iniciar un mensaje, binario 1, binario 2, etc. Transmitiendo secuencias
de seales de tiempo encendido/apagado se pueden completar mensajes para varios botones en solo
milisegundos.

El LED IR y receptor que son usados para enviar mensajes de componentes de sistemas de
entretenimiento tambin pueden usarse para detectar objetos. En este mtodo el LED IR y el receptor
son colocados para que la luz rebote en un objeto y regrese al receptor IR. El LED IR tiene que
modular su luz para el paso de frecuencia del receptor. Si la luz del LED IR se refleja en un objeto y
regresa al Receptor IR, el Receptor enva una seal indicando que est recibiendo una seal IR. Si el
IR no refleja el objeto para regresar al Receptor IR enva una seal indicando que no est recibiendo
seal IR.

L
Este mtodo de deteccin usa partes baratas y cada vez es ms popular en robtica.

El receptor IR del kit PE mostrado en la derecha de la Figura 7-12 tiene un filtro de 38 kHz. Un
modulo contador en el chip Propeller puede usarse para generar la seal de 38kHz para el LED IR y
transmitir para deteccin de objetos o un control de sistema de entretenimiento. Esta seccin de la
prctica solo prueba la deteccin de objetos, pero el mismo principio simple aplicara para
decodificacin remota y control de componentes de sistemas de entretenimiento

3 Construya el circuito mostrado en la Figura 7-12 Figura 7-14, usando las fotos de las partes
como gua.

Figura 7-12: Deteccin por IR Partes y Esquemtico


(1) Resistencia 1 k +5V
(1) LED IR
(1) Detector IR
(1) LED shield P1 -/|! 10 k
(1) LED standoff 1 k IRLED P0 /
(misc) Cables ~
GND ~ PNA4602
GND o
equivalente

La Figura 7-13 muestra como ensamblar el LED IR para deteccin de objetos. Primero inserte el LED
IR en el soporte del LED. Posteriormente ensamble el protector del LED al soporte.

Figura 7-13: Ensamble del IR LED

Un arreglo de la placa de prueba que funciona para el LED IR y receptor se ve en la Figura 7-14.
Note como la fuente de 5V del receptor es un puente del centro de la tarjeta (K, 3) a la izquierda del
contacto de la placa (G, 1). La tierra del receptor IR es un puente del contacto del centro de la placa
(K, 4) a la izquierda (G, 2). El ctodo del LED IR se conecta al riel de la izquierda vertical (NEGRO,
4). Una resistencia de 1 k est en serie entre el nodo del LED IR y P1. Es importante conectar una
resistencia ms grande de la salida de 5V a la entrada 3.3V del chip Propeller; una resistencia de 10
k se usa entre la salida 5V del receptor IR y el pin E/S P0 del chip Propeller. Una resistencia de 1 a
2 k es til en serie con el LED IR para reducir el rango de deteccin. Una resistencia pequea como
100 puede ocasionar una deteccin fantasma de objetos lejanos como el techo.

Figura 7-14: LED IR y Detector de Orientacin

Deteccin de Objetos por IR con NCO
El objeto IrObjectDetection programa una seal de 38kHz usando modo NCO. Cada que el pin de E/S
conectado al LED IR se programa a salida se transmite 38kHz. En un ciclo repeat el programa
permite al LED IR transmitir la seal de 38 kHz IR por 1ms, luego guarda ina[0] en una variable
llamada state y lo muestra en la Terminal Serial Parallax (Figura 7-15).

Figura 7-15: Pantalla Deteccin de Objeto

3 Cargue IrObjectDetection.spin en la EEPROM (F11) e inmediatamente despus presione el
botn Enable de la Terminal.
3 El estado debera ser 1 sin obstculos o 0 cuando coloca su mano frente el Receptor / LED IR

'' IrObjectDetection.spin
'' Detecta objetos con LED IR y receptor y muestra en la Terminal Serial '' Parallax

CON

_xinfreq = 5_000_000

' Constantes para la Terminal Serial Parallax.
HOME = 1, CR = 13, CLS = 16, CRSRX = 14, CLREOL = 11

OBJ


PUB IrDetect | state

'Inicia 38 kHz onda cuadrada
SqrWave.Freq(0, 1, 38000) ' Seal 38 kHz P1
dira[1]~ ' Activa pin E/S a entrada
' cuando no se necesita seal

'Inicia FullDuplexSerialPlus
Debug.start(31, 30, 0, 57600) ' Inicia FullDuplexSerialPlus
waitcnt(clkfreq * 2 + cnt) ' Da tiempo de presionar Enable
Debug.tx(CLS) ' Limpia Pantalla

repeat

' Detecta objeto.
dira[1]~~ ' pin E/S salida para
' transmitir 38 kHz
waitcnt(clkfreq/1000 + cnt) ' Espera 1 ms
state := ina[0] ' Almacena IR salida detector
dira[1]~ ' Pin E/S entrada para detener seal

' Muestra deteccin (0 detectado, 1 no detectado)
Debug.str(String(HOME, "State = "))
Debug.Dec(state)
Debug.str(String(CR, "Object "))
if state == 1
Debug.str(String("not "))
Debug.str(String("detected.", CLREOL))

Deteccin de Distancia con IR usando cambios NCO y DUTY

Si el LED IR brilla ms hace el detector ms intuitivo. Si brilla menos lo hace menos eficiente.
Recuerde que el modo DUTY del modulo contador puede usarse para controlar el brillo del LED e
incluso para intercambiar el brillo de bajo a brilloso (ver pgina 130). Este mismo alcance duty puede
combinarse con la seal NCO para el ejemplo de deteccin de objetos con IR para hacer que el LED
parpadee a 38kHz cambiando de menor a mayor brillo. Con cada incremento en brillo la salida del
detector IR puede ser verificada nuevamente en un ciclo. El nmero de veces que el detector IR
reporte que detecto algo estar relacionado a la distancia del objeto desde el detector LED IR.

Aun si el circuito de la Figura 7-12 puede usarse para deteccin de distancia con una combinacin
NCO y seales DUTY el circuito en la Figura 7-16 lo hace posible para obtener mejores resultados
del receptor IR. En vez de conectar el ctodo del LED IR a tierra se conecta a P2. El programa puede
entonces cambiar el voltaje aplicado al ctodo del LED IR de 0 a 3.3 V a travs de P2 mientras la
seal de P1 transmite la seal NCO de 38kHz a la terminal del nodo en l circuito. Como un LED es
una vlvula de 1 sentido la porcin baja de la seal de 38kHz no se transmite porque es menor que el
voltaje DC que la seal duty producida en P2. Durante las porciones altas de la seal de 38kHz los
voltajes incrementados aplicados a P2 reducen el voltaje a travs del circuito LED lo cual a su vez
reduce el brillo. As es la misma seal de 38 kHz solo sucesivamente menos brillosa.

Figura 7-16: Deteccin IR Partes y Esquemtico


(1) Resistencia 100 IR Detector +5V
(1) LED IR
(1) Detector IR
(1) LED Proteccin P1 -/|!- P2 10 k
(1) LED Soporte 100 LED IR P0 /
(misc) Cables
~
GND

PNA4602 o
equivalente

El objeto IrDetector.spin de abajo desarrolla la deteccin de distancia justo como lo platicamos. EL
objeto padre tiene que llamar al mtodo init para decirle cuales pins se conectan al nodo y ctodo
del circuito LED IR y las salidas del Receptor IR. Cuando el mtodo distance se llama utiliza el
cambio duty que platicamos y los nmeros de pin que pasaron al mtodo init para medir la distancia
de los objetos.

El mtodo distance del objeto IrDetector utiliza el objeto SquareWave para comenzar a transmitir la
seal de 38kHz al nodo del circuito LED IR usando el contador B. Luego configura el contador A
para modo DUTY de terminacin sencilla e inicializa frqa y phsa a 0 lo cual resulta en una baja seal
inicial al ctodo del circuito LED IR. Despus un ciclo repeat cambia muy rpidamente duty de
0/256 a 255/256. Con cada cambio se incrementa el voltaje al circuito LED IR en el ctodo haciendo
menos brilloso el LED IR y el Detector IR con menor alcance. Entre cada incremento duty, el ciclo
suma la salida del receptor IR al valor de regreso dist. Como la salida del receptor IR esta en alto
cuando no ve el reflejo IR dist almacena el nmero de veces en 256 que no vio un objeto. Cuando el
objeto es ms cercano este nmero ser menor, cuando es ms lejano el numero ser mayor. As
despus del ciclo el valor de regreso del mtodo dist contiene una representacin de la distancia del
objeto.

L
Tenga en cuenta que esta medicin de distancia puede variar con la superficie que refleja el IR.
Por ejemplo, si la distancia regresa 175, la distancia medida por una hoja Blanca de papel podr ser cinco
veces la distancia de una hoja de vinil negro. La razn es que el papel blanco refleja el infrarrojo por lo que
ser visible al receptor mucho ms lejos. En contraste el vinil negro tiende a absorberlo y solo es vivible en
rangos muy cortos.

''IrDetector.spin
CON

scale = 16_777_216 ' 2 256

OBJ

SquareWave : "SquareWave" ' Importa objeto SquareWave
' SquareWave

VAR

long anode, cathode, recPin, dMax, duty

PUB init(irLedAnode, irLedCathode, irReceiverPin)

anode := irLedAnode
cathode := irLedCathode
recPin := irReceiverPin

PUB distance : dist
{{
Realiza una prueba de respuesta en el Receptor/LED IR y regresa dist,
Un valor de zona de 0 (mas cercano) a 256 (objeto no detectado).
}}
'Inicia seal de 38 kHz.
SquareWave.Freq(1, anode, 38000) ' ctrb 38 kHz
dira[anode]~~

'Configura seal Duty.
ctra[30..26] := %00110 ' Activa ctra a modo DUTY
ctra[5..0] := cathode ' Activa ctra's APIN
frqa := phsa := 0 ' Activa registro frqa
dira[cathode]~~ ' Activa P5 a salida

dist := 0

frqa := duty * scale ' Actualiza registro frqa
waitcnt(clkfreq/128000 + cnt) ' Detiene por 1/128 s
dist += ina[recPin] ' Objecto no detectado?
' Agrega 1 a dist.

Figura 7-17: Pantalla de Deteccin de
Distancia
El objeto TestIrDutyDistanceDetector obtiene medidas de distancia del objeto IrDetector y las
muestra en la Terminal erial Parallax (Figura 7-17). Con la resistencia de 100 en serie con el LED
IR si el sistema detecta la altura de la mesa al techo o no depender de que tan alto y que tan
reflectivo sea el techo y que tan sensitivo es el detector en particular. Si el sistema no detecta objetos
regresara 256. La luz del da entrando por la ventana podr generar un poco de ruido en la salida del
detector resultando en valores menores que 256 aun cuando no se detecta un objeto. Tan pronto se
acerca el objetivo al receptor LED/IR la medicin se decrementara, pero no a cero tpicamente a
menos que el LED IR este apuntando directamente en el fototransistor del receptor IR (La concha
negra debajo de los metales cruzados).

3 Asegrese que IrDetector.spin est grabado en la misma carpeta que
TestIrDutyDistanceDetector.spin y FullDuplexSerialPlus.spin.
3 Use la herramienta Propeller para cargar TestIrDutyDistanceDetector.spin en la EEPROM
(F11) e inmediatamente presione el botn Enable de la Terminal Serial Parallax.
3 Experimente con una variedad de objetivos y distancias para obtener una idea de para qu
puede ser til el sistema.

'' TestIrDutyDistanceDetector.spin
'' Prueba distancia de deteccin con el objeto IrDetector.

CON

_xinfreq = 5_000_000

CLS = 16, CRSRX = 14, CLREOL = 11

OBJ

ir : "IrDetector"
debug : "FullDuplexSerialPlus"

PUB TestIr | dist

'Inicia comunicacin serial y espera 2 s para la conexin con la
'Terminal Serial Parallax.

debug.Start(31, 30, 0, 57600)
debug.tx(CLS)
debug.str(string("Distance = "))
'Configure IR detectors.
ir.init(1, 2, 0)

repeat

'Obtiene y muestra la distancia.

debug.str(string(CRSRX, 11))
dist := ir.Distance
debug.dec(dist)
debug.str(string("/256", CLREOL))
Contando Cambios con Modos POSEDGE y NEGEDGE
Los mdulos contadores tambin tienen modos detectores de limites (ver Figura 7-18). En modo
POSEDGE un modulo contador suma FRQ a PHS cuando detecta un cambio de bajo a alto en un pin
de E/S. El modo NEGEDGE hace que se ocurra la suma cuando detecta un cambio de alto a bajo.
Cualquiera puede usarse para contar los ciclos de seales que pasan por encima y de regreso debajo
del lmite lgico de 1.65 V. (Tenga cuidado ya que igual que POS los modos POSEDGE y
NEGEDGE tienen opciones con retroalimentacin aun si no se muestra en nuestro extracto de la
Tabla de Modos de Modos Contadores en la Figura 7-18).

L
Entrada o Salida? Estos modos contadores pueden usarse para contar los cambios de una seal aplicada al
pin de E/So a los cambios de la seal de la transmisin de un pin de E/S.

Figura 7-18: Extracto de Detector de Limites de la Tabla de Modos Contadores del Objeto CTR
Acumulado APIN BPIN
CTRMODE Descripcin FRQ a PHS output* output*

%00000 Contador deshabilitado(off) 0 (nunca) 0(ninguno) 0(ninguno)

.
.
.
%01010 detector POSEDGE A & !A 0 0
.
.
.
%01110 detector NEGEDGE !A & A 0 0
.
.
.

* debe activar el bit DIR correspondiente para afectar el pin


Observe en las notas del extracto en la Tabla del Modo de Contadores en la Figura 7-18 que la suma
de FRQ a PHS sucede un ciclo despus del lmite. Esto podra hacer la diferencia en algunos
lenguajes de programacin donde el tiempo es justo, pero no tiene un impacto significativo en la
interpretacin del programa en lenguaje Spin

Los pasos para programar un contador aun contemplan la activacin del campo bit de CTRMODE del
registro CTR (bits 30..26) y su bit de campo APIN (bits 5..0) junto con la programacin del registro
FRQ al valor que debera ser sumado al registro PHS cuando se detecta al lmite. Antes de la
medicin pueden activarse a cero.
ctrb[30..26] := %01110
ctrb[5..0] := 27
frqb~
phsb~

Un ejemplo del siguiente programa que demuestra una forma de usar el modo detector NEGEDGE
para controlar la duracin de un tono tocado en una bocina. El modulo contador A se activa para
transmitir una onda cuadrada de 2kHz en modo NCO de terminacin sencilla en el mismo pin E/S que
el registro del contador B va a monitorear con el modo detector NEGEDGE. El registro frqb se activa
a 1 para que con cada ciclo de reloj se sume 1 a frqb. Para tocar un tono de 2kHz por 1 segundo toma
2000 ciclos. El comando repeat while phsb < 2000 solo permite al programa continuar y limpiar
frqa para detener el sonido despus de que se han detectado los 2000 cambios.

frqb := 1
frqa := SquareWave.NcoFrqReg(2000)

repeat while phsb < 2000

frqa~

L
Censando: Este ejemplo censa el registro phsb esperando a que el numero de cambios exceda un cierto
valor, pero no necesariamente necesita censar durante los 2000 ciclos. Esto libera el cog para hacer algunas
cosas mientras la seal se est transmitiendo y verifica peridicamente para revisar que tan cerca esta phsb
de los 2000 cambios.

3 Cargue CountEdgeTest.spin en el chip Propeller y verifique que el contador de limites se
puede usar para controlar la duracin de un tono.

{{
CountEdgeTest.spin
Transmite la seal NCO con el contador A
Usa el contador B para monitorear los lmites negativos de la seal
Y detener la seal despus de los 2000.
}}

CON

_clkmode = xtal1 + pll16x 'Reloj de Sistema 80 MHz
_xinfreq = 5_000_000

OBJ


PUB TestFrequency

' Configura Mdulos Contadores.

ctra[30..26] := %00100 'ctra modulo a modo NCO
ctra[5..0] := 27

ctrb[30..26] := %01110 'ctrb modulo a NEGEDGE detector
ctrb[5..0] := 27
frqb~
phsb~

'Transmite la seal por 2000 ciclos.

outa[27]~ ' P27 salida-baja
dira[27]~~

frqb := 1 ' Inicia la seal
frqa := SqrWave.NcoFrqReg(2000)

repeat while phsb < 2000 ' Espera por 2k repeticiones

frqa~ ' Detiene la seal

Deteccin de Limites ms Rpido
El siguiente programa puede parar frecuencias cerca de 43.9kHz en el lmite de cada. Para controlar
el nmero de pulsos entregados por seales ms rpidas un programa en lenguaje ensamblador ser
ms rpido y puede detectar el lmite de cada y detenerlo en un par de ciclos de reloj.

BetterCountEdges.spin monitorea una seal de 3kHz transmitida por el Contador A. En vez de
monitorear limites negativos activa el contador B para monitorear limites positivos en P27 con
ctrb[30..26] := 01010 and ctrb[5..0] := 27. Activa frqb a 1 para que se sume 1 al registro PHS
con cada lmite positivo. En vez de limpiar el registro PHS y esperar los 3000 limites positivos activa
phsb a -3000. Por ltimo activa el bit 27 a 1 en una variable llamada a con el comando a |< 27.

3 Observe la funcin del operador |< en el Manual Propeller.

Cuando el comando frqa := SquareWave.CalcFreqReg(3000) se ejecuta P27 enva una onda
cuadrada de 3 kHz. Como phsb es un bit-direccional el comando repeat while phsb[31] se repite
mientras el registro phsb es 1. Recuerde que el bit mas alto de un registro o variable ser 1 aunque el
valor sea negativo. As phsb[31] ser 1 (no cero) mientras phsb sea negativo. El registro phsb se
mantendr negativo hasta que frqb = 1 se suma a phsb 3000 veces.

Cuando el ciclo repeat termina, la seal esta en alto porque estaba buscando un lmite positivo. La
meta es detener la seal despus de que baja. El comando waitpeq(0, a, 0) espera hasta que P27 es
cero. El comando waitpeq(0, |< 27, 0) tambin se puede usar pero el programa no responde tan
rpido porque tiene que calcular primero |< 27; mientras waitpeq(0, a, 0) ya tiene el valor
calculado y almacenado en la variable a. As el comando waitpeq permite continuar el programa hasta
frqa~ para limpiar el registro y detener la seal en salida baja despus del ciclo 3000.

3 Vea y lea acerca de waitpeq en el Manual Propeller
3 Cargue BetterCountEdges.spin en el chip Propeller y verifique que toca la seal de 3 kHz por
1 s.
3 Si usted tiene un osciloscopio asigne la seal para 10 ciclos en vez de 3000. Entonces intente
incrementar la frecuencia y vea la mxima frecuencia que se entregan 10 ciclos.

''BetterCountEdges.spin

CON

_clkmode = xtal1 + pll16x 'Reloj de Sistema 80 MHz
_xinfreq = 5_000_000


OBJ

SquareWave : "SquareWave"

PUB TestFrequency | a, b, c

' Configura Mdulos Contadores.

ctra[30..26] := %00100 'ctra modulo a modo NCO
ctra[5..0] := 27
outa[27]~ 'P27 salida-baja
dira[27]~~

ctrb[30..26] := %01010 'ctrb modulo a detector
'POSEDGE
ctrb[5..0] := 27
frqb := 1 'Suma 1 por cada ciclo
phsb := -3000 'Inicia el contador a -3000

a := |< 27 'Activa un pin mascara para
'el comando waitpeq

frqa := SquareWave.NcoFrqReg(3000) 'inicia la onda cuadrada
repeat while phsb[31] 'Espera por el cambio 3000
'de alto a bajo
waitpeq(0, a, 0) 'Espera por seal baja
frqa~ 'Detiene la seal

PWM con Modos NCO
PWM significa Modulacin de Ancho de Pulso, y puede ser til para servos y control de motores. Un
modulo contador operando en modo NCO puede usarse para generar pulsos de duracin precisa y un
ciclo repeat con un comando waitcnt puede usarse para mantener el tiempo de ciclo de la seal

Vamos a ver como se enva un pulso sencillo con un modulo contador. Este mtodo preciso es tan
bueno como el ciclo de Reloj del chip Propeller. Despus de activar el contador en modo NCO solo
active el registro PHS a la duracin que se quiere que dure el pulso cargndolo en un valor negativo.
Por ejemplo el comando phsa := -clkfreq en el siguiente ejemplo activa el registro phsa a -
80,000,000. Recuerde que el bit 31 de un registro ser 1 mientras sea negativo, y tambin recuerde
que el bit 31 del registro PHS en modo NCO controla un estado de salida de un pin de E/S. As que
cuando el registro PHS se activa como valor negativo (y FRQ a 1) el pin de E/S enviara una seal alta
por el mismo nmero de ciclos de reloj que tiene el numero negativo en PHS.

3 El ejemplo de programa en esta seccin de PWM enviara seales al circuito LED de la Figura
7-6 en la pagina 131. Si removi el circuito de la Figura 7-6 en la pgina 131 de su tarjeta
reconstryalo ahora.
Enviando un Pulso Sencillo
El objeto SinglePulseWithCounter usa esta tcnica para enviar un pulso de 1 segundo al LED en P4.
Aun considerando que el programa puede moverse tan pronto como active el registro PHS a -
clkfreq, no puede ignorar el registro PHS indefinidamente. Por qu? Porque 2
31
1 = 2,147,483,647
ciclos de reloj despus el registro PHS cambiara de un numero positivo muy grande a un numero
negativo muy grande y volver a contar. Como el bit 31 del registro PHS cambiara de 0 a 1 en ese
punto el pin de E/S cambiara de bajo a alto sin ninguna razn aparente.

3 Cargue SinglePulseWithCounter.spin en el chip Propeller y verifique que enva un pulso de 1
segundo. Este pulso durara exactamente 80,000,000 ciclos de reloj.
3 Con el chip Propeller corriendo a 80 MHz el pin cambiara a alto nuevamente despus de
aproximadamente 26.84 segundos despus. Verifique esto con una calculadora y esperando
27 segundos despus de que la seal alta de 1 segundo trmino.
3 Si tiene un osciloscopio intente programar el registro PHS a -1 y vea como puede detector el
pulso de 12.5 ns que transmite el chip Propeller. Tambin intente programar phsa a
clkfreq/1_000_000 por un pulso de 1 s.

''SinglePulseWithCounter.spin
''Enva un pulso alto al LED en P4 que dura exactamente 80_000_000 ciclos de reloj

CON

_xinfreq = 5_000_000

PUB TestPwm | tc, tHa, tHb, ti, t

ctra[30..26] := %00100 ' Configura Contador A a NCO
ctra[5..0] := 4
frqa := 1
dira[4]~~

phsa := - clkfreq ' Enva el pulso

' Mantiene corriendo el programa y el pulso tiene tiempo para terminar.
repeat
Modulacin de Ancho de Pulso
Para una seal repetitiva PWM el programa tiene que establecer el tiempo de ciclo usando waitcnt.
Entonces la duracin de pulso se determina cada vez a travs del ciclo activando el registro PHS a un
valor negativo al principio del ciclo.

El objeto 1Hz25PercentDutyCycle.spin parpadea el LED cada Segundo por 0.25 segundos. El ciclo
repeat repite una vez cada segundo y el contador enva una seal alta al LED P4 por s con cada
repeticin. EL comando tC := clkfreq activa la variable que detiene el tiempo de ciclo a el numero
de ciclos de reloj en un segundo. El comando tHa := clkfreq/4 activa el tiempo en alto para el
modulo contador A a s. El comando t := cnt graba el registro cnt a un tiempo inicial.

Despus un ciclo repeat administra el tren de pulso. Empieza enviando phsa igual a -tHa, lo cual
inicia el pulso que durara exactamente clkfreq/4 ciclos. Despus suma tC, el tiempo de ciclo de
clkfreq, a t, el tiempo meta para el siguiente ciclo. El comando waitcnt(t) espera el numero de
ciclos en 1 s antes de repetir el ciclo.

3 Corra el programa y verifique la seal alta de s cada 1 s en el LED conectado a P4
3 Si tiene un osciloscopio intente una seal que dure 1.5 ms, repetida cada 20 ms. Esto podra
ser bueno para hacer que un servo detenga su posicin central.

''1Hz25PercentDutyCycle.spin
''Enva una seal de 1 Hz a 25% del ciclo de trabajo al LED en P4.

CON

_xinfreq = 5_000_000

PUB TestPwm | tc, tHa, t

ctra[5..0] := 4
frqa := 1
dira[4]~~

tC := clkfreq ' Activa ciclo y tiempo alto
tHa := clkfreq/4
t := cnt ' Marca tiempo de contador
repeat ' Repite seal PWM
phsa := -tHa ' Activa el Pulso
t += tC ' Calcula ciclo repeat
waitcnt(t) ' Espera el siguiente ciclo

Este es otro lugar donde poder examinar las seales diferenciales. Las nicas diferencias entre este
ejemplo y el previo son:

El modo se active a NCO diferencial usando ctra[30..26] := %00101 (diferencial) en vez de
ctra[30..26] := %00100 (terminacin sencilla)
Un segundo pin de E/S se selecciona para seales diferenciales con ctra[14..9] := 5
P4 y P5 se activan a salidas con dira[4..5]~~ en vez de solo dira[4]~~

3 Pruebe el programa y verifique que P5 est encendido cada vez que P4 est apagado.

''1Hz25PercentDutyCycleDiffSig.spin
''Versin diferencial de 1Hz25PercentDutyCycle.spin

CON

_clkmode = xtal1 + pll16x ' reloj 80 MHz
_xinfreq = 5_000_000

PUB TestPwm | tc, tHa, t

ctra[30..26] := %00101 ' Contador A NCO (diferencial)
ctra[5..0] := 4 ' Selecciona pin E/S
ctra[14..9] := 5
frqa := 1 ' Suma 1 a phs con cada ciclo
' de reloj

dira[4..5]~~ ' Activa ambos pins
' diferencial a salida

' El resto es lo mismo que 1Hz25PercentDutyCycle.spin

tC := clkfreq ' Activa ciclo y tiempos
tHa := clkfreq/4
t := cnt ' Marca tiempo de contador

phsa := -tHa ' active el Pulso
t += tC ' Calcula el siguiente ciclo
waitcnt(t) ' Espera el siguiente ciclo

El objeto TestDualPwm.spin usa ambos contadores para transmitir seales PWM que tienen el mismo
tiempo de ciclo pero independientemente de los tiempos altos (1/2 s de tiempo alto con contador A y
1/5 con contador B). Las seales del ciclo DUTY se transmiten en P4 y P6.

3 Intente hacer ambas seales diferenciales usando los pins E/S P4..P7.
3 Nuevamente si tiene un osciloscopio intente crear una seal de 1.3 ms y la otra de 1.7 ms.
Esto podra hacer un robot con dos controles servos de rotacin continua para ir hacia delante
o hacia atrs.

{{
TestDualPWM.spin
Demuestra usando dos mdulos contadores el envi de una seal PWM.
El tiempo de ciclo es el mismo para ambas seales
pero los tiempos altos son independiente uno del otro.
}}

CON

_xinfreq = 5_000_000

PUB TestPwm | tc, tHa, tHb, t

ctra[30..26] := ctrb[30..26] := %00100 ' Contadores A y B NCO
' terminacin sencilla
ctra[5..0] := 4 ' Activa los pins para
' contadores de control
ctrb[5..0] := 6
frqa := frqb := 1 ' Suma 1 a phs con cada
' ciclo de reloj

dira[4] := dira[6] := 1 ' Activa pins E/S a salida

tC := clkfreq ' Activa tiempo de ciclo
tHa := clkfreq/2 ' Activa tiempos altos para
' ambas seales
tHb := clkfreq/5
t := cnt ' Marca tiempo actual

phsa := -tHa ' Definen e inicia pulso A

phsb := -tHb ' Definen e inicia pulso B

t += tC ' Calcula siguiente ciclo
waitcnt(t) ' Espera siguiente ciclo

Una variable o constante puede usarse para almacenar un incremento de tiempo para pulso y tiempo
de ciclo. En el ejemplo la variable tInc almacena clkfreq/1_000_000. Cuando se activa tC a 50_000
* tInc, significa que el tiempo de ciclo ser 500,000 s. As mismo tHa ser 100,000 s.

''SinglePwmwithTimeIncrements.spin

CON

_xinfreq = 5_000_000

PUB TestPwm | tc, tHa, t, tInc

ctra[5..0] := 4 ' Activa salida de contador
' a P4
frqa := 1 ' Suma 1 a phsa con cada
' ciclo de reloj
dira[4]~~ ' P4 salida

tInc := clkfreq/1_000_000 ' Determina incremento tiempo
tC := 500_000 * tInc ' Usa incremento de tiempo
' para activar tiempo de ciclo

tHa := 100_000 * tInc ' Usa incremento de tiempo
' para activar tiempo alto

' El resto es lo mismo que 1Hz25PercentDutyCycle.spin

t := cnt ' Marca tiempo contador

phsa := -tHa ' Activa el pulso
waitcnt(t) ' Espera siguiente ciclo

Prueba y Muestra PWM Agrega un Objeto, Cog y Par de Contadores
Como el chip Propeller tiene mltiples procesadores algunos pueden correr aplicaciones mientras
otros monitorean y diagnostican cdigos. En este ejemplo vamos a incorporar los objetos ya probados
en la seccin anterior MonitorPWM y FullDuplexSerialPlus (monitoreo/diagnostico) en el objeto
TestDualPwm (aplicacin). El objeto MonitorPWM es importante porque usa contadores en un
Segundo cog para monitorear el tren de pulso transmitido por el cog que est ejecutando el cdigo
TestDualPwm (que tambin est utilizando dos contadores).

NOTA: despus de demostrar un ejemplo de uso del objeto MonitorPWM del objeto
TestDualPwmWithProbes, vamos a examinar a detalle el objeto MonitorPWM.

La aplicacin TestDualPwmWithProbes es una versin modificada de TestDualPwm que hace posible
monitorear el tren de pulsos enviados en P4 y P6 probndolos con P8. La informacin de prueba se
muestra en la Terminal Serial Parallax mostrado en la Figura 7-19. El esquemtico en la Figura 7-19
mientras el pin E/S P8 probando P6. En otras palabras hay un puente conectando P6 y P8. Para probar
P4 simplemente se desconecte P6 y conecte P4. Las mediciones son mostradas en la Terminal Serial
Parallax en trminos de 12.5 ns ciclos de reloj. Sin embargo la aplicacin puede fcilmente
modificarse para mostrarlos en trminos de ms s, duty cycle, etc. Una segunda instruccin de
MonitorPWM puede declararse y usarse para monitorear simultneamente otro canal.

Figura 7-19: Use P8 para Medir una Seal PWM de P6


(2) Resistencia 100 LED
(1) LED - verde 100 verde
(1) LED - amarillo P4 -/|!
(misc) Cables LED
100 amarillo
P6 -/|!

P8 ~
GND

El cdigo agregado al objeto TestDualPwm monitorea y muestra el tren de pulsos en el objeto
TestDualPwmWithProbes. La mayora del cdigo agregado es para mostrar los valores en la Terminal
Serial Parallax todo lo que se necesita incorporar al objeto es:

Tres declaraciones variables: tHprobe, tLprobe, y pulseCnt
Una declaracin de objeto: probe : "MonitorPWM"
Una llamada al mtodo start del objeto MonitorPWM que pasa la direccin de tHprobe,
tLprobe y pulseCnt, como esta: probe.start(8, @tHprobe, @tLprobe, @pulseCnt).

Despus de eso el objeto MonitorPWM automticamente actualiza los valores almacenados por
tHprobe, tLprobe, y pulseCnt con cada nuevo ciclo. Estas mediciones son mostradas en la Terminal
Serial con debug.dec(tHprobe), debug.dec(tLprobe), y debug.dec(pulseCnt).

3 Asegrese que el objeto TestDualPwmWithProbes.spin est guardado en la misma carpeta
que MonitorPwm.spin y FullDuplexSerialPlus.spin.
3 Cargue TestDualPwmWithProbes.spin en la EEPROM (F11) e inmediatamente presione el
botn Enable de la Terminal Serial Parallax.
3 Desconecte la terminal del cable P8 P6 que est conectado en P6 y conctelo a P4. La
pantalla deber mostrar la actualizacin de los diferentes tiempos altos y bajos.

{{
TestDualPwmWithProbes.spin
Demuestra cmo usar un objeto que usa contadores en otro cog
Para medir (probar) actividad de pin E/S
Generada por los contadores en este cog.
}}

CON

_xinfreq = 5_000_000

' Constantes de la Terminal Serial Parallax
CLS = 16, CR = 13, CLREOL = 11, CRSRXY = 2

OBJ

probe : "MonitorPWM"

PUB TestPwm | tc, tHa, tHb, t, tHprobe, tLprobe, pulseCnt

' Inicia MonitorServoControlSignal.
probe.start(8, @tHprobe, @tLprobe, @pulseCnt)

'Inicia FullDuplexSerialPlus.
Debug.start(31, 30, 0, 57600)
Debug.str(String(CLS, "Cycle Times", CR, "(12.5 ns clock ticks)", CR))

Debug.str(String("tH = ", CR))
Debug.str(String("tL = ", CR))
Debug.str(String("reps = "))

ctra[30..26] := ctrb[30..26] := %00100 ' Contadores A y B NCO
' Terminacin sencilla
ctra[5..0] := 4 ' Activa pins para
' controlar contadores
ctrb[5..0] := 6
frqa := frqb := 1 ' suma 1 a phs con cada
' ciclo de reloj

dira[4] := dira[6] := 1 ' Activa pins E/S a Salida

tC := clkfreq ' Activa tiempo de ciclo
tHa := clkfreq/2 ' Activa tiempos altos para
' ambas seales
tHb := clkfreq/5
t := cnt ' Marca tiempo actual.

phsa := -tHa ' Define e inicia el pulso A

phsb := -tHb ' Define e inicia el pulso B

' repite
' Muestra informacin
debug.str(String(CLREOL, CRSRXY, 5, 2))
debug.dec(tHprobe)
debug.dec(tLprobe)
debug.dec(pulseCnt)

waitcnt(t) ' Espera por siguiente ciclo

Monitoreo PWM Ejemplo de un Objeto que Usa Contadores en Otro Cog
El objeto MonitorPWM puede usarse por otros objetos para medir las caractersticas de un tren de
pulsos (su tiempo alto y bajo). El cdigo en otros cogs pueden transmitir pulsos y la aplicacin puede
usar este objeto para medir el tiempo alto y bajo de los pulsos. Hasta este punto todos los objetos han
usado los mdulos contadores en el cog 0. En contraste el objeto MonitorPWM inicia un cog Nuevo y
usa los contadores del Nuevo cog para medir el pulso alto y bajo. Despus pone a disposicin las
mediciones disponibles para otros objetos y acordar las localidades en la memoria principal RAM.

Hay tres claves importantes para escribir objetos que inician cogs y usan los mdulos contadores de
esos cogs. Tngalo en cuenta mientras examina el objeto MonitorPWM:

1) Si el objeto se inicia en un cog Nuevo debe tener mtodos start y stop y variables globales
llamadas cog y stack. Esta es una regla introducida por Parallax que s usa en la Librera
Propeller y el Intercambio de Objetos Propeller. El objeto deber declarar cualquier variable
global requerida por el proceso que se inicia en un cog nuevo. (Esto fue revisado en la
prctica de Objetos).
2) El mtodo start deber copiar cualquier parmetro que recibe de las variables globales antes
de iniciar el mtodo que administra el proceso en el cog Nuevo.
3) El mtodo que se inicia en el cog nuevo deber hacer configuraciones de contadores y
asignaciones de pins E/S.

De acuerdo a la clave 3: Vamos a decir que el cog 0 llama al mtodo start del objeto y el mtodo
start inicia un contador usando mtodos en el cog 1 con el comando cognew. Tendr que poner el
cdigo para la configuracin del contador y asignacin de pins E/S en el mtodo que se inicia por
cognew si quiere que el contador en el cog 1 trabaje. Si intenta configurar los contadores o pins E/S en
el mtodo start (antes de iniciar el cog) esas configuraciones afectaran al cog 0 en vez del cog 1.
Esto podra crear en su caso problemas de programacin porque los mdulos contadores en el cog 1
no estarn disponibles para accesar los pins E/S.


{{
MonitorPWM.spin

Monitorea caractersticas de una seal PWM probada y actualice
Direcciones en la RAM principal con el tiempo de pulso alto/ bajo
mas reciente medido y contador de pulsos.

Como usar este objeto en su aplicacin
------------------------------------------
1) Declare variables para tiempo alto, bajo y contador de pulso. Ejemplo:

VAR
long tHprobe, tlprobe, pulseCnt

2) Declare el objeto MonitorPWM. Ejemplo:

OBJ
probe : MonitorPWM

3) Llame al mtodo start y pase el pin E/S usado para probar y las direcciones de variable
del paso 1. Ejemplo:

PUB MethodInMyApp
'...
probe.start(8, @tHprobe, @tLprobe, @pulseCnt)

4) La aplicacin puede ahora usar valores de tHprobe, tLprobe, y pulseCnt para monitorear
los pulsos medidos en los pins E/S pasados al mtodo start (P8 en este ejemplo).
En el ejemplo, este objeto actualizara continuamente tHprobe, tLprobe, y pulseCnt con
el tiempo de pulso alto/bajo mas reciente y el contador de pulsos

Ver tambin
--------
TestDualPwmWithProbes.spin para un ejemplo de aplicacin.

}}

VAR
long cog, stack[20] ' Clave 1, variables globales
' para cog y stack.
long apin, thaddr, tladdr, pcntaddr ' Clave 1, variables globales
' para el proceso.

PUB start(pin, thighAddr, tlowaddr, pulsecntaddr) : okay

'' Inicia el objeto y el proceso de monitoreo PWM en un cog Nuevo.
'' Todo el tiempo las mediciones estn en trminos de ciclos de reloj.
''
'' pin Numero de pin E/S
'' tHighAddr direccin long que recibe la medicin de la seal actual
'' de tiempo alto.
'' tLowAddr - direccin long que recibe la medicin de la seal actual
'' de tiempo bajo.
'' pulseCntAddr - direccin long que recibe la medicin del conteo
'' actual de pulsos medidos.

' Copia la variables locales del mtodo a variables globales del objeto
' Puede usar longmove(@apin, @pin, 4) en vez de los cuatro comandos:

apin := pin ' Clave 2, copia parmetros
' a variables globales
thaddr := tHighAddr ' que usara el proceso.
tladdr := tLowAddr
pcntaddr := pulseCntAddr

' Inicia el cog nuevo.
okay := cog := cognew(PwmMonitor, @stack) + 1

PUB stop

'' Detiene el proceso de monitoreo PWM y libera un cog.

if cog
cogstop(cog~ - 1)

PRI PwmMonitor

' Clave 3, Activa las configuraciones de pin E/S y los mdulos (Desde el
' nuevo cog!)

ctra[30..26] := %01000 ' Detector POS
ctra[5..0] := apin ' Pin E/S
frqa := 1

ctrb[30..26] := %01100 ' Detector NEG
ctrb[5..0] := apin ' Pin E/S
frqb := 1

phsa~ ' Limpia contadores
phsb~

' Activa estados y direcciones de pins E/S.
dira[apin]~ ' Hace salida un pin

' Ciclo de monitoreo PWM.

repeat ' Ciclo principal
' Monitorea Cog
waitpeq(|<apin, |<apin, 0) ' Espera por apin
' para ir alto.
long[tladdr] := phsb ' Guarda tlow,
' despus limpia
phsb~
waitpeq(0, |<apin,0) ' Espera por apin
' para ir bajo.
long[thaddr] := phsa ' Guarda thigh luego
' limpia.
phsa~
long[pcntaddr]++ ' Incrementa contador
' de pulsos.

Dentro del Objeto MonitorPWM
Al principio MonitorPWM declara sus variables globales. Las variables cog y stack se presentaron en
la prctica de Objetos. La variable cog se usa para rastrear en cual cog el mtodo start del objeto
inicio el proceso. Posteriormente si se llama el mtodo stop del objeto sabr cual cog apagar. Como
dos mtodos usan esta variable tiene que ser global porque los mtodos no pueden ver otras variables
locales. La variable stack proporciona espacio de pila para el cdigo que se inicia en el nuevo cog
para clculos, punteros de regreso, etc.

VAR
long cog, stack[20] ' Clave 1, Variables globales
' para cog y stack.
long apin, thaddr, tladdr, pcntaddr ' Clave 1, Variables globales
' para el proceso.
Tambin se declaran variables globales llamadas apin, thaddr, tladdr, y pcntaddr. Estas variables se
usan por dos mtodos: start y pwmMonitor. El mtodo start recibe parmetros de un objeto que
llama y los copia en estas variables globales para que el mtodo pwmMonitor pueda usarlas. El mtodo
PwmMonitor usa la variable apin para configurar pins E/S y usa las otras tres variables como
apuntadores de direcciones para almacenar sus medidas en la localidad acordada mutuamente en la
RAM principal mencionada anteriormente.

Cuando otro objeto llama este mtodo start del objeto pasa el numero de pin E/S que estar
monitoreando la seal junto y tambin las direcciones donde la medicin de pulsos altos y bajos
debera almacenarse y una direccin para almacenar el numero de pulsos que se han contado. Tenga
en mente que estos parmetros (pin, thighAddr, tlowaddr, pulsecntaddr) son variables ocales en el
mtodo start. Para disponer de esto valores en otros mtodos el mtodo start tiene que copiarlos a
variables globales. As antes de iniciar el nuevo cog el mtodo start copia pin a apin, tHighAddr a
thaddr, tLowAddr a tlAddr y pulseCntAddr a pcntaddr. Despus de eso el comando cognew inicia el
mtodo PwmMonitor en un nuevo cog y pasa las direcciones del arreglo stack. El arreglo stack se
presento en la prctica de Objetos.

PUB start(pin, thighAddr, tlowaddr, pulsecntaddr) : okay
'...
' Copia variables locales del mtodo a variables globales del objeto
apin := pin ' Clave 2, copia parmetros
' a variables globales
thaddr := tHighAddr ' que usara el proceso.
tladdr := tLowAddr
pcntaddr := pulseCntAddr

' Inicia el nuevo cog.
okay := cog := cognew(PwmMonitor, @stack) + 1

Los objetos que inician nuevos cogs que estn diseados para intercambiar informacin con otros
objetos tienen mtodos start y stop por regla. Tambin por regla si el objeto no inicia un nuevo cog
pero necesita configurarse, se utiliza un mtodo llamado init o config.

Observe la ltima lnea en el mtodo start. El comando cognew regresa -1 si no hay cogs disponibles
o regresa el numero de cog en el que se inicio el mtodo PwmMonitor, el cual puede ser 0 a 7. Despus
se suma uno a este valor y el resultado se almacena en la variable cog del objeto y el valor de regreso
okay del mtodo start. As, el mtodo start regresa 0 (falso) si el proceso fallo al inicio o un no-cero
si tuvo xito. El objeto llamando al mtodo start puede usar el valor de regreso del mtodo start en
un bloque if para decidir qu hacer. Nuevamente si el valor regresado es 0 (falso) significa que no
hay cogs disponibles; mientras que si el valor es no-cero la aplicacin sabe que el cog se inicio
exitosamente.

El mtodo stop tambin puede determinar si el proceso se inicio apropiadamente porque la variable
cog tambin almacena el resultado regresado cognew mas uno. Si se llama el mtodo stop la primer
cosa que hace es usar un enunciado if para asegurarse que realmente se inicio un cog. Por tercera
vez, si el valor del cog es cero, no hay un proceso actual bajo el control del objeto que necesite
detenerse. En otras palabras si el valor de cog es no-cero cogstop(cog~ 1) hace 3 cosas:

1) Resta 1 del valor almacenado por cog para obtener el numero de cog que necesita detener.
(Recuerde, un comando en el mtodo start sumo 1 a la variable cog).
2) Detiene el cog
3) Limpia el valor de cog para que el objeto sepa que no est a cargo actualmente de un proceso
activo (cog)

PUB stop

'' Detiene el proceso de monitoreo PWM y libera un cog.

if cog
cogstop(cog~ - 1)

El mtodo PwmMonitor se inicia en un Nuevo cog por un comando cognew en el mtodo start. As,
hay cdigo corriendo en el mtodo PwmMonitor en un procesador separado dl cdigo que llamo el
mtodo start. Lo primero que hace el mtodo PwmMonitor es configurar los mdulos contadores y los
pins E/S que va a usar. Recuerde su cdigo no puede hacer esto desde otro cog; el cdigo ejecutado
por un cog dado tiene que hacer sus propias configuraciones de contadores y asignacin de pins E/S.
(Vea la Clave 3 discutida previamente)

PRI PwmMonitor

' Clave 3, active mdulos contadores y configuraciones d pins E/S
' (desde el Nuevo cog)

ctra[30..26] := %01000 ' Detector POS
ctra[5..0] := apin ' Pin E/S
frqa := 1

ctrb[30..26] := %01100 ' Detector NEG
ctrb[5..0] := apin ' Pin E/S
frqb := 1

phsa~ ' Limpia conteos
phsb~

' Activa direcciones y estados de pins E/S.
dira[apin]~ ' Hace apin una
' entrada

' Ciclo monitoreando PWM.

El ciclo principal en el mtodo PwmMonitor espera a que la seal este en alto. Luego copia el
contenido de phsb, lo cual acumula el tiempo bajo a una direccin en RAM principal. Recuerde que la
direccin en memoria principal se paso del parmetro thighaddr del mtodo start. El mtodo start
lo copio a la variable global thaddr. Como thaddr es una variable global es accesible en este mtodo
tambin. Similar con tlowaddr tladdr y pulsecntaddr pcntaddr. Antes de esperar medir el
tiempo bajo de la seal el cdigo limpia el registro phsb para la siguiente medida. Despus de que la
seal va a bajo, copia phsa a la memoria asignada para medir el tiempo alto. Antes de medir el
siguiente ciclo se agrega 1 a la memoria apuntada por la variable pcntaddr, la cual lleva cuenta del
nmero de ciclos.

' Ciclo de monitoreo PWM.
' monitoreo del cog
waitpeq(|<apin, |<apin, 0) ' Espera por apin para
' ir alto.
long[tladdr] := phsb ' Guarda tlow, luego limpia.
phsb~
waitpeq(0, |<apin,0) ' Espera por apin par air
' bajo.
long[thaddr] := phsa ' Guarda thigh, luego limpia.
phsa~
long[pcntaddr]++ ' Incrementa contador pulso.
Modos PLL para Aplicaciones de Alta Frecuencia
Hasta este punto hemos utilizado modos NCO para generar ondas cuadradas en la frecuencia audible
(20 a 20 kHz) y el rango de detector de IR (38kHz). El modo NCO puede usarse para generar seales
hasta clkfreq/2. As con el chip Propeller P8X32A usado en estas prcticas la frecuencia tope para
este modo es 40 MHz.

Para seales ms rpidas de clkfreq/2, se puede usar el modulo contador en modo PLL (ciclo de fase
cerrada). En vez de enviar el bit 31 del registro PHS directo a un pin E/S el modo PLL pasa la seal a
travs de dos subsistemas adicionales antes de transmitirlo. Estos subsistemas no son solo capaces de
enviar frecuencias de 500 kHz hasta 128 MHz, tambin disminuyen las fluctuaciones que hay en las
seales NCO. El primer subsistema (contador PLL) toma la frecuencia del bit 31 del registro PHS y la
multiplica por 16 usando un circuito oscilador de voltaje controlado (VCO). El Manual Propeller y el
objeto CTR llama a esto la frecuencia VCO. El segundo subsistema (divisor) divide el resultado de la
frecuencia por una potencia 2 de rangos de 1 a 128.

El PLL est diseado para aceptar frecuencias del bit PHS de 4 a 8 MHz. El subsistema PLL
multiplica la entrada de frecuencia por 16, para un rango de frecuencia del contador PLL de 64 a 128
MHz. El subsistema divisor divide esta frecuencia por una potencia dos de 128 a 1 para que la salida
final de la seal PLL pueda estar en el rango de 500 kHz a 128 MHz.
Configurando el Modulo Contador para Modos PLL
La Figura 7-20 es el ahora familiar extracto del objeto CTR de la Librera Propeller, esta vez con la
lista de modos PLL. Hay tres modos PLL. El primero PLL interno usado para sincronizar seales de
video. Aunque aun no se comentan en esta prctica usted puede verlo aplicado en el objeto TV de la
Librera Propeller.

Como con los modos DUTY y NCO hay opciones de modo PLL de terminacin sencilla y diferencial.
Los valores CTRMODE para dirigir las seales PLL a los pins E/S son %00010 para terminacin
sencilla y %00011 para diferencial.

Figura 7-20: Modo PLL Extractos de la Tabla de Modos Contadores del Objeto CTR

Acumulado APIN BPIN
CTRMODE Descripcin FRQ a PHS Salida* Salida*

%00000 Contador Deshabilitado(off) 0 (nunca) 0 (ninguno) 0 (ninguno)

.
.
.

%00001 PLL interno (modo video) 1 (siempre) 0 0
%00010 PLL terminacin sencilla 1 PLL 0
%00011 PLL diferencial 1 PLL !PLL

.
.
.


* debe activar el bit correspondiente DIR para afectar el pin
El bit de campo PLLDIV del Registro CTR
Para programar frecuencias de pin E/S en modo NCO se hizo directamente a travs del registro FRQ.
El valor en FRQ se sumaba a PHS cada ciclo de reloj y eso determinaba el rango de cambio del bit 31
de PHS, el cual directamente controlaba una spin E/S. Aun cuando programar frecuencias de pin E/S
con modo PLL todava se usa el bit 31 hay algunos pasos extras.

En modo PLL el rango de cambio de bit 31 de PHS aun est determinado por el valor de FRQ, pero
antes de que el pin E/S transmita la seal el bit 31 de PHS se multiplica por 16 y luego se divide por
potencia dos de su eleccin (2
0
= 1, 2
1
= 2, 2
2
= 4, 2
6
= 64, 2
7
= 128). La potencia 2 se selecciona
por un valor almacenado en el bit de campo PLLDIV del registro CTR (bits 25..23) en la Figura 7-21.

Figura 7-21: Mapa de Registro CTRA/B de CTR.spin

bits 31 30..26 25..23 22..15 14..9 8..6 5..0

Name CTRMODE PLLDIV BPIN APIN

Calculando la Frecuencia PLL dando FRQ y PLLDIV
Vamos a decir que est examinando un cdigo ejemplo que est generando una cierta frecuencia PLL.
Usted puede calcular que frecuencia est generando usando los valores de clkfreq, el registro FRQ, y
el valor en el bit de campo PLLDIV del registro CTR solo siga estos pasos:

(1) Calcule la frecuencia del bit 31 de PHS:

clkfreq registro FRQ
Frecuencia bit 31 de PHS =
2
32

(2) Use la frecuencia del bit 31 de PHS para calcular la frecuencia VCO:

Frecuencia VCO = 16 Frecuencia bit 31 PHS

(3) Divida el resultado PLLDIV el cual es 2
7PLLDIV
por la frecuencia VCO:

Frecuencia VCO
Frecuencia PLL =
2
7-PLLDIV

Ejemplo: Dado una frecuencia de reloj de sistema (clkfreq) de 80 MHz y el cdigo de abajo, calcule
la frecuencia PLL transmitida en el Pin E/S P15.

'Configura modulo ctra
ctra[30..26] := %00010
frqa := 322_122_547
ctra[25..23] := 2
ctra[5..0] := 15
dira[15]~~

(1) Calcule la frecuencia del bit 31 de PHS:

80_000_000 322_122_547
Frecuencia bit 31 de PHS =
2
32

= 5_999_999

(2) Use la frecuencia del bit 31 de PHS para calcular la frecuencia VCO:

Frecuencia VCO = 16 5_999_999
= 95_999_984

(3) Divida el resultado PLLDIV el cual es 2
7PLLDIV
por la frecuencia VCO:

95_999_984
Frecuencia PLL =
2
7-2

= 2_999_999 MHz

3 MHz
Calculando FRQ y PLLDIV dando una Frecuencia PLL
Calcular la frecuencia PLL dando algunos cdigo pre escritos est bien, pero que pasa si quiere
calcular los valores del registro FRQ y bit de campo PLLDIV para generar una frecuencia con cdigo
propio?. Aqu hay unos pasos que se pueden usar para calcularlo:

(1) Use la tabla de abajo para calcular el valor para colocar en el bit de campo PLLDIV del
registro CTR basado en la frecuencia que quiere transmitir.

MHz PLLDIV MHz PLLDIV

0.5 a 1 0 8 a 16 4
1 a 2 1 16 a 32 5
2 a 4 2 32 a 64 6
4 a 8 3 64 a 128 7

(2) Calcule la frecuencia VCO con la frecuencia PLL que quiere transmitir y el divisor PLL y
redondee al siguiente integro ms bajo.

Frecuencia VCO = Frecuencia PLL 2
(7-PLLDIV)

(3) Calcule la frecuencia del bit 31 de PHS que necesitara para la frecuencia VCO. Esto es la
frecuencia VCO dividida por 16

Frecuencia del bit 31 PHS = Frecuencia VCO 16

(4) Use los clculos de la frecuencia NCO para determinar el valor del registro FRQ para la
frecuencia del bit 31 de PHS.
2
32

Registro FRQ = Frecuencia bit 31 PHS
clkfreq

Ejemplo: clkfreq est corriendo a 80 MHz y quiere generar una seal de 12 MHz con PLL. Calcule
el Registro FRQ y el bit de campo PLLDIV.

(1) Use la tabla para calcular el valor a colocar en el bit de campo PLLDIV del registro CTR:

Como 12 MHz esta en el rango de 4 a 16 MHz, PLLDIV es 4.7. Redondeo abajo y se usa 4.

(2) Calcule la frecuencia VCO con la frecuencia final PLL y el divisor PLL:

Frecuencia VCO = 12 MHz 2
(7-4)

= 12 MHz 8
= 96 MHz

(3) Calcule la frecuencia del bit 31 de PHS. Necesitara la frecuencia VCO. Esto es frecuencia
VCO dividida por 16:

Frecuencia bit 31 de PHS = 96 MHz 16
= 6 MHz

(4) Use la frecuencia NCO para determinar el valor del registro FRQ para la frecuencia del bit 31
de PHS:
2
32

Registro FRQ = 6 MHz
80 MHz

= 322_122_547
Probando frecuencias PLL
El objeto TestPllParameters lo deja controlar la frecuencia de salida PLL del contador A ingresando
manualmente los valores de frqa y el bit de campo PLLDIV de ctra en la terminal Parallax (Figura
7-22). El programa trasmite la frecuencia que ingreso por 1 s, contando los ciclos con el contador B
programado en modo detector NEGEDGE.

Note que hay una pequea diferencia entre la frecuencia medida y la frecuencia calculada
manualmente discutida previamente. Si los clculos delay := clkfreq + cnt en el objeto
TestPllParameters.spin se coloca inmediatamente despus de phsb~, el conteo de frecuencia ser
ligeramente menor a la actual. Si se mueve despus de phsb~, la medicin ser ligeramente mayor que
la actual. Se puede obtener una medicin exacta con la ayuda de un objeto lenguaje ensamblador.

Figura 7-22: Calcular la frecuencia dando
FRQA y PLLDIV

Aun cuando el PLL puede generar frecuencias de 128 MHz el contador del Propeller solo detecta
frecuencias hasta 40MHz con mdulos contadores. Esto coincide con el rango de muestreo de
Nyquist, el cual debe ser dos veces ms rpido que la frecuencia ms alta. Tambin si considera que
el modo detector NEGEDGE suma FRQ a PHS cuando detecta una seal alta durante un ciclo y una
seal baja en el siguiente necesita al menos dos ciclos para detectar un ciclo completo de la seal.

3 Calcule el registro FRQ y el bit de campo de PLLDIV para varias frecuencias en el rango de
500 kHz a 40MHz.
3 Cargue TestPllParameters.spin en EEPROM (F11) a inmediatamente despus presione el
botn Enable de la Terminal Serial Parallax.
3 Ingrese los valores FRQ y PLLDIV en la ventana de transmisin de la Terminal Serial
Parallax y verifique que la frecuencia medida es aproximadamente la misma que usted
calculo.

{{ TestPllParameters.spin
Prueba frecuencias PLL hasta 40 MHz. Los valores del registro PHS y el bit de campo PLLDIV
se ingresan en la Terminal Serial Parallax. El programa usa estos valores para sintetizar
la onda cuadrada con el modo PLL usando el contador A. El contador del modulo B cuenta los
ciclos en 1 s y los reporta. }}

CON

_xinfreq = 5_000_000

' Constantes para la Terminal Serial Parallax.
CLS = 16, CR = 13

OBJ


PUB TestFrequency | delay, cycles

Debug.Start(31, 30, 0, 57600)
Debug.tx(CLS)

' Configura mdulos contadores.
ctra[30..26] := %00010 ' Modulo ctra a PLL modo
' terminacin sencilla
ctra[5..0] := 15

ctrb[30..26] := %01110 ' Modulo ctrb para modo
' detector NEGEDGE
ctrb[5..0] := 15
frqb:= 1

repeat

Debug.str(String("Enter frqa: ")) ' frqa y PLLDIV se ingresan
' por el usuario
frqa := Debug.GetDec

Debug.str(String("Enter PLLDIV: "))
ctra[25..23] := Debug.GetDec

dira[15]~~ ' P15 salida
delay := clkfreq + cnt ' Pre calcula retraso de
' ciclos de reloj
phsb~ ' Espera 1 s.
waitcnt(delay)
cycles := phsb ' Almacena ciclos
dira[15]~ ' P15 entrada

Debug.str(String("f = ")) ' Muestra ciclos como frec.
debug.dec(cycles)
debug.str(String(" Hz", CR, CR))

Deteccin de Metal con Modos Detectores PLL, POS y un Circuito LC
Los inductores son bobinas que cuando se colocan en un circuito tienen la capacidad de almacenar
energa. Se usan en muchas aplicaciones una de las cuales es deteccin de metal. Hay diferentes
instrumentos de deteccin de metales adems de los que quiz ha visto que pasan en las playas en un
fin de semana. Otros ejemplos incluyen instrumentos que identifican el tipo de metal verifica
fracturas en superficies metlicas y mide precisamente la distancia de una superficie de metal desde
un instrumento.

Aun pensando que no hay ningn inductor en el kit PE hay muchos cables que pueden enredarse para
formar pequeos inductores. Esta parte de la prctica demuestra como un cog puede usar dos
contadores, uno PLL de terminacin sencilla y el otro en modo POS para enviar seales de alta
frecuencia a una entrada de circuito LC (Inductor Capacitor) y deducir la presencia o ausencia de
metal examinando la seal de salida.

Para el proyecto necesitamos doblar un cable Puente en forma de U para hacer nuestro inductor. La
Figure 7-23 muestra una lista de partes y un circuito para el detector de metales del kit PE. Debido a
las partes pequeas y las altas frecuencias este circuito puede ser fastidioso. Para mejores resultados
almbrelo exactamente como muestra la Figura 7-24. El capacitor y resistencia deber estar todos
hacia arriba de la placa y los dos cables deben estar en el mismo plano que la placa.

Este circuito tambin requiere ajustes. La Figure 7-23 empieza con R1 a 100 , y R2 (100 ) y R3
(470 ) estn en paralelo. El detalle es que estas prcticas usaran combinaciones de resistencias
R2 || R3. El circuito en particular quiz necesite mayor o menor resistencia en paralelo con R1 o R2,
pero por ahora comience con R1 = 100 y R2 = 100 || 470 .

3 Construya el circuito de la Figure 7-23 en la Plataforma PE exactamente como se muestra en
la Figura 7-24. Para la lista de componentes vea el Apndice C: Lista de Componentes kit PE
en la pgina 219

Figure 7-23: Detector de Metal Partes y Esquemtico


(1) Capacitor 100 pF P13
(2) cables 100 pF
(2) Resistencias 100 R1 |
(misc) resistencias: / - P15
220, 470, 1000, R2 -
2000, 10k ~ 2.5 inch
GND wire loop

3 Asegrese que el cable que usa como inductor tiene forma de U y est en paralelo a la
superficie de la tarjeta mientras que las otras partes estn perpendiculares.

Figura 7-24: Cableado del
Detector de Metales

Detectando Frecuencia Resonante
El circuito LC mostrado en la Figure 7-23 comnmente se llama rechazo de banda, paro de banda o
filtro. El Filtro atena ciertas frecuencias de onda senoidal de una seal de entrada, idealmente baja a
nada en ciertas frecuencias. La frecuencia que se filtra se llama el centro de la frecuencia o tambin
frecuencia resonante del circuito LC. La Figura 6-1 muestra una grafica de simulacin de como el
filtro responde a un rango de entrada (P15) d onda de frecuencia senoidal de 30 a 90 MHz. Note que
el centro de frecuencia es 50MHz. As, si la entrada fue una onda senoidal su amplitud se atenuara
casi nada; mientras a frecuencias fuera del centro de la frecuencia la salida de amplitud de la onda
senoidal estar en el rango de 1.6V.

Figura 7-25: Salida
simulada P13 Vs.
P15 Entrada para
Frecuencias de
Onda Senoidal

L
Mas acerca de filtros y programas de simulacin:
Si cambia R y C || L, tendr un filtro pasa bandas. La frecuencia de respuesta es la versin invertida de lo que
muestra la Figura 7-26. Para ms informacin en Filtros LC vea los trminos de circuitos de frecuencia
selectiva, filtros, pasa-bajas, pasa-altas, pasa-bandas y rechazo de banda en un libro de electrnica.
Las simulaciones en esta seccin se desarrollaron con el programa Demo OrCAD el cual est disponible
gratuitamente en www.cadence.com

Sin importar si es filtro rechaza-banda o pasa bandas, la frecuencia del circuito resonante puede
calcularse con la ecuacin que se muestra abajo. L es la inductancia, medida en Henrios (H), y C es la
capacitancia medida en Faradios (F). Por supuesto L y C en la Figure 7-23 a diminutas fracciones de
Henrios y Faradios respectivamente.

LC
f
R
2
1
=

Eq. 6

Reacomodando los trminos es posible calcular la inductancia basada en la respuesta de frecuencia de
las pruebas.

C f
L
R
2
) 2 (
1
=

Eq. 7

En esta prctica la entrada del circuito LC ser una onda cuadrada de P15. Aun cuando la salida est
relacionada a las caractersticas de filtrado del circuito, su comportamiento tendr ms sentido si se
examina del punto de vista de la respuesta de paso. Una respuesta de paso de circuito es importante
en circuitos digitales y la meta tpica es hacer que la salida del circuito responda rpido y preciso a la
entrada. La respuesta de paso ms deseable se llama amortiguacin critica porque alcanza su objetivo
rpidamente sin rebasarlo. Algunos diseos pueden obtener respuestas rpidas con un circuito su
amortiguado pero con alguna penalidad de oscilacin sobre y debajo del nuevo objetivo de voltaje
antes de que la seal se estabilice. Otros diseos necesitan una respuesta de paso sobre amortiguado,
lo cual es ms lento para alcanzar su objetivo de voltaje pero asegura que no lo rebasara o resonara.

Figura 7-26: Respuesta a la Frecuencia Resonante

La respuesta de paso simulada en la Figura 7-26 es un caso drstico de una seal su amortiguada.
V(P15Step) en la grafica de arriba es la entrada de seal del circuito LC. V(P13) es la seal de salida,
y V(Threshold) es una seal DC de disparo en el chip Propeller de 1.65V. La simulacin no es
realmente una respuesta tpica porque una onda cuadrada de 50 MHz se aplico por 960 ns antes de
que la llamada de paso (seal alta) se aplicara. El resultado fue que el inductor y el capacitor
acumularon alguna energa lo que hace la respuesta de V(P13) un pseudo-paso a la derecha de la
marca de 960 ns ms pronunciada de lo que seria. Lo importante es notar V(P13) a la derecha de la
marca de 960 ns que es una que decrementa gradualmente. Esta onda senoidal ocurre en la frecuencia
resonante de 50 MHz en el circuito LC.

Tambin observe la lnea V(P13) entre 930 y 960 ns con cada cambio de la seal de V(P15Step)
50MHz, V(P13) comienza una reaccin de onda senoidal que es inicialmente opuesta a la entrada
V(P15Step). Como la seal V(P13) pasa por la mitad de la onda senoidal de 50MHz antes de que la
seal V(P15Step) cambie, las porciones de esas respuestas de ondas senoidales nunca pasaran el
voltaje de disparo 1.65 V del chip Propeller.

Figura 7-27: Circuito LC Respuesta de Salida P13 a Varias Frecuencias

Ahora, compare la respuesta V(P13) a la frecuencia de la onda cuadrada ligeramente arriba y debajo
de la frecuencia resonante del circuito, mostrado en la Figura 7-27. A 47.62 MHz la onda senoidal
completa ligeramente ms de de su ciclo, parte de la cual paso por encima de 1.65V (marcado por
la lnea con el carcter +). A 49.02 MHz la onda senoidal est repitiendo mas del ciclo completo, pero
no tanto, as que la seal tarda ms tiempo abajo del voltaje de disparo. A 50 MHz la frecuencia de
entrada coincide con la respuesta senoidal y como solo se repite la mitad de la onda senoidal
47.62 MHz
49.02 MHz
50.00 MHz
51.02 MHz
52.63 MHz
entonces no est mucho tiempo por encima del voltaje de disparo. A 51.02 y 52.63 MHz la seal
nuevamente pasa tiempo encima del 1.65 V de disparo, esta vez porque la seal de entrada cambia
antes de que la onda senoidal ha completado su ciclo.

La parte ms importante de la Figura 7-27 es que la seal de salida, la cual puede monitorearse por
P13, pasara ms tiempo sobre l la lnea de disparo lgica de 1.65 V cuando la seal de entrada P15
esta mas lejos de la frecuencia resonante del circuito, ya sea arriba o abajo. El Propeller puede usar un
contador en modo PLL para generar ondas cuadradas en el rango de las frecuencias mostradas en la
Figura 7-27 y puede usar otro contador en modo detector POS para medir que tanto tiempo pasa el
circuito arriba del voltaje de disparo 1.65 V del pin E/S P13.

As el chip Propeller puede usar dos mdulos contadores y un pequeo cdigo para cambiar la
frecuencia PWM en P15 a travs de un rango de valores para encontrar la frecuencia resonante del
circuito de la Figure 7-23, pero, como hace posible que detecte metal? La respuesta es que un objeto
metlico cercano interacta electromagnticamente con el cable del circuito de la Figure 7-23 de
modo que cambia su inductancia y aumenta un poco su Resistencia. Cuando la inductancia del
circuito cambia, su frecuencia resonante tambin cambia y el chip Propeller puede detectar eso
intercambiando las frecuencias PLL de P15 y midiendo el tiempo en alto de P13, lo cual alcanzara un
mnimo en de frecuencias resonantes diferentes como resultado de un objeto metlico cercano.

Como la Corriente Eddy Afecta el Ciclo de Frecuencia Resonante Cerca de Objetos
Metlicos
La Figura 7-28 muestra la interaccin entre un objeto metlico cerca del alambre de inductancia. Las
corrientes alternas a travs del ciclo crean efectos electromagnticos. Estos campos magnticos hacen
viajar grupos de electrones en el metal conductivo en patrones circulares. Estos patrones circulares se
llaman Corriente Eddy. Las corrientes alarmas generan un campo magntico opuesto al del cable.

Figura 7-28: Corrientes Eddy Causando Campos Magnticos Opuestos

Las Corrientes Eddy mostradas en la Figura 7-28 nos da un ejemplo de cmo se transmite la potencia
en lneas AC. Una espiral conectada a la lnea de potencia es acoplada magnticamente con un espiral
de pocas vueltas. La corriente alterna en el primario induce un campo magntico alterno que induce la
corriente AC en el espiral secundario. La Figura 7-29 muestra como el espiral secundario y la carga
afectan al primario. La inductancia del espiral secundario y cualquier carga resistiva pueden verse en
el primario y se puede contarse como L2 y R.

I
Figura 7-29: Efecto de Corriente Eddy en la Inductancia del Ciclo

La Figura 7-29 tambin representa como la Corriente Eddy, la cual tiene cierta inductancia debido al
hecho que son inducidas en un metal, afecta a la inductancia del circuito primario y resistencia. As es
que la corriente Eddy en el metal cercano afecta la inductancia del metal. Como la inductancia del
ciclo se mide en L en la ecuacin de resonancia, cambiara la frecuencia resonante del circuito LC.
Tambin como el chip Propeller puede detectar la frecuencia resonante del circuito al intercambiar
frecuencia de onda cuadrada PLL en un pin mientras mide el numero de ciclos de la seal de salida
del circuito cuando esta encima del punto de disparo, la aplicacin puede detectar presencia o
ausencia de metales.

Probando una Frecuencia Resonante
El objeto Calibrate Metal Detector proporciona una conexin para probar la respuesta del circuito LC
con el chip Propeller.. Como se menciono anteriormente los pequeos valores y relativa alta
frecuencia usada en este circuito pueden hacerlo fastidioso. Por ejemplo si el capacitor es ms que 90
del ciclo, la frecuencia resonante cae, si es menos de 90 la frecuencia resonante se incrementa.
Tambin las partes tendrn diversas caractersticas as que tomara algo de prctica para dejar el
circuito a punto para que la resistencia divisora haga que la seal de salida del circuito LC se
mantenga debajo del disparo el pin E/S y se mueva sobre este lmite cuando la frecuencia cambie muy
por encima o debajo.

La Figura 7-30 muestra la salida de CalibrateMetalDetector.spin despus de calibrar el circuito. El
conteo alto en la izquierda es similar a la respuesta de frecuencia graficada en la Figura 7-25. Los
conteos en la derecha muestran que todava hay una frecuencia resonante pero cambia alrededor de
50.6 MHz. Como el ciclo inductivo tambin incrementa su resistencia puede evitar atenuar la seal
para que las mediciones tarden menos tiempo debajo de cero (o quiz nunca deje de ser cero).

Figura 7-30: Respuesta de Calibrated Metal Detector sin metal (izq.) y con metal (der.)

Aqu se muestra como calibrar manualmente el circuito detector. La deteccin automtica se deja para
la seccin de proyectos.

3 Cargue CalibrateMetalDetector.spin en la EEPROM (F11) e inmediatamente despus
presione el botn Enable de la Terminal Serial Parallax. (Recuerde que ni siquiera tiene que
esperar a que el programa termine de cargarse).
3 Cuando el cursor est listo ingrese la frecuencia comenzando por 48,000,000
3 Ingrese una nueva frecuencia de 200,000
3 Compare su pantalla con la de la izquierda en la Figura 7-30, observando no tanto para que
coincidan los nmeros pero viendo que los perfiles sean similares, lo cual muestra una
frecuencia resonante centrada cuando el contador es = 0.
3 Si su pantalla muestra una frecuencia resonante clara intente colocar una moneda
directamente debajo, pero sin tocar el cable de alambre y presione la tecla R en su teclado
para repetir el mismo cambio de frecuencia.
3 Si la pantalla cambia significativamente como el de la derecha en la Figura 7-30 su detector
medidor aparentemente no necesita mayor calibracin.
3 Si no est viendo frecuencias resonantes claras intente refinar la frecuencia de inicio y la
frecuencia de paso para que el cambio claro indique la presencia o ausencia de metal.
3 Si aparentemente no hay respuesta del filtro (ya sea todos ceros o valores mayores) intente las
sugerencias que se muestran a continuacin.

Quiz el circuito en vez de necesitar algn ajuste muestre respuestas similares a la Figura 7-30. Si en
cambio ve nmeros que estn muy altos, ceros o valores muy bajos, el divisor de voltaje quiz
necesite ajustarse. Est diseado para hacer una salida justo debajo del punto de disparo.

3 Si ve puros ceros, el divisor de voltaje necesita estar menos distanciado de la seal. Primero
intente sucesivamente resistencias mayores en lugar de R3, Intente 1 k, 2 k, 10 k.
3 Si el divisor de voltaje esta aun tomando mucho de la seal desconecte R3 totalmente y en
cambio agregue una R4 en paralelo con R1. Comience con una resistencia grande como 10
k, y trabaje bajando la Resistencia 2 k, 1 k, y as sucesivamente. Repita el cambio de
frecuencia entre ajustes hasta que encuentre un divisor de voltaje que trabaje bien para el
circuito y el voltaje de disparo del chip Propeller.
3 Si no hay respuesta del filtro, en otras palabras, ningn grupo de valores como en la Figura
7-30 quiz necesite buscar valores de menores o mayores frecuencias despus de ajustar el
divisor de voltaje. Esto implica comenzar el cambio a valores bajos como 46 MHz en vez de
48 y usar incrementos ms pequeos como 100,000 en vez de 200,000 y seleccionar M o
Enter cuando se coloque el cursor en pantalla.
3 Una vez que ha tenido frecuencias resonantes buenas, puede usted tambin diferenciar la
distancia del objeto metlico entre 1mm, 5mm y 10mm?

'' CalibrateMetalDetector.spin

CON

_clkmode = xtal1 + pll16x ' 80 MHz Reloj Interno
_xinfreq = 5_000_000

CLS = 16, CR = 13

OBJ

frq : "SquareWave"

PUB Init | count, f, fstart, fstep, c

'Inicia FullDuplexSerialPlus
Debug.start(31, 30, 0, 57600)
Debug.tx(CLS)

'Configura modulo ctra para onda cuadrada de 50 MHz
ctra[30..26] := %00010
ctra[25..23] := %110
ctra[5..0] := 15
frq.Freq(0, 15, 50_000_000)
dira[15]~~

'Configura modulo ctrb para deteccin negativa de limite
ctrb[30..26] := %01000
ctrb[5..0] := 13
frqb := 1

c := "S"

repeat until c == "Q" or c == "q"

case c
"S", "s":
Debug.Str(String("Starting Frequency: "))
f := Debug.GetDec
Debug.Str(String("Step size: "))
fstep := Debug.GetDec
Debug.tx(String(CR))

case c
"S", "s", 13, 10, "M", "m":
repeat 22
frq.Freq(0, 15, f)
count := phsb
count := phsb - count
Debug.Str(String(CR, "Freq = "))
Debug.Dec(f)
Debug.Str(String(" count = "))
Debug.Dec(count)
f += fstep

Debug.str(String(CR,"Enter->more, Q->Quit, S->Start over, R->repeat: "))
c := Debug.rx
Debug.tx(CR)

"R", "r":
f -= (22 * fstep)
c := "m"

"Q", "q": quit

Debug.str(String(10, 13, "Bye!"))

Tiempo de Estudio
Preguntas
1) Cuntos mdulos contadores tiene un Cog y como son etiquetados?
2) Qu trminos usa esta prctica para referirse a los tres registros del modulo contador sin
especificar cual modulo se est usando? En otras palabras Qu trminos genricos se usan
para referirse a los tres registros del modulo contador?
3) Cules son los tres nombres usados para referirse al contador A en cdigo Spin?
4) Cules son los tres nombres usados para referirse al contador B en cdigo Spin?
5) Qu registro se suma condicionalmente al registro PHS con cada ciclo de reloj?
6) Qu registro puede usar para activar condiciones por las cuales el registro PHS se actualiza?
7) Cmo afecta el registro PHS los pins E/S con ciertos bits?
8) Como indica la medicin de descarga RC el estado de una variable ambiental?
9) Es una resistencia limitadora de corriente necesaria en una red RC conectada al chip Propeller
10) Es posible crear un circuito RC que empieza en 0V y acumula hasta 5 V durante la medicin.
Cual valor de CTRMODE debera tener para ser usada para medir este tipo de circuito?
11) Cmo es un modo detector positivo del modulo contador usado para medir descarga RC?
12) Donde residen los bits de CTRMODE?
13) Qu seleccionan los bits CTRMODE?
14) Para mediciones de descarga RC, cuales campos se programan en el registro CTR?
15) Qu valor tiene que almacenar el registro FRQ para mediciones de descarga RC?
16) Cules son los tres pasos necesarios para configurar un modulo contador para tomar
mediciones de descarga RC?
17) Asuma que un contador ha sido programado para tomar medicin de descarga RC, Que tiene
que hacerse para iniciar la medicin?
18) Porque pueden tomarse simultneamente mediciones RC?
19) En que difiere un contador con pin E/S de la descarga RC y aplicaciones de conversin
D/A?
20) Cmo controla el registro FRQ una seal D/A en modo DUTY?
21) Qu componente del modulo contador controla el pin E/S?
22) Qu propsito tiene scale = 16_777_216 en LedDutySweep.spin?
23) Cmo se direccionan los registros de propsito especial 8 a 13?
24) Qu registros de propsito especial pueden usarse para controlar el valor de ctrb?
25) Qu registros de propsito especial pueden usarse para activar el valor de frqa?
26) Qu tiene myVariable despus de ejecutar el comando myVariable := spr[13]?
27) Cules son las dos formas de asignar el valor almacenado en myVar a ctrb?
28) Cmo puede afectar ciertos bits con spr[8] o spr[9], y porque es tan til?
29) Qu elemento del contador de registro de propsito especial controla un pin E/S en modo
NCO?
30) Cul es la condicin para sumar FRQ a PHS en modo NCO?
31) Qu relacin necesita la frecuencia deseada NCO para ser multiplicada por un determinado
valor de registro FRQ?
32) Si un contador es activado a modo NCO y un programa copia un valor al registro FRQ del
contador, Qu relacin necesita el registro FRQ para ser multiplicado para determinar la
frecuencia?
33) Si in pin E/S est transmitiendo una onda cuadrada NCO, cuales son tres formas de
detenerlo?
34) Puede un cog enviar dos ondas cuadradas en dos frecuencias no relacionadas?
35) Qu tiene que hacer un programa para cambiar la frecuencia NCO si un contador est
transmitiendo?
36) Puede un modulo contador usarse para medir seal de frecuencia?
37) Son POSEDGE y NEGEDGE incrementados basndose en el lmite de una seal?
38) Hay un comando escrito repeat while phsb[31] en BetterCountEdges.spin en la seccin de
deteccin rpida de lmites en la pagina 157. Sera posible sustituir un registro de propsito
especial en lugar de phsb?
39) Qu rango de frecuencia puede transmitir un modo PLL de contador?
40) Qu elementos del modo NCO usa PLL?
41) A diferencia del modo NCO, el modo PLL no usa el bit 31 de su registro PHS para controlar
el pin E/S. Qu pasa a esta seal?
42) Cules son los pasos para calcular la frecuencia PLL dando los valores almacenados en los
registros FRQ, PLLDIV y CLKFREQ?
43) Cules son los pasos para calcular FRQ y PLLDIV para sintetizar una frecuencia PLL?
Ejercicios
1) Modifique TestRcDecay.spin ara que mida ascensos en vez de tiempo de descarga.
2) Inicie un modo Duty terminacin sencilla para conversin D/A a 1V usando contador modulo
B y los nombres de registros del modulo contador.
3) Inicie un modo Duty terminacin sencilla para conversin D/A a 1V usando contador modulo
B y registros de propsito especial. Tenga cuidado al usar elementos del arreglo de registro
de propsito especial que afectan DIRA. Para cambiar solo un bit del registro DIRA tome el
valor existente almacenado por el registro y hacerlo OR con la mscara del bit 7 puesto a 1.
4) Calcule las celdas vacas en la Tabla 7-1 de la pagina 139.
5) Asuma que el sistema de reloj del chip Propeller corre a 20 MHz, escriba el cdigo para
enviar una onda cuadrada aproximada de la nota Do7 en P16 que use el contador B
6) Modifique DoReMi.spin para que toque las doce notas de la Tabla 7-1 de la pagina 142.
7) Modifique TwoTonesWithSquareWave.spin para que toque correctamente las notas con un
cristal de 2 MHz.
8) Modifique IrDetector.spin para que trabaje en una escala de 0 a 128 en vez de 0 a 256.
9) Modifique CountEdgeTest.spin para que cuente limites positivos en vez de negativos
10) Modifique 1Hz25PercentDutyCycle.spin para que enve la seal central a un servo. Esto har
que el servo estndar se mantenga en la posicin del centro de su rango de movimiento o que
un servo de rotacin continua se quede sin movimiento. La seal es una serie de pulsos de
1.5ms cada 20ms.
11) Modifique 1Hz25PercentDutyCycle.spin para que haga que la salida del servo cambia de un
extreme de su rango de movimiento al otro en 1.5 segundos. Para un servo estndar de 180
grados, la duracin del pulso deber cambiar nominalmente de 0.5 ms a 2.5 ms y de regreso.
El pulso deber entregarse aun a 20ms. En la prctica es bueno asegurarse que el servo no
trate de moverse ms all de sus topes mecnicos. Para los servos estndar Parallax un rango
seguro esta en el rango de 0.7 a 2.2 ms.
12) Modifique TestDualPwm para que cambia dos servos entre sus extremos opuestos de
movimiento en un periodo de 1.5 segundos.
Proyectos
1) Escriba un objeto DAC modo DUTY de dos canales modo terminacin sencilla que le
permita crear y reclamar canales contadores DAC (Contador A y Contador B). Cada canal
DAC deber tener su propia resolucin en trminos de bits. El DAC deber soportar el cdigo
prueba y documentacin mostrada abajo. Si va a altas resoluciones recuerde dejar algo de
espacio en los niveles bajos y altos. Vea claves para programar DUTY en la pagina 133.

CODIGO PRUEBA
''Test DAC 2 Channel.spin
''DAC 2 canales.

OBJ

dac : "DAC 2 Channel"

PUB TestDuty | level

dac.Init(0, 4, 8, 0) ' Ch0, P4, 8-bit DAC, inicia a 0 V
dac.Init(1, 5, 7, 64) ' Ch1, P5, 7-bit DAC, inicia a 1.65 V

repeat
repeat level from 0 to 256
dac.Update(0, level)
dac.Update(1, level + 64) ' DAC salida automticamente reducida a 128

DOCUMENTACION DE OBJETO
Object "DAC 2 Channel" Interface:

PUB Init(channel, ioPin, bits, level)
PUB Update(channel, level)
PUB Remove(channel)

Program: 20 Longs
Variable: 2 Longs

______________________________________

Inicia un DAC.
channel - 0 o 1
ioPin - Escoge pin E/S DAC
bits - Resolucin (8 bits, 10 bits, etc.)
bits
level - Nivel voltaje inicial = 3.3 V * level 2

___________________________

Actualiza el nivel transmitido por un canal ADC a
bits
level = 3.3 V * level 2

____________________
PUB Remove(channel)

Recupera el modulo contador y programa los pins asociados E/S a entrada

GUIA:
Defina dos arreglos de variables globales lsb para almacenar el LSB de cada DAC
Las variables lsb son las versiones ajustables de la constante scale en
LedSweepWithSpr.spin.
Defina cada elemento del arreglo lsb en el mtodo Init usando lsb[channel] := |<
(32 - bits). Por ejemplo si bits es 8, el operador encode asigna 24 del elemento del
arreglo bits. Cul es el valor? 16_777_216. Es el mismo que la constante scale que
se declaro para el DAC 8-bit en LedSweepWithSpr.spin.
Para asignar el nivel de voltaje use spr[10 + channel] := level * lsb[channel],
donde level es el valor de voltaje deseado. Por ejemplo si bits es 8 (un DAC de 8-
bits) entonces un level de 128 resultara en 1.65 V.

2) La solucin del ejercicio 12 (mostrado abajo) controla dos servos usando dos mdulos
contadores. Cada contador en el ciclo repeat entrega un pulso en el rango de 700 a 2200 s.
Entonces el comando waitcnt espera por los 20ms restantes. El mximo tiempo que toma el
pulso es 2200 s (2.2 ms). Como el ciclo repeat se repite cada 20 ms eso deja 17.8 ms para
pulsos de otros servos. Modifique el programa para que controle otros dos servos (para un
total de cuatro) durante 17.8 ms. Recuerde que los mdulos contadores corren
independientemente, as que tendr que insertar retrasos para completar cada par de pulsos
antes de moverse al siguiente par.

{{
TestDualPWM.spin
Demuestra cmo usar dos contadores para enviar una seal doble PWM.
El tiempo de ciclo es el mismo para ambas seales, pero los tiempos
En alto son independientes del otro.
}}

CON

_clkmode = xtal1 + pll16x ' Reloj sistema 80MHz
_xinfreq = 5_000_000

PUB TestPwm | tc, tHa, tHb, t, us ' <- Suma us

us := clkfreq/1_000_000 ' <- Suma

ctra[30..26] := ctrb[30..26] := %00100 ' Contadores A y B NCO terminacin
sencilla
ctra[5..0] := 4 ' Pins para contadores para control
ctrb[5..0] := 6
frqa := frqb := 1 ' Suma 1 a phs con cada ciclo de
reloj

dira[4] := dira[6] := 1 ' Activa pisn E/S a salida

tC := 20_000 * us ' <- Cambia Set up tiempo de ciclo
tHa := 700 * us ' <- Cambia Set up tiempo alto
tHb := 2200 * us ' <- Cambia

t := cnt ' Marca tiempo actual

repeat tHa from (700 * us) to (2200 * us) ' <- Cambia seal PWM
t += tC ' Calcula siguiente ciclo repeat
waitcnt(t) ' Espera por ciclo

3) Desarrolle un objeto que inicie un cog y permita a otros objetos controlar su modo duty
conversin D/A de acuerdo a la documentacin mostrada. Pruebe este objeto con un objeto
superior que usa un sistema de men para obtener valores D/A del usuario y los pasa a
control de brillo de un LED.

''DualDac.spin

''Proporciona los canales de dos mdulos contadores de otro cog para conversin
D/A

Como usar este objeto en la aplicacin
------------------------------------------
1) Declare variables los canales D/A. Ejemplo:

VAR
ch[2]

2) Declare el objeto DualDac. Ejemplo:

OBJ
dac : DualDac

3) Llame al mtodo start. Ejemplo:

PUB MethodInMyApp
'...
dac.start

4) Active salidas D/A. Ejemplo:
ch[0] := 3000
ch[1] := 180

5) Configure los canales DAC. Ejemplo:
'Canal 0, pin 4, 12-bit DAC, ch[0] almacena el valor DAC.
dac.Config(0,4,12,@ch[0])
'Como ch[0] se activo a 3000 en el paso 4, la salida P4 de
DAC ser
' 3.3V * (3000/4096)

'Canal 1, pin 6, 8-bit DAC, ch[1] almacena el valor de DAC.
'Como ch[1] se activo a 180 en el paso 4, la salida P6 de DAC ser
' 3.3V * (180/256)

6) Mtodos y caractersticas en este objeto harn posible tambin:
- remover un canal DAC
- cambiar un canal DAC:
o Pin E/S
o Resolucin
o Direccin variable de control
o Valor almacenado por la variable control

Ver tambin
-----------
TestDualDac.spin para un ejemplo de aplicacin.

Objeto "DualDac" Interface:

PUB Start : okay
PUB Stop
PUB Config(channel, dacPin, resolution, dacAddress)
PUB Remove(channel)
PUB Update(channel, attribute, value)

Program: 73 Longs
Variable: 29 Longs

_________________
PUB Start : okay

Inicia un cog Nuevo D/A. Usa mtodo Config para activar un dac en un pin dado.

_________
PUB Stop

Detiene el proceso DAC y libera el cog.

____________________________________________________

Configura un DAC. Bloquea la ejecucin del programa hasta que otro cog completa
el comando.
channel - 0 = canal 0, 1 = canal 1
dacPin - Numero de pin E/S que desarrolla el D/A
resolution - bits de conversin D/A (8 = 8 bits, 12 = 12 bits, etc.)
dacAddress Direccin de la variable que tiene el nivel de conversin D/A,
un valor entre 0 y (2^resolucion) - 1.

____________________
PUB Remove(channel)

Remueve un canal. Activa canales de pin E/S a entrada y limpia el modulo
contador.
Bloquea la ejecucin del programa hasta que otro cog completa el comando.

______________________________________

Actualiza la configuracin de un canal DAC.
Bloquea la ejecucin del programa hasta que otro cog completa el comando.
channel - 0 = canal 1 = canal 1
attribute - el atributo DAC para actualizar
0 -> dacPin
1 -> resolution
2 -> dacAddr
3 -> dacValue
value - el valor del atributo para ser actualizado


Apndice A: Lista de Cdigos de Objetos
Apndice A: Lista de Objetos Cdigo

FullDuplexSerialPlus.spin

'' De Parallax Inc. Kit Educativo Propeller Practica de Objetos
{{

Archivo: FullDuplexSerialPlus.spin
Versin: 1.1
Derechos Reservados (c) 2008 Parallax, Inc.
Ver al final del archive para trminos de uso.

Este es el objeto FullDuplexSerial v1.1 de la carpeta de la Librera de la Herramienta
Propeller con documentacin modificada y mtodos para convertir cadenas de texto en
valores numricos en diversas bases.

}}

CON ''
''Caracteres Constantes de Control Terminal Serial Parallax
''
HOME = 1 ''HOME = 1
CRSRXY = 2 ''CRSRXY = 2
CRSRLF = 3 ''CRSRLF = 3
CRSRRT = 4 ''CRSRRT = 4
CRSRUP = 5 ''CRSRUP = 5
CRSRDN = 6 ''CRSRDN = 6
BELL = 7 ''BELL = 7
BKSP = 8 ''BKSP = 8
TAB = 9 ''TAB = 9
LF = 10 ''LF = 10
CLREOL = 11 ''CLREOL = 11
CLRDN = 12 ''CLRDN = 12
CR = 13 ''CR = 13
CRSRX = 14 ''CRSRX = 14
CRSRY = 15 ''CRSRY = 15
CLS = 16 ''CLS = 16

VAR

long cog 'bandera/identificacin cog

long rx_head '9 longs prximos
long rx_tail
long tx_head
long tx_tail
long rx_pin
long tx_pin
long rxtx_mode
long bit_ticks
long buffer_ptr

byte rx_buffer[16] 'transmite y recibe buffers
byte tx_buffer[16]

Lista de Cdigos de Objetos
PUB start(rxpin, txpin, mode, baudrate) : okay
{{
Inicia controlador serial en un cog nuevo

rxpin entrada recibe seales del pin perifrico de TX
txpin salida enva seales al pin perifrico de RX
mode - bits en esta variable configuran la seal
bit 0 invierte rx
bit 1 invierte tx
bit 2 abre fuente/drenado tx
bit 3 ignora eco tx en rx
baudrate - bits por segundo

okay regresa falso si no hay cog disponible.
}}

stop
longfill(@rx_head, 0, 4)
longmove(@rx_pin, @rxpin, 3)
bit_ticks := clkfreq / baudrate
buffer_ptr := @rx_buffer
okay := cog := cognew(@entry, @rx_head) + 1

PUB stop

'' Detiene controlador serial libera un cog

if cog
cogstop(cog~ - 1)
longfill(@rx_head, 0, 9)

PUB tx(txbyte)

'' Enva byte (puede esperar por espacio en buffer)

repeat until (tx_tail <> (tx_head + 1) & $F)
tx_buffer[tx_head] := txbyte
tx_head := (tx_head + 1) & $F

if rxtx_mode & %1000
rx

PUB rx : rxbyte

'' Recibe byte (puede esperar por byte)
'' rxbyte regresa $00..$FF

repeat while (rxbyte := rxcheck) < 0

PUB rxflush

'' Flush receive buffer

repeat while rxcheck => 0

PUB rxcheck : rxbyte

'' Verifica si recibi byte (nunca espera)
'' rxbyte regresa -1 si no se recibi byte, $00..$FF si hay byte

rxbyte--
if rx_tail <> rx_head
rxbyte := rx_buffer[rx_tail]
rx_tail := (rx_tail + 1) & $F

PUB rxtime(ms) : rxbyte | t

'' Espera milisegundos ms para recibir byte
'' regresa -1 si no se recibi byte, $00..$FF si hay byte

t := cnt
repeat until (rxbyte := rxcheck) => 0 or (cnt - t) / (clkfreq / 1000) > ms

PUB str(stringptr)

'' Enva cero terminal de cadena que inicia en la direccin de memoria stringptr

repeat strsize(stringptr)
tx(byte[stringptr++])

PUB getstr(stringptr) | index
'' Obtiene cero terminal de cadena y lo almacena, inicia en la direccin de memoria
stringptr
index~
repeat until ((byte[stringptr][index++] := rx) == 13)
byte[stringptr][--index]~

PUB dec(value) | i

'' Imprime un nmero decimal

if value < 0
-value
tx("-")

i := 1_000_000_000

repeat 10
if value => i
tx(value / i + "0")
value //= i
result~~
elseif result or i == 1
tx("0")
i /= 10

PUB GetDec : value | tempstr[11]

'' Obtiene la representacin de carcter decimal de un numero de la terminal
'' Regresa el valor correspondiente

GetStr(@tempstr)
value := StrToDec(@tempstr)

PUB StrToDec(stringptr) : value | char, index, multiply

'' Convierte la representacin de cero terminal de cadena de un numero decimal a un
valor

value := index := 0
repeat until ((char := byte[stringptr][index++]) == 0)
if char => "0" and char =< "9"
value := value * 10 + (char - "0")
if byte[stringptr] == "-"
value := - value

PUB bin(value, digits)

'' Enva representacin de carcter de un numero binario a la terminal.

value <<= 32 - digits
repeat digits
tx((value <-= 1) & 1 + "0")

PUB GetBin : value | tempstr[11]

'' Obtiene representacin de carcter binario de un numero de la terminal

GetStr(@tempstr)
value := StrToBin(@tempstr)

PUB StrToBin(stringptr) : value | char, index

'' Convierte representacin de cero terminal de cadena de un numero binario a un valor

value := index := 0
if char => "0" and char =< "1"
value := - value

PUB hex(value, digits)

'' Imprime un nmero hexadecimal

value <<= (8 - digits) << 2
repeat digits
tx(lookupz((value <-= 4) & $F : "0".."9", "A".."F"))

PUB GetHex : value | tempstr[11]

'' Obtiene representacin de carcter hexadecimal de un numero de la terminal

GetStr(@tempstr)
value := StrToHex(@tempstr)

PUB StrToHex(stringptr) : value | char, index

'' Convierte una representacin de cero terminacin de cadena de un numero hexadecimal
a un valor

value := index := 0
if (char => "0" and char =< "9")
elseif (char => "A" and char =< "F")
value := value * 16 + (10 + char - "A")
elseif(char => "a" and char =< "f")
value := value * 16 + (10 + char - "a")
value := - value

DAT

'*******************************************
'* Controlador serial lenguaje ensamblador *
'*******************************************

org
'
'
' Entry
'
entry mov t1,par 'obtiene direccin estructura
add t1,#4 << 2 'salta encabezado y finales pasados

rdlong t2,t1 'obtiene rx_pin
mov rxmask,#1
shl rxmask,t2

add t1,#4 'obtiene tx_pin
rdlong t2,t1
mov txmask,#1
shl txmask,t2

add t1,#4 'obtiene rxtx_mode
rdlong rxtxmode,t1

add t1,#4 'obtiene bit_ticks
rdlong bitticks,t1

add t1,#4 'obtiene buffer_ptr
rdlong rxbuff,t1
mov txbuff,rxbuff
add txbuff,#16

test rxtxmode,#%100 wz 'inicia tx pin de acuerdo a modo
test rxtxmode,#%010 wc
if_z_ne_c or outa,txmask
if_z or dira,txmask

mov txcode,#transmit 'inicia ping-pong multitarea
'
'
' Recibe
'
receive jmpret rxcode,txcode 'correo pedazo de cdigo tx, luego
regresa

test rxtxmode,#%001 wz 'espera por bit de inicio en pin rx
test rxmask,ina wc
if_z_eq_c jmp #receive

mov rxbits,#9 'listo para recibir byte
mov rxcnt,bitticks
shr rxcnt,#1
add rxcnt,cnt

:bit add rxcnt,bitticks 'listo siguiente periodo bit

:wait jmpret rxcode,txcode 'corre pedazo de codigo tx, luego
regresa

mov t1,rxcnt 'verifica de completo periodo
recibir bit
sub t1,cnt
cmps t1,#0 wc
if_nc jmp #:wait

test rxmask,ina wc 'recibe bit en pin rx
rcr rxdata,#1
djnz rxbits,#:bit

shr rxdata,#32-9 'justifica y corta byte recibido
and rxdata,#$FF
test rxtxmode,#%001 wz 'si rx invertido, invierte byte
if_nz xor rxdata,#$FF

rdlong t2,par 'guarda byte recibido
add t2,rxbuff
wrbyte rxdata,t2
sub t2,rxbuff
add t2,#1
and t2,#$0F
wrlong t2,par

jmp #receive 'byte completo, recibe siguiente
byte
'
'
' Transmite
'
transmit jmpret txcode,rxcode 'corre pedazo de cdigo rx, luego
regresa

mov t1,par 'verifica encabezado y final
add t1,#2 << 2
rdlong t2,t1
add t1,#1 << 2
rdlong t3,t1
cmp t2,t3 wz
if_z jmp #transmit

add t3,txbuff 'obtiene byte

rdbyte txdata,t3
sub t3,txbuff
add t3,#1
and t3,#$0F
wrlong t3,t1

or txdata,#$100 'lectura byte para transmitir
shl txdata,#2
or txdata,#1
mov txbits,#11
mov txcnt,cnt

:bit test rxtxmode,#%100 wz 'salida bit en pin tx
test rxtxmode,#%010 wc 'de acuerdo a modo
if_z_and_c xor txdata,#1
shr txdata,#1 wc
if_z muxc outa,txmask
if_nz muxnc dira,txmask
add txcnt,bitticks 'listo siguiente cnt

:wait jmpret txcode,rxcode 'corre pedazo de cdigo rx, luego
regresa

mov t1,txcnt 'verifica si termino periodo
transmisin de bit
sub t1,cnt
cmps t1,#0 wc
if_nc jmp #:wait

djnz txbits,#:bit 'otro bit para transmitir?

jmp #transmit 'byte completo, transmite siguiente
byte.
'
'
' datos no inicializados
'
t1 res 1
t2 res 1
t3 res 1

rxtxmode res 1
bitticks res 1

rxmask res 1
rxbuff res 1
rxdata res 1
rxbits res 1
rxcnt res 1
rxcode res 1

txmask res 1
txbuff res 1
txdata res 1
txbits res 1
txcnt res 1
txcode res 1

{{

TERMINOS DE USO: MIT Licencia

Se autoriza, de forma gratuita, a cualquier persona que obtenga una copia de este
software y archivos de documentacin asociados (el "Software"), para trabajar
con el Software sin restriccin, incluyendo sin limitacin los derechos de uso ,
copiar, modificar, fusionar, publicar, distribuir, sublicenciar, y / o vender
copias del Software, y para autorizar a los sujetos a quienes se proporcione el
Software para ello, sin perjuicio de las siguientes condiciones:

El aviso de copyright anterior y esta nota de permiso se incluir en
todas las copias o partes sustanciales del Software.

EL SOFTWARE SE ENTREGA "TAL CUAL", SIN GARANTA DE NINGN TIPO, EXPRESA O IMPLCITA,
INCLUYENDO PERO NO LIMITADO A LAS GARANTAS DE COMERCIALIZACIN, ADECUACIN
A UN PROPSITO PARTICULAR Y NO INFRACCIN.

EN NINGN CASO LOS AUTORES O TITULARES SERAN RESPONSABLES DE
CUALQUIER RECLAMACIN, DAO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIN DE CONTRATO,
AGRAVIO O DE OTRA DERIVADA DE O EN RELACION CON EL SOFTWARE O EL USO PARA OTROS FINES
DEL SOFTWARE

}}

SquareWave.spin

'' De Parallax Inc. Kit Educativo Propeller Practica de Contadores y Circuitos
'' SquareWave.spin
''Puede usarse para hacer alguno de los dos mdulos contadores del cog
''para transmitir ondas cuadradas

PUB Freq(Module, Pin, Frequency) | s, d, ctr

'' Determina parmetros CTR para sntesis de 0..128 MHz en pasos de 1 Hz
''
'' entrada: Pin = pin para salida de frecuencia
'' Freq = actual Hz para sintetizar
''
'' salida: ctr y frq tienen valores ctra/ctrb y frqa/frqb
''
'' Usa modo NCO %00100 para 0..499_999 Hz
'' Usa modo PLL %00010 para 500_000..128_000_000 Hz
''

Frequency := Frequency #> 0 <# 128_000_000 'limite de frecuencias

if Frequency < 500_000 'si 0 a 499_999 Hz,
ctr := constant(%00100 << 26) '..activa modo NCO
s := 1 '..shift = 1

else 'si 500_000 a 128_000_000 Hz,
ctr := constant(%00010 << 26) '..activa modo PLL
d := >|((Frequency - 1) / 1_000_000) 'determina PLLDIV
s := 4 - d 'determina shift
ctr |= d << 23 'activa PLLDIV

spr[10 + module] := fraction(Frequency, CLKFREQ, s) 'calcula frqa/frqb value
ctr |= Pin 'activa PINA para
'completar valores ctra/ctrb
spr[8 + module] := ctr

dira[pin]~~

PUB NcoFrqReg(frequency) : frqReg

{{
Regresa frqReg = frequency (2 clkfreq) calculada con divisin long binaria.
Esto es ms rpido que la librera de punto flotante y toma menos espacio de cdigo.
Este mtodo es una adaptacin del mtodo fraccin del objeto CTR
}}

frqReg := fraction(frequency, clkfreq, 1)

PRI fraction(a, b, shift) : f

if shift > 0 'si shift, pre-shift a o b izq
a <<= shift 'para mantener bits significativos
if shift < 0 'mientras asegura resultado
b <<= -shift

repeat 32 'realiza divisin long de a/b
f <<= 1
if a => b
a -= b
f++
a <<= 1
Apndice B: Estudio de Soluciones
Apndice B: Soluciones de Estudios
Soluciones de la Practica E/S y Tiempo
Soluciones a las preguntas de E/S y Tiempo
1) Ocho
2) 32 KB
3) El chip Propeller proporciona 3.3 V. Cuando el pin E/S es alto el chip Propeller conecta
internamente el pin E/S a su voltaje de 3.3V y cuando esta bajo se conecta a Tierra o 0V.
4) El cdigo Spin se almacena en la RAM global del chip Propeller y el cog corriendo un
programa interprete obtiene y ejecuta el cdigo.
5) En vez de ejecutar cdigo Spin que obtiene y ejecuta de la RAM global, el cdigo maquina
generado por lenguajes ensamblador se almacena en la RAM de 2KB del cog y se ejecuta
directamente por el cog.
6) Hay diferentes formas de responder, la ms concreta y centrada en Propeller seria que un
mtodo en un bloque de cdigo con un mnimo de reglas de accesos declarados y nombre;
mientras que un objeto es u n bloque comprimido de todos los cdigos en un archivo .spin.
Cada objeto contiene uno o ms mtodos.
7) Es el objeto que proporciona un punto de inicio para una aplicacin dada que se carga en la
RAM del chip Propeller. Aun si no es requerido, los objetos superiores organizan
frecuentemente y orquestaran los objetos de la aplicacin.
8) Cada bit en dira active la direccin (Entrada o salida) de un pin E/S para un cog. Cada bit en
outa activa el estado de la salida (encendido o apagado) para un cog proporcionando el bit
correspondiente en el registro dira que es activado como salida.
9) Hay cuatro formas diferentes de condiciones. El numero d repeticiones se puso a la derecha
del comando repeat para especificar cuantas veces se repite el ciclo. La condicin while
especifica mantener corriendo el ciclo mientras una condicin es verdadera. La condicin
until se uso para mantener el cdigo corriendo hasta que ciertas condiciones ocurren.
Finalmente una variable se incremento cada vez que pasaba por el ciclo repeat de cierto valor
a cierto valor.
10) clkfreq
11) Necesitan estar abajo a indentados del comando repeat para ser parte del ciclo. El siguiente
comando siguiendo el comando repeat que es del mismo o menor nivel de indentacion no es
parte del ciclo repeat, ni lo es un comando que lo sigue sin importar su nivel de indentacin.
12) El objetivo del valor del comando waitcnt fue tpicamente calculado al sumar alguna
fraccin de clkfreq al registro cnt. As waitcnt espera hasta que el registro cnt excede el
valor waitcnt.
13) _xinfreq almacena la frecuencia de entrada del oscilador, mientras en esta prctica _clkmode
se uso para definir la retroalimentacin del cristal del chip Propeller y activar el PLL. Para
ms informacin revisar los trminos en el Manual Propeller.
14) Multiplica la frecuencia por un valor. Las opciones de mltiplos son 1, 2, 4, 8 o 16.
15) La constante clkfreq se ajusta con la frecuencia del reloj del sistema del chip Propeller;
mientras un valor constante para retrasos resultara en retrasos que cambian con el reloj del
sistema
16) Un cristal externo.
17) Los registros de control de direccin y salida dira y outa respectivamente. Si un pin E/S se
activa como entrada el valor del registro ina actualizara al correr cuando un comando ina se
entrego regresando 1 o 0 para cada bit dependiendo del voltaje aplicado al pin E/S
Estudio de Soluciones
correspondiente. Los voltajes aplicados a un pin E/S sobre 1.65V generan un 1, los voltajes
debajo de 1.65V regresan un 0.
18) Un valor sencillo entre los corchetes a la derecha de dira/outa/ina se refiere a un bit sencillo
en el registro. Dos valores separados por dos puntos se refieren a un grupo de bits seguidos.
19) %, El indicador binario de numero.
20) El pin E/S se active como entrada, as que solo monitorea el voltaje aplicado al pin y
almacena un 1 en su bit ina si el voltaje esta encima de 1.65V o un 0 si est por debajo de
1.65V. Como entrada este pin no tiene efecto en circuitos externos.
21) Cero.
22) Asigna-Igual :=, Post-Activar ~~, Post-Limpiar ~, Bit inteligente !, Limite Mximo<#=,
Limite mnimo #>=, Pre y Post-Incremento ++, Pre y Post-Decremento --, Movimiento a la
Derecha >>=, y Movimiento a la izquierda <<=.
23) Es igual ==, No es Igual <>, Es menor que <, Es mayor que >, Es igual o menor que =<, Es
igual o mayor que =>.
24) := es el asignador de igual mientras == es la comparacin igual a. EL resultado de :=
asigna el valor del operando en la derecha del operando al operando en la izquierda. EL
resultado de == simplemente compara dos valores y regresa -1si son iguales o 0 si no lo son.
25) No, no es necesario aunque se piense til. En esta prctica el valor que regresa ina para un bit
fue 1 o 0 lo cual funciona bien para bloques if porque el cdigo se ejecuta si una condicin
es no cero o no se ejecuta si la condicin es cero (-1 es no cero)
26) Global y Local. Variables globales se declaran en una seccin VAR del objeto. Variables
locales solo se usan por un mtodo segn se ejecuta.
27) Los tres tamaos de una variable son byte (0 a 255), Word (0 a 65535) y long (-2,147,483,648
to 2,147,483,647). Las variables locales son automticamente tamao long mientras que las
variables globales pueden declararse como byte, Word o long.
28) Un carcter pipa |se usa para declarar variables locales a la derecha de la declaracin de
mtodo. A la derecha de la pipa, puede declararse ms de un nombre de variable separando
por comas.
Soluciones a Ejercicios de la Practica de E/S y Tiempo
1) Solucin:
outa[8..12] := dira[8..12] := %1111

2) Solucin:
dira[9] := outa[9]:= 1
outa[13..15] := %000
dira[13..15] := %111

3) Solucin:
dira[0..8] :=%111000000

4) Solucin:
outa[8]~~
outa[9]~
repeat
!outa[8..9]

5) Solucin:
repeat
outa[0..7]!= ina[8..15]

6) Solucin:
CON
_xinfreq = 5_000_000

7) Solucin:

8) Solucin:
outa[5..11]~~
outa[5..11] := %1010101

9) Solucin:
PUB LightsOn | counter
dira[4..9] := %111111
repeat counter from 4 to 9
outa[counter] := 1
repeat

10) Solucin:
PUB method
dira[27] := 1
repeat
if ina[0]
outa[27]~~
outa[27] ~

11) Solucin:
PUB SecondCountdown
dira[9..4]~~
repeat outa[9..4] from 59 to 0

12) Solucin:
PUB SecondCountdown
dira[9..4]~~
repeat

13) Solucin:
PUB PushTwoStart
dira[4]~~
repeat until ina[23..21] == %101
outa[4]~~

14) Solucin:
PUB PushTwoCountdown
dira[9..4]~~
repeat until ina[23..21] == %101
outa[4]~~
Soluciones a Proyectos de la Practica E/S y Tiempo
1) Ejemplo de Solucin:
''File: NonActuatedStreetlights.spin
''Un prototipo alta velocidad de semforo controlador N/S E/O.

PUB StreetLights

dira[9..4]~~ ' Activa pins E/S a salida


outa[4..9] := %001100 ' N/S verde, E/O rojo
waitcnt(clkfreq * 8 + cnt) ' 8 s
outa[4..9] := %010100 ' N/S amarillo,E/O rojo
outa[4..9] := %100001 ' N/S rojo, E/O Verde
outa[4..9] := %100010 ' N/S rojo,E/O amarillo

''File: ActuatedStreetlightsEW.spin
''Un prototipo alta velocidad de semforo controlador N/S E/O.

PUB StreetLightsActuatedEW


repeat ' Ciclo Principal

outa[4..9] := %001100 ' N/S verde, E/O rojo
repeat until ina[21] ' Auto en calle E/O
outa[4..9] := %010100 ' N/S amarillo,E/O rojo
outa[4..9] := %100001 ' N/S rojo, E/O verde
outa[4..9] := %100010 ' N/S rojo,E/O amarillo

''File: LedFrequenciesWithoutCogs.spin
''Experimente la molestia de desarrollar procesos que de otra
''manera podran funcionar de manera independiente en Cogs
''separados. En este ejemplo, los LED parpadean a 1, 2, 3, 5, 7 y
'' 11Hz.

CON

_xinfreq = 5_000_000 ' 5 MHz cristal externo
_clkmode = xtal1 + pll16x ' 5 MHz cristal multiplicado 80 MHz

T_LED_P4 = 2310 ' Constantes de incremento de tiempo
T_LED_P5 = 1155
T_LED_P6 = 770
T_LED_P7 = 462
T_LED_P8 = 330
T_LED_P9 = 210

PUB Blinks | T, dT, count

dira[9..4]~~ ' Activa Pins E/S a Salida

dT := clkfreq / 4620 ' Activa incremento de tiempo
T := cnt ' Marca tiempo actual

repeat ' Ciclo Principal

T += dT ' Activa sig meta cnt
waitcnt(T) ' Espera por meta

if ++count == 2310 ' Reinicia cada 2310
count := 0

' Actualiza cada estado de LED al conteo correcto.
if count // T_LED_P4 == 0
!outa[4]
!outa[5]
!outa[6]
!outa[7]
!outa[8]
!outa[9]

''File: MinuteSet.spin
''Imita botones de alarma de reloj.

PUB SetTimer | counter, divide



'Retrasa por 1 ms.
waitcnt(clkfreq/1000 + cnt) ' Retrasa 1 ms

{Si se presiona un botn...
NOTA: Reiniciar el contador a -1 hace posible presionar y soltar
rpidamente el botn y avanzar la pantalla minuto sin ningn retraso aparente.}

if ina[21] or ina[23] ' si se presiona botn
counter++ ' incrementa contador
else ' de otra forma
counter := -1 ' deja contador a -1

'Inicia sobre flujo de minuto
if outa[9..4] == 63 ' Si 0 pasa 63
outa[9..4] := 59 ' reinicia a 59
elseif outa[9..4] == 60 ' si no 59 incrementos a 60

outa[9..4] := 0 ' activa a 0
'Activa contador duracin de tiempo ms
if counter > 2000 ' Si contador > 2000 (10 incrementos)
divide := 50 ' 50 ms entre incrementos
else ' de lo contrario

'Si uno de los ciclos de ms han pasado
if counter // divide == 0 ' si paso un tiempo
if ina[21] ' si botn P21 se presiona
outa[9..4]++ ' incrementa outa[9..4]
elseif ina[23] ' si botn P23 se presiona
outa[9..4]-- ' decrementa outa[9..4]

''File: SecondCountdownTimer.spin
''Imita botones de alarma de reloj.

PUB SetTimerWiCountdown | counter, divide, T

dira[9..4]~~ ' Activa pisn E/S a salida

repeat until ina[22] ' Quiebra si

'Retraso de 1 ms.
waitcnt(clkfreq/1000 + cnt) ' Retraso 1 ms

{Si se presiona un botn...
NOTA: Reiniciar el contador a -1 hace posible presionar y soltar
rpidamente el botn y avanzar la pantalla minuto sin ningn retraso aparente.}
if ina[21] or ina[23] ' Si se presiona un botn
counter++ ' incrementa contador
else ' de otra forma
counter := -1 ' active contador a -1

'Reinicia sobre flujo minutos
if outa[9..4] == 63 ' Si 0 pasa sobre 63
outa[9..4] := 59 ' reinicia a 59
elseif outa[9..4] == 60 ' De otra forma si 59 incrementa a 60
outa[9..4] := 0 ' Activa a 0

'Activa duracin de tiempo
if counter > 2000 ' Si contador > 2000 (10 incrementos)
else ' de lo contrario

'Si uno de los tiempos ha pasado
if counter // divide == 0 ' si uno de los tiempos ha pasado
if ina[21] ' si botn P21 se presiona
outa[9..4]++ ' incrementa outa[9..4]
elseif ina[23] ' de otra forma si botn P23 se
presiona
outa[9..4]-- ' decrementa outa[9..4]

T := cnt ' Marca el tiempo
repeat while outa[9..4] ' repite mientras outa[9..4] no es 0
T += clkfreq ' Calcula el siguiente valor de
segundos
waitcnt(T) ' Espera por el...
outa[9..4]-- ' Decrementa outa[9..4]

Soluciones al Estudio de la Practica Mtodos y Cogs
Soluciones a las Preguntas de la Prctica Mtodos y Cogs
1) Automticamente regresa el control del programa y un valor a la llamada de mtodo.
2) Eso depende de cuantos parmetros de variables locales aparezca en la lista de parmetros de
las definiciones de mtodo. La llamada a mtodo pasa un valor a cada parmetro.
3) Uno
4) Si no hay valor especificado el mtodo regresa el valor almacenado en su resultado variable,
el cual es iniciado a cero cuando el mtodo se llama. Un apodo para la variable resultante se
puede declarar a la derecha del parmetro seguida por dos puntos. Por ejemplo un mtodo
declarado PUB MyMethod(parameter1, parameter2) : returnAlias regresara el valor
almacenado por la variable returnAlias.
5) Una llamada de mtodo y la direccin del arreglo variable que servir como pila del cog.
6) Cog 0 usa RAM no utilizada para su pila; mientras otros cogs tiene que declarar espacio de
pila en el bloque VAR.
7) El comando cognew automticamente inicia un mtodo en el siguiente cog disponible y
regresa el numero de cog, mientras coginit permite especificar cual cog se va a usar para
iniciar un mtodo
8) Usar el comando cogstop.
9) Regresa informacin de direccin, regresa resultado, valor de parmetros y variables locales.
10) Los valores se almacenan en direcciones RAM que siguen de la ultima variable local. Los
valores se ponen y mueven de estas localidades para soportar clculos y operaciones de ciclo.
11) Un Segundo grupo de valores (direccin de regreso, resultado regresado) se agrega a la
pila. Cuando el mtodo regresa el espacio de pila se reclama.
12) Declarar ms espacio de pila de la que se piensa se va a usar.
13) El comando cognew regresa el valor del cog donde el mtodo se inicio
14) Si, Se demostr en la seccin Indexando Identificaciones de Cog
Soluciones a los Ejercicios de Mtodos y Cogs
1) Ejemplo:
PUB SquareWave(pin, tHigh, tCycle) : success | tC, tH

2) Ejemplo:
yesNo := SquareWave(24, clkfreq/2000, clkfreq/100)

3) Ejemplo:
VAR
swStack[40]

4) Ejemplo:
VAR
byte swCog

5) En este caso swCog almacenara el resultado de cognew (con o sin xito). Vea el Manual
Propeller para detalles:
swCog := cognew(SquareWave(24, clkfreq/2000, clkfreq/100), @swStack)

6) Ejemplo:
swCog := coginit(5, SquareWave(24, clkfreq/2000, clkfreq/100), @swStack)

7) Ejemplo:
VAR
long swStack[120]

8) Ejemplo:
VAR
byte swCog[3]

9) Ejemplo:
swCog[0] := cognew(SquareWave(5, clkfreq/20, clkfreq/10), @swStack)
swCog[1] := cognew(SquareWave(6, clkfreq/100, clkfreq/5), @swStack[40])

Soluciones a los Proyectos de la Practica Mtodos y Cogs
1) Ejemplo de Mtodo:
PUB SquareWave(pin, tHigh, tCycle) : success | tH, tC

outa[pin]~
dira[pin]~~

tC := cnt

repeat
outa[pin]~~
tH := tC + tHigh
tC += tCycle
waitcnt(tH)
outa[pin]~
waitcnt(tC)

''File: TestSquareWaveMethod.spin

CON

_xinfreq = 5_000_000

VAR

long swStack[120]
byte swCog[3]

PUB TestSquareWave

swCog[0] := cognew(SquareWave(5, clkfreq/20, clkfreq/10), @swStack)

3) No se da solucin, divirtase experimentando!
Soluciones al Estudio de la Practica de Objetos
Soluciones a las Preguntas de la Practica de Objetos
1) Una llamada de mtodo en el mismo objeto usa el nombre del mtodo. Una llamada a un
mtodo en otro objeto usa un apodo que fue dado objeto en el bloque OBJ, luego un punto y
luego el nombre de mtodo. As la diferencia es en vez de usar el NombreMetodo es
ApodoObjeto.NombreMetodo
2) No, los parmetros se pasan y regresa de la misma forma que se hara en un mtodo en el
mismo objeto.
3) El objeto que est siendo declarado tiene que estar en la misma carpeta del objeto que lo est
declarando o en la misma carpeta del programa de la Herramienta Propeller.
4) En la ventana del objeto, la cual puede verse a la izquierda de la ventana de informacin (F8)
y tambin en la esquina superior izquierda del panel de la Herramienta Propeller.
5) Dos apostrofes pueden ponerse a la izquierda de un comentario que deber aparecer en el
modo de vista de la Herramienta Propeller. Un bloque de documentacin de texto puede
definirse con dobles llaves {{Comentarios de documentacin}}
6) Presionando el botn de Documentacin sobre el cdigo.
7) Nombres de Mtodo Start y Stop.
8) Declare mltiples copias del objeto en la seccin OBJ, y llame cada uno de sus mtodos
Start.
9) Si el proceso que administra el objeto est corriendo en otro cog, la llamada al mtodo Stop
lo termina antes de iniciar el proceso en un cog nuevo.
10) Presionando en los caracteres de la Herramienta Propeller
11) Mtodos pblicos se declaran con PUB, privados con PRI. Mtodos pblicos pueden llamarse
por comandos en otros objetos; mtodos privados solo pueden llamarse del mismo objeto.
12) Declare mltiples copias del mismo objeto declarando un arreglo de objeto. Por ejemplo, el
comando nickname[3] : ObjectName declara tres copias de ObjectName, nickname[0],
nickname[1], and nickname[2]. Note que no hace copias extras del cdigo objeto. Cada
instruccin utiliza la misma copia de cdigo Spin que se carga en el chip.
13) Se almacenan en la misma carpeta con el programa Herramienta Propeller archivo .exe
14) Para ver la informacin de interface del objeto presione el botn de documentacin y la
herramienta Propeller automticamente genera esa informacin y la muestra junto con los
comentarios de documentacin.
15) En los cdigos de programa.
16) Dada una direccin de inicio en RAM el mtodo Str del Objeto FullDuplexSerial obtiene y
transmite caracteres hasta que obtiene un cero.
17) Comentarios de documentacin deben explicar que hace el mtodo, sus parmetros (si hay) y
sus valores de regreso.
18) Cadenas de caracteres y otras listas de valores pueden almacenarse en una seccin del objeto
DAT
19) Se usan para (1) declarar variables en bloques VAR, (2) Declarar tamaos de lista de elementos
en bloques DAT y (3) regresar valores a direcciones dadas en bloques PUB y PRI.
20) El objeto Float usa FAdd para agregar dos nmeros de punto flotante.
21) FloatString.
22) No, la herramienta Propeller empaca 1.5 en el formato de punto flotante al compilar y lo
almacena con los cdigos byte del programa. El comando a := 1.5 copia el valor en una
variable
23) Una direccin de variable se pasa a un parmetro de mtodo de objeto con el operador @. En
vez de este formato: ObjectNickname.MethodName(variableName), usa el siguiente formato:
ObjectNickname.MethodName(@variableName).
24) Un objeto puede declarar una lista de variables en cierto orden y luego asignarles valores que
el objeto usara. As, las direcciones de la primer variable en la lista pueden pasarse al mtodo
del objeto.
25) El objeto usara long, word o byte y las direcciones. Por ejemplo, si la direccin se pasa a un
parmetro llamado address, el objeto puede accesar el valor almacenado por la variable con
long[address][0] o solo long[address]. Para almacenar la variable declarada
inmediatamente a la derecha de la variable en address puede usar long[address][1]. Para la
segunda variable a la derecha puede usar long[address][1] y as sucesivamente.
26) Si, Esto puede ser til algunas veces porque el objeto padre puede simplemente actualizar un
valor variable y un objeto corriendo otro proceso se actualizara automticamente basado en
ese valor.
27) Si, Esto se usa cuando un proceso est corriendo en otro cog y el objeto padre necesita uno o
ms de sus variables para actualizarse automticamente por otros procesos,
Soluciones a los Ejercicios de la Practica de Objetos
1) Solucin:
led : "MyLedObject"

2) Solucin:
led.On(4)

3) Con la ayuda del mapa de Caracteres de la Herramienta Propeller: 102, 32, 61, 32, 84, 22.

4) Solucin:
PRI calcArea(height, width) : area

5) Solucin:
Uart[5] : "FullDuplexSerial"

6) Solucin:
uart[2].str(String("Hello!!!"))

7) Solucin:
DAT
Hi byte Hello!!! , 0

8) Solucin:
c := f.fmul(d, pi)

9) Solucin:
address := fst(c)
Soluciones a los Proyectos de la Practica de Objetos
1) Objeto Ejemplo:

{{Bs2IoLite.spin

Las caractersticas de esta llamada a mtodo similares a los comandos PBASIC para
el micro controlador BASIC Stamp 2, tales como high, low, in0 a in15, toggle, y
pause.

}}

PUB high(pin)
''Hace pin salida-alta.

outa[pin]~~
dira[pin]~~

PUB low(pin)
''Hace pin salida-baja

outa[pin]~
dira[pin]~~

PUB in(pin) : state
{{Regresa el estado del pin. Si el pin es salida el estado refleja la seal de
salida. Si el pin es entrada el estado ser 1 si el voltaje aplicado al pin esta
sobre 1.65V o 0 si esta debajo}}

state := ina[pin]

PUB toggle(pin)
''Cambia el estado de pin de salida (alto a bajo o bajo a alto).

!outa[pin]

PUB pause(ms) | time
''Detiene el programa por ms. Esto aplica al cog haciendo la
''llamada. Otros cogs no se afectan.

time := ms * (clkfreq/1000)
waitcnt(time + cnt)

2) Para modificar la Terminal Serial Parallax, guarde una copia de PropellerCOM con un nuevo
nombre como TestPropellerStack.ht. Cambie el Baud Rate de la Terminal Serial Parallax de
57600 a 19200.

El objeto modificado StackLenghtDemo tiene varios cambios. EL cdigo debajo del
objeto/cdigo probndose para uso de pila se reemplazo con el cdigo del objeto Blinker. La
variable de pila de objeto Stack se incremento a 32 longs. As en el cdigo temporal para
probar la seccin de uso de pila la llamada a mtodo start se modifico para trabajar con el
objeto Blinker.

Corra el objeto StackLenghtDemo para probar la pila requerida por el mtodo Blink para
iniciar otro cog. Despus de que la herramienta Propeller ha completado la descarga tendr 2
segundos para conectar la Terminal Serial Parallax. El resultado deber ser 9

Como el resultado es 9 en vez del 10 predicho por el mtodo en la prctica, este proyecto
expone un error en la seccin titulada Cuanto espacio de pila se necesita para iniciar un
cog? La variable local time se elimino del mtodo Blink pero no de la discusin de cuanto
espacio de pila necesita el mtodo Blink.

{{StackLengthDemoModified.spin

Esta es una versin modificada del Objeto StackLengthDemo de la carpeta de
librera demos del Propeller. Esta versin modificada prueba el mtodo Blink del
objeto Blinker de la Prctica de Objetos del Kit Educativo Propeller para
requerimientos de espacio de pila. Ver proyecto #2 en la prctica de Objetos para
ms informacin.}}


{
Cdigo Temporal para uso de Pila
}

CON
_clkmode = xtal1 + pll16x 'Usa cristal * 16 para serial rpida
_xinfreq = 5_000_000 'Cristal Externio5 MHz en XI & XO

OBJ
Stk : "Stack Length" 'Incluye Objeto Stack Length

PUB TestStack
Stk.Init(@Stack, 32) 'Inicia espacio de pila reservado (reservado abajo)
start(4, clkfreq/10, 20) 'Ejercicio cdigo/objeto bajo prueba
waitcnt(clkfreq * 3 + cnt) 'Espera tiempo para uso mx. de pila
Stk.GetLength(30, 19200) 'Transmite resultados salida serial P30 a 19,200
baud

{
Probando Cdigo/Objeto para uso de pila
}

{{
File: Blinker.spin
Ejemplo administracin de cog para proceso LED blinking.

SCHEMATIC

100 LED
pin -/|!
~
GND

}}

VAR
long stack[32] 'Cog Espacio de pila
byte cog 'Cog ID

{{
Inicia Nuevo proceso blinking en Nuevo cog; Regresa verdadero si tiene xito.

Parmetros:
pin la E/S conectada al circuito LED ver esquemtico
rate Ciclo encendido/ Apagado definido por ciclos de reloj
reps el nmero de ciclos encendido/apagado
}}

Stop

PUB Stop
''Detiene proceso Blinking, si hay.

if Cog
cogstop(Cog~ - 1)


{{
Parpadea un circuito LED conectado a un pin a una frecuencia dada por rep
repeticiones

Parmetros:
pin la E/S conectada al circuito LED ver esquemtico
rate Ciclo encendido/ Apagado definido por ciclos de reloj
reps el nmero de ciclos encendido/apagado
}}

dira[pin]~~
outa[pin]~

repeat reps * 2
!outa[pin]

3) Esta solucin usa variables globales para days, hours, minutes, y seconds, y el mtodo
GoodTimeCount actualiza los cuatro valores. Tambin es posible solo seguir segundos y usar
otros mtodos para convertir a das, horas, etc.

''File: TickTock.spin

VAR

long stack[50]
byte cog
long days, hours, minutes, seconds

PUB Start(setDay, setHour, setMinutes, setSeconds) : success
{{
Rastera tiempo en otros cogs.

Parmetros valores de inicio para:
setDay - da
setHour - hora
setMinutes - minuto
setSeconds - segundo
}}

days := setDay
hours := setHour
minutes := setMinutes
seconds := setSeconds

Stop
cog := cognew(GoodTimeCount, @stack)
success := cog + 1

PUB Stop
''Detiene tiempo continuo.

if Cog
cogstop(Cog~ - 1)

PUB Get(dayAddr, hourAddr, minAddr, secAddr) | time
{{
Obtiene el tiempo actual. Los valores se guardan en variables a las direcciones
proporcionadas para los parmetros del mtodo

Parmetros:
dayAddr - direccin variable da
hourAddr - direccin variable horas
minAddr - direccin variable minutos
secAddr - direccin segundos
}}

long[dayAddr] := days
long[hourAddr] := hours
long[minAddr] := minutes
long[secAddr] := seconds

PRI GoodTimeCount | dT, T

dT := clkfreq
T := cnt

repeat

T += dT
waitcnt(T)
seconds ++

if seconds == 60
seconds~
minutes++
if minutes == 60
minutes~
hours++
if hours == 24
hours~
days++

Soluciones al Estudio de Mdulos Contadores y Aplicaciones de Circuitos
Soluciones a Preguntas de Mdulos Contadores y Aplicaciones de Circuitos
1) Cada cog tiene dos mdulos contadores, A y B.
2) PHS, FRQ, y CTR.
3) PHSA, FRQA, y CTRA.
4) PHSB, FRQB, y CTRB.
5) El registro FRQ.
6) El registro CTR (control).
7) En modo NCO el bit 31 de un registro phs dado se usa para controlar una E/S en modo
terminacin sencilla o dos en modo diferencial. En modo PLL la bandera de acarreo controla
el estado de pins E/S (a.k.a PHS bit 32).
8) Si una resistencia de sensor o capacitancia varia con una variable ambiental, una medicin de
descarga RC regresa un tiempo proporcional al valor del sensor.
9) No, Pero lo es con muchos otros micro controladores.
10) Si, con modo NEG, CTRMODE es %01100.
11) Despus de que el capacitor se carga completamente, su voltaje tomara un tiempo en
descargarse mientras drena a travs de una Resistencia. Como resultado el voltaje tarda cierto
tiempo arriba del lmite lgico 1.65V. Por cada ciclo de reloj que el voltaje est por encima
del disparo lgico del pin E/S suma el valor de FRQ a PHS. Despus de que se descargo el
voltaje FRQ ya no se suma a PHS, as PHS continua almacenando el nmero de ciclos que la
sea estaba en alto.
12) En bits 30..26 de un registro dado CTR.
13) El modo de una operacin de modulo contador dado.
14) Los campos MTRMODE y APIN
15) El valor recomendado es 1, pero mientras FRQ almacena un valor no cero no causa sobre
flujo en el registro PHS durante la medicin, puede usarse para medir la descarga RC.
16) (1) Activa el bit de campo de modo del registro CTR. (2) Activa el bit de campo PIN del
registro CTR. (3) Activa el registro PHS a un valor no cero, preferentemente 1.
17) El capacitor en el circuito RC tiene que cargarse. Entonces el valor inicial del registro PHS
necesita notarse o puede limpiarse. Inmediatamente despus el pin E/S debe activarse como
entrada.
18) Porque cada contador cumula independientemente su registro PHS basado en el valor de un
pin E/S dado. As dos contadores pueden acumular sus respectivos registros PHS mientras
sus respectivos circuitos RC estn descargando pero que estn por encima del disparo lgico.
Mientras tanto el cog puede ejecutar otros comandos.
19) Con mediciones de descarga RC el modulo contador esta monitoreando el voltaje aplicado a
un pin E/S. En conversin D/A el modulo contador est controlando un pin E/S.
20) El rango de FRQ a 2
32
determina el duty.
21) El bit de acarreo de suma de fase, el cual puede pensar como el bit 32 del registro PHS.
22) Lo hace posible para el cdigo para seleccionar de 256 diferentes niveles en vez de 2
32
diferentes niveles.
23) spr[8] hasta spr[13].
24) spr[9].
25) spr[10].
26) El valor en el registro phsb.
27) (1) ctrb := myVar, y (2) spr[9] := myVar
28) spr[8] es ctra, y SPR[9] es ctrb. Cada uno de estos registros tiene varios bits de campo que
afectan el comportamiento del contador. El operador mover a la izquierda << puede usarse
para mover un grupo de bits a la izquierda con uno de estas variables. Una serie de
operaciones mover a la izquierda pueden combinarse con sumas para determinar cada uno de
los bits de campo del registro CTR dado.
29) Bit 31 del registro PHS.
30) La condicin de acuerdo a CTR.spin as Siempre, quiere decir que el registro FRQ se suma al
registro PHS con cada ciclo de reloj.
31) 2
32
/clkfreq
32) clkfreq/2
32

33) (1)Activar pin E/S a entrada, (2) limpiar registro FRQ, o (3) limpiar bits 31..26 en el registro
CNT.
34) Si, El contador A puede enviar una seal y el Contador B puede enviar la otra.
35) Actualizar el valor almacenado en el registro FRQ.
36) Si, cualquier detector POSEDGE o NEGEDGE pueden muestrear el nmero de transiciones
en un determinado tiempo para almacenar frecuencia. Detectores positivos y Negativos
tambin se pueden usar para rastrear el tiempo alto y bajo el cual puede usarse para calcular
frecuencia de una seal.
37) No, comparan el estado del estado actual lgico del pin E/S con el estado lgico del ciclo
previo. Si por ejemplo el estado lgico previo del pin fue 0 y el estado actual es 1, en modo
POPSEDGE sumara FRQ a PHS porque ocurri una transicin positiva.
38) No, mientras spr[13] refiere a phsb, no es bit direccional. El comando repeat while esta
refirindose a un bit en el registro phsb. Sera posible determinar el valor de ese bit usando
varias operaciones, tomara ms tiempo que solo verificar phsb[31] .
39) 500 kHz a 128 MHz
40) El circuito PLL del modulo contador necesita recibir una frecuencia de entrada del bit 31 del
registro PHS. El valor almacenado en el registro FRQ determina la frecuencia del bit 31 del
registro PHS, as como sucede en modo NCO.
41) El circuito PLL del modulo contador multiplica por 16, luego un divisor reduce la frecuencia
por una potencia de 2 que cae en el rango de 1 a 128.
42) (a) Calcula la frecuencia del bit 31 de PHS. (b) Usa la frecuencia del bit 31 de PHS para
calcular la frecuencia VCO. (c) Divide la frecuencia VCO por 2
7-PLLDIV
.
43) (1) Calcula el PLLDIV, lo cual es la potencia de 2 que la frecuencia VCO tendr para este
clculo. (2) Multiplica la frecuencia PLL por 2
(7-PLLDIV)
para calcular la frecuencia VCO. (3)
Dada la frecuencia VCO, calcula 1/16 de ese valor el cual es el bit 31 PHS (NCO) que el
circuito PLL necesitara. (4) Como el valor almacenado en FRQ determina la frecuencia NCO,
usa la frecuencia NCO para calcular el valor de registro FRQ.
Soluciones a los Ejercicios de Mdulos Contadores y Aplicaciones de Circuitos
1) Solucin:
...

' ctra[30..26] := %01000 ' Set mode to "POS detector"
ctra[30..26] := %01100 ' Set mode to "NEG detector"

...

' Charge RC circuit.
' Descarga Circuito RC

' dira[17] := outa[17] := 1 ' Set pin to output-high
dira[17] := 1 ' Set pin to output-low
outa[17] := 0

...
2) Solucin:
'El duty para esta seal es 1/3.3. Como duty = FRQ/2
32
, podemos resolver
1/3.3 = 'FRQ/2
32
para FRQ. FRQ = 1_301_505_241
ctrb[32..26] := %00110 ' Contador B a modo DUTY
ctrb[5..0] := 7
frqb := 1_301_505_241 ' Activar duty para 3.3 V
dirb[7] := 1 ' Activar P7 a salida

3) Solucin:
'El duty para esta seal es 1/3.3. Como duty = FRQ/2
32
, podemos resolver
1/3.3 = 'FRQ/2
32
para FRQ. FRQ = 1_301_505_241
spr[9] := (%00110<<26) + 7 ' Contador B a modo duty, transmite P7
spr[11] := 1_301_505_241 ' Activa duty para 3.3 V
spr[6] |= |< 7 ' Activa P7 a salida

4) Usando registro FRQ = Frecuencia bit 31 PHS 2
32
/ (clkfreq = 80 MHz) redondeado al
entero ms cercano:
Do6# 59475, Re6# 66787, Fa6# 79457, Sol6# 89185, La6# 100111

5) El registro frqa deber contener la frecuencia del bit 31 contenida en PHS 2
32
/ (clkfreq =
20 MHz) = 224_734 (redondeado al entero ms cercano).
ctra[30..26] := %00100 ' Contador B a modo duty, transmite P16
ctra[5..0] := 16
frqb := 224_734 ' 20 MHz Do7
dira[16]~~ ' 20 MHz Do7

6) Solucin:
...

'repeat index from 0 to 7
Repite index de 0 to 12
...

DAT
'MODIFICADO..............................................
'Valores 80 MHz frqa para onda cuadrada de nota musical
'aproximaciones con el modulo contador configurado a NCO:
' Do6 Do6# Re6 Re6# Mi6 Fa6 Fa6#
notes long 56_184, 59_475 63_066, 66787, 70_786, 74_995, 79457
' Sol6 Sol6# La6 La6# Si6 Do7
long 84_181, 89_185, 94_489, 100_111, 105_629, 112_528

7) Como el objeto SquareWave usa clkfreq para calcular los valores de su registro FRQ, el
nico cambio que necesita hacerse es _xinfreq = 2_000_000 en vez de _xinfreq =
5_000_000.

8) Anexar scale = 16_777_216 con * 2, y luego ajustar el ciclo repeat de 0 a 266 a 0 a 127.

9) Cambiar ctrb[30..26] := %01110 a ctrb[30..26] := %01010. Para obtener ciclos
completos. Puede iniciar el outa[27] alto en vez de bajo. Esto asume un piezospeaker, el cual
no consume corriente cuando se le aplica voltaje. Algunas bocinas parecen piezospeakers
pero tienen inductores dentro lo cual toma mucha corriente cuando un se aplica un voltaje
DC.

10) Active tC a clkfreq/50 (es 20 ms). Por el pulso 1.5 ms, 1.5 10
-3
clkfreq es
aproximadamente equivalente a (1/667) clkfreq, o clkfreq/667. As, tHa debe ser
clkfreq/667. Otra forma de hacerlo sera sumar un bloque CON con
us = clkfreq/1_000_000. Entonces, tHa puede ser 1500 * us.
11) Sume un bloque CON con us = clkfreq/1_000_000. Inicialice tC a 20_000 * us. Inicialice
tHa a 700 * us. Sume una variable local llamada count al mtodo TestPwm. Cambie repeat a
repeat tHa from (700 * us) to (2200 * us).

12) Solucin:
{{
TestDualPWM(Exercise 12).spin
Usando dos mdulos contadores demuestra como enviar una seal PWM.
El ciclo de tiempo es el mismo para ambas seales pero los tiempos en alto son
independientes uno del otro.
}}

CON

_clkmode = xtal1 + pll16x ' Reloj sistema 80 MHz
_xinfreq = 5_000_000


us := clkfreq/1_000_000 ' <- Suma

sencilla
ctra[5..0] := 4 ' Activa pins para contadores para
control
ctrb[5..0] := 6
reloj

dira[4] := dira[6] := 1 ' Activa pins E/S salida

tC := 20_000 * us ' <- Cambia Set up cycle time
tHa := 700 * us ' <- Cambia Set up tiempo alto
tHb := 2200 * us ' <- Cambia


repeat tHa from (700 * us) to (2200 * us) ' <- Cambia seal Repeat PWM
t += tC ' Calcula ciclo
repeat
waitcnt(t) ' Espera por ciclo

Soluciones a Proyectos de Mdulos Contadores y Aplicaciones de Circuitos
1) Solucin: Versiones comentadas y no comentadas de DAC 2 Channel.spin se muestran
abajo. Note en la versin no comentada que realmente no toma mucho cdigo para llevar a
cabo la especificacin del proyecto.

''DAC 2 Channel.spin
''Objeto 2 channel DAC. Cada canal se puede configurar para pin E/S y resolucin
(bits)

VAR
' Almacena valores que funcionan como escaleras LSB para los registros FRQ.
long lsb[2]

{{
Inicia un DAC.
channel - 0 o 1
ioPin - Escoge pin E/S DAC
bits - Resolucin (8 bits, 10 bits, etc.)
bits
level - Nivel de Voltaje Inicial = 3.3 V * level 2
}}
dira[ioPin]~ ' Activa pin E/S a entrada
spr[8 + channel] := (%00110 << 26) + ioPin ' Configura CTR para modo duty y
pin E/S

lsb[channel] := |< (32 - bits) ' Define LSB para registro FRQ
Update(channel, level) ' Activa duty inicial
dira[ioPin] ~~ ' Activa pin E/S a salida

'' Actualiza el nivel transmitido por un canal ADC a
'' bits
'' level = 3.3 V * level 2
spr[10 + channel] := level * lsb[channel] ' Actualiza salida DAC

PUB Remove(channel)
''Reclama el mdulo contador y activa los grupos de pin E/S a entrada.
dira[spr[8+channel] & %111111]~ ' Activa pin E/S a entrada
spr[8+channel]~ ' Limpia canales registro CTR

''DAC 2 Channel.spin (versin no comentada)

VAR
long lsb[2]


dira[ioPin]~
spr[8 + channel] := (%00110 << 26) + ioPin

lsb[channel] := |< (32 - bits)
Update(channel, level)
dira[ioPin] ~~


spr[10 + channel] := level * lsb[channel

PUB Remove(channel)

dira[spr[8+channel] & %111111]~
spr[8+channel]~

2) Solucin: Lneas sumadas estn marcadas abajo. Vamos a asumir que los servos estn
conectados a P5 y P7. En el ciclo repeat los campos PIN de ctra y ctrb tendrn que
activarse a 4 y 6 por el primer par de pulsos, luego cambiar a 5 y 7 por el segundo grupo de
pulsos. Tambin un waitcnt tiene que agregarse despus de cada par de pulsos para que los
pulsos puedan terminar antes de moverse al siguiente par de pulsos

A este punto el cdigo todava tiene 15.6 ms en el ciclo repeat, porque no agregar otros
servos y hacer un objeto servo control? Vea forums.parallax.com Propeller Chip
Propeller Education Kit Labs PE Kit Servo Control para un ejemplo.

{{
TestDualPWM (Project 2).spin
Usando dos mdulos contadores demuestra como enviar una seal dual PWM. El tiempo
de ciclo es el mismo para ambas seales pero los tiempos alto son independientes
uno del otro.

Modificado para controlar cuatro servos.

}}

CON

_clkmode = xtal1 + pll16x ' Reloj sistema 80 MHz
_xinfreq = 5_000_000


us := clkfreq/1_000_000 ' <- Suma

sencilla
ctra[5..0] := 4 ' Activa pins para control
ctrb[5..0] := 6
reloj

dira[4] := dira[6] := 1 ' Activa pisn E/S a salida
dira[5] := dira[7] := 1

tC := 20_000 * us ' <- Cambia Set up tiempo de ciclo
tHa := 700 * us ' <- Cambia Set up tiempos alto
tHb := 2200 * us ' <- Cambio


repeat tHa from (700 * us) to (2200 * us) ' <- Cambia seal PWM Repeat

' Primer par de pulsos
ctra[5..0] := 4 ' Activa pins para controlar
contadores
ctrb[5..0] := 6
phsa := -tHa ' Define e inicia el Pulso A
waitcnt(2200 * us + cnt) ' Espera por pulsos para terminar

' Segundo par de pulsos
ctra[5..0] := 5 ' Activa pins para controlar
contadores
ctrb[5..0] := 7
waitcnt(2200 * us + cnt) ' Espera por pulsos para terminar

' Espera por ciclo 20 ms para completar antes de repetir ciclo
t += tC ' Calcula ciclo
repeat
waitcnt(t) ' Espera ciclo

3) Solucin Objeto DAC: (Trabaja pero tenga en cuenta que no es la nica solucin posible)

{{
''DualDac.spin

''Proporciona dos canales de mdulos contadores de otro cog para conversin D/A

Como usar este objeto en la aplicacin
------------------------------------------
1) Declare canales D/A variables. Ejemplo:

VAR
ch[2]

2) Declare el objeto DualDac. Ejemplo:

OBJ
dac : DualDac

3) Llame el mtodo start. Ejemplo:

PUB MethodInMyApp
'...
dac.start

4) Active salidas D/A. Ejemplo:
ch[0] := 3000
ch[1] := 180

5) Configure canales DAC. Ejemplo:
'Como ch[0] se activo a 3000 en paso 4, la salida DAC P4 ser
'3.3V * (3000/4096)

'Como ch[1] se activo a 180 en paso 4, la salida DAC P6 ser
' 3.3V * (180/256)

6) Mtodos y caractersticas en este objeto tambin hace posible:
- remover un canal DAC
- cambiar en canal DAC:
o pin E/S
o Resolucin
o Direccin de Control variable
o Valor almacenado por la variable control

ver tambin
--------
TestDualDac.spin para un ejemplo de aplicacin.

}}

VAR ' Variables globales
long cog, stack[20] ' Para objeto
long cmd, ch, pin[2], dacAddr[2], bits[2] ' Para intercambio de info en cogs

PUB Start : okay

'' Inicia un cog D/A. Usa mtodo Config para activar un dac en un pin.

okay := cog := cognew(DacLoop, @stack) + 1

PUB Stop

'' Detiene el proceso DAC y libera un cog.

if cog
cogstop(cog~ - 1)


'' Configura un DAC. Bloque ejecucin de programa hasta que otro cog completa
el comando.
'' channel - 0 = canal 0, 1 = canal 1
'' dacPin - nmero pin E/S que desarrolla el D/A
'' resolution - bits de conversin D/A (8 = 8 bits, 12 = 12 bits, etc.)
'' dacAddress direccin de la variable que tiene el nivel de conversin D/A,
un valor entre 0 y (2^resolucion) - 1.

ch := channel ' Copia parmetros a variable global.
pin[channel] := dacPin
bits[channel] := |<(32-resolution)
dacAddr[channel] := dacAddress
cmd := 4 ' Activa el comando para PRI DacLoop.
repeat while cmd ' Bloquea ejecucin hasta que se
completa cmd.

PUB Remove(channel)

'' Remueve un canal. Activa canales pin E/S a entrada y limpia el modulo
contador.
'' Bloque ejecucin de programa hasta que otro cog completa el comando.

ch := channel ' Copia parmetro a variable global
cmd := 5 ' Activa comando para PRI DacLoop.
repeat while cmd ' Bloque ejecucin hasta completar
cmd.


'' Actualiza configuracin de canal DAC.
'' Bloquea ejecucin de programa hasta que cog completa comando.
'' channel - 0 = canal 0, 1 = canal 1
'' attribute - El atributo DAC para actualizar
'' 0 -> dacPin
'' 1 -> resolution
'' 2 -> dacAddr
'' 3 -> dacValue
'' value - El valor del atributo a ser actualizado

ch := channel ' copia parmetro a variable global.
case attribute ' atributo param decide que hacer.
0 : ' 0 = cambia pin DAC.
cmd := attribute + (value << 16) ' pin E/S en upper 16 bits, lower 16
'cmd = 0.
' Opciones 1 a 3 no requiere un comando para PRI DacLoop -> PRI
' DacConfig.
' Solo requiere actualizar ciertas variables globales.
1 : bits[ch] := |<(32-value) ' 1 = Cambia resolucin.
2 : dacAddr[channel] := value ' 2 = Cambia direccin variable de
control.
3 : long[dacAddr] := value ' 3 = Cambia valor de variable de
control.
repeat while cmd ' Bloquea ejecucin hasta completar
cmd.

PRI DacLoop | i ' Ciclo checa por cmd, Luego actualiza
' Valores salida DAC.
repeat ' Ciclo principal por con iniciado.
if cmd ' Si cmd <> 0
DacConfig ' llama DatConfig
repeat i from 0 to 1 ' Actualiza modulo contador FRQA y
FRQB.
spr[10+ch] := long[dacAddr][ch] * bits[ch]

PRI DacConfig | temp ' Actualiza configuracin DAC basada
' en cmd.

temp := cmd >> 16 ' Si attribute = 0, temp obtiene pin.

case cmd & $FF ' Mascara cmd y evala caso por caso.
4: ' 4 -> Configura DAC.
spr[8+ch] := (%00110 << 26) + pin[ch] ' Almacena mode y pin en registro CTR.
dira[pin[ch]]~~ ' Direccin de pin -> salida.
5: ' 5 -> Remueve DAC.
spr[8+ch]~ ' Limpia registro CTR.
dira[pin[ch]]~ ' Hace pin E/S entrada.
0: ' 0 -> actualice pin.
dira[pin[ch]]~ ' Hace pin entrada.
pin[ch] := temp ' Obtiene Nuevo pin de variable temp
local

spr[8+ch] := (%00110 << 26) + pin[ch] ' Actualiza CTR con nuevo pin.
dira[pin[ch]]~~ ' Actualiza nueva direccin pin E/S ->
salida

cmd := 0 ' limpia cmd para detener bloqueo en
otro cog.

Solucin Men manejando objeto prueba para DualDac.spin

''TestDualDAC.spin
''Men de usuario para pruebas DualDac.spin

CON

_clkmode = xtal1 + pll16x ' Sistema reloj 80 MHz
_xinfreq = 5_000_000

' Constantes Terminal Serial Parallax
CLS = 16, CR = 13, CLREOL = 11, CRSRXY = 2, BKSPC = 8, CLRDN = 12

OBJ

dac : "DualDAC"

PUB TestPwm | channel, dacPin, resolution, ch[2], menu, choice

debug.start(31, 30, 0, 57600)
debug.str(@_Menu)

dac.start

repeat

debug.tx(">")
case menu := debug.rx
"C", "c":
debug.str(@_Channel)
channel := debug.getdec
debug.str(@_Pin)
dacPin := debug.getdec
debug.str(@_Resolution)
resolution := debug.getdec
dac.Config(channel, dacPin, resolution, @ch[channel])
"S", "s":
debug.str(@_Value)
ch[channel] := debug.getdec
"U", "u":
debug.str(@_Update)
case choice := debug.rx
"P", "p":
debug.str(@_Pin)
dacPin := debug.getdec
dac.update(channel, 0, dacPin)
"B", "b":
debug.str(@_Resolution)
resolution := debug.getdec
dac.update(channel, 1, resolution)
"R", "r":
dac.Remove(channel)
debug.str(String(CRSRXY, 1,4, BKSPC, CLRDN))

DAT
_Menu byte CLS, "C = Configure DAC", CR, "S = Set DAC Output", CR
byte "U = Update DAC Config", CR, "R = Remove DAC", CR, 0
_Channel byte CR, "Channel (0/1) > ", 0
_Pin byte "Pin > ", 0
_Resolution byte "Resolution (bits) > ", 0
_Value byte "Value > ", 0
_Update byte "Update Choices:", CR, "P = DAC Pin", CR,"B = Bits (resolution)"
byte CR, 0

Apndice C: Lista de Componentes
Apndice C: Lista de Componentes kit PE
Partes, cantidades y estilos de estn sujetos a cambios sin previo aviso.

Tabla C-1: Kit Educativo Propeller Versin 40-Pin DIP (#32305)
# Parte Cant. Descripcin
130-32305 1 Propeller DIP Plus Kit, ver Tabla 3-3 en pgina 25
130-32000 1 Kit de partes Proyecto Propeller, ver Tabla C-2 abajo
700-00077 1 Breadboard Set, ver Tabla 3-1 en pgina 24
32201 1 Propeller Plug con Cable retrctil USB A a Mini-B, ver Tabla 3-2 en pgina 24
110-32305 1 Caja de plstico

Tabla C-2: Kit de partes Proyecto PE (#130-32000)
150-01011 20 Resistencia 100 , 1/4 watt (caf-negro-caf)
150-01020 4 Resistencia 1 k, 1/4 watt (caf-negro-rojo)
150-01030 8 Resistencia 10 k, 1/4 watt (caf-negro-anaranjado)
150-01040 3 Resistencia 100 k, 1/4 watt (caf-negro-amarillo)
150-02020 4 Resistencia 2 k, 1/4 watt (rojo-negro-rojo)
150-02210 8 Resistencia 220 , 1/4 watt (rojo-rojo-caf)
150-04710 4 Resistencia 470 , 1/4 watt (Amarillo-violeta-caf)
150-04720 1 Resistencia 4.7 k, 1/4 watt (Amarillo-violeta-rojo)
152-01031 2 Potenciometro10 k
200-01010 4 Capacitor 100 pF, mono radial (101)
200-01031 4 Capacitor 0.01 F 50 V, poly (103)
200-01040 4 Capacitor 0.1 F, mono radial (104)
201-01050 1 Capacitor 1 F, electrolitico (1F)
201-01062 2 Capacitor 10 F, electroltico (10F)
350-00001 2 LED Verde
350-00003 2 LED Infrarrojo
350-00006 2 LED Rojo
Lista de Componentes
Tabla C-2: Kit de partes Proyecto PE (#130-32000)
350-00007 2 LED Amarillo
350-00014 2 Receptor Infrarrojo
350-00018 2 Fototransistor Infrarrojo
350-00029 2 Fototransistor
350-90000 2 Protector LED
350-90001 2 Malla LED
400-00002 4 Switch
451-00303 2 Conector 3-pin
602-00015 1 CI Amp-Op Dual IC, 8-pin DIP
800-00016 4 3" cable, bolsa de 10
900-00001 2 Piezospeaker
Apndice D: Diagrama de Bloque del Microcontrolador
Apndice D: Diagrama de Bloque del Micro controlador

Apndice E: LM2940CT-5.0 Lmite de Corriente
A pesar de que el regulador de voltaje LM2940CT-5.0 marca una temperatura comercial de 0 C a
125 C el diseo del regulador de 5V de la plataforma PE es para uso a temperatura ambiente. Los
voltajes pueden reducirse o incrementarse y usted puede usar estas ecuaciones para determinar la
mxima salida de corriente a una temperatura dada.

Tenga en mente que las placas del kit PE estn diseadas para utilizarse en temperatura ambiente y
que el plstico se deformara si se expone a altas temperaturas.
Carga de Corriente vs. Temperatura Ambiente

De acuerdo a la hoja de datos del LM2940 de National Semiconductor (disponible en national.com),
la mxima unin admisible a la resistencia trmica del ambiente (
JA
) para el empaque TO220
utilizado en el kit PE es 53 C/W. Esta cantidad puede describirse en trminos del mximo pico
permitido (T
RMAX
) y la potencia disipada (P
D
) como:

W
C
P
T
D
MAX R
JA

= 53
) (

...donde TR
(MAX)
es la diferencia entre la mxima unin posible de temperatura (TJ
(MAX)
) y la mxima
temperatura ambiente T
A(MAX)
. La unin mxima de temperatura es 125 C para el LM2940CT-5.0

) ( ) ( ) ( ) (
125
MAX A MAX A MAX J MAX R
T C T T T = =

P
D
tambin est relacionada a la entrada de voltaje (V
IN
), salida de voltaje (V
OUT
), carga de corriente
(I
L
), y corriente esttica (I
G
) por:

G IN L OUT IN D
I V I V V P ) ( ) ( + =

Para el kit PE, V
IN
= 9 V, V
OUT
= 5 V, y de la hoja de datos, I
G
no exceder 20 mA.

Resolviendo para la carga de corriente en trminos de las otras variables y contantes tenemos:

OUT IN
G IN
JA
MAX A MAX J
L
V V
I V
T T
I
) (
) ( ) (

Substituyendo las constantes proporcionadas por la hoja de datos, la carga de corriente como una
funcin de la temperatura mxima de ambiente para un voltaje de entrada fijo de 9V.

V V
mA V
W C
T C
I
MAX A
L
5 9
) 20 ( ) 9 (
/ 53
125
) (

) (
3
) 10 72 . 4 ( 545 . 0
MAX A L
T I

Apndice D: Diagrama de Bloque del Microcontrolador

Para una temperatura ambiente mxima de 80 F 26.7 /C, la mxima carga de corriente I
L
= 419
mA.

Salida ESR de Capacitor
La hoja de datos LM2940 tiene requerimientos de estabilidad para la salida capacitancia (mnimo 22
F) y ESR (Equivalente en Resistencia Serial). Para el kit PE en el rango de 0 to 400 mA la salida
ESR del capacitor tiene que estar en el rango de 0.1 a 1.0 para prevenir oscilaciones de salida de
voltaje.

A este momento la salida del capacitor del kit PE es un capacitor Nichicon VR serie 25 V, 1000 F.
La especificacin del catalogo para este capacitor estipula que la perdida de disipacin (tan ) es 0.16
a 120KHz para un capacitor de 1000 F, 25V. De acuerdo a Nichicons General Description of
Aluminum Electrolytic Capacitors, la prdida por disipacin en el reciproco de la impedancia, lo cual
puede usarse para determinar el ESR (NOTAS TECNICAS CAT.8101E, Pagina 6)

) ( 2
1
tan ESR fC
X
C
= =

= = = 212 . 0
) 1000 ( 120 2
16 . 0
2
tan

fC
ESR

Las especificaciones de la serie VR tambin establecen que el rango de la mxima impedancia de
(Z-25C)/(Z+20C) es 2. Este rango de impedancia junto con el clculo de la temperatura ambiente
indica que la ESR no exceder 0.424 a -25 C. As mientras la hoja de datos del LM2940 establece
que los valores ESR del capacitor electroltico pueden incrementarse drsticamente a bajas
temperaturas el capacitor de 1000 F en el kit PE no posee un riesgo de estabilidad a -25 C lo cual
est muy por debajo del rango de temperatura del regulador LM2940CT-5.0

Kit Educativo Propeller

Uploaded by

Document Information

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

Kit Educativo Propeller

Uploaded by

Copyright:

Available Formats

Ki t Educ at i vo Pr opel l er

You might also like