kit educativo propeller. fundamentos

Kit Educativo Propeller Fundamentos

Versión 1.1.1

Por Andy Lindsay Traducido por Oscar Villarreal

GARANTÍA Parallax Inc. garantiza sus productos contra defectos en materiales y fabricación por un periodo de 90 días a partir de la recepción del producto. Si el producto tiene un defecto, Parallax Inc. a su conveniencia reparará o remplazará la mercancía o reembolsara el monto de la compra. Antes de regresar un producto a Parallax se debe llamar a Parallax y obtener un número de RMA (Autorización de Regreso de Material). Para regresar la mercancía a Parallax escriba el número de RMA es la parte exterior de la caja. Por favor incluya la siguiente información con la mercancía a regresar: Nombre, Número de Teléfono, Dirección de envío y una descripción del problema. Parallax regresara el producto o su reemplazo usando el mismo método de envío que se utilizo para enviar el producto a Parallax.

14-DÍAS DE GARANTÍA PARA REGRESO DEL DINERO Si dentro de los 14 días 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 envío y/o manejo. Esta garantía no es válida si el producto ha sido alterado o dañado. Vea la sección de Garantía mencionada en el párrafo anterior para instrucciones de regresará del producto a Parallax. DERECHOS RESERVADOS Y MARCAS REGISTRADAS Esta documentación está protegida bajo derechos reservados © 2006-2009 por Parallax Inc. Al obtener una copia electrónica o impresa de esta documentación o el software usted está de acuerdo en utilizarla exclusivamente con productos Parallax. Cualquier otro uso no es permitido y puede representar una violación 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 documentación 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 electrónicamente, duplicar y distribuir este texto sin permiso de Parallax Inc. Este derecho se basa en las siguientes condiciones: el texto o cualquier porción 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 comúnmente 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 página 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 página web. Otros nombres de productos contenidos en este documento son marcas o marcas registradas de sus respectivos dueños.

ISBN 9781928982555 1.1.0-09.03.06-HKTP

ESTIPULACIONES DE REPONSABILIDAD LEGAL Parallax Inc. no se hace responsable por incidentes especiales o daños resultantes de cualquier violación de garantía o cualquier otra teoría legal incluyendo perdidas de ganancias, tiempo perdido, daños o reemplazos de equipo o propiedad, así como cualquier costo de recuperación, reprogramación o reproducción de cualquier dato almacenado en o usado con los productos Parallax.. Parallax Inc. tampoco es responsable por daños personales incluyendo vida o salud resultante por el uso de cualquiera de nuestros productos. Usted toma completa responsabilidad de su aplicación en los micro controladores Propeller.

LISTAS DE DISCUSIONES EN INTERNET Mantenemos foros de discusión activos en internet para gente interesada en los productos Parallax. Estas listas son accesibles desde www.parallax.com a través de Soporte-Menú de Foros de discusión (Support → Discussion Forums menu). Estos son foros que operamos de nuestro sitio web: Propeller chip – Esta lista es específicamente 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 retroalimentación de nuestros materiales educativos y así proporcionar un lugar para educadores que desean desarrollar y compartir recursos de clase.

• Robotics – Diseñado para robots Parallax, este foro tiene la intención de abrir diálogos para aquellas personas entusiastas en robótica. Los temas incluyen ensamble, código fuente, expansiones y actualizaciones de manuales. En este foro se discute acerca del Boe-Bot®, Toddler®, SumoBot®, Scribbler® and PenguinTM.

• SX Microcontrollers and SX-Key – Discusión de la programación del micro controlador SX con lenguaje ensamblador Parallax, herramientas SX-Key® y compiladores BASIC y C.

• Javelin Stamp – Discusión de aplicaciones y diseño usando Javelin Stamp, un modulo de Parallax que se programa usando un lenguaje una versión de Java de Sun Microsystems®.

ERRATA A pesar de que se realizó un gran esfuerzo para lograr la precisión de nuestros textos podría existir algún error. Si encuentra un error por favor envíenos la información a través de un correo electrónico a [email protected]. Continuamente mejoraremos nuestros materiales educativos y la documentación, 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 páginas de los productos individuales para encontrar el archivo de erratas correspondiente.

Tabla de Contenidos

Kit Educativo de Practicas Propeller: Fundamentos · Página 3

Índice PREFACIO .............................................................................................................................................5 1: INTRODUCCIÓN AL MICRO CONTROLADOR PROPELLER .........................................................7

El Micro controlador Propeller............................................................................................................7 El Kit Educativo Propeller.................................................................................................................13 Practicas para el Kit Educativo Propeller .........................................................................................15

2: PROGRAMAS, DOCUMENTACIÓN Y RECURSOS.......................................................................17 Descarga de Software y Documentación.........................................................................................17 Instalar la Terminal Serial Parallax ..................................................................................................18 Sitios Web útiles...............................................................................................................................18 Recursos y Soporte Técnico ............................................................................................................18

3: INICIO Y PRUEBAS PARA PLATAFORMA PE 40-PIN DIP ...........................................................19 La Plataforma PE .............................................................................................................................19 Descripción General.........................................................................................................................23 Inventario de Equipo y Partes ..........................................................................................................24 Ensamble de las placas de prueba..................................................................................................25 Configuración y Reguladores de Voltaje de la Plataforma PE ........................................................27 Prueba del cableado de la Plataforma PE .......................................................................................29 Conexión 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 Solución de problemas para el arranque de la Plataforma PE de 40 pins-DIP...............................39

4: PRACTICA BÁSICA DE E/S Y TIEMPO ..........................................................................................45 Introducción......................................................................................................................................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 Configuración 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 MÉTODOS Y COGS.............................................................................................69 Introducción......................................................................................................................................69 Lista de partes y esquemas .............................................................................................................69 Definiendo un comportamiento de Método con variables locales ...................................................70 Llamando un Método........................................................................................................................70 Pasando Parámetros........................................................................................................................71 Indexando Identificación del Cog.....................................................................................................78 Tiempo de Estudio ...........................................................................................................................80

Tabla de Contenidos

Pagina 4 · Kit Educativo de Prácticas Propeller: Fundamentos

6: PRACTICA DE OBJETOS ............................................................................................................... 83 Introducción ..................................................................................................................................... 83 Equipo, Partes y Esquemas ............................................................................................................ 84 Revisión de la llamada a método..................................................................................................... 85 Llamando Métodos en otros Objetos con la Notación Dot .............................................................. 85 Objetos que pueden iniciar Procesos en Cogs ............................................................................... 88 Reglas para Métodos Start y Stop en Librerías de Objetos ............................................................ 92 Comentarios de Documentación ..................................................................................................... 92 Métodos Públicos vs. Privados........................................................................................................ 95 Ejemplo de Múltiples Objetos .......................................................................................................... 96 Comunicación Chip Propeller – PC Terminal .................................................................................. 97 FullDuplexSerial y otros objetos de la Librería .............................................................................. 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: MÓDULOS CONTADORES Y APLICACIONES DE CIRCUITOS ................................................ 123 Introducción ................................................................................................................................... 123 Como trabajan los Módulos Contadores ....................................................................................... 124 Midiendo Descarga RC con un Detector de Modo Positivo .......................................................... 124 Conversión D/A – Controlando luminosidad del LED con Modos DUTY ...................................... 133 Registros de Propósito Especial.................................................................................................... 138 Generando Tonos en Piezospeaker con Modo NCO.................................................................... 141 Aplicaciones Objeto IR y Detección 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 Detección de Metal con Modos Detectores PLL, POS y un Circuito LC....................................... 176 Tiempo de Estudio......................................................................................................................... 184

APÉNDICE A: LISTA DE OBJETOS CÓDIGO.................................................................................. 191 FullDuplexSerialPlus.spin .............................................................................................................. 191 SquareWave.spin .......................................................................................................................... 198

APÉNDICE B: SOLUCIONES DE ESTUDIOS .................................................................................. 199 Soluciones de la Practica E/S y Tiempo........................................................................................ 199 Soluciones al Estudio de la Practica Métodos y Cogs .................................................................. 205 Soluciones al Estudio de la Practica de Objetos ........................................................................... 207 Soluciones al Estudio de Módulos Contadores y Aplicaciones de Circuitos................................. 213

APÉNDICE C: LISTA DE COMPONENTES KIT PE ......................................................................... 223 APÉNDICE D: DIAGRAMA DE BLOQUE DEL MICRO CONTROLADOR ....................................... 225 APÉNDICE E: LM2940CT-5.0 LÍMITE 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 programación 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 electrónicos, robótica 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 compañeros 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 interés es alcanzar también 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 Prácticas PE se escribió primordialmente para colegas y estudiantes de universidades que tienen conocimientos previos y experiencia en programación y electrónica, preferentemente con micro controladores. Los temas introductorios incluyen:

• Básicos de micro controladores tales como control de Entradas/Salidas y manejo del reloj • Programación en tópicos como operadores, llamadas y objetos, así como direcciones

variables • Control de Multiprocesadores Programados • Interacciones Micro controlador-Circuitos con luces indicadoras, botones de presión circuitos

sensores de ambiente y que pueden ser medidos con circuitos RC, circuitos de frecuencia y circuitos selectores de frecuencia

• Tópicos avanzados que incluyen utilización de módulos contadores para desarrollar tareas en el fondo

La intención de esta colección de Kit de Practicas PE es dar al lector un buen comienzo con la programación 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 línea. Más practicas y aplicaciones serán publicadas periódicamente. Este texto también incluye referencias a la riqueza de información 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 través de estos laboratorios. El contenido del Manual Propeller y el índice servirán de referencia para obtener más información 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. Además, si usted (o sus alumnos) realizaron algún buen experimento con el Kit de PE, se publicara su proyecto documentado en los foros para que otros puedan ver lo que hizo y cómo lo hizo.

Reconocimientos Parallaxianos:

• Autor: Andy Lindsay, Ingeniero de Aplicaciones • Portada: Jennifer Jacobs, Director de Arte • Edición: Stephanie Lindsay, Editor Tecnico • Ilustraciones: Andy Lindsay, con ayuda de Rich Allred, Gerente de Producción • Fotografía: Rich Allred • Revisión: Jessica Uelmen, Asociado de Educación

Comunidad Parallax – gracias a:

• Aaron Klapheck por sus comentarios en el código ilustrado cog variable bookkeeping en el tema avanzado: dentro de métodos Start y Stop en la sección 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 crítica incisiva y profunda de los primeros borradores del Kit de Laboratorios PE.

• Traducción al Español: Oscar Villarreal – FIX Ingeniería

1: Introducción al Microcontrolador Propeller


1: Introducción al Micro controlador Propeller Este capítulo proporciona datos generales del micro controlador Propeller y alguna información introductoria a las prácticas de Laboratorio y el Kit Educativo Propeller. Información más detallada del micro controlador Propeller, su arquitectura y lenguajes de programación pueden encontrarse en el Manual de Propeller y la Hoja de Datos del Propeller. Ambos están 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 simultáneamente, 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 señal de reloj (hasta 80MHz). La Figura 1-1 (b) muestra como cada cog toma su turno en la opción exclusiva del acceso leer/escribir de la memoria principal del chip Propeller a través 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. También previene que un cog lea una dirección particular de memoria mientras que otro lo está escribiendo. Así el acceso exclusivo asegura que nunca existirán 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 interacción de Hub y Cog. Ver Apéndice 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 gráficos. La ROM también almacena el código de arranque que es usado por el Cog 0 al inicializar e interpretar el código que cualquier cog puede usar para buscar y

Generalidades del Microcontrolador Propeller


ejecutar alguna aplicación 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 diseño único de multiprocesamiento del chip Propeller genera una variedad de aplicaciones del micro controlador relativamente simples que de otra forma serian difíciles. Por ejemplo, los procesadores se pueden asignar a entradas de audio, salidas de audio, ratón, 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 más 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 podría ser utilizada en algún tipo de aplicación. El Propeller también sobresale como controlador robótico, con la habilidad de asignar procesadores a tareas tales como control de motores DC a través de PWM, video procesador, matriz de sensores de vigilancia y alta velocidad de comunicación 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 difícil 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 pequeñas encontrados en diseños 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 aplicación también usa un ratón estándar 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 cortesía de mydancebot.com.

Aplicaciones con el chip Propeller Los programas para el Propeller son escritos usando una Computadora para posteriormente cargarlo en el chip típicamente a través de una conexión USB. Los lenguajes que soporta la herramienta de Programación incluyen lenguajes de alto nivel llamado Spin y lenguaje ensamblador de bajo nivel. Las aplicaciones desarrolladas en lenguaje Spin pueden contener opcionalmente código de lenguaje ensamblador. Estas aplicaciones se guardan en la computadora como archivos .spin



Otros lenguajes de programación han sido desarrollados para programar el chip Propeller. Algunos son gratuitos y están disponibles a través de los recursos como los foros Parallax, otros están disponibles y pueden ser comprados o se puede obtener una versión limitada a través del sitio Parallax o con otras compañías que venden compiladores.

Antes de que un cog pueda comenzar a ejecutar una aplicación Spin tiene que cargar un intérprete 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 configuración, variables y pines de entrada/salida así como lectura de ROM. Los cogs pueden ejecutar códigos de maquina generados por lenguaje ensamblador. Como se muestra en la Figure 1-4, estos códigos 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 través 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 través 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. Después del primer acceso el lenguaje ensamblador puede sincronizarse con el Cog alternándose 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/EjecutarConfiguracion

Aplicacion

Pila+ VAR

Conjunto de Caracteres

Registro, Antiregistro y

TablasArranque Interprete

(Hub) Memoria Principal

RAM

ROM

Configuracion

Aplicacion

Pila + VAR



Tablas Arranque Interprete


RAM

ROM

Configuracion

Aplicacion

Pila + VAR





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 información. El lenguaje Spin tiene características incorporadas para pasar direcciones de una o más variables usadas en código a otros objetos y Cogs. Esto hace la cooperación entre Cogs muy sencilla. El código en un Cog puede ejecutar código en otro Cog y pasarle una o más direcciones variables (ver Figure 1-5). Estas direcciones variables pueden ser utilizadas por dos Cogs para intercambiar información.

Figure 1-5: Dos (o más) Cogs trabajando en conjunto a través de memoria compartida.

Los Cogs del chip Propeller están numerados del Cog 0 al Cog 7. Una vez que la aplicación se carga en el chip Propeller este carga un intérprete en Cog 0 y este interprete comienza a ejecutar las fichas del código Spin almacenadas en la memoria principal. Entonces los comandos en el código Spin pueden ejecutar bloques de código (que puede ser Spin o Lenguaje Ensamblador) en otros Cogs como muestra la Figure 1-6. El código ejecutado por otros Cogs puede ejecutar otros Cogs no importando si es Spin o Código 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





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




Main (Hub) Memory

R A M

R O M

COG

COG



Figure 1-6: Arranque de Cogs El código en un Cog puede poner en marcha otros Cogs el cual puede poner en marcha otros… Los Cogs también pueden parar otros Cogs para liberarlos y usarlos en otras tareas.

Escribiendo Código de Aplicaciones Spin es un lenguaje de programación basado en objetos. Los objetos son diseñados para construir bloques o una aplicación y cada archivo .spin puede ser considerado un objeto. Mientras que la aplicación puede ser desarrollada como un objeto simple (un programa), las aplicaciones son comúnmente una colección de objetos. Estos objetos pueden proporcionar una variedad de servicios. En los ejemplos se incluyen soluciones que de otra forma complicaría el código, la comunicación con los periféricos, control de actuadores y monitoreo de sensores. Esta construcción de objetos bloque son distribuidos a través del objeto de intercambio Propeller (obex.parallax.com) y también en el archivo de librería en la herramienta de programación Propeller. Incorporando estos objetos pre-escritos en una aplicación 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 código de aplicación en el siguiente objeto Robot.spin hace que el uso de objetos pre-escritos para detección infrarroja (IR Detector.pin) controle los cálculos 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 aplicación puede también 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: Construcción 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 línea de código ejecutable donde el chip Propeller comienza cuando la aplicación corre. En cada caso el Cog 0 arranca y comienza ejecutando código del objeto superior. Nuestro objeto superior en el ejemplo Following Robot.spin contiene código que inicializa 3 objetos debajo del, convirtiéndolo 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 aplicación. Independientemente de si un objeto padre comienza un Cog en Spin o Ensamblador los objetos hijos tienen un sistema integrado y documentación 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 más de un Cog. También 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 práctica hacer responsable de parar al Cog al Objeto que lo inicializo.

Como se ejecuta el código en el chip Propeller La herramienta de programación Parallax puede utilizarse para desarrollar aplicaciones en el chip Propeller. Cuando una aplicación se carga en el chip Propeller el código Spin se compila en los ficheros y el Código Ensamblador opcional se compila en códigos maquina. La herramienta Propeller transfiere la aplicación al chip Propeller típicamente con una conexión serie USB. El programador puede escoger cargarlo directamente en la memoria RAM principal del chip Propeller o en una EEPROM (Memoria de Solo Lectura Eléctricamente 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 información a la RAM antes de comenzar la ejecución.

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 mayoría de los casos). Mientras que cargar programas en RAM puede ser más rápido para probar resultados de cambios durante el diseño del código los programas deberían estar cargados en EEPROM cuando la aplicación es finalizada o si se espera que comience después de un ciclo de encendido o re inicialización. Los programas cargados en RAM son volátiles, lo que significa que se pueden borrar por una interrupción de corriente o reinicializado del chip Propeller. En contraste los programas cargados en EEPROM no son volátiles. Después 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 están documentados en el kit de prácticas PE. Estas prácticas le ayudaran a aprender cómo desarrollar aplicaciones con el micro controlador Propeller.

Figura 1-9: Kit Educativo Propeller (Versión 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 después 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 volátiles • Cristal externo oscilador de 5.00 MHz para señal precisa • Botón de reinicio para arranques manuales • Indicador de Potencia LED • Batería 9 V para conectar a placas de prueba • Conexión USB-Serie para descargas y comunicación bidireccional con la computadora

En conjunto, las placas de interconexión 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 versión 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 Conexión USB se muestra en la Figura 1-10 (a). La conexión USB es un pequeño 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 más rápida la conexión de la Plataforma PE para comenzar a trabajar puede ser relativamente costoso reemplazar la conexión USB en vez de los componentes individuales si alguna vez se dañan. Figura 1-10: Plataformas PE

(a) Versión 40-pin DIP

(b) Versión conexión USB



Practicas para el Kit Educativo Propeller Las prácticas del Kit Educativo Propeller están incluidas en este texto y de igual forma existen prácticas adicionales disponibles para descargar desde www.parallax.com. Las prácticas en este texto muestran como conectar circuitos al micro controlador Propeller y como escribir programas para interactuar con los circuitos. Los programas también utilizan algunas características del lenguaje Spin así como algunas capacidades de multiprocesamiento del micro controlador.

Prerrequisitos En estas prácticas se asume experiencia previa con micro controlador. A pesar de que las prácticas incluyen diagramas de conexión para el arranque y prueba el resto no. Como mínimo deberá tener experiencia construyendo circuitos a partir de esquemáticos así como experiencia en lenguaje de programación de algún micro controlador o computadora.

Recursos para principiantes: Para una introducción de cómo construir circuitos, micro controlador, programación 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 básico 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 están disponibles a la venta desde el sitio web o con algún distribuidor. Para encontrar algún distribuidor cerca de usted verifique la lista de distribuidores bajo la categoría de Compañía en el sitio web de Parallax.

Practicas del Kit PE en este texto • Programas Documentación y Recursos – Descargue la documentación y el programa,

instale el programa. • Inicio y Pruebas para Plataforma PE 40-Pin DIP – Preparación del equipo. Si usted tiene

la versión USB en el kit PE, utilice el método alternativo. Es gratuito descargándolo de la página de producto en www.parallax.com.

• Practica básica de E/S y tiempo – Como configurar las E/S del chip Propeller, señales de entrada a monitor, señales de transmisión de salida y coordinación los eventos basado en el sistema de reloj.

• Practicas de Métodos y Cogs – Como escribir métodos en Spin y arranque de métodos opcionales en uno o más de los chips Propeller (procesadores).

• Objectos – Como utilizar objetos pre-escritos para simplificar tareas y como escribir objetos. • Módulos Contadores y Aplicaciones de Circuitos – Como emplear los módulos contadores

generados en cada Cog para desarrollar procesos de control y medición que requieren tiempo preciso. (Cada Cog tiene dos módulos contadores que pueden funcionar en paralelo con la secuencia del programa).

Las últimas cuatro practicas (E/S, Tiempo, Módulos Contadores y Aplicaciones de Circuitos) tienen preguntas, ejercicios y proyectos al final de cada capítulo con respuestas en el Apéndice B: , empezando en la pagina 199. Para mejores resultados inserte manualmente los ejemplos de código según vaya avanzando en las prácticas. Con esto va a darle tiempo a su mente para examinar cada línea de código junto con los conceptos y técnicas introducidas en las diversas secciones de cada laboratorio.



Mas practicas del Kit PE y aplicaciones en línea 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 prácticas utilizan partes del Kit PE y otras requieren partes adicionales las cuales puede encontrar en su mayoría en Parallax o con algún otro proveedor de componentes electrónicos. Figura 1-11: Practica Extractos de ViewPort

Señales de Osciloscopio y Analizador de Espectro generadas por un micrófono mientras alguien esta silbando. El micro controlador Propeller muestrea estas señales y las envía el programa ViewPort en la Computadora Personal. Esta es una de las actividades que aparecen en las prácticas de ViewPort.

2: Programas, Documentación y Recursos


2: Programas, Documentación y Recursos Las herramientas de programación 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 comunicación bidireccional entre la Computadora Personal y el chip Propeller. En la misma página junto con la herramienta de programación usted encontrara diferentes documentos de referencia y los programas ejemplos para estas prácticas. Este capítulo incluye instrucciones para descarga e inicialización 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 Documentación En esta práctica usted usara la herramienta de programación Propeller, la Terminal Serial Parallax y el Manual de Propeller. Estos elementos junto con la hoja de datos del micro controlador Propeller están en una sola página en www.parallax.com.

Ir a www.parallax.com/go/PEKit → Downloads & Resources. 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 Código Fuente – para Practicas del Kit Educacional Propeller: Fundamentos (.zip) o Libro – Practicas Educativas Propeller: Fundamentos (.pdf) o Si usted está utilizando la versión PropStick USB del kit de PE, asegúrese de

localizar a su instalación independiente y prácticas en formato PDF Una de las herramientas Propeller incluida por defecto en el Kit PE es el controlador USB para programación/comunicación/depuración. Cuando instala la herramienta de programación automáticamente se instalaran los controladores que necesitara para comunicarse con la herramienta de programación Propeller en su Computadora. Estos son controladores FTDI’s VCP USB para Windows 2000/XP/Vista/7. Usted también podrá obtener los controladores desde www.ftdichip.com.

Instale la herramienta de programación cargando el programa de arranque y siguiendo las instrucciones. Cuando usted se encuentre en el paso de instalar las opciones de controladores mostrado abajo asegúrese de marcar la casilla Instalar/Actualizar automáticamente controladores.

Programas, Documentación y Recursos


!

! Deje esta casilla marcada! Usted podrá observar este paso durante la instalación del Software Propeller. El controlador opcional se requiere para estas prácticas. 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 aplicación ejecutable independiente que puede ser utilizada para intercambiar mensajes con el chip Propeller mientras está corriendo. Además de mejorar algunos de los ejemplos del Kit PE con mensajes de texto para indicar el estado y los valores, también puede ser útil para registro de datos rudimentarios y la depuración. A pesar de que es una aplicación 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 programación del Propeller.

Desempaque la Terminal Serial Parallax en la carpeta donde se instalo la herramienta de programación Propeller. La localización por defecto en la Versión 1.2 es C:\Program Files\Parallax Inc\Propeller Tool v1.2.

Genere un icono de inicio a la Terminal Serial Parallax junto al icono de inicio de la herramienta de programación Parallax.

Sitios Web útiles Además 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.

• Página 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 Técnico Parallax Inc. ofrece diversos caminos para soporte técnico:

• Correo Electrónico: [email protected] • Fax: (916) 624-8003 • Teléfono: 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: Configuración y Prácticas de Laboratorio


3: Inicio y Pruebas para Plataforma PE 40-Pin DIP Este es el programa de instalación y Prueba para la versión 40-pin DIP del Kit PE.

Si usted tiene la versión del Kit PE 40-Pin DIP (#32305) continúe aquí. Si usted tiene la versión PropStick USB del Kit PE (#32306) verifique la versión impresa de

instalación y pruebas del PropStick USB incluida con su Kit. También 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 electrónica y robótica. Es también un punto de arranque para aprender los básicos de la programación del micro controlador Propeller para ser integrado como el cerebro de computadora en su próximo invento. Esta práctica lo introduce a la Plataforma PE, sus componentes y características y lo guía a través del ensamble y prueba de su Plataforma PE. Figura 3-1: Kit Plataforma PE (Versión 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 fácil acceso. Cada tarjeta de prueba tiene conectores de voltaje en ambos lados por lo que cada punto a tierra y 3.3 V están junto a la placa. Este arreglo hace a la mayoría de los circuitos sencillos de conectar y analizar. También minimiza el espagueti de cables y problemas de que pueden ocurrir.

Configuración y Prácticas de Laboratorio


Componentes de la Plataforma PE y Características La Figura 3-2 muestra los mayores componentes de la plataforma de 40-Pin DIP PE incluyendo:

• Micro controlador Propeller con calcomanía de mapa de pins incluido. • Batería 9 V con conector a placa de prueba • Reguladores 5.0 V y 3.3 V • Indicador LED • Botón para reinicio manual de programa • Cristal Oscilador Externo de 5.00 MHz para señal de reloj preciso • EEPROM de 32 KB no volátil para almacenamiento de programas • Herramienta de conexión Propeller de programación y comunicación para descargas y

comunicación 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 increíble 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 código muy simple y directa. Si usted ha escrito una subrutina en BASIC y una subrutina “Call” (o una función de C y la función “Call”, o un método Java y el método “Call”) hacer que un procesador ejecute esa subrutina, función o método toma solo dos pasos más. Usted verá muchos ejemplos en estas prácticas del Kit PE.

Hoja de Datos y Manual del Propeller

La hoja de Datos del Propeller proporciona una descripción completa del micro controlador Propeller y el Manual explica la programación del chip y el lenguaje a detalle. Ambos están disponibles para descarga en formato PDF desde www.parallax.com La versión impresa del Manual Propeller también 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



Botón de Reinicio El Botón de reinicio se puede presionar y soltar para reiniciar la ejecución de un programa. También se puede presionar y sostener para finalizar la ejecución. Cuando se suelta el chip Propeller cargara el programa almacenado en la plataforma EEPROM y reiniciara desde el principio. Batería 9 V para el conector de las placas de prueba Este pequeño componente proporciona una conexión de la fuente de poder a la tarjeta de prueba. El voltaje DC recomendado a través de VIN-VSS es de 6 a 9.5VDC y la fuente de poder recomendada para VIN-VSS incluye:

• Baterías alcalinas de 9 V • Baterías recargables de 9 V (rangos de voltajes incluyen 9V, 8.4V y 7.2 V)

Siempre desconecte la batería del conector y almacene por separado. Las Baterías de 9V nunca deberán almacenarse en la caja de plástico del Kit PE ya que las partes sueltas podrían causar corto en las terminales. La Batería de 9V deberá desconectarse del conector de la placa de prueba y debe almacenarse donde las terminales no pueden causar corto a través de cualquier objeto metálico o algún otro material conductivo.

“Wall Warts”: Este término describe comúnmente los transformadores DC que se conectan a través de contactos AC y normalmente proporcionan un voltaje mucho más alto de lo que se menciona. Si va a usar una conexión de este tipo es conveniente escoger una que esta regulada a 6V DC con una capacidad de corriente de 500 mA o más. El Kit PE DIP Plus incluye un capacitor de 47uF que puede ser colocado a través de la entrada de la batería 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 línea de suministro de la conexión.

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 módulos contadores y prácticas. Una resistencia en serie (típicamente 10kΩ) deberá estar conectada entre la salida 5V y el pin de entrada del Propeller el cual es 3.3V. El regulador de 5V también sirve como etapa intermediaria entre la batería y el regulador 3.3V que alimenta al chip Propeller. El regulador de voltaje LM2940 está diseñado para proporcionar 400mA de corriente usando una batería 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.

Más información:

• Apéndice E: LM2940CT-5.0 Límite de Corriente a partir de la página 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 más información, 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. También puede indicar baterías bajas, cortos circuitos y hasta puede indicar si la herramienta de comunicación Propeller está conectada. Según conexiones en esta práctica consume hasta 12mA. Después de completar esta práctica usted puede usar una resistencia mayor para una menor iluminación y menor consumo de corriente. Cristal Oscilador de 5.00 MHz El cristal oscilador de 5.00 MHz proporciona una señal precisa de reloj al chip Propeller que se puede usar para aplicaciones sensitivas al tiempo tales como comunicación serial, mediciones RC y Servo Control. El chip Propeller tiene un circuito integrado de bucle cerrado que puede utilizar la señal 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 rápido 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 comunicación serial, modulación de pulso para servo control o generación de señales de TV asegúrese de utilizar el oscilador externo. EEPROM de 32 KB La plataforma PE de almacenamiento de datos y programa es no volátil, lo cual significa que no puede borrarse al presionar y soltar el botón 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 millón de ciclos de lecto/escritura. Después de eso las celdas se desgastan y no serán confiables para almacenar valores. Así que si un programa modifica una EEPROM cada segundo esta se gastara en tan solo 11.6 días. De otra forma si la celda se modifica cada 10 minutos servirá por hasta 19 años.

EEPROM: Memoria de Solo Lectura Borrable y Programable Eléctricamente (Por siglas en ingles)

RAM: Memoria de Acceso Aleatorio.

Tenga en cuenta que su aplicación 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 aplicación necesite posteriormente, especialmente si los datos se utilizaran después de reconectar la fuente de poder. La aplicación de solicitud de registro de datos EEPROM (disponible en www.parallax.com → Propeller → Downloads & Articles) presenta un objeto para respaldar periódicamente los valores almacenados en RAM a la EEPROM. Herramienta de Programación y Comunicación Propeller El Propeller Plug proporciona una conexión Serial sobre USB entre en chip Propeller y la Computadora para programar, comunicar y limpiar. El LED azul indica la recepción 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 señal USB de la computadora en señales 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 programación Propeller. Fuera de ser necesario para cargar programas en el chip Propeller, el puerto virtual hace conveniente la comunicación con programas seriales tales como la Terminal Serial Parallax.



Más información del Puerto virtual COM

Después de instalar el Puerto virtual COM de FTDI a través 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 envía 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 recepción. Los programas de comunicación serial tales como la Terminal Serial Parallax utilizan esta forma de comunicación para intercambiar información con los dispositivos seriales periféricos.

Prerrequisitos Por favor siga las instrucciones en el programa, documentación y recursos que comienzan en la página 17 antes de continuar aquí.

Descripción General En estas prácticas usted ensamblara la plataforma PE Versión 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 • Configuración y Reguladores de Voltaje de la Plataforma PE • Prueba del cableado de la Plataforma PE • Conexión 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 • Solución 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 corazón de las prácticas del Kit PE, todas las conexiones eléctricas deberán probarse antes de continuar con las prácticas. Seguir estos pasos le ayudara a descartar posibles errores de conexiones que pueden pasar fácilmente 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 • Batería alcalina de 9V (Para esta configuración y pruebas utilice una batería 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 pequeñas y cortadoras/peladoras de cable • Multímetro (DC + AC Voltímetro y Óhmetro) • Osciloscopio Digital, similares al Osciloscopio USB de Parallax (#28014) • Brazalete y Tapete antiestático

!

Precauciones ESD: Las Descargas Electrostáticas (ESD) pueden dañar 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 estáticas periódicamente es con el chasis de una Computadora conectada a tierra física. La parte del chasis típicamente expuesta es la parte trasera. El monitor y equipos periféricos normalmente están conectados al marco metálico con tornillos. Toque el marco expuesto (no los puertos) antes de abrir una bolsa antiestática y posteriormente hágalo 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 estáticas busque otra área de trabajo con menos problemas de estática. De igual forma si usted observa que un suéter genera cargas en una silla no utilice ese suéter mientras traba con la Plataforma PE.

Junte los componentes mencionados en la Tabla 3-1, Tabla 3-2, y la Tabla 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 Apéndice 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 Retráctil USB A a Mini B



Tabla 3-3: Kit Propeller DIP Plus (130-32305) Número de Parte Cantidad Descripción

571-32305 1 Conexión de Batería 9V

201-01085 2 Capacitor, Electrolítico, 6.3 V, 1000 µF

201-04740 1 Capacitor, Electrolítico, 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 Botón – 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, números en renglones). Cada columna tiene una letra en la parte superior e inferior de la placa y cada renglón tiene un número 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 renglón de seis están conectados por un conductor metálico bajo de ellos. Así que para conectar dos cables o más solo conéctelos en el mismo renglón.



Usando los entrelazados conecte las placas de prueba como se muestra en la Figura 3-3.

Figura 3-3: Placas de Prueba

Véalo a color y acercamiento: Este archivo está disponible gratuitamente en formato PDF en la página del producto Kit Educativo Propeller (32305) en www.parallax.com. Usted también 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 están indicados en Negro y Rojo y los renglones son identificados por números. 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 línea vertical negra estas eléctricamente conectados. Estos conectores típicamente sirven como una tierra común y cada uno de estas columnas es conectada a la terminal negativa de la batería. Cada conector de potencia tiene grupos de 12 conexiones denotados por 2 líneas rojas verticales. Las doce superiores junto a la línea roja están agrupadas en conjunto pero no están conectadas a las doce bajas de la siguiente línea roja. La ruptura en la línea roja indica la ruptura de continuidad. El diseño 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

Ejemplo de coordenada: (C, 7) en la derecha

Ejemplo de coordenada:(Rojo, 28)a la derecha del

conector de potencia

Ejemplo de coordenada: (Negro, 22) a la mitad del conector de potencia



para acomodar dos diferentes voltajes en el mismo conector de potencia. Esta característica 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.

Configuración 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 sección usted lo configurara y probara sin batería, Propeller Plug, chip Propeller o 24LC256 EEPROM. Después algunas pruebas eléctricas para verificar el cableado, usted conectara y probara cada componente. Siguiendo este procedimiento usted minimizara la posibilidad de dañar algún 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 batería no están conectados. Note también 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á más fácil 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

Asegúrese que la placa está orientada para que los números y letras indicados en la placa coincidan con las coordenadas de la Figura 3-5.



Conecte los cables y componentes exactamente como se muestra en la Figura 3-5. Asegúrese que todos los cables embonan correctamente en las conexiones. Si accidentalmente corto un cable más pequeño y tiene un contacto ligero tire el cable y coloque uno Nuevo, usted tiene que cortar a la medida correcta.

El ánodo del LED debe estar conectado al (Rojo, 10) y su cátodo a (L,10). El cátodo es el que está más cerca de la parte plana en la parte opuesta a la superficie redonda del LED

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

La Resistencia entre (D, 5) y (D, 9) es de 10 Ω (café, negro, naranja) y 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 algún error que de otra forma puede causar un problema al sistema, no trabajar o incluso dañar algunos componentes. Aunque las partes de la Plataforma PE no son costosas, a menos que tenga más a la mano, esperar para obtener nuevas partes puede ser un retraso inconveniente.

Haga una impresión de la Figura 3-5 y verifique cada conexión marcando sobre cada punto su cableado observando que las coordenadas coincidan con las coordenadas para cada conexión mostrada en la figura.



La terminal positiva de la Batería de 9V deberá conectarse en el centro de la placa (L, 1) y su terminal negativa conectarse en (L, 2)

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.

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.

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 posición en (J, 6) o (J, 7)

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

Verifique que el ánodo del LED esté conectado a (Rojo, 10) y que su cátodo (indicado por un

pin más corto en la parte plana del encapsulado) se conecta a (L, 10)

Prueba del cableado de la Plataforma PE Esta sección muestra una lista de puntos de prueba que con un multímetro puede verificar que:

• Los reguladores de voltaje están cableados correctamente y que trabajan apropiadamente • Los voltajes distribuidos en los rieles son correctos • Los voltajes están direccionados correctamente a las conexiones para proporcionar potencia

al chip Propeller y al a EEPROM

Si usted tiene un multímetro los puntos de prueba se mencionan a continuación:

Puntos de prueba con batería desconectada Continuidad La mayoría de los multímetros ofrecen la opción de continuidad la cual permite probar bajas resistencias. El símbolo de continuidad es típicamente 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 indicación 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 medición. La medición dependerá de la calibración de su multímetro y la resistencia de prueba. Usted puede encontrar el punto de cero ohms juntando las puntas de su multímetro. 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.



En el conector de la batería de la terminal negativa a las columnas NEGRAS en las cuatro conexiones. (La terminal negativa en el conector de la batería es la del diámetro más pequeño y que está más cerca de los cables)

La terminal positiva del conector de la batería al centro de la placa (G,1) La terminal negativa del conector de la batería a los siguientes puntos: (G,19), (G,20), (F,22),

(D, 4), (G, 6, 7, 8, 9), (G, 2) y (K, 4) (I, 5) a (ROJO, 13) y (Rojo, 18) en las cuatro conexiones de potencia (ROJO, 18) a: (F, 19), (G, 22), (B, 5,), y (B, 6).

Prueba con batería conectada Si su voltímetro es preciso los voltajes medidos estarán típicamente en el rango de ± 0.1 VDC. Algunos voltímetros más económicos tienen menor precisión. Si usted está usando un voltímetro económico o uno que desconoce el historial quizá identifique algunas variaciones mayores durante las mediciones.

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 más largo que el adaptador para conectar la batería de 9V proporcionado en el kit.

Conecte una batería alcalina de 9V nueva o una recién cargada al conector de Batería de la

Plataforma PE. El LED deberá brillar. Si el LED no brilla o esta naranja en vez de verde desconecte la batería inmediatamente y revise los pasos de solución de problemas (2) en la página 39

Voltaje DC

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 solución de problemas en la pagina 42. Si el voltaje es incorrecto diríjase a la solución de problemas (3) en la página 49

Repita la prueba para 3.3VDC en (ROJO, 18) y (NEGRO, 13). (I, 1) en centro de la placa a (NEGRO, cualquiera): igual que voltaje en terminales de batería. (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 diríjase a la solución de problemas (11) en la página 42

Conexión 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.

Desconecte la batería del conector para los siguientes pasos. Identifique la muesca de referencia en el chip Propeller y la calcomanía del mapa, compare la

orientación con la muesca entre el chip y el mapa en la Figure 3-6. (La muesca de referencia es un semicírculo entre el Pin 0 y el Pin 31 en el mapa y deberá coincidir con la muesca física en el chip Propeller.)

Coloque el mapa del chip Propeller asegurándose que la muesca de referencia en la calcomanía está orientada en la misma dirección que la muesca en el chip.

Asegúrese que cada pin está alineado con la conexión correcta en la placa de prueba donde será instalado.



Coloque el chip Propeller en la placa de prueba, verifique su orientación contra la Figure 3-6. Presione firmemente con ambos pulgares.

Localice la muesca de referencia en la EEPROM 24LC256 y oriéntelo como se muestra en la Figure 3-6 y presiónelo. La muesca de referencia deberá estar entre los Pins que están 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 programación Propeller debe estar cargada en su computadora antes de comenzar.

Si usted no ha hecho esto, antes de continuar aquí complete los pasos de Programa, Documentación 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 deberán 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 comunicación deberán titilar, pero Windows típicamente ya no desplegara los mensajes de instalación del puerto serial.

La batería debe estar desconectada



Conecte el Propeller Plug a su computadora con el cable USB y verifique que ambos LEDs de comunicación (Rojo y Azul) están titilando brevemente inmediatamente después de que usted hizo la conexión.

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.

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 continúe con el siguiente paso; en vez de seguir vaya al paso (5) en la solución de problemas de la pagina 40.

Conecte la Batería Cuando usted conecta la batería 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 están junto a las tiras rojas en los conectores de potencia.

Conecte la batería al clip como se muestra en la Figure 3-6. El LED de la Plataforma PE deberá iluminarse brillante. Si no sucede desconecte la batería inmediatamente y vaya a la solución de problemas (4) en la pagina 40. Lo mismo aplica si el LED verde obtiene una tonalidad anaranjada.

Si usted tiene un voltímetro, verifique el voltaje en el conector rojo y negro. Deberá medir 3.3VDC. Si el voltaje es incorrecto desconecte la batería y vaya a la solución de problemas (3) en la pagina 40.

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 solución de problemas (11) en la página 42

Prueba de Comunicación La característica de identificación de Hardware en la herramienta de programación Propeller puede usarse para verificar la comunicación entre la PC y el chip Propeller.

Asegúrese que la batería está conectada. Verifique que el cable de USB conecta la PC al conector del Propeller. Verifique que el conector Propeller está conectado al conector de 4 pins (etiqueta hacia abajo) Abra el programa Propeller, Presione en Menú y seleccione Identify Hardware…(o F7). Si la herramienta reporta, “Propeller Chip versión 1 found on COM…”, continúe a la

siguiente sección (Cargar el programa y probar los pins E/S) De otra forma vaya a la solución de problemas (6) en la pagina 41 y solución 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 prácticas 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 difícil de identificar visualmente pero si un pin de E/S no identifica entrada o salida de control esta prueba puede identificar el problema rápidamente. De otra forma podrá tomar mucho tiempo buscar un error en la aplicación o el código antes de descubrir que el problema es un pin doblado. Así que realice las pruebas. No tomara mucho tiempo y podrá ahorrarle mucho tiempo después.



Partes para el circuito de prueba de pins E/S

Abra la bolsa de partes del proyecto PE y verifique su contenido contra la lista de partes en la Tabla C-2 en el Apéndice C: Lista de Componentes kit PE.

Para los siguientes circuitos reúna 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) Botón pulsador (4) Alambres de conexión

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 solución de problemas (9) en la pagina 41. Comience por verificar que el circuito LED es correcto y que todos los conectores de potencia están proporcionando 3.3V como sigue:

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

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

Desconecte el alambre del LED de (L, 14) en la Figure 3-8, y conéctelo 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 asegúrese que el LED no está conectador al revés. Su parte más corta (Ánodo) deberá estar conectado en el socket siguiente a la línea 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 están conectados a la fuente de 3.3 V. Si usted ya realizo esta prueba con un voltímetro puede brincarse esta parte.

Desconecte el cable de (ROJO, 13) y conéctelo 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.

Después 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 están funcionando apropiadamente como salidas.

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 botón 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 rápidamente los pins de E/S.

E/S es una abreviatura para Entrada/Salida.

La dirección y el estado de cada E/S son controlados por el programa. En los programas puede modificarse la dirección 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 botón pulsador se presiona y parpadea a 10 HZ después 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. Después de que todas las Salidas en la izquierda del chip Propeller y todas las Entradas del lado derecho se probaron, el botón 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). Después 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 botón 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).

Abra el archivo PushbuttonLedTest.spin en la herramienta propeller o escríbalo. Si lo escribe tenga cuidado de escribir cada línea exactamente como se muestra.

Presione el menú Run de la herramienta Propeller y seleccione Compile Current → Load EEPROM (F11).

La ventana de comunicación Propeller aparecerá brevemente y mostrara el progreso de la carga del programa. Si se cierra después del mensaje “Verifying EEPROM” entonces cargo correctamente.



Si en cambio se abre una ventana que dice “EEPROM programming error...” vaya a solución de problemas (8) en la pagina 41.

Verifique que el LED conectado a P3 parpadea encendido/apagado rápidamente a 10Hz Presione y sostenga el botón pulsador y verifique que el LED parpadea más lento a solo 2 Hz. Si todo funciono como se anticipaba pase a la prueba de pins E/S mostrada abajo. Si no

funciono vaya a solución 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 solución 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.

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.

Después, use el botón pulsador para verificar que cada pin de E/S que está al lado derecho del chip Propeller funciona como entrada.

Presione y sostenga el botón pulsador a la derecha de la placa. El circuito LED en la izquierda de la placa deberá parpadear a 2Hz en vez de 10Hz.

Desconecte la batería del clip. Desconecte el cable del botón pulsador en (A, 28) en el centro de la placa y conéctelo en P16

(A,30) Modifique el programa para monitorear P16 en vez de P18 cambiando la directiva PUSHBUTTON CON en el objeto PushButtonLedTest.spin de 18 a 16.

Reconecte la batería al clip Cargue el programa modificado en la RAM presionando el menú Run y seleccionando

Compile Current → Load RAM (F10). Verifique que el botón pulsador, ahora conectado a P16, controla la frecuencia del LED. Repita este procedimiento para P17, P19, P20 y así hasta P27.

Cargar RAM (F10) vs. Cargar EEPROM (F11): La herramienta de programación Propeller Cargar RAM es rápida pero el programa se borra cada que la corriente se corta o el botón de reinicio se presiona. Después de un reinicio el chip Propeller cargara el programa que más recientemente se cargo en EEPROM y comenzara a ejecutarlo. Los programas cargados en EEPROM no se borran pero toma un poco más de tiempo cargarlos. Como la prueba del botón 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 están 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 aplicación no dañara y no podrá ser dañada por los otros circuitos conectados a P28…P31. Vea la Figura 3-4 en la pagina 27 para detalles. Para la mayor parte las prácticas 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 envíe señales incorrectas a los pins de E/S. La corriente deberá desconectarse cuando se cambia el circuito. Para asegurarse que el programa vacio corre automáticamente cuando la corriente se conecta deberá cargarse en EEPROM usando F11.

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



'' File: DoNothing.spin PUB main ' Método main vacío Ahora la corriente puede desconectarse, el botón pulsador puede moverse al lado izquierdo de la placa y el circuito LED puede moverse al lado derecho de la placa de prueba.

Desconecte la batería y el cable USB. Mueva el circuito LED a la derecha de la placa de prueba y conéctelo a P16. Mueva el botón pulsador del lado izquierdo de la placa de prueba y conéctelo a P15. 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.

Reconecte el cable USB y la batería. Cargue el programa objeto modificado PushbuttonLedTest.spin en EEPROM usando F11. Repita las pruebas de salida LED para P16 hasta P27 Repita las pruebas de entrada del botón pulsador empezando en P15, luego P14 y así hasta

P0. Recuerde modificar el código 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 señal alta (3.3V) a un circuito que está enviando una señal 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 dañar el siguiente circuito que se conecta. De hecho hágalo un hábito. Siempre cargue DoNothing.spin en EEPROM usando F11 antes de desconectar la corriente y construir un circuito Nuevo o hacer cambios al existente.

Ahora cargue DoNothing.spin en EEPROM (F11). Cuando usted reconecte la corriente DoNothing.spin se cargara automáticamente 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 fluctuación en la fuente de voltaje se pasará directamente en fluctuaciones de las señales altas 3.3 V enviadas por los pis E/S del Propeller. También 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 señales de los pins E/S del Propeller se usan también en una variedad de aplicaciones análogo-digital (medidas de voltaje) y digital-análogo (síntesis de voltaje). Así que cualquier fluctuación de voltaje que afecte la salida alta y niveles de disparo de entrada reducirá la precisión de medición y síntesis de voltaje.



Los productos y prototipos de circuitos impresos diseñados con chips Propeller típicamente tienen varias características 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 típicamente más anchas que otras pistas que transmiten señales. 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 protección adicional de fluctuaciones de voltaje y mejorar aun mas la estabilidad.

Mejore la estabilidad de la Fuente de Poder del Kit En comparación 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 idénticos 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 fluctuación ocasionada por líneas largas de fuentes. Lista de Partes:

(1) Plataforma construida y probada del Kit PE – Versión 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 están conectados entre si con un cable puente y los pins de Tierra están conectados con otro cable puente. Capacitores de 0.1 μF se conectan entre los pins 3.3 V y Tierra en ambos lados.

Desconecte la fuente de poder y el Puerto de programación Corte los cables puentes para reducir cualquier exceso de longitud cuando se conecten como

se muestra en la Figura 3-6. Use un cable rojo para conectar (J, 22) a (D, 19). Use un cable negro para conectar (J, 20) a (D, 22). Conecte las terminales del capacitor 0.1 μF en (K, 22) y (J, 19). Conecte las terminales del otro capacitor 0.1 μF en (B, 19) y (B, 22). Verifique sus conexiones. Reconecte la fuente de poder y el Puerto de programación.



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

Solución de problemas para el arranque de la Plataforma PE de 40 pins-DIP (1) Conexión de programación y Puerto Serial

a. Cuando conecte el Propeller Plug al Puerto USB los LED rojo y azul junto al mini USB del Propeller Plug deberán parpadear brevemente. Si no sucede intente un puerto diferente. Si ninguno de los puertos responde contacte a Soporte Técnico en Parallax . (Vea los recursos de Soporte Técnico en la página 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. Asegúrese 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. También asegúrese que la batería está conectada y que el LED verde de la Plataforma PE esta brillando ligeramente. Después 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 comunicación

c. Si aun tiene el mensaje de la Figura 3-9 después de asegurarse que el cable del USB está

conectado: i. Presione el botón Edit Ports en el mensaje de error. La lista de búsqueda 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 botón 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 Port”como el COM46 que se muestra en la Figura 3-10.

iii. Si este aparece en un gris ligero presione el botón derecho y seleccione Include Port (COMX), o en algunos casos Re-Include Port.

Figura 3-10: Lista de búsqueda de Puerto Serial

d. Si la lista de búsqueda 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 después siga las instrucciones para solución de problemas.

e. Si la herramienta de programación 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 botón derecho en Mi Computadora y seleccione Propiedades. Presione la pestaña de Hardware y presione el botón 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 programación 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 desinstálelo. Usted puede hacer esto al presionar el botón derecho mientras esta sobre el controlador y seleccionando desinstalar.

2. Desconecte el Propeller Plug. Antes de conectarlo nuevamente asegúrese que se instalo el controlador USB FTDI. La manera más sencilla de hacerlo es desinstalar y reinstalar la herramienta Propeller.

3. Cuando reinstala la herramienta de programación Propeller: a. Asegúrese que la instalación de controladores USB esta

marcado! Para mayor información vea la sección de Descarga de Programas y Documentación en la pagina 17.

b. Después de que reinstalo el programa el controlador correcto se instalara automáticamente cuando conecte el Propeller Plug a la computadora. Asegúrese de dejar la batería desconectada cuando conecte el Propeller Plug a la computadora con el cable USB por primera vez.

f. Contacte a Soporte Técnico de Parallax (Vea pagina 18.) (2) Si el LED de la Plataforma PE no enciende o si brilla anaranjado cuando la batería se

desconecto: a. Si el LED se enciende anaranjado:

i. Verifique si hay corto entre el cátodo del LED y tierra. El LED deberá tener una resistencia en serie entre su cátodo (L, 10) y tierra (NEGRO, 9). La resistencia deberá conectar (K, 9) a (K, 10).

ii. Asegúrese que el voltaje en el ánodo del LED (ROJO, 10) es 3.3V. b. Si el LED no encendió quizá esté conectado al revés. Verifique que el cátodo está

conectado a la resistencia y el ánodo conectado a la fuente de 3.3V. En términos de la Figura 3-5 en la página 28 el pin que sale de la parte plana de la base cilíndrica 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 página 28.



c. Asegúrese que la terminal (+) de la batería este conectada a (L, 1) y su terminal (-) esté conectada a (L, 2).

d. Podría existir un error de cableado que ocasione un corto circuito de la fuente de poder a tierra. Si usted no tiene multímetro comience a verificar visualmente su cableado. Con un multímetro usted puede verificar resistencia entre la terminal negativa de la batería y las 3 fuentes positivas. Asegúrese de desconectar el cable USB y la batería antes de hacer la prueba de resistencia.

iii. Comience a medir la Resistencia entre la conexión 3.3V y la terminal negativa de la batería. Por ejemplo pruebe entre los puntos (ROJO, 13) y (J, 4) en el centro de la placa de prueba.

iv. Repita la medición 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 batería (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 Técnico 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 verifíquelo contra una fuente conocida de voltaje antes de confiar en sus mediciones.

b. Repita la Verificación de Conexiones de Cables empezando en la página 28, cuidadosamente continúe hasta las conexiones de la Batería en la página 32, ponga atención a los detalles esperando que pueda encontrar a algún 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 batería después de conectar el chip

Propeller pero si encendía en pruebas anteriores: a. Verifique errores en los pins: Si un cable termina en un renglón que se comparte con el

chip Propeller o con el pin de la EEPROM 24LC256 es un punto sospechoso. Asegúrese que las coordenadas son idénticas 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 verificación de cableado de la pagina 28. Continúe detalladamente hasta las conexiones de la batería en la pagina 32 y quizá pueda detectar algún error esta vez.

c. Contacte a Soporte Técnico de Parallax (vea pagina 18). (5) Si el LED de encendido no brilla ligeramente después 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 cátodo

conectado a (L, 10). El cátodo es el pin con la parte plana en la base cilíndrica 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 (cátodo) 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. Continúe hasta la conexión de la batería en la pagina 32 y quizá usted detecte un problema esta vez.

h. Contacte a Soporte Técnico de Parallax (vea pagina 18). (6) Causas comunes del mensaje “No Propeller Chip found…” son:



a. Batería desconectada. Conecte la batería. b. Batería descargada, la batería tiene que volver a cargarse. c. El cable USB no está conectando el Propeller Plug a la computadora. Asegúrese que

ambas terminales están conectadas. d. El Propeller Plug no está conectado al conector de 4 pins o está conectado al revés. La

conexión deberá ser con los componentes hacia arriba (etiqueta hacia abajo). e. Conexión USB dañada o gastada. La mayoría de las computadoras tienen más de una

conexión USB, intente con otro puerto. f. El chip Propeller o la EEPROM 24LC256 no están conectadas totalmente. La parte de

abajo del chip Propeller y la EEPROM deben estar tocando la placa de prueba. Si no es así asegúrese que todos los pins están 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 sección. h. Fuentes de poder – Si usted no verifico los voltajes con un multímetro es hora de hacerlo.

(Vea la prueba de cableado de la Plataforma PE en la página 29). Si los voltajes son incorrectos vea el punto (3).

i. El Propeller Plug esta invertido. El pin 1 y el indicador de semicírculo 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 renglón 11 no en el renglón 30. Verifique también que la muesca impresa coincide con la muesca física del chip Propeller, ambos deben estar orientados al renglón 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. Asegúrese que el cátodo del LED esta conectodo al conector de potencia que esta junto a la línea negra.

b. Si él LE no encendió cuando probo el conector de potencia en la izquierda asegúrese 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 batería. 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 conexión 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. Asegúrese 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 Técnico de Parallax (Vea pagina 18.) (9) Si el programa se descarga pero el circuito LED no parpadea:

a. Si ingreso el programa manualmente entonces descárguelo directamente la pagina del kit Educativo Propeller. Ábralo con la herramienta de programación 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 asegúrese que el oscilador está conectado. (Vea la Figura 3-2 de la página 20 del cristal de 5.00 MHz y verifique que los conectores están colocados en las posiciones correctas)

c. Remueva el oscilador y conecte nuevamente para realizar la prueba otra vez.



d. Cambie la línea 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 comuníquese a Soporte Técnico Parallax (Ver página 18).

(10) Los pins de E/S del chip Propeller se prueban antes de enviar. Si la prueba de LED o

Botón Pulsador indican que hay un pin dañado: a. Asegúrese 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 eléctrico 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 multímetro 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 Técnico Parallax (Ver página 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. También tome notas de cualquier evento que observe durante la prueba y contacte a Soporte Técnico Parallax. (Ver recursos en página 18)

d. Por favor vea la póliza de garantía en www.parallax.com para más información de reemplazo del modulo con pins E/S dañados.

(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 están entre 1 a 2.5V sobre lo que debería estar. i. Asegúrese que las puntas del capacitor están conectadas en los lugares correctos.

ii. Asegúrese que las puntas del capacitor son lo suficientemente largas y están 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 batería (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 Técnico de Parallax (Vea pagina 18).

4: Práctica básica de E/S y tiempo


4: Practica básica de E/S y tiempo

Introducción La mayoría de aplicaciones en micro controladores requiere de una lectura de entrada, toma de decisiones y control de salidas. También 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 práctica le darán ejemplos sencillos de aplicaciones que puede monitorear con los pins de E/S del Propeller. Del mismo módulos circuitos LED le darán un sencillo y efectivo significado del monitoreo de pins de E/S en el Propeller y los eventos de tiempo. Aunque la práctica del botón pulsador y el ejemplo del LED pueden parecer simples, están hechos para presentar claramente un número importante de técnicas de código que serán usadas y reusadas en otras prácticas. Esta es una lista de ejemplos de aplicaciones y de técnicas de código:

• Encender un LED – Asignar direcciones de E/S y estados de Salidas • Encender grupos de LEDs – Asignar grupos de E/S • Estado de botón 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 • Señales 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 – Introducción a mas operadores Spin que son usados comúnmente en registros de E/S

• Desplegar conteos binarios – Introducción a varios tipos de operadores y ejecución de bloques de código de ciclos condicionales

• Cambiar desplegados de luz – Ejecución de bloques de código y cambio de operaciones • Cambiar desplegados de luz con botón pulsador-rango controlado de refrescado –

Variables globales y locales y mas ejecución de cloques de código • Desplegado de Hora normal en segundos– Introducción a eventos de tiempo sincronizados

que funcionan independientemente de otras tareas dadas a un Cog

Pre requisitos para la practica • Inicialización y prueba

Lista de partes y esquemas Esta práctica utilizara seis circuitos LED y tres circuitos de botones pulsadores.

(6) LEDs – diversos colores (6) Resistencia – 100 Ω (3) Resistencia – 10 kΩ (3) Botón Pulsador – Normalmente abierto (Misceláneos) cables de unión

Construir el circuito que se muestra en la Figura 4-1.

Práctica básica de E/S y tiempo


Figura 4-1: Circuitos de Botón Pulsador y LED

Nomenclatura del Propeller La documentación del micro controlador Propeller frecuentemente hace referencia a Cogs, Spin, Objetos, Métodos y variables Globales y Locales. Esta es una breve explicación de cada término:

• 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 súper 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 código Spin o Ensamblador.

• Lenguaje Spin – El lenguaje Spin es un lenguaje de programación de alto nivel creado por Parallax para el chip Propeller. Los Cogs que ejecutan el código lo hacen cargando un intérprete 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 cómo hacerlo. El lenguaje ensamblador genera código maquina que reside en la RAM del Cog y lo ejecuta directamente el Cog. Los programas en lenguaje ensamblador hacen posible escribir código que optimiza el desempeño del Cog, sin embargo requiere un entendimiento profundo de la arquitectura del chip Propeller. El kit fundamental PE se enfoca en programación Spin.

• Método – Un bloque ejecutable de comandos Spin que tiene nombre, regla de acceso y puede como opción crear variables locales (temporalmente), recibir parámetros y regresar un valor.

• Variables Globales y Locales – Las variables Globales están disponibles para todos los métodos en un objeto dado y reservan espacio variable como “long” en una aplicación que está corriendo. Las variables Locales están definidas en un método, solo puede ser usada dentro de ese método y solo existe mientras el método ejecuta comandos. Cuando termina, la memoria de esa variable local queda disponible para otros métodos y sus variables locales. Las Variables Globales y Locales se definen con sintaxis diferente.

• Objeto – Un Bloque de aplicación de todo el código dado en un archivo .spin. Algunas aplicaciones Propeller usan solo un objeto pero la mayoría usa varios. Los objetos tienen una variedad de usos dependiendo parcialmente de como se escribieron y parcialmente en cómo se configuraron y son utilizados por otros objetos. Algunos objetos sirven como objetos de primera categoría que proporcionan un punto de inicio donde el primer comando en una aplicación dada se ejecuta. Otros objetos son escritos para proporcionar una librería de métodos útiles para objetos iniciales u otros objetos a utilizar.



Los objetos se pueden escribir para usar solo un Cog o puede incluir código que inicializa uno o más Cogs. Algunos objetos tienen métodos que proporcionan datos para intercambiar información con procesos en otros Cogs. Algunos objetos pueden incluso hacer múltiples copias de otros objetos y darle a cada uno diferentes tareas. Los objetos pueden usar otros objetos los cuales pueden usar todavía otros objetos. En aplicaciones más complejas un conjunto de objetos forman una relación funcional que se ve como una estructura de archivos en la herramienta Propeller. Los ejemplos en esta práctica solo cubren objetos sencillos usando solo un método. En futuras prácticas se presentaran varias técnicas de construcción de bloques para usar en múltiples objetos y métodos en una aplicación así como aplicaciones multiprocesos usando varios Cogs. Como los objetos en esta práctica 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 continuación contiene un método 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.

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

'' File: LedOnP4.spin PUB LedOn ' Declaración de método dira[4] := 1 ' Asigna P4 a Salida outa[4] := 1 ' Asigna P4 alto repeat ' Esta operación previene que termine el programa

Como trabaja LedOnP4.spin La primera línea en el programa es un comentario de documentación. Los comentarios de línea sencilla se denotan por dos apostrofes (no comillas) a la izquierda del texto de documentación.

Seleccione el botón “Documentation” sobre el código en el editor Propeller. Mientras que comandos como dira :=… y repeat no muestran modo de documentación, observe que en el texto a la derecha del doble apostrofe si aparecen. Observe también que los comentarios de no-documentación en el código es precedido por apostrofes sencillos y no aparecen en modo de certificación.

Seleccione otras opciones y observe que muestran y que no muestran los elementos del objeto.

Comentarios de bloque: También existen comentarios de documentación de bloques que pueden extenderse varias líneas. Estos tienen que comenzar y terminar con dobles llaves como: Comentarios de documentación del bloque. Los comentarios de no-documentación también pueden extenderse varias líneas comenzando y terminando con llaves sencillas como: Comentario de bloque de no-documentación.

Todos los comandos de lenguaje Spin que ejecuta el chip Propeller tienen que ser controlados con un bloque método. Cada bloque método tiene que declararse con al menos una regla de acceso y un nombre. Las reglas de acceso y los nombres de método se revisaran a detalle en otras prácticas, por ahora solo tenga en mente que PUB LedOn está declarado bloque método con una regla de acceso público (PUB) y el nombre LedOn.



Resaltar texto o no? En los párrafos de discusión la fuente usada en la herramienta Propeller se usa también para todo el texto que es parte de un programa. Las porciones de texto que son operadores o palabras reservadas estarán resaltadas. Las porciones que son definidas por el usuario tales como métodos, variables y nombres de constantes y valores no deberán estar resaltadas. Esto imita la sintaxis de la herramienta Propeller al remarcar el esquema Spin. Las listas de código y sobrantes no se les dan el resaltado. Para ver la versión de sintaxis completa véala 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 propósito 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 símbolo “:=” es el operador de asignación; 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.

E/S compartidas entre Cogs? Cada Cog tiene su propia salida E/S (outa) y su registro de dirección 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 propósitos al mismo tiempo. Cuando varios Cogs se utilizan en una aplicación cada dirección de pin E/S y estado de salida es el “cableado-OR” de los Cogs. Como trabajo esto lógicamente se describe en la sección Pin E/S en el Capítulo 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 línea de espacio. El siguiente comando después de repeat que no tiene espacio no es parte del bloque y será el siguiente comando a ejecutar después 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 después de que se queda sin comandos por ejecutar. Si el comando repeat no estuviera ahí el LED encendería muy brevemente como para verlo y después el chip se pondría en modo de bajo consumo. Para nuestros ojos parecería que nada sucedió.

Modificando LedOnP4 En una línea se puede hacer más de una asignación:

Remplace esto:

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

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

Por supuesto usted también puede expandir el método LedOn para que corra en más de un LED.

Modifique el método 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 método los LEDs se apagarían tan rápido que no sería posible verlos en ningún momento. Solo un osciloscopio o ciertos circuitos externos podrían observar el breve estado de “Encendido”.

Intente correr el programa con el comando repeat comentado, colocando un apostrofe a su izquierda.

Si usted tiene un osciloscopio, prográmelo para capturar una señal sencilla y vea como puede detectar la señal.

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 patrón 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 están apagados.

Cargue GroupIoSet.spin en la RAM (F10). 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 patrón hará que el bit 9 se ponga en (1), el bit 8 limpio (0) y así sucesivamente.

Remplace outa[4..9] := %101010 …con esto outa[9..4] := %101010

Cargue el programa en la RAM del chip Propeller y verifique que los LEDs tienen el patrón 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 están definidos como entrada en vez de salida cuando el registro dira está limpio. Un pin de E/S funcionando como entrada detecta una señal alta o baja en vez de enviarlas. Mientras un pin se configura como salida envía 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 presión eléctrica a través 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 presión eléctrica por lo que no fluye la corriente y las luces se quedan apagadas. La luz se queda apagada también cuando el pin E/S se configura como entrada pero esto sucede por otra razón. 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 ningún 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 prenderán porque sus pins E/S se están configurados como entradas con ceros en el registro dira.

Configurar todos los bits outa[4..9]. outa[4..9] := %111111

Limpiar los bits 6 7 7 en dira[4..9]. dira[4..9] := %110011

Cargar la modificación 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 lógica 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 botón 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 botón P21 se presiona o un 0 si no se presiona. Asignando repetidamente el valor almacenado en ina[21] a outa[6] el método ButtonLed hace que el LED en P6 encienda cada que el botón en P21 se presiona. Note que también el comando outa[6] := ina[21] se incluye bajo el comando repeat lo cual hace que esta línea se ejecute una y otra vez.

Cargue ButtonToLed.spin en la RAM. Presione y suelte el botón conectado a P21 y verifique que el LED conectado a P6 enciende

mientras el botón se mantiene presionado. '' Archivo: ButtonToLed.spin '' Led refleja el estado del botón 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 Múltiples Entradas, Controlar Múltiples 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 también tendrá que cambiarse a dira[6..4] := %111 antes de que los botones enciendan los LEDs.

Guarde una copia de ButtonToLed y modifíquelo para hacer que los botones P23, P22 y P21 enciendan los LEDs P4, P5 y P6 respectivamente. Sugerencia: Usted solo necesita el comando outa.

Intente invertir el orden de los pins en outa[6..4]. Como afecta esto a la forma en que el botón 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 más fáciles de estudiar con el código que controla el tiempo de ciertos eventos como cuando un LED enciende o cuánto tiempo se presiono un botón. Los tres constructores de bloques básicos 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 número 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 paréntesis. Para controlar el tiempo que waitcnt espera es mejor sumar el numero de ciclos de reloj del sistema que han pasado al número de ciclos de reloj que usted quiere que cnt espere. El ejemplo suma clkfreq, el número de ciclos de reloj en un segundo, al valor actual de cnt. El resultado de la suma entre paréntesis es el valor que el registro cnt alcanzara 1 segundo después. 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)



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 común que puede ocasionar resultados inesperados. En la izquierda las cuatro líneas bajo el comando repeat están mas indentadas que repeat. Esto significa que están anidadas en el comando repeat y los cuatro comandos se repetirán. En la derecha las líneas bajo repeat no están indentadas. Estas están 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 líneas sombreadas que conectan la “r” en repeat a los comandos debajo de ella. Estas líneas indican los comandos en el bloque en el que opera repeat.

Para habilitar esta función 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 rápido Ctrl +I

Figura 4-2: Bloque de Código Repeat Este ciclo repeat repite cuatro comandos

Los comandos bajo repeat no están 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 rápido (aproximadamente 12 MHz) para el reloj del sistema. Con el reloj de sistema por defecto a 12MHz la instrucción waitcnt(clkfreq + cnt) es equivalente a la instrucción 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 más 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

Configuración 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 operación. El bloque de asignación CON define una sección del código para declarar la configuración del Propeller así como las símbolos 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 límite de 80MHz

CON _xinfreq = 5_000_000 _clkmode = xtal1 + pll16x

La línea _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 línea _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 información) El modo de reloj xtal1 configura ciertos pins XO y XI con características para trabajar con cristales externos en el rango de 4 a 16 MHz La frecuencia del cristal externo proporciona la señal 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 señal 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 sección _CLKMODE.



Precisión 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 comunicación serial, generación de tonos, servo control y temporizadores el chip Propeller puede conectarse a cristales osciladores y otras señales de alta precisión a través 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 aplicación como comunicación serial asíncrona puede tolerar únicamente 5% de error y eso es sumando los errores del transmisor y el receptor. En diseños prácticos 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 diseños 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 mayoría 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 millón. Eso es un porcentaje de error de +/- 0.003%. Obviamente es más que preciso para una comunicación serial asíncrona y también para servo control y generación 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 día. Esto puede ser suficiente para relojes que se verifican continuamente con un reloj atómico para actualizarse. Tenga en mente que para hacer que el chip Propeller funcione con precisión de reloj de pulso solo necesita un oscilador más preciso

La hoja de datos del HC-49US también tiene límites para temperatura (+/- 50PPM) y desgaste (+/- 5 PPM por año). Incluso después de 5 años en su rango de -10 + 70ºC el máximo error podría ser 105PPM lo cual está todavía en control, pero nuevamente, una alarma de reloj podría ganar o perder 9 s por día.

Como clkfreq almacena la frecuencia del reloj del sistema el código objeto puede confiar en él para el tiempo sin importar la configuración del reloj del sistema. El comando clkfreq regresa el numero de ciclos por segundo basado en la configuración 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.

Cargue ConstantBlinkRate.spin en la RMA del chip Propeller (F10). El reloj del sistema correrá a 80 MHz.

Verifique que rango del parpadeo es de 1 Hz Modifique la declaración 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 _clkmode = xtal1 + pll16x PUB LedOnOff dira[4] := 1 repeat outa[4] := 1 waitcnt(clkfreq/2 + cnt) outa[4] := 0 waitcnt(clkfreq/2 + cnt) El reloj de sistema del Propeller trabaja ahora a 40MHz. El LED está parpadeando a 1Hz todavía?

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?

Guarde una copia del objeto ConstantBlinkRate como BlinkRatesWithConstants.spin. Asegúrese que el multiplicador PLL está en pll1x para que el reloj corra a 5MHz. Para una señal de encendido/apagado de 1Hz cambie ambas instancias clkfreq/2con 2_500_000. (La herramienta Propeller acepta guión bajo, pero no comas, el números largos para hacerlos más legibles)

Cargue el objeto en la RAM del chip Propeller y verifique que el LED parpadea a 1 Hz. Después, cambia el multiplicador PLL a pll2x. Cargue el objeto modificado en la RAM del

Propeller. La luz parpadea dos veces más rápido? 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 diseñados para usarse en otros objetos. De esta forma el programador puede escoger la mejor frecuencia de reloj para la aplicación sin tener que preocuparse acerca si algún objeto de la aplicación se comportara diferente.

Mas Operaciones de Registros de Salida En la sección 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 códigos publicados.

Los Operadores Post-Activo “~~” y Post-Limpio “~” Debajo hay dos ejemplos que hacen lo mismo. Mientras que el objeto a la izquierda usa técnicas 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.

Cargue cada programa en la RAM del chip Propeller y verifique que son idénticos. 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 waitcnt(clkfreq/4 + cnt) outa[4..9] := %000000 waitcnt(clkfreq/4*3 + cnt)

''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]~~ waitcnt(clkfreq/4 + cnt) outa[4..9]~ waitcnt(clkfreq/4*3 + cnt)



Intente modificar ambos programas para que solo afecte P4..P7. Note que los operadores Post-Activo y Post-Limpio requieren menos mantenimiento ya que automáticamente 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. Después 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 1’s se hacen 0’s, los 0’s se hacen 1’s). Por lo que el resultado de !outa[4..9] será %011110.

Cargue cada objeto en la RAM del chip Propeller y verifique que son idénticos. 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 dígitos o como número binario. Por ejemplo en la instrucción 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

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 waitcnt(clkfreq/4 + cnt) outa[4..9] := %011110 waitcnt(clkfreq/4 + cnt)

''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] waitcnt(clkfreq/4 + cnt)



'' 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]~~. Después outa[9..4]~ limpia todos los bits en el registro outa rango 9..4 a %000000 cero binario. La primera vez a través 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 patrón de LEDs pasa por cada posible permutación.

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

Modifique el comando outa en el ciclo repeat para usar solo outa[9..4]++. 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 número de veces a repetir un bloque de comandos. También puede repetirse until o while una o más condiciones existan, incluso intercambiar un valor variable de un valor from de inicio a un valor final a con la opcion del Delta step.

Lea la explicación en la sección REPEAT de la Referencia de Lenguaje Spin del Manual Propeller si lo encuentra útil.

Vamos a modificar IncrementOuta.spin para detenerlo después que el último valor (%111111 = 63) ha sido desplegado. Para limitar el ciclo a 63 solo agregue una expresión de conteo al comando repeat como este:

repeat 63

Guarde IncrementOuta.spin como BinaryCount.spin. Agregue el valor de contador 63 después del comando repeat. Para dejar los LEDs encendidos al terminar el bloque repeat agregue un segundo comando repeat debajo del bloque. Asegúrese que no está más indentado que el primer repeat.

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 código 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 condición del ciclo repeat. '' Archivo: IncrementUntilCondition.spin PUB BlinkLeds dira[4..9]~~ repeat until outa[9..4]++ == 19 waitcnt(clkfreq/2 + cnt) repeat

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

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 condición 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 condición hecha until ++outa[9..4] == 20. Verifique que aun para al contar hasta 20. Cuál es la diferencia? Si ++ se pone a la izquierda del outa[9..4], típicamente se llama Pre-Incremento y la operación se desarrolla antes de evaluar la condición ++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 típicamente Post-Incremento o Post-Decremento y la operación se desarrolla después de evaluar la condición. Con repeat until outa[9..4]++ == 19, el ciclo de retrasa en waitcnt cuando outa[9..4] almacena 0, 1, 2…19. Cuando outa[9..4] almacena 19, el ciclo no repite el waitcnt. Sin embargo como post-incremento sucede después de evaluar la condición 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 después de que outa[9..4] brinca a 1. El siguiente retraso sucede después 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 condición es verdadera un ciclo se puede repetir mientras una condición es verdadera. Aquí hay ejemplos de conteos hasta 20 usando la condición 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 versión pre-incrementada repite mientras outa[9..4]es menor que 20. Note que con repeat while…el operador “<” menor que se usa en vez del operador “==” igual que. Estas dos formas demuestran la distinción 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 también 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

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

Si usted todavía tiene preguntas acerca de esto, no se preocupe por el momento. El punto de esta sección es demostrar que hay una variedad de formas para hacer comparaciones e incrementar valores. Otras prácticas incluirán 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 condición mas para repeat, repitiendo outa[9..4] de un valor a otro valor. Con cada repetición del ciclo, esta forma de repeat automáticamente suma 1 a la cuenta cada vez. Fíjese en el fragmento de abajo. La primera vez a través del ciclo outa[9..4] empieza en 0. La segunda vez se suma automáticamente 1 y la condición 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. Después del ciclo donde outa[9..4] es igual a 19 se suma 1 a outa[9..4] haciéndolo 20. Como 20 no está en el rango “de 0 a 19” el código en el ciclo no se ejecuta.



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

Aquí se muestra un comando repeat que ofrece una función 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 repeat…from…a… 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

Pruebe las variaciones de los comandos repeat en esta sección para el objeto IncrementUntilCondition.

Vocabulario de operadores Los operadores Unarios tienen un operando. Por ejemplo el operador “-” en la expresión -1 es un operador unario y 1 es el operando. Los operadores binarios tienen dos operandos; por ejemplo el operador menos “-” en la expresión 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 expresión sin afectar a los operandos. Algunos operadores que hemos utilizado como :=, ~~, ~, y ! son operadores de asignación. Los operadores unarios de asignación tales como ~ , ~~, y ++ escriben el resultado de la operación de regreso al operando mientras que los operadores binarios de asignación 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 expresión. Los operadores de transferencia a la derecha “>>” y transferencia a la izquierda“<<” toman el patrón 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 patrón de bit. Si una forma de asignación (>>= o <<=) se usa, el valor original es sobrescrito con el resultado. Los operadores de transferencia son parte de un grupo más 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 asignación tienen características adicionales de ser Operadores de Comparación. Un Operador de Comparación regresa verdad (-1) si los valores en ambos lados del operador hacen la expresión verdadera o falso (0) si los valores en ambos lados hacen la expresión falsa. (Estos operadores de comparación binaria también se les llama Operadores Booleanos; también hay un operador booleano unario, NOT)

Bloques condicionales con if Como muchos lenguajes de programación, Spin tiene un comando if que permite ejecutar un bloque de código condicionalmente, basado en el resultado de una prueba. Un comando if puede usarse por sí mismo o como parte de una serie más compleja de decisiones cuando se combina con elseif, elseifnot y else. Los Operadores de Comparación son útiles para probar condiciones en una declaración.



if outa[9..4] == 0 outa[9..4] := %100000 waitcnt(clkfreq/10 + cnt)

Si la condición es verdadera el bloque de código debajo (una línea 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 declaración 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 patrón de luces con nuestro circuito de 6 LED.

Cargue ShiftRightP9toP4 en la RAM del chip Propeller. Oriente su plataforma para que parezca que las luces se mueven de izquierda a derecha una y

otra vez. Verifique que el patrón empieza en P9 y termina en P14 antes de repetir.

'' Archivo: ShiftRightP9toP4.spin '' Demuestra el operador de movimiento a la derecha y la declaración if PUB ShiftLedsLeft dira[9..4] ~~ repeat if outa[9..4] == 0 outa[9..4] := %100000 waitcnt(clkfreq/10 + cnt) 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 expresión es verdadera el resultado de la comparación 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 evalúa 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. Después de la pausa de 1/10s, >>= (el operador de asignación mover a la derecha) toma el bit en outa[9..4] y lo mueve a su derecha un bit con la siguiente instrucción: 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 después. Si el comando fuera outa[9..4] >>= 3, el resultado sería %000011 Cada vez que el ciclo se repite el comando outa[9..4] >>= 1 mueve el patrón 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.

Pruebe al cambiar el Segundo operando en la operación de mover a la derecha de 1 a 2 para hacer que el patrón 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 versión extendida de ShiftRightP9toP4 que le permite usar los botones para controlar la velocidad a la cual el LED cambiara su posición a la derecha. Si usted sostiene el botón P21 la velocidad baja; si sostiene el botón en P22 la velocidad sube. El control de velocidad se hace posible al almacenar un valor en una variable. El patrón que se mueve también 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].

Cargue ButtonShiftSpeed.spin en la RAM. Intente presionar P22 y observe el cambio en el comportamiento del LED, después presione

el botón 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 patrón 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 número 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 disposición 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 línea reasigna a pattern el valor de %11000000.



Los operadores Limite Mínimo “#>” y Limite Máximo “<#” Spin tiene operadores Limite Mínimo “#>” y Limite Máximo “<#” 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 if…elseif… que verifica el estado del botón pulsador. Si el botón P22 se presiona divide se incrementa en 1 con divide ++, y divide está limitado a 254 con <#=, la forma de asignar el operador de límite máximo. Si el resultado de divide ++ es 255 la siguiente línea 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 asignación #>= se usa para asegurarse que divide nunca será menor que 1, nuevamente previniendo de llegar al 0. Después de que la sentencia if…elseif… verifica el estado del botón y decrementa o incrementa la variable divide si alguno de los botones se presiono se ejecuta la función waitcnt(clkfreq/divide + cnt) para esperar un tiempo. Note que conforme divide es mayor waitcnt es menor. Después 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.

Comparación entre Operaciones y Condiciones Los operadores de comparación regresan un verdadero (-1) o falso (0). Cuando se usa en los bloques if y repeat el código especificado se ejecuta s la condición en no-cero. Siendo este el caso puede usarse if ina[22] en vez de if ina[22] == 1. El código funciona igual pero con menos procesamiento ya que se salta la operación de comparación. Cuando se presiona el botón la condición en if ina[22] == 1 regresa un -1 ya que ina[22] almacena un 1 haciendo la comparación verdadera. Usando solo if ina[22] aun se ejecuta el bloque de código cuando se presiona el botón ya que ina[22] almacena 1, el cual es no-cero, haciendo que el bloque de código se ejecute. Cuando el botón no se presiona ina[22] almacena un 0 y ina[22] == 1 regresa un falso (0). En cualquiera de los casos la condición de if es 0 así que el código debajo de if ina[22] == 0 o if ina[22] se salta.

Cambie if ina[22] == 1…elseif ina[21] == 1 a if ina[22]…elseif ina[21]…, y verifique que el programa modificado todavía funciona.

Variables Locales Mientras que todos los ejemplos de objetos en estas prácticas usan solo un método, los objetos frecuentemente tienen más de un método y las aplicaciones típicamente son colecciones de diversos objetos. Los métodos en las aplicaciones de paso de control de programa y parámetros opcionales van y vienen entre otros métodos del mismo objeto y también en otros métodos en otros objetos. Para preparar el trabajo con métodos múltiples en las siguientes prácticas veamos como un método puede crear una variable local. Las variables declaradas en la sección VAR de un objeto son globales para el objeto, lo que significa que todos los métodos en un objeto pueden usarlas. Cada método en un objeto también puede declarar variables locales para uso propio. Estas variables locales duran mientras se ejecuta el método. Si el método 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:

Remueva el bloque VAR (incluyendo su declaración de byte variable). Agregue el símbolo pipa a la derecha del bloque de declaración de método 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 métodos en el objeto no pueden usarlas; ya que nuestro objeto aquí solo tiene un método no hay consecuencias. Hay otra diferencia. Cuando usábamos la sintaxis del bloque VAR, teníamos la opcion de definir nuestras variables globales como byte, Word o Long. Sin embargo las variables locales se definen automáticamente como Long y no hay opcion para tamaños 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 precisión 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 ejecución 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 día mucha más 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 cuántas 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 _clkmode = xtal1 + pll1x VAR long seconds PUB BadTimeCount dira[4]~~ repeat waitcnt(clkfreq + cnt) seconds ++ ! outa[4]

''Archivo: TimekeepingGood.spin CON _xinfreq = 5_000_000

_clkmode = xtal1 + pll1x 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 señal que el chip Propeller obtiene de su cristal oscilador externo.

Consejo:

En TimeKeepingGood.spin, dos líneas:

T += dT waitcnt(T)

Pueden reemplazarse con esta línea:

waitcnt(T += dT).

Pruebe ambos objetos. Sin un osciloscopio no deberá observar una diferencia notable. 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 múltiplos 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 día. Vamos a decir que la aplicación corre al conteo de seconds. Una forma de determinar si ha transcurrido un segundo es dividir seconds por 60 para ver si hay algún recordatorio. El operador Modulus “//” regresa un recordatorio de problemas de división. 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 expresión 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 cálculo previo de minutes:

if seconds // 60 == 0 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 días 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 práctica que incrementa un tiempo basado en presionar un botón por diferente duración. También tiene la clave para otro proyecto en el cual los LEDs parpadean a diferente ritmo usando Cogs múltiples. (Cuando use Cogs múltiples en otras prácticas será mucho más fácil!)



Cargue TimeCounter.spin en la EEPROM, y verifique que el incremento del conteo LED es cada 1 s.

Modifique el código 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 _clkmode = xtal1 + pll1x VAR Long seconds, minutes, hours, days, dT, T PUB GoodTimeCount dira[9..4]~~ dT := clkfreq T := cnt repeat T += dT waitcnt(T) seconds++ if seconds // 60 == 0 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 limitación de almacenamiento. Por ejemplo cuando llegue a 2,147,483,647, el siguiente valor será -2,147843,648, y después -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 años. Si esto es aun un problema para su aplicación considere limpiar el contador seconds cada año.

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) Cuál 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 código Spin el chip Propeller y como se ejecuta? 5) Cuáles son las diferencias entre ejecutar código Spin y código Ensamblador? 6) Cuál es la diferencia entre un método 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 código indefinidamente.

Que tipos de argumentos opcionales se usaron en esta práctica y como limitaban el número 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 están bajo el comando repeat, como determina si se repetirán o no en el ciclo?

12) Cual fue el significado más frecuente de calcular un valor para el comando waitcnt y con cual registro hace que el comando waitcnt que compare este valor?

13) Cuál es la diferencia entre _xinfreq y _clkmode? 14) Que hace el circuito de fase cerrada a la señal de reloj del cristal? 15) Por qué es tan importante usar fracciones de clkfreq y no un valor constante para retrasos? 16) Cual señal de reloj es más precisa, el reloj RC interno del chip Propeller o un cristal externo? 17) Que registros controlan la dirección y salida de los pins E/S? Si un pin E/S se coloca como

entrada, que valor de registros cambiaran mientras corre la aplicación y como son los valores que regresa determinados por el Propeller?

18) Cuál 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 asignación se presentaron en esta práctica? 23) Que operadores de comparación se usaron en esta práctica? 24) Cuál es la diferencia entre los operadores := y ==? 25) Son necesarios los operadores de comparación para las condiciones if? 26) Cuáles son los dos diferentes alcances que una variable puede tener en un objeto? 27) Cuáles son los tres tamaños de variables que pueden declararse? Que rango de números

puede tener cada una? Se ve afectado el tamaño de la variable debido a su alcance? 28) Como se declara una variable local en un método? Qué carácter se necesita para declarar más

de una variable local?

Ejercicios 1) Escriba una sola línea de código 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 inicialización 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 cuál es la mejor opcion de operadores de asignación.

6) Escriba un bloque CON para hacer que el reloj del sistema del chip Propeller corra a 10MHz 7) Escriba un código para un retraso de 5 segundos. 8) Escriba un código que programe P5 a P11 alto por 3 segundos, después programe P6, P8 y

P10 bajo. Asuma que los bits dira han sido programados



9) Escriba un método 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. Asegúrese que las luces se vayan quedando encendidas.

10) Escriba un método que encienda un LED conectado a P27 por 5 s si se presiona un botón conectado a P0, incluso si el botón se suelta antes de 5 s. No asuma que las direcciones E/S han sido programadas. Asegúrese de apagar P27 después de los 5 s.

11) Escriba un método de conteo regresivo de 1 segundo que se despliegue de P4 a P9. Deberá contar de 59 a 0 en binario.

12) Escriba un método 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 método llamado PushTwoStart que requiere que presione los botones conectados a P21 y P23 al mismo tiempo para empezar la aplicación. Por ahora la aplicación puede al menos encender un LED y dejarlo encendido.

14) Escriba un método llamado PushTwoStart que requiere que presione los botones conectados a P21 y P23 al mismo tiempo para empezar la aplicación. La aplicación 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 patrón 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 colóquelo 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 más sencillo con múltiples Cogs como pudo observar en las últimas prácticas). 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 típicamente incrementan o decrementan el tiempo despacio hasta que usted ha detenido el botón por un par de segundos; después de eso el tiempo se incrementa/decrementa mas rápido. Los botones de la alarma de reloj también lo dejan incrementar/decrementar si presiona y suelta rápidamente el botón. Escriba una aplicación 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 botón, los primeros diez minutos incrementa/decrementa cada ½ s pero si continua presionando el botón los minutos se incrementaran 6 veces más rápido. 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 botón P22.

5: Prácticas de Métodos y Cogs


5: Practicas de Métodos y Cogs

Introducción Los objetos son organizados en bloques de código llamados métodos. En Spin se pueden usar nombres de métodos para pasar el control de programa y opcionalmente valores de parámetros de un método a otro. Cuando un método usa otro nombre de método para pasarle el control de programa se llama llamada método. Cuando el método llamado corre los comandos automáticamente regresa el control del programa y un resultado a la línea de código en el método que se le llamo. Dependiendo de cómo se escribe el método también puede recibir uno o más parámetros cuando se llama. Usos comunes para valores de parámetros incluyen configuración, definir el comportamiento de los métodos y valores de entrada para cálculos. Los métodos también pueden iniciarse en Cogs separados para que sus comandos se procesen en paralelo con comandos en otros métodos. El lenguaje Spin tiene comandos para iniciar métodos en Cogs, identificar Cogs y detener Cogs. Cuando los métodos se inician en Cogs se tienen que declarar variables globales para asignar memoria para los métodos y almacenar direcciones de regreso, valores de regreso, parámetros y valores usados en cálculos. Esta memoria normalmente se conoce como espacio de pila. Esta práctica muestra técnicas para escribir métodos, llamar métodos, pasar parámetros a métodos y regresar valores de métodos. También muestra cómo usar llamadas a métodos en comandos que inician instancias de métodos en Cogs separados así como una introducción a que tanto espacio de pila se necesita para uno o más métodos Spin que se ejecutan por un Cog.

Prerrequisitos para la Práctica • Configuración y Prueba • Básicos de E/S y tiempo

Lista de partes y esquemas Esta práctica 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

Construir el circuito mostrado en la Figura 5-1.

Prácticas de Métodos y Cogs


Figura 5-1: Esquema de botones pulsadores LED

Definiendo un comportamiento de Método 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 más 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 también el comando waitcnt utiliza rate/2 en vez de rate para el rango de parpadeo de 3Hz.

Corra el objeto AnotherBlinker.spin y verifique que hace que el LED P4 parpadee a 3Hz por 9 repeticiones.

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 Método El método Blink se usa nuevamente en el siguiente objeto ejemplo CallBlink, junto con otro método llamado Main. La Figure 5-2 muestra como el método Blink se llama desde el método Main. La ejecución del programa comienza en Main, en el primer bloque PUB. Cuando el programa llega a la línea Blink en el método Main el control del programa pasa al método Blink. Esta es una versión pequeña de una llamada de método. Cuando el método Blink termina de parpadear el LED 9 veces el



control del programa regresa al método Blink en el método Main. Eso es el regreso de método o simplemente regreso. Vamos a dar un vistazo al método Main del objeto CallBlink. Comienza por encender el LED en P9 para hacer saber al usuario que puede presionar el botón 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 método 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. Después el otro ciclo repeat comienza su siguiente iteración. A ese punto el LED P9 se enciende nuevamente indicando que el botón P23 puede disparar nuevamente la secuencia de 9 repeticiones a 3 Hz en P4.

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

Figure 5-2: Llamando un Método

Pasando Parámetros El método Blink que acabamos de usar programa los valores de sus variables locales pin, rate, y reps con instrucciones individuales var :=. Para hacer métodos más flexibles y eficientes de usar el valor de sus variables locales pueden definirse en la llamada de método en vez del método mismo. La Figura 5-3 muestra cómo funciona el objeto BlinkWithParams. La declaración del método modificado Blink ahora es: Blink( pin, rate, reps). El grupo de variables locales entre paréntesis se llama lista de parámetros. Note como el método Blink llamado en el método BlinkTest también tiene su lista de parámetros. Estos valores de parámetros se pasan a las variables locales en la declaración de la lista de parámetros del método 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 código en un método puede pasar valores a variables locales en otro método.

Cargue BlinkWithParams.spin en el chip Propeller y verifique que el resultado es el mismo que el objeto previo AnotherBlinker.

Ajuste valores de parámetro en la llamada a método para ajustar el comportamiento de Blink

'' CallBlink.spin PUB Main repeat outa[9] := dira[9] := 1 repeat until ina[23] outa[9] := 0 Blink waitcnt(clkfreq/2*3 + cnt) 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]

Llamada de Método

Regreso de Método

Siguiente Comando



Figura 5-3: Pasando Parámetros

Los métodos pueden reusarse con diferentes valores de parámetros en cada llamada de método; aquí se llama Blink tres veces con diferentes parámetros y una pausa de 1 s en medio.

PUB BlinkTest Blink(4, clkfreq/3, 9) waitcnt(clkfreq + cnt) Blink(5, clkfreq/7, 21) waitcnt(clkfreq + cnt) Blink(6, clkfreq/11, 39)

Aquí hay otro ejemplo en el que prende un LED diferente cada que se presiona y suelta en botón. Esta es una variación del método 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 método actualizada Blink pasa el valor en la variable al parámetro pin del método Blink. Como led cambia con cada iteración del ciclo repeat, la variable pin recibirá un valor diferente cada que se llama a Blink. ¿El resultado? Cada vez que se presiona en botón (después 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) waitcnt(clkfreq/2*3 + cnt)

La variable local led del método BlinkTest se pudo haber llamado pin porque es una variable local ya que solo el método BlinkTest la usa. El código en el método Blink tiene también una variable local pin, pero nuevamente, solo el código en el método Blink estará pendiente del valor de la variable pin.

Pruebe las dos versiones modificadas BlinkTest en discusión y asegúrese que hace sentido. Intente cambiar los parámetros para que el LED P4 parpadee 4 veces, P5 5 veces y así

sucesivamente.

'' BlinkWithParams.spin PUB BlinkTest Blink(4, clkfreq/3, 9) PUB Blink(pin,rate,reps) dira[pin]~~ outa[pin]~ repeat reps * 2 waitcnt(rate/2 + cnt) !outa[pin]



Arrancando métodos en los Cogs Todos los métodos en los objetos hasta este punto se han ejecutado en un solo Cog del chip Propeller, el Cog 0. Cada vez que el método Blink se llamaba, era llamado en secuencia, por lo que solo un LED parpadeaba a la vez. El método Blink puede arrancar en diferentes Cogs, cada uno con diferentes parámetros para hacer que los LEDs parpadeen simultáneamente. El objeto BlinkWithCogs mostrado en la Figura 5-4 muestra cómo hacer esto con los 3 comandos cognew. El primer método en el objeto superior automáticamente arranca en el Cog 0 por lo que el método 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. Después de que el último Cog se queda sin instrucciones el chip Propeller se va a bajo consumo. Figura 5-4: Arrancando métodos en Cogs con pase de parámetros

Mientras que el Cog 0 accesa RAM global no usada que viene después del código de programa para almacenar direcciones de regreso en llamadas de método, variables locales y cálculos de expresiones intermedias, otros Cogs que ejecutan métodos 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 declaración 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 método Blink en el siguiente Cog disponible con los parámetros 4, clkfreq/3, y 9 lo cual sucede en el Cog 1. El argumento @stack[0] pasa la dirección 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 dirección, variables locales y cálculos 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 dirección 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 parámetros de método y diferente dirección en el arreglo stack.

'' BlinkWithCogs.spin VAR long stack[30] PUB LaunchBlinkCogs cognew(Blink(4, clkfreq/3, 9), @stack[0]) cognew(Blink(5, clkfreq/7, 21), @stack[10]) cognew(Blink(6, clkfreq/11, 39), @stack[20]) PUB Blink( pin, rate, reps) dira[pin]~~ outa[pin]~ repeat reps * 2 waitcnt(rate/2 + cnt) !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 Blinker(5, clkfreq/7, 21) RAM @stack[10]

Cog 3 Blinker(6, clkfreq/11, 39) RAM @stack[20]

Cog 0 Comandos LaunchBlinkerCogs



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)

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 Información del Objeto mostrado en la Figura 5-5 (F8 muestra Hex). El color gris en la parte superior muestra códigos de inicialización que inician el Objeto superior en un Cog, programa el registro de reloj del chip Propeller y otras tareas. La memoria roja almacena el código 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 dirección inicial RAM del Cog 0 es hexadecimal 00F0. Figura 5-5: Ventana de Información del Objeto

Parando Cogs Con el comando cognew, el chip Propeller siempre busca el siguiente Cog disponible y lo empieza automáticamente. En el objeto BlinkWithCogs el patrón de asignación 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.

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 método 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 parámetro programado para que el objeto mantenga parpadeando el LED hasta que se repita un millón de veces. Después 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 métodos se cierra hasta ejecutarse un millón de veces.

Primera dirección RAM no usada para la pila del Cog 0



PUB LaunchBlinkCogs cognew(Blink(4, clkfreq/3, 1_000_000), @stack[0]) cognew(Blink(5, clkfreq/7, 1_000_000), @stack[10]) cognew(Blink(6, clkfreq/11, 1_000_000), @stack[20]) waitcnt(clkfreq * 3 + cnt) cogstop(1) waitcnt(clkfreq + cnt) cogstop(2) waitcnt(clkfreq + cnt) cogstop(3) Con algunos trucos de indexación, 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 identificación de Cogs. Hace lo mismo que la versión modificada del método LaunchBlinkCogs. Note que la variable local index se declara con el símbolo 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 parámetro de pin del método Blink es 0 + 4, pasando 4 al parámetro de pin del método 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 ecuación. Para 0, 10 y 20 como elemento de arreglo, index * 10 completa la ecuación. 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]) waitcnt(clkfreq * 3 + cnt) repeat index from 1 to 3 cogstop(index) waitcnt(clkfreq + cnt)

Pruebe las versiones modificadas de los métodos LaunchBlinkCogs. Los objetos pueden escribirse para monitorear que Cog se está ejecutando en un cierto método. Un avance es discutido en la sección Indexación de Identificaciones de Cogs en la página 78. Otros avances se mostraran en futuras prácticas de objetos.

¿Cuánto espacio de Pila para iniciar un Método en un Cog? Abajo se muestra una lista del numero longs de que cada método agrega a su pila cuando se llama.

• 2 – direcciones de regreso • 1 – regreso de resultado • Numero de parámetros del método • Numero de variables locales • Espacio de trabajo para expresiones de cálculo intermedias

Asuma que tiene un objeto con tres métodos: A, B y C. Cuando el método A llama al método B la pila crecerá conteniendo dos grupos de longs, uno para el método A y otro para el método B. Si el método B llama al método C habrá un tercero. Cuando el método 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 método de Blink repeat reps * 2 usa el área de trabajo de dos formas. La primera en la expresión reps * 2 empuja dos elementos a la pila: el valor almacenado por reps y 2. Después del cálculo * el 2 sale de la pila y el resultado del cálculo 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 método Blink lo más que usa de área de trabajo y cálculos de expresiones intermedias es 3 longs: uno para detener el resultado de reps * 2 hasta que el ciclo repeat se completa, y dos más para los diversos cálculos con operadores binarios como multiplicar (*) y dividir (/). Conociendo esto podemos verificar el número de variables long que el Cog necesita en la pila para ejecutar el método listado abajo. Así el total de espacio de pila (ej., número de variables long) que necesita un Cog para ejecutar el método Blink es 10.

• 2 – Regresos de direcciones • 1 – Resultado variable (cada método tiene esto incluido, aun cuando no se especifica un valor

de regreso. (Esto se analizara en la siguiente sección) • 3 – Parámetros pin, freq, y reps • 1 – Variable local time • 3 – Áreas de espacio para cálculo. ------------------------------------------------ • 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 método llama. Algunos métodos tendrán llamadas de métodos anidados donde un método A llama a un método B que a su vez llama un método C. Todos esos métodos necesitan memoria de pila asignada si el método A es el que se inicio en el Cog.

Errar en el lado de la precaución: La mejor forma de asignar espacio de pila para el Cog que inicia un método Spin es tener precaución y declarar mucho más memoria de lo que piensa que necesitara. Así usted puede usar un objeto en la librería 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 método. La práctica de objetos revisara un proyecto que usa el objeto Stack Length para verificar el número de variables Long requeridas por un método Spin que se inicia en un Cog.

Declarar un arreglo variable long llamado stack en un bloque de código 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 también funcionan, siempre y cuando el nombre que se escoge es aquel cuya dirección se pasa al Cog por el comando cognew. Recuerde que el operador @ a la izquierda del nombre de variable es el que especifica la dirección RAM de la variable global.

Acerca de _STACK: El lenguaje Spin tiene también 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 aplicación. Lea más acerca de esto en la sección de referencia de Lenguaje Spin en el manual del Propeller.

Llamada de Método y el Resultado Variable Cada método público y privado tiene integrada una local variable predefinida llamada result. Cada vez que se llama un método su result variable se inicializa a cero. Luego, el valor de result puede



definirse por el código en el método. Cuando ese método termina de ejecutarse se regresa el valor actual de result. A este punto esa llamada de método puede usarse como un valor (siendo el valor de result) en expresiones. Cuando una llamada de método aparece en una expresión el método se ejecuta para obtener el valor de result antes de que la expresión es evaluada.

Acerca de llamada de método en Expresiones: Una llamada de método 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 método no puede usarse con operadores de asignación unarios o como operando “objetivo” del lado izquierdo de n operador de asignación binario.

Una forma práctica de usar esta característica nos permite tomar un valor definido por un proceso en un método y tenerlo disponible para uso por otros métodos. Nuestro ejemplo ButtonBlink.spin usa tres métodos para demostrar Main, Blink, y ButtonTime. En esta aplicación presionando y soltando un botón en P23 hará que un LED en P4 parpadee 10 veces (usando el método Blink) y la frecuencia se determina por cuánto tiempo se presiona el botón usando el método ButtonTime. Figura 5-6: Usando un Resultado de Método Variable

Observe la Figura 5-6. el método Main de ButtonBlink declara solo una variable, time. Contiene solo dos llamadas de métodos en el ciclo repeat. En el primero ButtonTime(23) llama al método ButtonTime y pasa el valor 23 a su parámetro pin (Paso 1). El código 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 método (Paso 2). La expresión time := ButtonTime(23) asigna el valor regresado por la llamada de método ButtonTime a la variable time del método Main (Paso 3). Luego time está listo para usarse en la siguiente llamada de método Blink (4, time, 10) (Paso 4) como el valor a pasar al parámetro rate del método Blink (Paso 5).

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 waitcnt(rate/2 + cnt) !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 método

ButtonTime pasa 23 al parámetro pin

de ButtonTime

(Paso 2) El método ButtonTime define la variable result y regresa este valor a la llamada de método

(Paso 3) El resultado del método ButtonTime se asigna a la variable

time del método principal

(Paso 4) time se usa en lallamada a método

Blink

(Paso 5) El método Blink recive time como

valor a usar en su parámetro rate



Presione y suelte el botón y observe que el LED parpadea 10 veces a una frecuencia determinada por el tiempo que se sostiene el botón.

Después de que el LED termina de parpadear presione y suelte el botón en un tiempo diferente.

Intente varios tiempos desde presionar y soltar rápidamente hasta presionar por varios segundos.

Especificando Valores de Regreso Declaraciones de métodos públicos 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 método. Este nombre alias es practico especialmente para documentar el código pero no es requerido. A continuación hay una versión modificada del método ButtonTime que demuestra cómo se puede usar regresar un valor en vez de una variable result. Aquí se agrego :dt a la declaración del método y en la última línea 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 método este método aun funciona idénticamente que el objeto original ButtonBlink.

PUB ButtonTime(pin) : dt | t1, t2 ' Alias opcional especificado para el valor de regreso repeat until ina[pin] t1 := cnt repeat while ina[pin] t2 := cnt dt := t2 - t1 ' Automáticamente se regresa el valor almacenado por dt

Haga una copia del objeto ButtonBlink en un nuevo tabulador. Substituya esta versión modificada del método ButtonTime en la copia del objeto ButtonBlink

y verifique que trabaja igual. Utilice el sumario y vistas de documentación para comparar los dos objetos

En la versión modificada de ButtonBlink usted debe ver el valor de regreso dt incluido en el sumario y la vista de documentación. Hacer un hábito en definir valores de regreso cuando se declaran métodos que pueden llamarse dentro de la expresión hará más fácil entender y reusar sus objetos.

Indexando Identificación del Cog Como se menciono anteriormente los objetos no pueden predecir necesariamente cual Cog será iniciado en un método. El comando cognew regresa la identificación del Cog donde se ejecuta un método. Cada vez que un método se inicia en un Cog nuevo la identificación 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 aplicación que inicia un Nuevo Cog cada vez que el botón se presiona y se suelta. Usa el mismo método ButtonTime del objeto ejemplo anterior para medir el tiempo que el botón se presiono. Luego inicia el método Blink en un nuevo Cog con la medida time determinando la frecuencia de parpadeo. El resultado es una aplicación donde cada vez que se presiona y se suéltale botón otro LED comienza a parpadear a la frecuencia que coincide con el tiempo que se presiono el botón. Después 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 botón P23 13 veces el ciclo comenzara con el mismo efecto que el de la primera vez.



Cargue CogStartStopWithButton.spin en el chip Propeller y use el botón P23 para iniciar el método Blink en los otros seis Cogs.

Presione por diversos tiempos para que el LED obviamente parpadee a diferente frecuencia Asegúrese de presionar/soltar el botón P23 al menos 12 veces para iniciar y después apagar

los Cogs del 1 al 7. '' Archivo: CogStartStopWithButton.spin '' Inicia métodos en Cogs y detiene Cogs en las estructuras de ciclo que '' avanzan por pulsación de botón VAR long stack[60] PUB ButtonBlinkTime | time, index, cog[6] repeat repeat index from 0 to 5 time := ButtonTime(23) cog[index] := cognew(Blink(index + 4, time, 1_000_000), @stack[index * 10]) repeat index from 5 to 0 ButtonTime(23) cogstop(cog[index]) PUB Blink( pin, rate, reps) dira[pin]~~ outa[pin]~ repeat reps * 2 waitcnt(rate/2 + cnt) !outa[pin] PUB ButtonTime(pin) : delta | time1, time2 repeat until ina[pin] == 1 time1 := cnt repeat until ina[pin] == 0 time2 := cnt delta := time2 - time1

Dentro de ButtonBlinkTime El método 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 declaración del método repite el resto de los comandos en el método ya que están indentados. Debido a que este comando repeat no tiene condiciones el resto de los comandos en el método 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 presión del botón



cada vez que se llama. La siguiente línea 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 identificación del Cog para cada Cog en la cual se inician diferentes versiones de Blink. repeat index from 0 to 5 time := ButtonTime(23) cog[index] := cognew(Blink(index + 4, time, 1_000_000), @stack[index * 10]) Después de presionar/soltar seis veces entra a este ciclo repeat. Observe como se llama al método ButtonTime, pero su valor de regreso no se almacena en la variable time. Eso es porque el método se usa únicamente para esperar por la siguiente vez que se presiona/suelta el botón 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 identificación almacenada en cog[5]. La segunda vez apagara el Cog con la identificación en cog[4], y así sucesivamente hasta el cog[0],. repeat index from 5 to 0 ButtonTime(23) cogstop(cog[index])

Tiempo de Estudio

Preguntas 1) ¿Qué sucede si un método que fue llamado se queda sin comandos? 2) ¿Cuántos parámetros se pueden pasar a un método? 3) ¿Cuántos valores tiene un regreso de método? 4) ¿Cómo se determina el valor que regresa un método? 5) ¿Cuales dos argumentos necesita cognew para iniciar un método en un nuevo cog? 6) ¿Cuál es la diferencia entre la Pila del Cog 0 y las pilas de otros Cogs? 7) ¿Cuál es la diferencia entre cognew y coginit? 8) ¿Cómo puede detener un Cog? 9) ¿Cuando se llama un método que valores se copian a la pila del Cog? 10) ¿Qué puede suceder en la pila conforme se ejecutan los comandos en un método? 11) ¿Qué le pasa a la Pila durante las llamadas de métodos anidados? 12) ¿Cuál es la mejor forma de evitar problemas con la pila cuando estas iniciando un método

prototipo que corre en un Cog? 13) ¿Qué característica 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 declaración pública para un método de nombre SquareWave que espera

parámetros de nombre pin, tHigh, y tCycle, regresa success y tiene variables locales tC and tH.

2) Escriba una llamada al método 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 método SquareWave.

4) Declare una variable de nombre para almacenar la identificación del Cog donde se corre el método SquareWave.

5) Inicie el método SquareWave en un Cog Nuevo y almacene la identificación del Cog en la variable swCog con la dirección de arranque de la variable swStack.

6) Corra el método SquareWave en el Cog 5. 7) Modifique la declaración de la variable swStack para iniciar tres copias del método

SquareWave en Cogs separados. Recuerde esto es para prototipo y el espacio de pila no requerida será acomodado después (En la práctica de objetos)

8) Modifique la declaración de la variable swCog para almacenar tres identificaciones de Cogs diferentes,

9) Inicie tres copias del método SquareWave en Cogs separados. Aquí hay una lista de parámetros para cada método 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 método SquareWave descrito en la sección de ejercicios. Asegúrese de

incorporar las técnicas de código para prevenir inexactitudes debido al tiempo de ejecución de comandos de los cuales se hablo en la práctica de E/S y tiempo. (Tenga en cuenta que hay mejores formas de desarrollar ondas cuadradas que serán revisadas en prácticas de Contadores y Lenguaje Ensamblador)

2) Escriba un programa para probar el método SquareWave usando diversas características de la sección de ejercicios.

3) Más experimentos: Quizá haya notado que el Pin 9 brilla poco. Si usted decrementa el término tHigh incrementando el denominador será más bajo. Si incrementa el término tHigh decrementando el denominador entonces brillara mas. Asegúrese que tHigh es más pequeño que tCycle, de otra forma el programa no trabajara como se pretende. Inténtelo.

6: Práctica de Objetos


6: Practica de Objetos

Introducción En prácticas anteriores todas las aplicaciones de ejemplos de código eran para objetos individuales. Sin embargo las aplicaciones son organizadas en colecciones de objetos. Cada aplicación tiene un objeto superior, el cual es donde se inicia la ejecución del código. Los objetos superiores pueden declarar y llamar a métodos en uno o más objetos. Esos objetos pueden en su turno declarar y llamar métodos en otros objetos y así sucesivamente… Muchos objetos son incorporados en aplicaciones diseñadas para simplificar desarrollos. Algunos de estos objetos son colecciones de métodos prácticos que han sido publicados por lo que tareas comunes de código 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 práctica de métodos y Cogs, incluyendo declaración de valores de pila y rastreo de en que cog se inicio el proceso. Estos objetos que administran Cogs también tienen métodos de arranque y paro de procesos. Hay diferentes fuentes donde puede obtener objetos útiles que pueden ser incorporados en su aplicación, incluyendo la librería 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 documentación típicamente que explica como incorporarlo en su aplicación junto con uno o más ejemplos de archivos superiores que demuestran como declarar el objeto y llamar su método. Además de usar los objetos pre-escritos usted querrá modificar un objeto existente para usarlo de acuerdo a su aplicación 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 práctica lo guía a través de escrituras de varios objetos y la incorporación de ellos es sus aplicaciones. Algunos objetos son solo colecciones de métodos útiles mientras que otros administran procesos iniciados en Cogs. Algunos de los objetos serán escritos desde el principio y otros usaran la librería Propeller como recurso. Los ejemplos de aplicaciones lo guiara a través de:

• Llamar métodos en otros objetos • Usar objetos que inician procesos en Cogs • Escribir código que llama un método de un objeto basado en su documentación • Escribir documentación de objetos y esquemáticos • Usar objetos de la Librería Propeller de Objetos • Accesar valores y variables por su dirección de memoria • Usar objetos para iniciar Cogs que leen y/o actualizan las variables de los objetos padre

Prerrequisitos para la Practica • Configuración y Prueba • E/S y Tiempo • Métodos y Cogs

Práctica de Objetos


Equipo, Partes y Esquemas Aun cuando el circuito es el mismo que se uso en prácticas anteriores hay algunos cambios. Primero, el esquemático 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 documentación de objetos. Segundo, algunos de los ejemplos de código le permiten monitorear y controlar elementos del circuito desde su PC con el programa incluido en esta práctica que se llama Terminal Serial Parallax (PST.exe). Las aplicaciones Propeller que se comunican serialmente con la Terminal Serial Parallax lo harán con la ayuda de un objeto llamado FullDuplexSerial.spin.

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

Figura 6-1: Esquemático (Dibujado con el Programa de la Herramienta Propeller)



Revisión de la llamada a método El objeto ButtonBlink de abajo es un ejemplo de la práctica de Métodos y Cogs. Cada vez que presiona y suelta el botón conectado a P23 el objeto mide el tiempo aproximado que se presiono y usa este valor para determinar el periodo completo de encendido/apagado, después el LED parpadea diez veces. (El botón de eliminación de rebotes no se requiere con los botones del PE kit). El objeto cumple estas tareas llamando otros métodos en el mismo objeto. El código en el método Main llama al método ButtonTime para medir el tiempo que se presiono el botón. Cuando ButtonTime regresa un valor el método Blink se llama, con uno de los parámetros siendo el resultado de la medición de ButtonTime.

Cargue ButtonBlink.spin en el chip Propeller y pruébelo para asegurarse que puede usar el botón en P23 para programar el periodo de parpadeo del LED

'' 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 waitcnt(rate/2 + cnt) !outa[pin] PUB ButtonTime(pin) : dt | t1, t2 repeat until ina[pin] t1 := cnt repeat while ina[pin] t2 := cnt dt := t2 - t1

Llamando Métodos en otros Objetos con la Notación Dot Los métodos ButtonTime y Blink del objeto ButtonBlink nos dan un ejemplo simple del código que puede ser útil en diferentes aplicaciones. Estos métodos pueden almacenarse en archivos objetos separados y después cualquier objeto que lo necesite para hacer parpadear un LED o medir una pulsación de un botón puede accesar estos métodos siguiendo estos dos pasos:

1) Declarar el objeto en un código de bloque OBJ, y dar un apodo al archivo del objeto. 2) Use ObjectNickname.MethodName para llamar al método del objeto.

Lo que se llama Notación Dot aquí se refiere como “referencia método-objeto” en el Manual Propeller.



La Figura 6-2 muestra un ejemplo de cómo funciona. Los métodos ButtonTime y Blink se movieron a un objeto llamado ButtonAndBlink. Para tener acceso a los métodos públicos 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 código de bloque OBJ del objeto DotNotationExample. La declaración PbLed : "ButtonAndBlink" le da un apodo PbLed al objeto ButtonAndBlink. La declaración PbLed hace posible para el objeto DotNotationExample llamar métodos en el objeto ButtonAndBlink usando la notación ApodoObjeto.Nombre Método. Así DotNotationExample usa time := PbLed.ButtonTime(23) para llamar el método ButtonTime de ButtonAndBlink, pasa el parámetro 23 y asigna el resultado regresado a la variable time. DotNotationExample también usa el comando PbLed.Blink(4, time, 20) para pasar 4, el valor almacenado en la variable time y 20 al método Blink de ButtonAndBlink.

Ubicación 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 comúnmente se refiere como librería de objetos.

Figura 6-2: Llamando Métodos en otros Objetos con la Notación Dot

Cargue el objeto DotNotationExample en el chip Propeller. Si usted está ingresando el código manualmente asegúrese que ambos archivos están en el mismo directorio. También el nombre del archivo del objeto ButtonAndBlink debe ser ButtonAndBlink.spin.

Verifique que el programa hace lo mismo que el objeto del ejemplo anterior (ButtonBlink). Siga los pasos en la Figura 5-4 y asegúrese que está claro como ButtonAndBlink obtiene un

apodo en la sección OBJ y como se usa ese apodo por DotNotationExample para la llamada de método en el objeto ButtonAndBlink.

Compare DotNotationExample.spin con el objeto ejemplo anterior (ButtonBlink).

Organización 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 Información del Objeto con la característica Compilar de la Herramienta Propeller:

'' Archivo: ButtonAndBlink.spin '' Objeto Ejemplo con dos metodos PUB ButtonTime(pin): delta | time1, time2 repeat until ina[pin] == 1 time1 := cnt repeat until ina[pin] == 0 time2 := cnt delta := time2 - time1 PUB Blink( pin, rate, reps) dira[pin]~~ outa[pin]~ repeat reps * 2 waitcnt(rate/2 + cnt) !outa[pin]

'File: DotNotationExample.spin OBJ PbLed : "ButtonAndBlink" PUB Main | time repeat time := PbLed.ButtonTime(23) PbLed.Blink(4, time, 20)

Llamada a método con ApodoObjeto.NombreMetodo

Declaracion de Objeto



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 información 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. También puede presionar dos veces en la carpeta para abrir el archive Spin que contiene el código. Como la aplicación DotNotationExample declaro a ButtonAndBlink el código ButtonAndBlink ahora es parte de DotNotationExample por lo que este parece tener más código que ButtonAndBlink en la ventana de información, aun cuando tiene mucho menos código escrito. Figura 6-3: Ventana de Información del Objeto

Después de cerrar la ventana de información 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. También puede ver un objeto en modo de documentación al presionar el botón derecho del ratón sobre la carpeta. Puede presionar el botón izquierdo para regresar al modo de vista completa. Figura 6-4: Herramienta Propeller con Vista del Objeto (Ventana Superior Izquierda)



Objetos que pueden iniciar Procesos en Cogs En la práctica de métodos nos tomo varios pasos para escribir un programa que inicia un método en un Cog. En primer lugar tenían que declararse variables adicionales para darle al Co su memoria de pila y rastrear cual Cog corría un proceso antes de poder usar los comandos cognew o cogstart. También se requería una variable que almacena la identificación de los Cogs para escoger el Cog apropiado por si el programa tenía que parar un proceso después 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 método Start que inicializa el método Blink en un Cog nuevo y todas las variables que las acompaña. De esta forma todo lo que tiene que hacer el objeto superior es llamar al método 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 botón 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 botón nuevamente para cambiar el periodo (para las siguientes 20 veces). Hay dos razones. La primera porque el objeto Blinker automáticamente inicia el proceso de parpadeo del LED en un Cog nuevo. Esto libera al Cog 0 para que siga monitoreando el botón mientras que el Cog 1 hace parpadear el LED. La segunda el método Start del objeto Blinker automáticamente 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 método Blinker.Start para cualquier proceso (Cog) que pudiera estar corriendo antes de iniciar el nuevo proceso.

Si está usando archivos .spin pre-escritos disponibles para este texto (ver la pagina 17) todos están en la misma carpeta. Si usted está escribiendo el código asegúrese de guardar los tres archivos en la misma carpeta. Los objetos que tiene que guardar son CogObjectExample (arriba), Blinker, y Button (ambos abajo).

Cargue CogObjectExample en el chip Propeller. Intente presionar y soltar el botón en P23 para que haga parpadear el LED despacio. Antes del parpadeo 20 presione y suelte rápidamente el botón en P23. El LED deberá

parpadear más rápido inmediatamente.

Dentro del Objeto Blinker Construir cloques de objetos que inician procesos en Cogs se escriben típicamente para cuidar la mayoría de los detalles de grabación del Cog. Todos los objetos padres es declarar el objeto y luego inicializar el objeto llamando el método Start del objeto o detenerlo llamando el método 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 método Blink en otro Cog. También tiene una variable llamada cog para mantener el historial de en cual Cog se inicio el método Blink. El objeto Blinker tiene los métodos Start y Stop para iniciar el ahora método familiar Blink en un nuevo Cog y detenerlo nuevamente. Cuando el método Start inicia el método Blink en un nuevo Cog toma la identificación del Cog que regresa cognew, agrega 1 y copia el valor del resultado en la variable cog. El valor que regresa el método Start en la variable success también 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 típicamente cuando los ocho Cogs del chip Propeller están en uso. El método 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 identificación correcta del Cog que detendrá el Cog donde el método Start inicio el método Blink. Archivo: Blinker. Spin Ejemplo de administración 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 'Identificación del Cog PUB Start(pin, rate, reps) : success Inicia nuevo proceso blinking en Cog Nuevo; regresa True si tiene éxito. Parámetros: pin La E/S conectada al circuito LED → ver esquemático 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) PUB Blink(pin, rate, reps) Parpadea un circuito LED conectado al pin a una frecuencia dada por reps. Parámetros: pin La E/S conectada al circuito LED → ver esquemático rate Tiempo de ciclo de encendido/apagado definido por ciclo de reloj reps el número de ciclos de encendido/apagado dira[pin]~~ outa[pin]~ repeat reps * 2 waitcnt(rate/2 + cnt) !outa[pin]



Los métodos Start y Stop mostrados en este objeto es el alcance recomendado para objetos que administran Cogs. La lista de parámetros del método Start debería tener todos los parámetros que el proceso necesita para iniciarse en un Cog. Note que esos valores se pasan al método del objeto Blink a través de la llamada en el comando cognew. Los métodos Start y Stop se usan por convención en objetos que inician procesos en nuevos Cogs. Si está usando un objeto con métodos Start y Stop puede esperar que el método Start del objeto inicie el proceso en un nuevo Cog por usted y que el método Stop detenga el proceso y libere un Cog. Si está escribiendo código que depende de objetos construidos en bloques con métodos Start y Stop su principal problema será llamar al método Start desde un objeto padre y pasar los parámetros correctos. Estos parámetros se explican en los comentarios de documentación los cuales se revisaran en la sección de Comentarios de en la página 90. Los métodos Start y Stop también rastrean en cual Cog se inicio el proceso (el método Blink en el caso de Blinker. Spin). Si todos los Cogs están en uso el método Start regresa un 0; de otra forma regresa la identificación del Cog + 1 lo cual es un no-cero. Esto simplifica el trabajo del de verificar y encontrar si el método Start inicio correctamente el proceso en el nuevo Cog. Especialmente si el objeto padre ha llamado a métodos 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 método Start del objeto Blinker se desempeño correctamente como: if Blinker.Start 'Inserte el código si se inicio correctamente else 'Inserte código aquí si fallo la inicialización El código 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 método Blinker.Start regresa un cero indica que no fue posible iniciar el cog, lo cual puede suceder si todos los Cogs están ocupados. En este caso el código debajo de la condición else indentada se ejecutara. Una práctica común entre autores de bloques de objetos es copiar y pegar el ejemplo y Stop de los métodos del Manual Propeller o de este texto en los objetos que escriben. Después ajustan la lista de parámetros del método Start y la documentación necesaria. No solo hacen los ejemplos de los métodos Start y Stop de acuerdo a la convención de los métodos Start y Stop en la librería de objetos discutidos en la página 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 atención a la siguiente sección. De otra forma brínquese la sección El Objeto Button que empieza en la pagina 89.

Área Avanzada: Dentro de los métodos Start y Stop Cuando un método Spin se inicia desde otro Cog, además del arreglo de pila necesita declarar una variable cog en el objeto Blinker. Esta variable global es accesible para todos los métodos en el objeto, así el método Start puede almacenar un valor en esta variable que corresponde al Cog que fue ejecutado, y el método 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 método Start regresa la identificación 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 métodos Start y Stop tienen que hacer más trabajo de administración para rastrear el numero de Cog que está



corriendo el proceso (en caso de que su código decida parar después) mientras aun regresa valores que indican la inicialización del Cog (no-cero) o el fallo de inicio (0). En caso de que el objeto padre llame al método Start dos veces seguidas sin llamar al método Stop la primer cosa que hace el método Start es llamar al método Stop. Después el método Start usa el comando cognew para iniciar el método 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 Identificación de Cog + 1, lo cual es 0 si el método Blink no se inicio en un Cog y un no-cero si el comando cognew tuvo éxito. PUB Start(pin, rate, reps) : success ... Stop success := (cog := cognew(Blink(pin, rate, reps), @stack) + 1) ' ' 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 método Start fue llamar al método Stop. Recuerde: La variable del Cog almacena 0 si su proceso (El método Blink) no está corriendo en otro Cog, o Identificación del Cog + 1 si el proceso de administración del objeto esta activo. Si el Cog no se inicio o si el método Stop se llamo la variable cog almacenara un 0. En este caso se saltara el código debajo de la condición if y el método Stop regresara sin tomar otra acción. Si en vez de esto la variable cog almacena la Identificación + 1 la condición if empieza restando 1 de la variable cog de esta forma regresamos al valor de Identificación del Cog. El comando cogstop usa este valor para detener el Cog adecuado, el cual es el que se inicio por el método Start en un tiempo anterior. La última cosa que el método Stop hace es usar el operador Post-Limpiar ~ para dejar Cog en cero para que todo funcione correctamente la próxima vez que se llame a un método Start o Stop. Pub Stop '' ... ' 0 si no se ha iniciado un cog por el método start, ' 1 a 8 si se inicio un Cog por el método 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 también usa el objeto Button el cual hasta el momento tiene solo un método, pero puede expandirse en una colección de métodos útiles. Note que esta versión del objeto Button no inicia ningún proceso nuevo en Cogs así que no tiene un método Start o Stop. Todo lo que hace el objeto Button se hace en el mismo Cog del objeto que lo llama. Este objeto podría modificarse en diversas formas. Por ejemplo se podría agregar otro método relacionado con botón. El objeto podría modificarse para trabajar con un botón o grupo de botones. Podría agregarse un método Init o Config para programar el objeto y monitorear automáticamente un botón o grupo de botones. El objeto podría también modificarse para monitorear estos botones en un Cog separado, pero en ese caso se deberían agregar los métodos Start y Stop.



'' Archivo: Button.spin '' Comienza un objeto útil. PUB Time(pin) : delta | time1, time2 repeat until ina[pin] == 1 time1 := cnt repeat until ina[pin] == 0 time2 := cnt delta := time2 - time1

Reglas para Métodos Start y Stop en Librerías de Objetos Si un objeto se diseña como bloque de construcción para iniciar otros objetos en un Cog este deberá tener métodos Start y Stop. El método Start cuidara de iniciar el Cog. Si inicia un método spin en un Cog nuevo el método Start usa el comando cognew para pasar la llamada a método y la dirección de la variable global del arreglo de pila del objeto al Cog. También graba el Cog en el que el método se inicio con una de las variables globales del objeto, típicamente un byte variable de nombre cog. El método Stop encuentra cual Cog necesita detenerse verificando la misma variable cog. La regla del método Start y Stop en objetos de construcción de bloques que inician Cogs fue establecida por Parallax para mantener una línea de usuario simple y consistente. También ofrece al diseñador del objeto un lugar para cuidar del espacio de pila y numero de Cog para el objeto. Si usted usa un objeto de la librería Parallax o del intercambio de Objetos Propeller que inicia un Cog, este deberá tener los métodos Start y Stop que cuidan de estos detalles. Así todo lo que sus aplicaciones tienen que hacer es llamar al método Start del objeto y pasar los parámetros que necesita. La librería de objetos cuida de lo demás y debe proporcionar métodos y comentarios de documentación que simplifiquen el monitoreo y control del proceso que está ocurriendo en el Cog que se inicio.

Nunca use cognew o coginit para iniciar un método que está en otro objeto. Los comandos connew y coginit solo pueden iniciarse en un método spin en un nuevo cogsi está en el mismo objeto que el comando. Esta es otra razón por la cual construir objetos de construcción de bloques que inician cogs deberá contener siempre los métodos start y stop. El comando cognew se localiza en el método start del objeto asegurándose 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 método 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 método recomendado para configurar variables de objetos si no inicia un cog es Init o Config. No use el nombre de método start en este tipo de objetos porque podría llevarlo a pensar que inicia un cog. Del mismo modo no use start como nombre de método al principio del código de su aplicación. En su lugar utilice en método Go si nada más descriptivo viene a su mente.

Comentarios de Documentación La Figura 6-5 muestra la primera parte del objeto Blinker desplegado en vista de documentación. Para ver el objeto en esta modalidad asegúrese que está en el tabulador activo (presione el tabulador con el nombre de archivo Blinker), después presione el botón de radio Documentation justo arriba del código. Recuerde de la practica E/S y tiempo que una línea sencilla de comentarios de documentación es precedida por dos apostrofes: ''comment, y que los comentarios de documentación que ocupan más de una línea se inician y terminan con dobles llaves: comments. De un vistazo a los comentarios de documentación en modo de fuente completa y compárelos con los comentarios en modo de documentación.



La vista en modo de documentación agrega automáticamente alguna información que está en los comentarios de documentación. Primero está la línea de información del objeto, el cual es una lista de las declaraciones del método público del objeto incluyendo el nombre del método, lista de parámetros y valores de regreso. Esto le da al programador una vista d los métodos del objeto. Con esto en mente es importante escoger nombres descriptivos para un método de objeto, parámetros de método y valores de regreso. El modo de documentación también proporciona cuanta memoria agregara el objeto a un programa y cuanto toma para las variables. Estas por supuesto son importantes para características de vista rápida.

Figura 6-5: Vista de Documentación

El modo de vista de documentación también inserta cada declaración de método (sin variables locales no se usan como parámetros o variables de regreso). Note como también aparecen los comentarios de documentación debajo de la declaración del método y lo que hace el método, que información deberán recibir sus parámetros y que regresar. Cada documentación de método público deberá tener suficiente información para un programador sin tener que mover de regreso a la vista completa y hacer ingenieria inversa al método y tratar de adivinar que es lo que hace. Esta es otra buena razón para escoger los nombres de métodos y parámetros cuidadosamente ya que ayudara a hacer los comentarios más concisos. Con los comentarios de documentación debajo de cada declaración de método público explique qué hace el método. Explique cada parámetro, empiece con su nombre e incluya cualquier información adicional acerca de los valores que el parámetro tiene que recibir. Haga lo mismo para valores de regreso.

Intente agregar un comentario de documentación de bloque justo abajo del método ButtonBlinkTime del objeto CogObjectExample y verifique que la documentación aparece debajo de la declaración del método en el modo de vista de documentación.

Figura 6-6: Mas vista de documentación



Dibujando esquemáticos La fuente Parallax tiene símbolos para dibujar esquemáticos y deberán usarse para documentar los circuitos para los que los objetos fueron diseñados. La herramienta de caracteres se muestra en la Figura 6-7. Además de los símbolos para dibujar esquemáticos tiene símbolos para diagramas de tiempo , operadores matemáticos ± + - × ÷ = ≈ √ ¹ ² ³, y símbolos griegos para cantidades y medidas ω μ δ σ π.

Presione Help y seleccione View Character Chart. Presione el botón symbolic Order Coloque el curso en un área de comentario en el objeto 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 deberán tener esquemáticos para que también el circuito pueda hacerse y probarse. Por ejemplo el esquemático mostrado en la Figura 6-8 puede agregarse para CogObjectExample. El botón puede ser engañoso. La grafica que se muestra en la Figura 6-8, muestra el orden regular (presione el botón Standard Order). En este orden el carácter 0 es el superior izquierdo, carácter 1 el siguiente y así sucesivamente hasta llegar al carácter 255 en la inferior derecha. Esta es una lista de los caracteres que necesitara:

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

Intente agregar el esquemático mostrado en la Figura 6-8 a su copia de CogObjectExample.



Figura 6-8: Dibujando esquemáticos con el mapa de caracteres

Métodos Públicos vs. Privados El objeto Blinker está escrito para que su objeto padre pueda llamar al método 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 método Start el objeto padre llama al método Blink directamente.

Modifique una copia de CogObjectExample para que llame al método Blink del objeto Blinker en vez del método Start.

La versión modificada no lo dejara interrumpir el parpadeo del LED para reiniciar una nueva frecuencia. Esto porque todo el código se ejecuta en el mismo Cog mientras que la versión no modificada le permite llamar al método 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 botón. Algunos objetos se escriben para tener métodos públicos (PUB) que pueden llamarse por otros objetos y métodos privados (PRI) que solo pueden llamarse por otro método en el mismo objeto. Los métodos 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 métodos. Un método público puede recibir parámetros y luego llamar métodos privados en una cierta secuencia. Especialmente si llamando a esos métodos en la secuencia incorrecta podría llevar a resultados indeseables, esos otros métodos deberían ser privados.



Con el método Blink del objeto Blinker no hay razón actual para hacerlo privado fuera de examinar que sucede cuando un objeto padre intenta llamar otro método privado de objeto.

Cambie el método Blink del objeto Blinker de PUB a PRI. Intente correr la copia modificada de CogObjectExample y observe los mensajes de error.

Esto demuestra que el método Blink no puede accesarse por otro objeto ya que es privado. Corra la copia no modificada (la cual solo llama al método publico Start, no al método

privado Blink) y verifique que aun trabaja apropiadamente. Esto demuestra como el método privado Blink aun puede ser accesado del mismo objeto (Blinker) por su método Start.

Ejemplo de Múltiples Objetos Los objetos Spin que inician y administran uno o más cogs para un proceso dado son escritos típicamente para una sola copia del proceso. Si la aplicación necesita más de una copia de los procesos corriendo actualmente simplemente se puede declarar más 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 aplicación necesita controlar más de una TV entonces se declaran más de una copia del objeto TV.

¿Copias múltiples de Objetos? No hay Problema!

No hay penalizaciones para el espacio de código por declarar múltiples objetos. El compilador de la herramienta Propeller los optimiza así que solo se ejecuta el código una vez por todas las copias de los objetos. La única penalización para declarar más de una copia del mismo objeto es que habrá más de una copia de variables globales que declara el objeto, un paquete por cada objeto. Como más o menos se necesitan el mismo número de variables extras por una aplicación dada para hacer el mismo trabajo sin objetos, realmente no es una penalización.

El objeto MultiCogObjectExample demuestra cómo se pueden iniciar múltiples 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 también 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 método Start del objeto. El objeto MultiCogObjectExample es funcionalmente equivalente al objeto CogStartStopWithButton de la practica Métodos 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 duración del tiempo que se presiona el botón. De la primera a la sexta vez que se presiona el botón inicia el proceso de parpadeo de LED en nuevos cogs, de la séptima a la decimo segunda detiene cada cog en sentido contrario al que se arrancaron.

Cargue el objeto MultiCogObjectExample.spin en el chip Propeller Presione y suelte el botón P23 seis veces sucesivas (cada una con diferente duración) y

verifique que los seis cogs se iniciaron correctamente. Presione y suelte el botón en P23 seis veces más 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 repeat index from 0 to 5 time := Button.Time(23) Blinker[index].Start(index + 4, time, 1_000_000) repeat index from 5 to 0 Button.Time(23) Blinker[index].Stop

Comunicación 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 información de diagnósticos para pruebas de sistemas y depurado. La comunicación Terminal/Chip Propeller involucra un programa en la Computadora y el código del micro controlador. Para la computadora utilizaremos el programa Parallax Serial Terminal el cual se verá a continuación. Para el código del micro controlador haremos uso de objetos que atienden señales eléctricas y conversiones entre valores binarios y sus representaciones en carácter para poder enfocarnos en aplicaciones de escritura. Conforme desarrolle aplicaciones que hagan uso de objetos de comunicación serial considere como esos objetos disponibles simplifican la escritura de programas. Se da un ejemplo de cómo usando objetos de la Librería Propeller, Intercambio de Objetos Propeller y el foro del Chip Propeller hace posible hacer mucho con unas pocas líneas de código.

Terminal Serial Parallax El programa de la terminal serial Parallax (PST.exe) mostrado en la Figura 6-9 es una herramienta adecuada para la comunicación chip Propeller/Computadora. Muestra texto y mensajes numéricos del chip Propeller y también permite enviar mensajes similares al chip Propeller.

Si aun no lo ha hecho vaya a Programas, Documentación y Recursos (página 17) Y siga las instrucciones para descargar y preparar la Terminal Serial Parallax.

Este programa tiene una ventana de transmisión que envía los caracteres que usted teclea al chip Propeller y una ventana de recepción que muestra los caracteres que son enviados por el chip Propeller. Tiene menús para el Puerto de Comunicación y la Velocidad de Transmisión así como indicadores de actividad y selectores de controles para los diversos canales (TX, RX, etc). También hay un selector Echo On que esta seleccionado automáticamente para que los caracteres que ingresan a la ventana de transmisión también aparezcan en la ventana de recepción.



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 conexión al Puerto serial Parallax (Disable/Enable)

Figura 6-9: Terminal Serial Parallax

El botón 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 botón 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 botón muestra Enable. Después que cargo el programa usted puede presiona el botón Enable para regresar a la comunicación entre la Terminal y el chip Propeller.

Programar automáticamente Habilitar/Deshabilitar

En Prefs → Serial Port Selection por defecto las opciones Automatically Disable y Wait for Busy están seleccionadas. Con estos parámetros usted puede presionar en el programa de la herramienta Propeller, cargar un programa e inmediatamente presionar el botón Enable para reconectar. No hay necesidad de presionar Disable antes de cambiar la herramienta a carga de programa porque la Terminal Parallax se desconectara automáticamente 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 Comunicación)

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 botón 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 prácticas 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 categorías. La característica Automatically Disable hace que la Terminal Parallax este deshabilitada automáticamente 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 botón 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 características 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.

Cuando deshabilitar el parámetro Automatically disable…:

El parámetro Automatically disable… es muy conveniente para modificar el código con la Herramienta Propeller y observar los resultados en la Terminal Serial Parallax. EL evento que dispara el automático 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 algún otro programa tal como una hoja de datos para análisis de medición de un sensor con el parámetro Automatically disable… cada vez que presione en otra ventana la Terminal Serial automáticamente 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 conexión del Puerto serial mientras usted trabaja con otra ventana deshabilite el parámetro 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 parámetro no seleccionado usted tendrá que presionar manualmente el botón Disable antes de cargar un programa y Enable después de que el programa se cargo.

El botón de edición 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 también puede presionar con el botón derecho para incluir o excluir la entrada o incluso crear reglas para incluir o excluir puertos basado en el texto de la columna de descripción.



Mensajes de Prueba en la Terminal Serial Parallax La Figura 6-12 muestra la aplicación HelloFullDuplexSerial en la izquierda y los mensajes repetidos que envía 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 método start del objeto FullDuplexSerial con start y luego repetidamente llama el método str (string) con Debug.str en un ciclo repeat. Vamos a probar primero y luego ver más de cerca al objeto FullDuplexSerial, sus características y métodos. 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. También tendrá que seleccionar el Baud Rate igual al que usa el programa Spin. Después de eso solo cargue la característica Load EEPROM de la herramienta Propeller para cargar el programa en la EEPROM del chip Propeller y presione el botón Enable de la Terminal Serial Parallax para ver los mensajes

Abra HelloFullDuplexSerial.spin con la Herramienta de Programación Propeller Abra la Terminal Serial Parallax (presione dos veces en PST.exe para correrlo) Conecte la batería a su Plataforma PE y verifique que está conectada a la computadora con el

cable USB. En la herramienta Propeller presione Run, y seleccione Identify Hardware… (F7). Tome nota

del COM port donde se encontró el chip Propeller. Introduzca el COM port en el campo de la izquierda inferior de la Terminal Parallax,

asegúrese que es el mismo que encontró en el paso anterior. Verifique el parámetro baudrate en la llamada a método Debug.start para encontrar la

velocidad de transmisión (Actualmente es 57600). Coloque la velocidad de transmisión en la terminal Parallax para que sean iguales (a 57600). En la herramienta Propeller use F11 para cargar HelloFullDuplexSerial.spin en la EEPROM

del chip Propeller. En la Terminal Parallax presione el botón Enable para iniciar el desplegado de mensajes del

chip Propeller.



''HelloFullDuplexSerial.spin ''Prueba de mensaje a la Terminal Serial Parallax. CON _clkmode = xtal1 + pll16x _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)) waitcnt(clkfreq + cnt)

!

¡NOTA IMPORTANTE CUANDO EL CHIP PROPELLER NO ESTE CONECTADO A LA COMPUTADORA!

Si el chip Propeller está corriendo una aplicación pero no está conectado a la Computadora el código 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 señal 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 línea DTR que en su turno reinicia el chip Propeller.

La solución para la versión 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 intención 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 solución diferente. Antes de correr alguna aplicación que no está conectada a la Computadora con el cable USB asegúrese de remover todo el código que intente enviar mensajes a la Computadora. Esto previene que la aplicación misteriosamente se reinicie cuando la Plataforma PE no está conectada a la Computadora.

Cambiando Velocidad de Transmisión Si la velocidad de transmisión es la misma usted puede seleccionar la velocidad que mejor funcione para su aplicación. Por ejemplo usted puede cambiar la velocidad de 57.6 a 115.2 kbps como sigue:

En la herramienta Propeller modifique la llamada a método start del objeto HelloFullDuplexSerial para que pase el valor de 115200 al parámetro baudrate del método start del objeto FullDuplexSerial como sigue: Debug.start(31, 30, 0, 115200)

Cargue la versión modificada de HelloFullDuplexSerial en el chip Propeller. Escoja 115200 en la Terminal Serial Parallax del menú Baud Rate. Presione el botón Enable en la Terminal Serial Parallax Verifique que con la nueva velocidad los mensajes aun se muestran en pantalla. Asegúrese de cambiar los parámetros de regreso a 57600 en ambos programas y antes de

continuar asegúrese que aun trabajan.



FullDuplexSerial y otros objetos de la Librería El objeto FullDuplexSerial simplifica mayormente el intercambio de datos entre el Propeller y componentes Periféricos que se comunican con protocolos seriales asíncronos como RS232. Solo unos ejemplos de equipos que pueden conectarse al Propeller incluyen Computadoras, otros micro controladores, módems, el LCD Parallax y el modulo Pink Ethernet.

Comunicación Serial: Para mayor información acerca de comunicación serial asíncrona vea los artículos de Comunicación Serial y RS232 en Wiki pedía.

Serial-sobre-USB: Para mayor información acerca de la forma en la que el chip FT232 en el Propeller Plug y el ProStick USB envía datos seriales sobre una conexión USB vea la versión de Programación y Prueba del PropStick USB.

Como se menciono anteriormente un código en un objeto puede declarar otro objeto si:

• Los dos objetos están 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 librería Propeller:

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 librería propeller aparecerán 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 librería Propeller. Usted también puede ver estos archivos usando el Explorador de Windows. Asumiendo una instalación por defecto la ruta deberá ser C:\Program Files\Parallax Inc\Propeller Tool v1.2.

Figura 6-13: Código que declara una Librería Objeto

Cuando usa una librería objeto la primera tarea es examinar sus lineamientos para saber acerca de sus métodos y que puede hacer.

Presione dos veces sobre FullDuplexSerial en la herramienta propeller localizado en la parte baja izquierda, con esto usted podrá ver el contenido de la librería Propeller

Cuando la herramienta Propeller abre el objeto FullDuplexSerial presione el botón de Documentación para ver lo mostrado en la Figura 6-14.



Verifique la lista de métodos en la sección Interface del objeto “FullDuplexSerial” Baje el cursor y encuentre la documentación para el método start y str y examínelos. Se

usaran en el siguiente ejemplo. Figura 6-14: Vistas de Documentación del Objeto FullDuplexSerial

El objeto HelloFullDuplexSerial en la Figura 6-13 declara el objeto FullDuplexSerial dándole el apodo Debug. Entonces llama el método start del objeto FullDuplexSerial con el comando Debug.start(31, 30, 0, 57600). De acuerdo a la documentación programa los parámetros de E/S rxpin al pin 31, txpin al 30, mode en 0, y baudrate a 57600. Después de eso un ciclo repeat envía el mismo mensaje de texto a la Terminal Parallax cada segundo. El método Debug.str es el que transfiere la cadena "This is a test message!" a la memoria temporal. Después de eso FullDuplexSerial se encarga de enviar cada carácter sucesivamente en la cadena del chip FT232 el cual lo reenvía a la computadora a través del USB. Veamos más de cerca Debug.str(string("This is a test message!", 13)). Primero Debug.str llama al método str del objeto FullDuplexSerial. La declaración del método para el método str indica que el parámetro 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 documentación del método str no lo incluye (En realidad debería!) 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 dirección de inicio de la cadena. Debug.str pasa este parámetro al método str del objeto FullDuplexSerial. Entonces el método str envía caracteres hasta que ve un cero que lo finaliza.



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 línea 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 dónde queda almacenada la cadena en el programa con ayuda de la ventana de Información de la herramienta Propeller.

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 información que se muestra en la Figura 6-15.

Observe el texto en la columna de la derecha en la línea 4 y 5. El código hexadecimal ASCII ocupa las direcciones de memoria 0038 a 004F con el terminador 0 en la dirección 50.

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

Desplegando valores Observe nuevamente el objeto FullDuplexSerialen modo de documentación. (Vea la Figura 6-14 en la página 101). Observe que también tiene un método dec para mostrar números decimales. Este método toma un valor y lo convierte al carácter 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.

Modifique la declaración del mensaje del objeto HelloFullDuplexSerial agregando una declaración local variable: PUB TestMessages | counter

Modifique el ciclo repeat del objeto HelloFullDuplexSerial como se muestra: repeat Debug.str(String(13, "counter = ")) Debug.dec(counter++) waitcnt(clkfreq/5 + cnt)

Use la herramienta Propeller para cargar la versión modificada de HelloFullDuplexSerial en la EEPROM del chip Propeller (F11).

Vista amplia debajo.



Presione en el botón 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 botón 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 método 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 versión modificada de FullDuplexSerial con el nombre de FullDuplexSerialPlus. El objeto FullDuplexSerialPlus tiene los mismos métodos que FullDuplexSerial y otros mas como GetDec, GetBin, y GetHex. Los métodos adicionales pueden utilizarse para recibir la representación de caracteres decimales, hexadecimales y números binarios desde la Terminal Serial Parallax, convertirlos a sus valores numéricos y almacenarlos en variables. Como FullDuplexSerialPlus también tiene los mismos métodos que FullDuplexSerial llamadas como Debug.start, Debug.str, y Debug.dec siguen dando el mismo resultado.

FullDuplexSerialPlus Está incluido en la descarga de Practicas PE (Ver página 17) y una lista completa del código se proporciona en el apéndice A: Lista de Códigos de Objetos en la página 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 práctica. 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 declaración Debug : FullDuplexSerial se usa Debug : FullDuplexSerialPlus.

Abra ambos objetos FullDuplexSerial y FullDuplexSerialPlus en modo de documentación. Use la línea para observar cuales métodos se agregaron – hay 6 y los nombres de métodos

están en mayúsculas. Verifique la documentación para los nuevos métodos. Los comentarios para los otros

métodos se extendieron también, obsérvelos también.

Aplicación de prueba – EnterAndDisplayValues.spin El objeto EnterAndDisplayValues espera para que usted introduzca un valor en la ventana de transmisión de la terminal Parallax. Convierte el carácter a su valor equivalente numérico 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 envíe un cursor que se muestra en la ventana de recepción de la



Terminal. Después de teclear un valor decimal en la ventana de transmisión 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 representación decimal, hexadecimal y binaria.

Cargue EnterAndDisplayValues.spin en la EEPROM (F11) e inmediatamente presione el botón Enable de la Terminal Propeller.

La aplicación de dará dos segundos para conectar la Terminal Parallax al presionar el botón Enable. Si usted no ve el mensaje “Enter a decimal value:” quizá no presiono a tiempo el botón Enable. Usted puede reiniciar la aplicación presionando el botón de reinicio de la plataforma PE. Usted también puede reiniciar el chip Propeller al seleccionar y deseleccionar la línea DTR.

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 números 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.

Ingrese estos valores: 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, y discierna el patrón de complemento dos. 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. También 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 _clkmode = xtal1 + pll16x _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 método GetDec del objeto FullDuplexSerialPlus guarda los caracteres que recibe de la Terminal Serial Parallax hasta que presiona la tecla Enter. Convierte el carácter en su correspondiente valor decimal y regresa ese valor. El comando del objeto EnterAndDisplayValues value := Debug.GetDec copia el resultado de la llamada de método 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 tamaño byte, no hay razón 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 más pequeñas.

Haga una copia de EnterAndDisplayValues y cambia el comando Debug.Bin(value, 32) a Debug.Bin(value, 16).

Remueva la variable local | value de a declaración del método TwoWayCom (recuerde que las variables locales son arreglos de 32 bits, las variables globales pueden ser declaradas como long, Word o byte).

Agregue un bloque VAR al objeto y declare value como palabra (Word) variable. Corra el programa ingresando los valores de 0 a 65535. 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 dígitos mostrar todos los valores posibles en una palabra variable (16 bits).

Modifique la copia EnterAndDisplayValues para que solo muestre 4 dígitos 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 están 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 botón; 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 Botón en la Terminal Serial

El objeto DisplayPushbuttons utiliza el comando Debug.Bin(ina[23..21], 3) para mostrar el estado del botón. Recuerde de la práctica 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 parámetro al método bin del objeto



FullDuplexSerialPlus con el comando Debug.bin(ina[23..21], 3). Note que como solo hay 3 bits para mostrar el parámetro bits del método bin es 3 lo que en su turno hace que el método muestre solo 3 dígitos binarios. El objeto FullDuplexSerialPlus está corriendo en un controlador serial en otro cog y es posible transferir mensajes más rápido 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.

Use la herramienta Propeller para cargar el objeto DisplayPushbuttons.spin en EEPROM (F11) e inmediatamente presione el botón Enable. Nuevamente, si usted no lo presiona en los 2 segundos después de la descarga solo presione el botón de reinicio de la plataforma PE para reiniciar el programa.

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 botón en la Terminal Serial Parallax. Botones 3.3 V 3.3 V 3.3 V Botón Botón Botón P21 P22 P23 10 kω 10 kω 10 kω GND GND GND CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000 OBJ Debug: "FullDuplexSerialPlus" 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) waitcnt(clkfreq*2 + cnt) 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) waitcnt(clkfreq/100 + cnt)



Accesando constantes en objetos con ObjectNickname#OBJECT_CONSTANT Quizá ha notado que la expresión 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 documentación del objeto FullDuplexSerialPlus en la derecha de la Figura 6-18. En vez de usar los números o declararlos por segunda vez en el objeto superior DisplayPushbuttons usa el registro ObjectNickname#OBJECT_CONSTANT para especificar caracteres de control que se envían a la Terminal Serial Parallax.

Examine el objeto FullDuplexSerialPlus en ambos modos; documentación y fuente completa. Tome nota de como se declaran las constantes y como son documentadas con comentarios de

doble apostrofe. Figura 6-18: DisplayPushbuttons Completa (izq.), DisplayPushbuttons Documentación (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 señales de salida pueden así de fácil enviarse a otros pins de entrada de chips, salidas a circuitos que controlan salidas de alta corriente tales como solenoides, relevadores, motores DC, calentadores, lámparas, etc.

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

El comando outa[9..4] := Debug.GetBin llama al método GetBin del objeto FullDuplexSerialPlus. EL método regresa el valor correspondiente a los caracteres binarios (unos y ceros) que usted ingreso en la ventana de transmisión de la Terminal Parallax. El valor que el método GetBin regresa se asigna a outa[9..4], lo cual hace encender el LED correspondiente.



Cargue TerminalLedControl.spin en la EEPROM (F11) e inmediatamente presione el botón Enable de la Terminal Parallax.

Intente ingresar los valores mostrados en la Figura 6-19 en la ventana de transmisión 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 _clkmode = xtal1 + pll16x _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) waitcnt(clkfreq*2 + cnt) 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 más largos y diseños de menús, manteniendo todos los mensajes en un bloque DAT puede hacer más conveniente que usar string("...")en el código.



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 línea tiene una etiqueta, un tamaño 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 línea de texto.", 0 BlankLine byte Debug#CR, Debug#CR, 0 Recuerde que la directiva string regresa la dirección inicial de la cadena así que el método str del objeto FullDuplexSerial puede comenzar a enviar caracteres y luego terminar cuando encuentra un cero que lo termina. Con los bloques DAT el carácter de terminación tiene que ser ingresado manualmente. El nombre de una directiva de bloque DAT hace posible pasar la dirección inicial de la secuencia usando el operador @. Por ejemplo @MyString regresa la dirección del primer carácter en la secuencia MyString. Por lo que Debug.str(@myString) comenzara a obtener y transmitir caracteres a la dirección del primer caracter en MyString, y se detendrá cuando obtenga el 0 que sigue de los caracteres "…number: ".

Cargue el objeto TestMessages.spin en la EEPROM (F11), y presione inmediatamente el botón Enable en la Terminal Serial Parallax

Verifique que los tres mensajes se muestran cada segundo. '' TestMessages.spin '' Envía mensajes de texto almacenados en el bloque DAT de la Terminal. CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000 OBJ Debug: "FullDuplexSerialPlus" PUB TestDatMessages | value, counter ''Envía mensajes almacenados en el bloque DAT. Debug.start(31, 30, 0, 57600) waitcnt(clkfreq*2 + cnt) Debug.tx(Debug#CLS) repeat Debug.Str(@MyString) Debug.Dec(counter++) Debug.Str(@MyOtherString) Debug.Str(@BlankLine) waitcnt(clkfreq + cnt) DAT MyString byte "Este es el mensaje de prueba: ", 0 MyOtherString byte ", ", Debug#CR, "y esta es otra línea de texto.", 0 BlankLine byte Debug#CR, Debug#CR, 0

Expandiendo la sección DAT y Accesando sus Elementos Aquí hay una sección DAT modificada. El mensaje de texto tiene diferente contenido y diferentes etiquetas. Además hay un ValueList con elementos long en vez de elementos byte.



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 también 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

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 tamaños diferentes de variables. En bloques DAT, long, Word, y byte pueden usarse para declarar el elemento de tamaño de la lista. En métodos PUB y PRI, long, Word, y byte se usan para recuperar valores de ciertas direcciones.

Haga una copia del objeto TestMessages y reemplace la sección DAT con la mostrada arriba. Reemplace la sección PUB con la mostrada abajo. PUB TestDatMessages | value, index Debug.start(31, 30, 0, 57600) waitcnt(clkfreq*2 + cnt) Debug.tx(Debug#CLS) repeat repeat index from 0 to 4 Debug.Str(@ValTxt) value := long[@valueList][index] Debug.Dec(value) Debug.Str(@ElNumTxt) Debug.Dec(index) Debug.Str(@BlankLine) waitcnt(clkfreq + cnt)

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 números o dígitos. El formato de precisión (32-bit) punto flotante IEEE754 es soportado por la herramienta Parallax y por los objetos de las librerías Propeller Float y FloatString. Este formato usa un cierto número de bits en una variable de 32-bit para un número significativo, otros bits para almacenar exponente y otro para almacenar el valor del signo. Mientras los cálculos involucran dos valores de punto-flotante precisión-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 números grandes y pequeños. Por ejemplo variables long pueden manejar enteros de -2,147,483,648 a 2,147,483,647, los valores de punto-flotante precisión-simple pueden representar valores de entre ±3.403×1038 y ±1.175×10−38.



Para esta práctica solo es importante conocer que la librería Propeller tiene objetos que pueden usarse para procesar valores de punto flotante. TerminalFloatStringTest demuestra algunas operaciones básicas 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.

Cargue el objeto FloatStringTest.spin en la EEPROM (F11), e inmediatamente después presione el botón Enable de la Terminal Propeller.

Verifique que la ventana de recepción de la Terminal Parallax muestra 1.5 + Pi = 4.641593. ''FloatStringTest.spin ''Resuelve problema matemático de punto flotante y muestra el resultado ''en la Terminal Serial. CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000 OBJ Debug : "FullDuplexSerialPlus" fMath : "FloatMath" fString : "FloatString" PUB TwoWayCom | a, b, c ''Resuelve problema matemático 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 también tienen direcciones en RAM. Ciertos objetos son diseñados para iniciar con parámetros de direcciones variables. Frecuentemente corren en Cogs separados y actualizan su salida basándose 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 método Start tiene parámetros para dos valores de direcciones, pinAddress y rateAddress. El objeto padre tiene que pasar al método Start del objeto AddressBlinker la dirección de una variable que almacena el numero de pin de E/S y otro que almacena el tiempo. El método Start transmite estos parámetros al método Blink a través de la llamada de método en el comando cognew. Así cuando el



método Blink se inicia en un nuevo Cog también recibe copia de sus direcciones. Cada vez que el ciclo repeat del método 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 dirección el operador @ ya no se necesita.

Variables Globales vs. Locales : En este programa las variables pinAddress y rateAddressse pasan al método Start por el objeto padre como parámetros. EL método Start transmite estos valores al método Blink como parámetros también. Ambos métodos Start y Blink terminan con sus propias variables locales pinAddress y rateAddress porque las variables locales solo son accesibles por el método que las declara.

Otra práctica común en hacer que el método Start copie parámetros que recibe de variables globales declaradas en el bloque de objeto VAR. Otros métodos en el objeto pueden leer de y escribir a estas variables globales según se necesite. Tenga en cuenta que diferentes Cogs pueden ejecutar código en diferentes métodos. Aun así ambos métodos pueden trabajar con variables globales de objetos. N ejemplo de esta práctica importante se demuestra en la siguiente practica Dentro del Objeto MonitorPWM en la pagina 167.

Examine el objeto AddressBlinker.spin y ponga atención a las relaciones que acabamos de

discutir. '' Archivo: AddressBlinker.spin '' Ejemplo de administración de Cog que ve variables en su objeto padre VAR long stack[10] 'Cog stack space byte cog 'Cog ID PUB Start(pinAddress, rateAddress) : success ''Inicia un Nuevo proceso en un Cog Nuevo. Regresa True si tiene éxito. ''Parámetros: pinAddress - long dirección de la variable que almacena el pin E/S '' rateAddress - long dirección 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] waitcnt(rate/2 + cnt) 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. Después de pasar la dirección de sus variables pin y rateDelay al método 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.

Cargue el objeto AddressBlinkerControl.spin en la EEPROM (F11), y presione inmediatamente el botón Enable de la Terminal Parallax.

Ingreso los números de pins y retrasos de ciclos de reloj mostrados en la Figura 6-20 en la ventana de transmisión de la Terminal y verifique que la aplicación 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 envía al chip '' Propeller a través de la Terminal Serial Parallax CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000 OBJ Debug: "FullDuplexSerialPlus" AddrBlnk: "AddressBlinker" VAR long pin, rateDelay PUB UpdateVariables '' Actualiza variables que son observadas por el objeto AddressBlinker. Debug.start(31, 30, 0, 57600) waitcnt(clkfreq*2 + cnt) Debug.tx(Debug#CLS) pin := 4



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).

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 distinción entre un contenido de variable y su dirección.

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, típicamente tienen documentación que explica el orden y tamaño de cada variable que el objeto padre necesita declarar. Este tipo de métodos Start de objetos típicamente solo esperan un valor, la dirección de inicio de la lista de variables en el objeto padre. El objeto hijo toma esa dirección y la usa para accesar el resto de la variables en el objeto padre. AddressBlinkerWithOffsets es un ejemplo de un objeto del que el método start espera la dirección de inicio de una lista de variables. Diferente a AddressBlinker su método Start solo recibe la dirección de la variable del objeto padre que almacena el valor pin. Su documentación requiere que la variable almacene el retraso de la frecuencia de parpadeo para ser declarada, sin variables extra. Como el parámetro baseAddress almacena la dirección 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 parámetro de dirección.

Examine el objeto AddressBlinkerWithOffsets.spin. Note como su método start necesita un baseAddress que lo usa para encontrar variables en sus objetos padre que determinan el pin y el retraso en el parpadeo.

Considere como esto puede ser aplicado a listas más 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 dirección del long que '' almacena el numero de pin E/S de LED al método Start.



VAR long stack[10] 'Cog stack space byte cog 'Cog ID PUB Start(baseAddress) : success ''Inicia un nuevo parpadeo en un cog Nuevo; regresa True si tiene éxito. ''baseAddress...la dirección de la variable long que almacena el numero de pin LED. ''baseAddress + 1...la dirección 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] waitcnt(rate/2 + cnt) Tenga en cuenta que el punto de este ejemplo es demostrar como un objeto padre puede pasar una dirección base a su hijo y la documentación requiere una lista de variables de tamaño 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 aplicación que en el ejemplo previo, selección de LED y Frecuencia por Terminal. Manteniendo la documentación del objeto AddressBlinkerWithOffsets, AddressBlinkerControlWithOffsets declara una variable long para almacenar pin y la siguiente variable declara rateDelay. Así pasa la dirección de su variable pin al método Start del objeto AddressBlinkerControl. En este objeto la declaración de variables es long pin, rateDelay crucial. Si el orden de estas dos variables se intercambia la aplicación no trabaja bien. Esto es, nuevamente, porque el objeto AddressBlinkerWithOffsets espera recibir la dirección 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 después de estas dos. Es solo que pin y rateDelay tienen que ser variables long y tienen que declararse en orden específico por AddressBlinkerWithOffsets. La dirección de inicio de la lista variable también tiene que pasarse al método start del objeto hijo, en este caso con AddrBlnk.start(@pin). Ponga atención en este alcance de los objetos que son diseñados para trabajar con listas de variables long en sus objetos padre.



Prueba AddressBlinkerControlWithOffsets y verifique que es idénticamente funcional a AddressBlinkerControl.

Examine como AddressBlinkerControlWithOffsets se diseña de acuerdo de la documentación 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 método Start solo pasa una dirección variable pero la usa como su '' ancla para dos variables que se monitorean por ''AddressBlinkerWithOffsets. CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000 VAR long pin, rateDelay OBJ Debug: "FullDuplexSerialPlus" AddrBlnk: "AddressBlinkerWithOffsets" PUB TwoWayCom ''Envía mensajes de prueba y valores la Terminal Serial Parallax. Debug.start(31, 30, 0, 57600) waitcnt(clkfreq*2 + cnt) 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) ¿Cuáles son las diferencias entre llamar un método en el mismo objeto y llamar un método en

otro objeto? 2) ¿Llamar a un método en otro objeto afecta la forma en que se pasan los parámetros y valores

de regreso? 3) ¿Cuáles 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 aplicación? 5) ¿Cómo se incluyen los comentarios en un objeto? 6) ¿Cómo puede ver los comentarios de documentación del objeto mientras filtra el código? 7) Por regla, ¿Que nombres de métodos se usan para iniciar métodos 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 más de una ocurrencia de ese proceso en cogs múltiples? 9) ¿Cuál es el efecto neto de un método Start de objeto llamando su método Stop? 10) ¿Cómo se ingresan caracteres especiales para esquemáticos, medidas, expresiones

matemáticas y diagramas de tiempo en los comentarios de objeto? 11) ¿Cuáles son las diferencias entre método público y privado? 12) ¿Cómo se declaran múltiples copias de un objeto? 13) ¿Donde se almacenan los objetos de Librerías Propeller? 14) ¿Cómo se puede ver la información de un objeto? 15) ¿En qué parte de RAM la directiva String hace que se almacene un código de carácter? 16) ¿Por qué un cero de terminación de cadena es importante para el objeto FullDuplexSerial? 17) ¿Que debe explicar el comentario de documentación de un objeto acerca de un método? 18) ¿Cómo se pueden almacenar cadenas de caracteres aparte de la declaración String 19) ¿Cuáles son los tres diferentes usos de las palabras clave long, Word y byte en el lenguaje

Spin 20) ¿Qué método usa el objeto Float para sumar dos números de punto flotante? 21) ¿Qué método se usa para mostrar números de punto flotante como cadena de caracteres? 22) ¿Es el comando a := 1.5 procesado por el objeto FloatMath? 23) ¿Cómo se pasa una dirección de variable a un parámetro en un método de otro objeto? 24) ¿Cómo puede pasar una dirección a un método de objeto reducir el número de parámetros? 25) Dada una dirección de variable ¿Cómo un método de objeto accesa valores almacenados en

esa variable y variables declaradas posteriormente? 26) Dada una dirección ¿Puede un objeto monitorear un valor variable? 27) Dada una dirección ¿Puede un objeto actualizar la variable en otro objeto usando esa

dirección?

Ejercicios 1) Dado el archive MyLedObject.spin, escriba una declaración para otro objeto la misma carpeta

para que pueda usar sus métodos. Use el apodo led. 2) Escriba un comando que llame un método llamado on en un objeto apodado led. Este método

requiere el parámetro pin (use 4). 3) Liste los valores decimales de los caracteres de la fuente Parallax que se requieren para

escribir esta expresión en un comentario de documentación f = T. 4) Declare un método privado llamado calcArea que acepte parámetros height y width y regrese

área. 5) Declare cinco copias de un objeto llamado FullDuplexSerial (el cual podría ser usado para

cinco conexiones de comunicación seriales simultaneas bidireccionales) Use el apodo uart. 6) Llame el tercer método str del objeto FullDuplexSerial y envíe la cadena “Hola!!!”. Asuma

el apodo uart. 7) Escriba un bloque DAT e incluya una cadena etiquetada Hi con la terminación de cadena cero

“Hola!!!”. 8) Escriba un comando que calcule la circunferencia (c) de un círculo dado el diámetro (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 método en

FloatString que regresa la dirección de la representación de una cadena almacenada de un valor de punto flotante. Almacene esta dirección en la variable address. Asuma el apodo fst.



Proyectos 1) TestBs2IoLiteObject usa llamadas de método similares a los comandos del lenguaje de

programación del micro controlador BASIC Stamp. Este objeto necesita un objeto Bs2IoLite con métodos como high, pause, low, in, y toggle. Escriba un objeto que soporte estas llamadas a métodos usando las descripciones en los comentarios

''Archivo superior: TestBs2IoLiteObject.spin ''Enciende LED en P6 por 1 s, después parpadea LED P5 a 5 Hz cada ''que el botón 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 Librería Propeller, la longitud de pila en la carpeta Demo de la Librería Propeller. Haga una copia de longitud de pila Demo.spin, y modifíquela para probar el espacio de pila requerido para iniciar el método Blink del objeto Blinker (del inicio de ésta práctica) en un cog. Genere la conexión a la Terminal Serial Parallax basado en la documentación de StackLenthDemo para mostrar el resultado. NOTA: Las instrucciones para usar el objeto Stack Lenght están ocultas en los comentarios de TEORIA DE OPERACIÓN, los cuales son visibles en modo de vista.

3) Algunas aplicaciones tendrán un reloj corriendo en un cog para mantener el tiempo. Abajo

esta una pantalla que se actualiza cada que el botón 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 método es Time.Get(@days, @hours, @minutes, @seconds). Esta llamada de método pasa la dirección 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. Asegúrese de usar la segunda técnica de conteo del método GoodTimeCount de la práctica de E/S y Tiempo.

'' TerminalButtonLogger.spin '' Graba las veces que el botón conectado a P23 se presiona/suelta '' en la Terminal Serial Parallax. CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000 OBJ Debug : "FullDuplexSerialPlus" 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 día, hora, 'minuto y Segundo. Debug.Str(@BtnPrompt) 'Muestra instrucciones en 'La Terminal Serial Parallax repeat if Button.Time(23) ' Si se presiona el botón.

' 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)



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

7: Práctica de Módulos Contadores y Aplicaciones de Circuitos


7: Módulos Contadores y Aplicaciones de Circuitos

Introducción Cada Cog Propeller tiene dos Módulos Contadores y cada modulo contador puede configurarse para desarrollar tareas repetitivas independientemente. Así que el chip Propeller no solo tiene la habilidad de ejecutar código simultáneamente en cogs separados sino que cada cog puede también orquestar hasta dos procesos adicionales con módulos contadores mientras el cog continúa ejecutando comandos de programa. Los contadores pueden proporcionar una variedad de servicios como:

• Medir Pulsos y Tiempo de Decadencia • Contar ciclos de señales y Medir Frecuencia • Enviar señales de oscilador numéricamente controladas (NCO). Por ejemplo ondas cuadradas • Enviar señales de ciclos de fase cerrada (PLL) las cuales pueden ser útiles para ondas

cuadradas de mayor frecuencia • Detección de limite de señal • Conversiones Análogo Digital (A/D) • Conversiones Digital Análogo (D/A) • Proporcionar señales internas para generación 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 análogos. Esta práctica proporciona ejemplos de cómo usar 10 de 32 modos contadores diferentes para desarrollar variaciones de 8 diferentes tareas:

• Medición de tiempo en Decadencia RC para potenciómetros y foto resistores. • Conversión Digital Análoga para controlas luminosidad de LED • Señales NCO para enviar tonos de bocina • Señales NCO para IR modulada para objetos y detección de distancia • Contar ciclos de tonos de bocina • Detectar una transición de señal • Control de Amplitud de Pulso • Generar señales de alta frecuencia para detección de metal

Un cog no tiene necesariamente que “programar y olvidar” un modulo contador. También puede dedicarse a procesar envolviendo módulos contadores haciendo cosas increíbles, incluyendo un número de aplicaciones de audio y video. Esta práctica incluye un ejemplo que demuestra este tipo de relación cog-contador aplicada a enviar múltiples señales PWM.

Prerrequisitos de la Práctica

• Configuración y Pruebas • E/S y Tiempo • Métodos y Cogs • Objetos

Práctica de Módulos Contadores y Aplicaciones de Circuitos


Como trabajan los Módulos Contadores Cada cog tiene dos módulos contadores, Contador A y Contador B. Cada cog tiene también tres registros de propósito especial de 32-bit para cada uno de sus módulos 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 también una palabra reservada en Spin y Ensamblador Propeller. Si esta práctica esta refiriéndose a un registro generalmente pero no importa si es contador A o B usara nombres genéricos 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 también 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:

• Posición de perilla o joystick con uno o más potenciómetros • Niveles de ambientación de luces con Resistencia dependiente o fotodiodo • Reflectividad de superficie infrarroja con un LED infrarrojo y fototransistor • Presión con platos capacitivos y • Presión con placas del capacitor y un dieléctrico compresibles • Salinidad de un liquido con puntas de metal

Circuito de Descarga RC Las mediciones de descarga RC se desarrollan típicamente cargando un capacitor (C) y después monitoreando el tiempo que tarda el capacitor en descargarse a través de una resistencia (R). En la mayoría de los circuitos de descarga RC uno de los valores es fijo y el otro varía con la variable ambiental. Por ejemplo el circuito en la Figura 7-1 se usa para medir la posición de una perilla. El valor de C es fijo a 0.01 µF, y el valor de R vara con la posición del potenciómetro al ajustar la perilla (la variable ambiental)

Construya el circuito mostrado en la Figura 7-1 es la Plataforma PE. Este circuito y otros en esta práctica son adicionales al circuito básico construido en Configuración y Prueba.

Figura 7-1: Descarga RC Partes y Circuito Lista de Partes Esquemático (1) Potenciómetro 10 kω P17 (1) Capacitor - 0.01 μF (misc) Cables R 0.01 μF GND GND



Midiendo Descarga RC Antes de tomar la medición 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 medición 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 través 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

¿Dónde 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 límite de corriente previene de cualquier daño.

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. Asegúrese que sea lo suficientemente grande para prevenir daños del pin E/S.

Detector Positivo de Modos Hay dos opciones de detectores positivos de Modo, “regular” y “con retroalimentación”. 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. Después que la señal 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 automáticamente 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 Librería Propeller. El Objeto CTR tiene información de un modulo contador y un ejemplo de código 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 retroalimentación), 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 Descripción 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 código de 5-bit CTRMODE. Por ejemplo el código 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 función 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 código 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

La Tabla de Modos Contadores y el Mapa de Registro aparecen en el Objeto CTR de la Librería Propeller y también en el Manual Propeller en la sección CTRA/B localizada en el capítulo 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 también 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 números 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 lógico 1.65V. La única cosa que tiene que hacer antes de comenzar la medición 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 cálculos 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 expresión trabaja para el sistema de reloj del chip Propeller en frecuencias que normalmente son múltiplos 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 serán múltiplos 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 después que el ciclo de reloj se termino y puede continuarse con un comando que convierte a una medida conveniente tal como microsegundos.

Midiendo señales de entrada o salida. Este modo contador puede usarse para medir la duración en la cual un pin E/S envía una señal alta y su duración en la que esa señal se aplico a la entrada E/S. La única diferencia es la dirección del pin E/S cuando se toma la medida.

“Contando” la Medida de Descarga RC Antes de la medición de descarga RC el capacitor deberá estar cargado. Aquí hay una pieza de código que pone P17 como salida alta luego espera 10µs lo cual es más 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 medición de la descarga limpie el registro PHS y luego ponga el pin E/S que está cargando el capacitor como entrada: phsa~ dira[17]~ Después de limpiar phsa y dira, el programa queda libre para desarrollar otras tareas durante la medición. En algún 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 medición. 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 medición 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 mínimo 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

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 más bajo antes de que un cero se regresara. En el programa de prueba time := phsa reemplaza time := (phsa – 624) #> 0, y el valor medible más bajo fue 625.



Ejemplo de Objeto que mide el Tiempo de Descarga RC El objeto TestRcDecayaplica la técnica que acabamos de discutir para medir la descarga RC en un circuito con Resistencia variable controlada por la posición de una perilla de ajuste de potenciómetro. Como se muestra en la Figura 7-5, el programa muestra un mensaje “working on other tasks” después de iniciar la medición de descarga para demostrar que el modulo contador automáticamente incrementa el registro phsa hasta que el voltaje aplicado a P17 se descarga debajo de 1.65 V. El programa puede entonces verificar después para encontrar el valor almacenado en phsa.

Figura 7-5: Tiempos de Descarga RC

La mayoría de los ejemplos en esta práctica son objetos superiores que demuestran detalles de trabajo en los módulos contadores. Si usted planea incorporar estos conceptos en una librería de objetos diseñados para ser usados por otras aplicaciones asegúrese de poner atención en la sección titulada: Prueba y Muestra PWM – Agrega un Objeto, Cog y Par de Contadores

que comienza en la pagina 162.

Abra el objeto TestRcDecay.spin. Llamara métodos en FullDuplexSerialPlus.spin, asegúrese

de que están grabados en la misma carpeta. 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. Use la herramienta Propeller para cargar TestRcDecay.spin en el chip Propeller. Presione el botón Enable inmediatamente. (No espere a que el programa termine de cargar.

De hecho puede presionar el botón inmediatamente después de presionar F10 o F11 en la herramienta Propeller)

Pruebe ajustando el potenciómetro a varias posiciones y note los valores del tiempo. Estos deberán variar en proporción a la posición 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 comunicación serial y espera 2 s para conexión a la Terminal Serial Parallax. Debug.Start(31, 30, 0, 57600) waitcnt(clkfreq * 2 + cnt) ' 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 método 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. Automáticamente después esto... phsa~ ' Limpia el registro phsa dira[17]~ ' Pin a entrada detiene carga ' Opcional Hacer otras cosas durante la medición. Debug.str(String(CR, CR, "Working on other tasks", CR)) repeat 22 Debug.tx(".") waitcnt(clkfreq/60 + cnt) ' Medición lista hace tiempo. Ajusta ciclos entre phsa~ y dira[17]~. time := (phsa - 624) #> 0 ' Display Result Debug.Str(String(13, "time = ")) Debug.Dec(time) waitcnt(clkfreq/2 + cnt)

Dos mediciones simultaneas de descarga RC Como un modulo contador rastrea el tiempo en alto después de que empieza la descarga y como cada Cog tiene dos módulos 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 simultáneamente. En vez de un potenciómetro para medir la posición 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 más brillante el fototransistor permite pasar más corriente lo que resulta en una descarga más rápida del capacitor. Si la luz es menos brillante el fototransistor permite el paso de menor corriente resultando en tiempo de descargas más lentas.



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 idénticas son diodos emisores de luz infrarroja. La tercer parte tiene un encapsulado ligeramente más pequeño, ese es el fototransistor infrarrojo.

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

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 más corriente cuando la luz es más brillante. De forma que bajo condiciones de luz brillante, la resistencia en serie reduce la carga del fototransistor de lo contrario se pondría 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 medición de descarga. Si el fototransistor fuera reemplazado por un sensor resistivo de luz, menores resistencias podrían terminar en voltajes iniciales menores antes de que la medición de descarga inicie.

TestRcDecay.spin puede modificarse para usar el contador B para medir niveles de luz durante un periodo paralelo a la medición de descarga de la perilla del potenciómetro en el contador A. Como un Cog controla ambas mediciones, las inicia secuencialmente- una después de la otra. Sin embargo como ambos contadores pueden rastrear el tiempo de descarga independientemente el código del Cog no tiene que esperar a que termine la primera medición antes de comenzar la segunda. Puede iniciar ambas, una inmediatamente después 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 podría ser comenzar convirtiendo ka variable time a dos arreglos de elementos así cada medición 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 módulos 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 medición de descarga. El capacitor en el circuito fototransistor es 10 veces mayor que el del circuito del potenciómetro y hay también 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 medición 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 módulos contadores están midiendo el tiempo de descarga el Cog puede empezar cada medición en sucesión rápida sin esperar a que termine la primera antes de comenzar la segunda. La medición del potenciómetro 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 medición del fototransistor comienza limpiando phsb y dira[25]:

' Comienzan mediciones de descarga RC... phsa~ ' Limpia registro phsa dira[17]~ ' Pin a entrada detiene carga phsb~ ' Limpia registro phsb dira[25]~ ' Pin a entrada detiene carga

Después 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]) waitcnt(clkfreq/2 + cnt)

Haga una copia de TestRcDecay.spin. 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 código no tiene que esperar por un periodo fijo de tiempo antes de verificar los registros. Puede encontrar si se realizo una medición verificando el estado del pin E/S. Después de que la medición 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 todavía. Si en cambio almacena un 0 la medición se completó. Igualmente si ina[25] almacena un 1 la medición de la luz aun esta en proceso y no se tiene que verificar phsb todavía. Hay una modificación 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 código no hay una diferencia apreciable. Se hace más evidente cuando se comenta el código que ocasiona los retrasos (excepto el waitcnt que da a los capacitores el tiempo de carga). También ayuda declarar una variable para contar la repeticiones del ciclo repeat y mostrar su valor entre cada medición. Con este arreglo se podrá observar cuantas mediciones se toman por segundo.

Inténtelo.

Conversión D/A – Controlando luminosidad del LED con Modos DUTY Hay dos opciones de modos DUTY, terminación sencilla y diferencial. Un modulo contador en terminación sencilla permite controlar una señal que puede ser usada por conversión digital a análoga con el registro FRQ. Aun si la señal cambia rápidamente entre alto y bajo el tiempo promedio que esta alto (duty) es determinada por la proporción del registro FRQ a 232. pin high time FRQ duty = = time 4_294_967_296

Eq. 1

Para conversión D/A vamos a decir que el programa tiene que enviar una señal 0.825 V. Eso es 25% de 3.3 V por lo que se requiere 25% de una señal “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

También puede usar la Eq 1 para calcular que señal 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 terminación sencilla. 536_870_912 duty = = 0.125 4_294_967_296

En una escala de 3.3 V eso resultaría 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 señal de tarea de la conversión D/A.

Como trabaja el modo DUTY de terminación 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 operación de acarreo es similar a la operación de acarreo de la suma decimal. Vamos a decir que está permitido 3 posiciones decimales y se intenta agregar dos valores que suman más de 999. Algún valor normalmente no sería acarreado de los cientos a los miles. La versión binaria de la suma con acarreo se aplica cuando el registro FQR se



suma al registro PHS cuando el resultado es mayor que 232 − 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 232. En modo DUTY de terminación 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/232 es lo mismo para el estado de salida del pin E/S. El pin E/S puede cambiar rápidamente entre alto y bajo pero el promedio en el que el pin esta en alto es determinado por FRQ-to-232 mostrado en la ecuación Eq. 1.

Partes y Circuitos Si, de regreso a LEDs por un poco más y después nos moveremos a otros circuitos. Prácticas previas usan LEDs para indicar el estado de pins E/S y tiempo. Esta porción de la práctica usara modo DUTY de terminación sencilla para conversión D/A para controlar el brillo de un LED. Figura 7-6: Circuito LED para control de iluminación con señales Duty Lista de Partes Esquemático (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

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 más entradas del objeto CTR en la tabla del Modo Contador del Manual Propeller. Como se menciono previamente los dos tipos de modos DUTY son terminación sencilla y diferencial. Con modo DUTY de terminación 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 señal parecerá que brilla a ¼ de su brillo total. Con modo DUTY de terminación 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 debería 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 Descripción FRQ to PHS salida* salida* %00000 Contador deshabilitado(off) 0 (never) 0 (none) 0 (none) . . . %00110 DUTY terminación 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 A¹ = APIN entrada retrasada por 1 clock A² = APIN entrada retrasada por 2 clocks B¹ = BPIN entrada retrasada por 1 clock La Figura 7-8 es una repetición 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 terminación sencilla) o %00111 (DUTY diferencial). Entonces el bit APIN (y opcionalmente BPIN) tienen que activarse como pins E/S que transmitirán las señales 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 aplicación 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 aplicación el registro FRQ está programando valores que controlan el tiempo en alto de una señal DUTY aplicada a un pin E/S. No hay condición para sumar con modo duty; FRQ se suma a PHS cada ciclo de reloj.

Activando una señal Duty Aquí tiene unos pasos para activar una señal duty también 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 señal duty que desea



Ejemplo – Enviar una señal 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 patrón 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 terminación 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 terminación 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 señal 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 propósito 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 fracción de 232 el pin E/S y el LED comenzara a enviar la señal duty, Teniendo 232 diferentes niveles de iluminación no es práctico, pero 256 diferentes niveles trabajaran bien. Un forma simple de llegar a esto es declarando una constante que es 232 ÷ 256. CON scale = 16_777_216 ' 232 ÷ 256 Ahora el programa puede multiplicar la escala constante por un valor entre 0 y 255 para tener 256 niveles de iluminación. Si se quiere ¼ de brillo multiplique la escala por ¼ de 256. frqa := 64 * scale

Variación de Tiempo D/A y Filtro: Cuando se modula el valor de frqa para enviar señales de variaciones de tiempo un circuito RC filtran la señal típicamente. Es mejor usar una fracción más pequeña que la señal de uso, decir 25% a 75% o 12.5% a 18.75%. Manteniendo la señal en este rango el D/A será menos ruidoso y resistencias y capacitores más pequeños se pueden usar para respuestas más rápidas. Esto es importante para señales que varían rápidamente tales como audio, lo cual será visto en otra practica.

R Señal duty voltage C GND



Código Ejemplo de Modo DUTY de Terminación Sencilla El objeto LedDutySweep.spin demuestra los pasos para configurar un contador DUTY terminado sencillo y transmisión de una señal duty con un pin E/S. También cambia una variable duty de 0 a 255 repetidamente provocando que el LED en P4 incremente gradualmente en brillo y se apague.

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 Terminación Sencilla vs. Diferencial Diferencial es la segunda opción para modos DUTY, al igual que muchos otros modos contadores. Las señales diferenciales son útiles para obtener señales a través de líneas de transmisión más largas y se usan en Ethernet cableado, RS485 y ciertas señales de audio. Cuando un modulo contador funciona en modo diferencial usa un pin E/S para transmitir la misma señal que transmite la terminación sencilla junto con un segundo pin E/S que transmite la señal de polaridad opuesta. Por ejemplo un modulo contador activado para modo diferencial puede enviar la señal opuesta que P4 transmite en P5 o algún otro pin. Cada que la señal en P4 es alta la de P5 es baja y viceversa. Intente modificar una copia de LedDutySweep.spin para que envíe la señal diferencial en P5. Así en cuanto P4 se empieza a iluminar más P5 ira bajando de intensidad. Aquí están los pasos:

Guarde una copia del objeto LedDutySweep que modificara. Para activar el modulo contador a modo DUTY diferencial cambie ctra[30..26] := %00110 a ctra[30..26] := %00111.

Active el campo BPIN agregando un comando ctra[14..9] := 5 Active P5 a salida para que la señal se transmita por el pin E/S con el comando dira[5]~~.

Usando ambos módulos contadores A y B Usando ambos contadores para mostrar la intensidad del LED también es un ejercicio valioso. Para obtener dos módulos contadores enviando señales duty en pins separados intente estos pasos:

Guarde otra copia del objeto original, no modificado LedDutySweep objeto.



Agregue ctrb[30..26] := %00110. Asuma que ctrb controlara P6, agregue ctrb[5..0] := 6. También asumiendo que ctrb controlara P6, agregue dira[6]~~. 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 más rápido que el LED P4.

Dentro del Modo DUTY Vamos a observar cómo trabaja examinando la versión 3-bit. Como el denominador de la fracción es 2 de exponente de bits en el registro una versión 3-bit de FRQ seria dividida por 23 = 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 versión 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 símbolo ↓ 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

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 dígitos 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 Propósito Especial Cada cog tiene un arreglo de registro de propósito especial (SPR) del cual los elementos pueden accesar con spr[index]. El valor index lo deja escoger un registro dado de propósito 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.

Observe SPR en la sección de referencia de Lenguaje Spin del Manual Propeller y revise la explicación de SPR y la tabla de arreglo de elementos SPR.



La ventaja de usar arreglos SPR es que son accesibles por los valores index. También 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 declaración de condiciones para decidir cual modulo contador usar y también hace posible inicializar y actualizar módulos contadores con estructuras cíclicas. Una desventaja de los registros de propósito 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 propósito 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 patrón 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 aplicación enviara señales duty en P4 y P5. Un ciclo que podría activar estos pins de E/S para señales duty se vería 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 parámetros. Si los parámetros sostienen el valor del pin quizá no estarán juntos o ligados por alguna relación matemática. Una manera de mantener una lista de pins no ligados si no está esperando que vengan de otro lado podría 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 versión 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 propósito 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 código LedDutySweep modificado en la sección “Usando ambos Módulos 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 módulos A y B.

Compare la copia de LedDutySweep que mueve ambos contadores contra el código en LedSweepWithSpr.spin.

Corra LedSweepWithSpr y use LEDs para verificar que controla dos señales duty separadas. ''LedSweepWithSpr.spin ''Ciclo P4 y P5 LEDs de apagado hasta brillo máximo en diferentes rangos. CON scale = 16_777_216 ' 2³²÷ 256 PUB TestDuty | apin, duty[2], module 'Configura ambos módulos 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 repeat duty from 0 to 255 ' Cambia duty de 0 a 255 duty[1] := duty[0] * 2 ' duty[1] dos veces más rápido 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 Señales Diferenciales Intente actualizar el objeto LedSweepWithSprpara que haga dos señales diferenciales, una en P4 y P5 y la otra en P6 y P7.

Haga una copia de LedSweepWithSpr.spin. Agregue una variable bpin a la lista de variables locales del método TestDuty. Agregue el comando bpin := lookupz(module: 5, 7) justo debajo del comando que asigna

el valor apin con un comando lookup. Cambie spr[8 + module] := (%00110 << 26) + apin a spr[8 + module] := (%00111 << 26) + (bpin << 9) + apin.

Agregue dira[bpin]~~ inmediatamente después de dira[apin]~~. Cargue la copia modificada de LedSweepWithSpr.spin en el chip Propeller y verifique que

envía dos señales diferenciales duty.



Generando Tonos en Piezospeaker con Modo NCO NCO significa Oscilador Controlado Numéricamente. Al igual que DUTY hay dos modos NCO, terminación sencilla y diferencial. Si un modulo contador se configura para modo NCO terminación sencilla hará que un pin E/S envíe una onda cuadrada. Asumiendo que clkfreq es constante, la frecuencia de su onda cuadrada es “numéricamente controlada” por un valor almacenado en un registro FRQ del modulo contador en un cog dado.

Construya el esquemático mostrado en la Figura 7-9. Figura 7-9: Rango de Audio NCO Lista de Partes y Circuitos Lista de Partes Esquemático (2) Piezospeakers Piezospeakers (misc) cables \+ +/ ((( P3 P27 ))) / \ GND GND

Modulo Contador en Modo NCO de Terminación Sencilla Cuando se configura a modo NCO de terminación 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 envía una señal alta y cuando es 0 una señal 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 ecuación: 232 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 solución empiece sustituyendo 80,000,000 en Eq. 2 para clkfreq y 2093 para frequency.

frqa = 2,093 × 232 ÷ 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 están para que se calculen. Tenga en cuenta que estas son las versiones de onda cuadrada. En otra práctica 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 también 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 = 232

Eq. 3

Ejemplo: Un objeto tiene su contador B del cog operando en modo NCO terminación sencilla y almacena 70,786 en su registro frqb. El sistema de reloj corre a 80 MHz. ¿Cuál 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 232

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 aplicación del modo NCO que será explorado en la sección PWM en la página 158. Como se menciono el modo NCO tiene opciones de terminación sencilla y diferenciales. Modo NCO de Terminación Sencilla hace que iguala el bit 31 del registro PHS sea transmitida por el APIN. Modo diferencial envía la misma señal en APIN junto con la señal 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 señal 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 Descripción 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] . . . %11111 LOGIC siempre 1 0 0

• 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í están 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 terminación sencilla con envío de señal 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 versión 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 señal conviértalo en salida: dira[27]~~ Después de iniciar el modulo contador corre independientemente. El código 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 versión de onda cuadrada de Do en la 7ma octava por un Segundo.

• Examine el objeto SquareWaveTest, compárelo con los pasos 1 a 3 que acabamos de discutir. • Cargue el objeto SquareWaveTest en el chip Propeller. Córralo 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

más alta. • Cargue el objeto modificado en el chip Propeller. Esta vez la nota deberá sonar a un tono más

agudo. ''SquareWaveTest.spin ''Envía 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 señal por 1 s dira[27]~~ ' Activa P27 a salida waitcnt(clkfreq + cnt) ' Espera por tono para tocar 1 s

Deteniendo (y reiniciando) la Señal 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 señal. Los 3 caminos más sencillos de detener (y comenzar) la señal de transmisión son:

1) Cambien la dirección del pin E/S a entrada. En el objeto SquareWaveTest esto podría hacerse con dira[27] := 0 o dira[27]~ cuando el programa está listo para detener la señal. (Para reiniciar la señal 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. Después examinaremos una forma de asegurarse que la señal termina cuando el pin E/S está transmitiendo una señal 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 podría correr pero como agregara un cero a phsa con cada el bit 31 de phsa no cambiara, así el pin E/S también dejara de cambiar. Igual de detener el contador el pin E/S detendrá el estado de salida que tenía en el momento que se limpio frqa. (Para reiniciar la señal 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 método 1 para iniciar y detener la señal. Su trabajo será modificar dos copias del código para hacerlo a través de las opciones 2 y 3.



Cargue Staccato.spin en el chip Propeller y verifique que suena a 15 Hz por 1 s. Haga dos copias del programa. Modifique una copia para que utilice el método 2 para iniciar y detener la señal. Modifique la otra copia para usar el método 3 para iniciar y detener la señal.

''Staccato.spin ''Envía 2093 Hz sonidos en sucesiones rápidas (15 Hz por 1 s). CON _clkmode = xtal1 + pll16x ' Reloj de Sistema → 80 MHz _xinfreq = 5_000_000 PUB TestFrequency 'Configure ctra module ctra[30..26] := %00100 ' Activa ctra para "NCO terminación sencilla" ctra[5..0] := 27 ' Activa APIN a P27 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, también detiene el modulo contador.

Use F10 y F11 para comprara programas fácilmente:

Es conveniente colocar el original Staccato.spin en EEPROM con F11, luego usar F10 cuando pruebe las modificaciones. Después de correr el programa nuevo puede presionar y soltar el botón de reinicio de la Plataforma PE para tener una comparación 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 más por el momento el pin E/S que envía 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 instrucción: 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: repeat index from 0 to 7 'Set the frequency. frqa := long[@notes][index] ...

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 Terminación sencilla" ctra[5..0] := 27 ' Activa APIN a P27 frqa := 0 ' No toca notas todavía repeat index from 0 to 7 frqa := long[@notes][index] ' Asigna la frecuencia. 'Transmite la señal 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 waitcnt(clkfreq/4 + cnt) 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) ÷ 2bit + 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) ÷ 2bit + 1 = (4 × 8 Hz) ÷ 23 + 1 = 32 Hz ÷ 16 = 2 Hz

La Tabla 7-2 muestra cómo 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

Método 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 también toca el tono en el piezospeaker de P27 (ver Figura 7-11). El método NcoFrqReg del objeto es una adaptación del método fraction del objeto CTR de la Librería Propeller. Dando una frecuencia de onda cuadrada calcula:

frqReg = frequency × (232 ÷ 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 método NcoFrqReg.

Figura 7-11: Calculando frqa dando una frecuencia en HZ

Ventana de Transmision

Ventana de Recepcion



El método NcoFrqReg usa cálculos binarios para lograr obtener el valor que fue generado por Eq. 5. También sería posible usar la librería FloatMath para desarrollar estos cálculos. Sin embargo el método NcoFrqReg necesita mucho menos espacio de código que la librería FloatMath. También toma menos tiempo completar los cálculos, así que lo hace buen candidato para un objeto contador matemático.

Cargue TerminalFrequencies.spin en EEPROM (F11) a inmediatamente después presione el botón Enable de la Terminal Serial Parallax. (Recuerde, no necesita esperar a que termine de cargar el programa)

Cuando muestre el cursor ingrese la porción 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 transmisión de la Terminal Serial Parallax mostrada en la Figura 7-11.

Verifique que los cálculos del método NcoFrqReg coinciden con los valores de registro FRQ en la Tabla

Recuerde presionar el botón 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 _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _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 terminación sencilla" ctra[5..0] := 27 ' Activa APIN a P27 frqa := 0 ' No envía tono aun. dira[27]~~ ' pin E/S a salida 'Inicia FullDuplexSerialPlus y limpia la Terminal Serial Parallax. Debug.start(31, 30, 0, 57600) waitcnt(clkfreq * 2 + cnt) 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 señal por 1 s frqa := temp waitcnt(clkfreq + cnt) frqa~ PUB NcoFrqReg(frequency) : frqReg Regresa frqReg = frequency × (2³² ÷ clkfreq) calculado por división long binaria. Esto es más rápido que la librería de punto flotante y toma menos espacio de código. Este método es una adaptación del método fraction del objeto CTR. repeat 33 frqReg <<= 1 if frequency => clkfreq frequency -= clkfreq frqReg++ frequency <<= 1

Use Dos Módulos 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 podría desarrollar otras tareas antes de regresar y esperar por el registro CLK para obtener el siguiente incremento.

Cargue el objeto TwoTones.spin en el chip Propeller. Verifique que toca la onda cuadrada de la aproximación 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 _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _xinfreq = 5_000_000 OBJ SqrWave : "SquareWave" PUB PlayTones | index, pin, duration 'Inicializa módulos contadores repeat index from 0 to 1 pin := byte[@pins][index] spr[8 + index] := (%00100 << 26) + pin dira[pin]~~ 'Busca tonos y duraciones en la sección DAT y los toca. repeat index from 0 to 4 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 apéndice A) en su bloque OBJ y le da el apodo SqrWave. Este objeto tiene un método con el mismo nombre y función que NcoFrqReg en el objeto TerminalFrequencies, pero el código se basa en métodos adaptados del objeto CTR de la Librería Propeller para desarrollar el cálculo El primer ciclo repeat en el método PlayTones se inicializa el método 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 números 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 parámetro en la llamada de método 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 método Freq que permite escoger el modulo contador 0 o 1 para contador A o Contador B), un pin y una frecuencia. El método Freq considerablemente simplifica el objeto TwoTones.

Compare TwoTonesWithSquareWave (abajo) con el objeto TwoTones (arriba). 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 _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _xinfreq = 5_000_000 OBJ SqrWave : "SquareWave"



PUB PlayTones | index, pin, duration 'Busca tonos y duraciones en la sección DAT y los toca. repeat index from 0 to 4 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 Detección de Distancia con modos NCO y DUTY Cuando apunta el control remoto a la TV y presiona un botón el remoto parpadea un LED IR rápidamente 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 señal de 120Hz que se transmite por la luz de su hogar.

La longitud de onda usada de IR por Control Remoto esta típicamente en el rango de 800 a 940 nm.

El remoto transmite la información modulando la señal IR. El tiempo que se envía la señal puede contener información tal como iniciar un mensaje, binario 1, binario 2, etc. Transmitiendo secuencias de señales 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 también pueden usarse para detectar objetos. En este método 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 envía una señal indicando que está recibiendo una señal IR. Si el IR no refleja el objeto para regresar al Receptor IR envía una señal indicando que no está recibiendo señal IR.

Este método de detección usa partes baratas y cada vez es más popular en robótica.

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 señal de 38kHz para el LED IR y transmitir para detección de objetos o un control de sistema de entretenimiento. Esta sección de la práctica solo prueba la detección de objetos, pero el mismo principio simple aplicara para decodificación remota y control de componentes de sistemas de entretenimiento

Construya el circuito mostrado en la Figura 7-12 – Figura 7-14, usando las fotos de las partes como guía.



Figura 7-12: Detección por IR Partes y Esquemático Lista de Partes Esquemático (1) Resistencia 1 kω +5V (1) Resistencia 10 kω (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 detección 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 cátodo 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 más 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 detección. Una resistencia pequeña como 100 Ω puede ocasionar una detección fantasma de objetos lejanos como el techo. Figura 7-14: LED IR y Detector de Orientación



Detección de Objetos por IR con NCO El objeto IrObjectDetection programa una señal 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 señal 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 Detección de Objeto

Cargue IrObjectDetection.spin en la EEPROM (F11) e inmediatamente después presione el

botón Enable de la Terminal. El estado debería ser 1 sin obstáculos 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 _clkmode = xtal1 + pll16x ' Reloj de Sistema → 80 MHz _xinfreq = 5_000_000 ' Constantes para la Terminal Serial Parallax. HOME = 1, CR = 13, CLS = 16, CRSRX = 14, CLREOL = 11 OBJ Debug : "FullDuplexSerialPlus" SqrWave : "SquareWave" PUB IrDetect | state 'Inicia 38 kHz onda cuadrada SqrWave.Freq(0, 1, 38000) ' Señal 38 kHz → P1 dira[1]~ ' Activa pin E/S a entrada ' cuando no se necesita señal '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 señal ' Muestra detección (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)) waitcnt(clkfreq/10 + cnt)

Detección de Distancia con IR usando cambios NCO y DUTY Si el LED IR brilla más hace el detector más 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 página 130). Este mismo alcance duty puede combinarse con la señal NCO para el ejemplo de detección 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 número 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 detección de distancia con una combinación NCO y señales DUTY el circuito en la Figura 7-16 lo hace posible para obtener mejores resultados del receptor IR. En vez de conectar el cátodo del LED IR a tierra se conecta a P2. El programa puede entonces cambiar el voltaje aplicado al cátodo del LED IR de 0 a 3.3 V a través de P2 mientras la señal de P1 transmite la señal NCO de 38kHz a la terminal del ánodo en l circuito. Como un LED es una válvula de 1 sentido la porción baja de la señal de 38kHz no se transmite porque es menor que el voltaje DC que la señal duty producida en P2. Durante las porciones altas de la señal de 38kHz los voltajes incrementados aplicados a P2 reducen el voltaje a través del circuito LED lo cual a su vez reduce el brillo. Así es la misma señal de 38 kHz solo sucesivamente menos brillosa. Figura 7-16: Detección IR Partes y Esquemático Lista de Partes Esquemático (1) Resistencia 100 ω IR Detector +5V (1) Resistencia 10 kω (1) LED IR (1) Detector IR (1) LED Protección 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 detección de distancia justo como lo platicamos. EL objeto padre tiene que llamar al método init para decirle cuales pins se conectan al ánodo y cátodo del circuito LED IR y las salidas del Receptor IR. Cuando el método distance se llama utiliza el cambio duty que platicamos y los números de pin que pasaron al método init para medir la distancia de los objetos. El método distance del objeto IrDetector utiliza el objeto SquareWave para comenzar a transmitir la señal de 38kHz al ánodo del circuito LED IR usando el contador B. Luego configura el contador A para modo DUTY de terminación sencilla e inicializa frqa y phsa a 0 lo cual resulta en una baja señal inicial al cátodo del circuito LED IR. Después un ciclo repeat cambia muy rápidamente duty de 0/256 a 255/256. Con cada cambio se incrementa el voltaje al circuito LED IR en el cátodo 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 número de veces en 256 que no vio un objeto. Cuando el objeto es más cercano este número será menor, cuando es más lejano el numero será mayor. Así después del ciclo el valor de regreso del método dist contiene una representación de la distancia del objeto.

Tenga en cuenta que esta medición 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 razón es que el papel blanco refleja el infrarrojo por lo que será visible al receptor mucho más 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 señal de 38 kHz. SquareWave.Freq(1, anode, 38000) ' ctrb 38 kHz dira[anode]~~ 'Configura señal 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 repeat duty from 0 to 255 ' Cambia duty de 0 a 255 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 Detección 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 día 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 medición se decrementara, pero no a cero típicamente a menos que el LED IR este apuntando directamente en el fototransistor del receptor IR (La concha negra debajo de los metales cruzados).

Asegúrese que IrDetector.spin está grabado en la misma carpeta que TestIrDutyDistanceDetector.spin y FullDuplexSerialPlus.spin.

Use la herramienta Propeller para cargar TestIrDutyDistanceDetector.spin en la EEPROM (F11) e inmediatamente presione el botón Enable de la Terminal Serial Parallax.

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 detección con el objeto IrDetector. CON _xinfreq = 5_000_000 _clkmode = xtal1 + pll16x CLS = 16, CRSRX = 14, CLREOL = 11 OBJ ir : "IrDetector" debug : "FullDuplexSerialPlus" PUB TestIr | dist 'Inicia comunicación serial y espera 2 s para la conexión con la 'Terminal Serial Parallax.



debug.Start(31, 30, 0, 57600) waitcnt(clkfreq * 2 + cnt) 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)) waitcnt(clkfreq/3 + cnt)

Contando Cambios con Modos POSEDGE y NEGEDGE Los módulos contadores también 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 señales que pasan por encima y de regreso debajo del límite lógico de 1.65 V. (Tenga cuidado ya que igual que POS los modos POSEDGE y NEGEDGE tienen opciones “con retroalimentación” aun si no se muestra en nuestro extracto de la Tabla de Modos de Modos Contadores en la Figura 7-18).

Entrada o Salida? Estos modos contadores pueden usarse para contar los cambios de una señal aplicada al pin de E/So a los cambios de la señal de la transmisión 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 Descripción 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 . . . %11111 LOGIC siempre 1 0 0 * debe activar el bit DIR correspondiente 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 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 después del límite. Esto podría hacer la diferencia en algunos



lenguajes de programación donde el tiempo es justo, pero no tiene un impacto significativo en la interpretación del programa en lenguaje Spin Los pasos para programar un contador aun contemplan la activación del campo bit de CTRMODE del registro CTR (bits 30..26) y su bit de campo APIN (bits 5..0) junto con la programación del registro FRQ al valor que debería ser sumado al registro PHS cuando se detecta al límite. Antes de la medición 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 duración de un tono tocado en una bocina. El modulo contador A se activa para transmitir una onda cuadrada de 2kHz en modo NCO de terminación 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 después de que se han detectado los 2000 cambios. frqb := 1 frqa := SquareWave.NcoFrqReg(2000) repeat while phsb < 2000 frqa~

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 señal se está transmitiendo y verifica periódicamente para revisar que tan cerca esta phsb de los 2000 cambios.

Cargue CountEdgeTest.spin en el chip Propeller y verifique que el contador de limites se

puede usar para controlar la duración de un tono. CountEdgeTest.spin Transmite la señal NCO con el contador A Usa el contador B para monitorear los límites negativos de la señal Y detener la señal después de los 2000. CON _clkmode = xtal1 + pll16x 'Reloj de Sistema → 80 MHz _xinfreq = 5_000_000 OBJ SqrWave : "SquareWave" PUB TestFrequency ' Configura Módulos 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 señal por 2000 ciclos. outa[27]~ ' P27 → salida-baja dira[27]~~ frqb := 1 ' Inicia la señal frqa := SqrWave.NcoFrqReg(2000) repeat while phsb < 2000 ' Espera por 2k repeticiones frqa~ ' Detiene la señal

Detección de Limites más Rápido El siguiente programa puede parar frecuencias cerca de 43.9kHz en el límite de caída. Para controlar el número de pulsos entregados por señales más rápidas un programa en lenguaje ensamblador será más rápido y puede detectar el límite de caída y detenerlo en un par de ciclos de reloj. BetterCountEdges.spin monitorea una señal 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 límite 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.

Observe la función del operador |< en el Manual Propeller. Cuando el comando frqa := SquareWave.CalcFreqReg(3000) se ejecuta P27 envía 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 señal esta en alto porque estaba buscando un límite positivo. La meta es detener la señal después de que baja. El comando waitpeq(0, a, 0) espera hasta que P27 es cero. El comando waitpeq(0, |< 27, 0) también se puede usar pero el programa no responde tan rápido 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 señal en salida baja después del ciclo 3000.

Vea y lea acerca de waitpeq en el Manual Propeller Cargue BetterCountEdges.spin en el chip Propeller y verifique que toca la señal de 3 kHz por

1 s. Si usted tiene un osciloscopio asigne la señal para 10 ciclos en vez de 3000. Entonces intente

incrementar la frecuencia y vea la máxima 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 Módulos 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 señal baja frqa~ 'Detiene la señal

PWM con Modos NCO PWM significa Modulación 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 duración precisa y un ciclo repeat con un comando waitcnt puede usarse para mantener el tiempo de ciclo de la señal Vamos a ver como se envía un pulso sencillo con un modulo contador. Este método preciso es tan bueno como el ciclo de Reloj del chip Propeller. Después de activar el contador en modo NCO solo active el registro PHS a la duración que se quiere que dure el pulso cargándolo 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 también 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 señal alta por el mismo número de ciclos de reloj que tiene el numero negativo en PHS.

El ejemplo de programa en esta sección de PWM enviara señales al circuito LED de la Figura 7-6 en la pagina 131. Si removió el circuito de la Figura 7-6 en la página 131 de su tarjeta reconstrúyalo ahora.

Enviando un Pulso Sencillo El objeto SinglePulseWithCounter usa esta técnica 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 231 – 1 = 2,147,483,647 ciclos de reloj después 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 razón aparente.



Cargue SinglePulseWithCounter.spin en el chip Propeller y verifique que envía un pulso de 1 segundo. Este pulso durara exactamente 80,000,000 ciclos de reloj.

Con el chip Propeller corriendo a 80 MHz el pin cambiara a alto nuevamente después de aproximadamente 26.84 segundos después. Verifique esto con una calculadora y esperando 27 segundos después de que la señal alta de 1 segundo término.

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. También intente programar phsa a clkfreq/1_000_000 por un pulso de 1 µs.

''SinglePulseWithCounter.spin ''Envía un pulso alto al LED en P4 que dura exactamente 80_000_000 ciclos de reloj CON _clkmode = xtal1 + pll16x ' Reloj de Sistema → 80 MHz _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 ' Envía el pulso ' Mantiene corriendo el programa y el pulso tiene tiempo para terminar. repeat

Modulación de Ancho de Pulso Para una señal repetitiva PWM el programa tiene que establecer el tiempo de ciclo usando waitcnt. Entonces la duración de pulso se determina cada vez a través 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 envía una señal alta al LED P4 por ¼ s con cada repetición. 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. Después 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. Después 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.

Corra el programa y verifique la señal alta de ¼ s cada 1 s en el LED conectado a P4 Si tiene un osciloscopio intente una señal que dure 1.5 ms, repetida cada 20 ms. Esto podría

ser bueno para hacer que un servo detenga su posición central. ''1Hz25PercentDutyCycle.spin ''Envía una señal de 1 Hz a 25% del ciclo de trabajo al LED en P4. CON _clkmode = xtal1 + pll16x ' Reloj de Sistema → 80 MHz _xinfreq = 5_000_000



PUB TestPwm | tc, tHa, t ctra[30..26] := %00100 ' Configura Contador A a NCO 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 señal 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 señales 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 (terminación sencilla)

• Un segundo pin de E/S se selecciona para señales diferenciales con ctra[14..9] := 5 • P4 y P5 se activan a salidas con dira[4..5]~~ en vez de solo dira[4]~~

Pruebe el programa y verifique que P5 está encendido cada vez que P4 está apagado. ''1Hz25PercentDutyCycleDiffSig.spin ''Versión 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 repeat ' Repite señal PWM 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 señales 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 señales del ciclo DUTY se transmiten en P4 y P6.



Intente hacer ambas señales diferenciales usando los pins E/S P4..P7. Nuevamente si tiene un osciloscopio intente crear una señal de 1.3 ms y la otra de 1.7 ms.

Esto podría hacer un robot con dos controles servos de rotación continua para ir hacia delante o hacia atrás.

TestDualPWM.spin Demuestra usando dos módulos contadores el envió de una señal PWM. El tiempo de ciclo es el mismo para ambas señales pero los tiempos altos son independiente uno del otro. CON _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _xinfreq = 5_000_000 PUB TestPwm | tc, tHa, tHb, t ctra[30..26] := ctrb[30..26] := %00100 ' Contadores A y B → NCO ' terminación 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 señales tHb := clkfreq/5 t := cnt ' Marca tiempo actual repeat ' Repite señal PWM 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 _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _xinfreq = 5_000_000 PUB TestPwm | tc, tHa, t, tInc ctra[30..26] := %00100 ' Configura Contador A a NCO 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 repeat ' Repite señal PWM phsa := -tHa ' Activa el pulso t += tC ' Calcula siguiente ciclo waitcnt(t) ' Espera siguiente ciclo

Prueba y Muestra PWM – Agrega un Objeto, Cog y Par de Contadores Como el chip Propeller tiene múltiples procesadores algunos pueden correr aplicaciones mientras otros monitorean y diagnostican códigos. En este ejemplo vamos a incorporar los objetos ya probados en la sección anterior MonitorPWM y FullDuplexSerialPlus (monitoreo/diagnostico) en el objeto TestDualPwm (aplicación). 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 código TestDualPwm (que también está utilizando dos contadores). NOTA: después de demostrar un ejemplo de uso del objeto MonitorPWM del objeto TestDualPwmWithProbes, vamos a examinar a detalle el objeto MonitorPWM. La aplicación TestDualPwmWithProbes es una versión modificada de TestDualPwm que hace posible monitorear el tren de pulsos enviados en P4 y P6 probándolos con P8. La información de prueba se muestra en la Terminal Serial Parallax mostrado en la Figura 7-19. El esquemático 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 términos de 12.5 ns ciclos de reloj. Sin embargo la aplicación puede fácilmente modificarse para mostrarlos en términos de ms µs, duty cycle, etc. Una segunda instrucción de MonitorPWM puede declararse y usarse para monitorear simultáneamente otro canal. Figura 7-19: Use P8 para Medir una Señal PWM de P6 Lista de Partes Esquemático (2) Resistencia 100 ω LED (1) LED - verde 100 ω verde (1) LED - amarillo P4 (misc) Cables LED 100 ω amarillo P6 P8 GND



El código agregado al objeto TestDualPwm monitorea y muestra el tren de pulsos en el objeto TestDualPwmWithProbes. La mayoría del código 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 declaración de objeto: probe : "MonitorPWM" • Una llamada al método start del objeto MonitorPWM que pasa la dirección de tHprobe,

tLprobe y pulseCnt, como esta: probe.start(8, @tHprobe, @tLprobe, @pulseCnt). Después de eso el objeto MonitorPWM automáticamente 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).

Asegúrese que el objeto TestDualPwmWithProbes.spin está guardado en la misma carpeta que MonitorPwm.spin y FullDuplexSerialPlus.spin.

Cargue TestDualPwmWithProbes.spin en la EEPROM (F11) e inmediatamente presione el botón Enable de la Terminal Serial Parallax.

Desconecte la terminal del cable P8 → P6 que está conectado en P6 y conéctelo a P4. La pantalla deberá mostrar la actualización de los diferentes tiempos altos y bajos.

TestDualPwmWithProbes.spin Demuestra cómo 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 _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _xinfreq = 5_000_000 ' Constantes de la Terminal Serial Parallax CLS = 16, CR = 13, CLREOL = 11, CRSRXY = 2 OBJ debug : "FullDuplexSerialPlus" 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) waitcnt(clkfreq * 2 + cnt) 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 ' Terminación 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 señales tHb := clkfreq/5 t := cnt ' Marca tiempo actual. repeat ' Repite señal PWM phsa := -tHa ' Define e inicia el pulso A phsb := -tHb ' Define e inicia el pulso B t += tC ' Calcula siguiente ciclo ' repite ' Muestra información debug.str(String(CLREOL, CRSRXY, 5, 2)) debug.dec(tHprobe) debug.str(String(CLREOL, CRSRXY, 5, 3)) debug.dec(tLprobe) debug.str(String(CLREOL, CRSRXY, 7, 4)) 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 características de un tren de pulsos (su tiempo alto y bajo). El código en otros cogs pueden transmitir pulsos y la aplicación puede usar este objeto para medir el tiempo alto y bajo de los pulsos. Hasta este punto todos los objetos han usado los módulos 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. Después pone a disposición 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 módulos contadores de esos cogs. Téngalo en cuenta mientras examina el objeto MonitorPWM:

1) Si el objeto se inicia en un cog Nuevo debe tener métodos start y stop y variables globales llamadas cog y stack. Esta es una regla introducida por Parallax que s usa en la Librería 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 práctica de Objetos).

2) El método start deberá copiar cualquier parámetro que recibe de las variables globales antes de iniciar el método que administra el proceso en el cog Nuevo.

3) El método 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 método start del objeto y el método start inicia un contador usando métodos en el cog 1 con el comando cognew. Tendrá que poner el código para la configuración del contador y asignación de pins E/S en el método 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 método start (antes de iniciar el cog) esas configuraciones afectaran al cog 0 en vez del cog 1. Esto podría crear en su caso problemas de programación porque los módulos contadores en el cog 1 no estarán disponibles para accesar los pins E/S.



MonitorPWM.spin Monitorea características de una señal 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 aplicación ------------------------------------------ 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 método 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 aplicación puede ahora usar valores de tHprobe, tLprobe, y pulseCnt para monitorear los pulsos medidos en los pins E/S pasados al método 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 también -------- TestDualPwmWithProbes.spin para un ejemplo de aplicación. 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 están en términos de ciclos de reloj. '' '' pin Numero de pin E/S '' tHighAddr dirección long que recibe la medición de la señal actual '' de tiempo alto. '' tLowAddr - dirección long que recibe la medición de la señal actual '' de tiempo bajo. '' pulseCntAddr - dirección long que recibe la medición del conteo '' actual de pulsos medidos. ' Copia la variables locales del método a variables globales del objeto ' Puede usar longmove(@apin, @pin, 4) en vez de los cuatro comandos: apin := pin ' Clave 2, copia parámetros ' 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 módulos (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, ' después 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 práctica de Objetos. La variable cog se usa para rastrear en cual cog el método start del objeto inicio el proceso. Posteriormente si se llama el método stop del objeto sabrá cual cog apagar. Como dos métodos usan esta variable tiene que ser global porque los métodos no pueden ver otras variables locales. La variable stack proporciona espacio de pila para el código que se inicia en el nuevo cog para cálculos, 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.



También se declaran variables globales llamadas apin, thaddr, tladdr, y pcntaddr. Estas variables se usan por dos métodos: start y pwmMonitor. El método start recibe parámetros de un objeto que llama y los copia en estas variables globales para que el método pwmMonitor pueda usarlas. El método 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 método start del objeto pasa el numero de pin E/S que estará monitoreando la señal junto y también las direcciones donde la medición de pulsos altos y bajos debería almacenarse y una dirección para almacenar el numero de pulsos que se han contado. Tenga en mente que estos parámetros (pin, thighAddr, tlowaddr, pulsecntaddr) son variables ocales en el método start. Para disponer de esto valores en otros métodos el método start tiene que copiarlos a variables globales. Así antes de iniciar el nuevo cog el método start copia pin a apin, tHighAddr a thaddr, tLowAddr a tlAddr y pulseCntAddr a pcntaddr. Después de eso el comando cognew inicia el método PwmMonitor en un nuevo cog y pasa las direcciones del arreglo stack. El arreglo stack se presento en la práctica de Objetos. PUB start(pin, thighAddr, tlowaddr, pulsecntaddr) : okay '... ' Copia variables locales del método a variables globales del objeto apin := pin ' Clave 2, copia parámetros ' 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 están diseñados para intercambiar información con otros objetos tienen métodos start y stop por regla. También por regla si el objeto no inicia un nuevo cog pero necesita configurarse, se utiliza un método llamado init o config. Observe la última línea en el método start. El comando cognew regresa -1 si no hay cogs disponibles o regresa el numero de cog en el que se inicio el método PwmMonitor, el cual puede ser 0 a 7. Después se suma uno a este valor y el resultado se almacena en la variable cog del objeto y el valor de regreso okay del método start. Así, el método start regresa 0 (falso) si el proceso fallo al inicio o un no-cero si tuvo éxito. El objeto llamando al método start puede usar el valor de regreso del método 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 aplicación sabe que el cog se inicio exitosamente. El método stop también puede determinar si el proceso se inicio apropiadamente porque la variable cog también almacena el resultado regresado cognew mas uno. Si se llama el método 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 método 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 método PwmMonitor se inicia en un Nuevo cog por un comando cognew en el método start. Así, hay código corriendo en el método PwmMonitor en un procesador separado dl código que llamo el método start. Lo primero que hace el método PwmMonitor es configurar los módulos contadores y los pins E/S que va a usar. Recuerde su código no puede hacer esto desde otro cog; el código ejecutado por un cog dado tiene que hacer sus propias configuraciones de contadores y asignación de pins E/S. (Vea la Clave 3 discutida previamente)

PRI PwmMonitor ' Clave 3, active módulos 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 método PwmMonitor espera a que la señal este en alto. Luego copia el contenido de phsb, lo cual acumula el tiempo bajo a una dirección en RAM principal. Recuerde que la dirección en memoria principal se paso del parámetro thighaddr del método start. El método start lo copio a la variable global thaddr. Como thaddr es una variable global es accesible en este método también. Similar con tlowaddr → tladdr y pulsecntaddr → pcntaddr. Antes de esperar medir el tiempo bajo de la señal el código limpia el registro phsb para la siguiente medida. Después de que la señal 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 número de ciclos. ' Ciclo de monitoreo PWM. repeat ' Ciclo principal ' 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 señales hasta clkfreq/2. Así con el chip Propeller P8X32A usado en estas prácticas la frecuencia tope para este modo es 40 MHz. Para señales más rápidas 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 señal a través de dos subsistemas adicionales antes de transmitirlo. Estos subsistemas no son solo capaces de enviar frecuencias de 500 kHz hasta 128 MHz, también disminuyen las fluctuaciones que hay en las señales 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á diseñado 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 señal 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 Librería Propeller, esta vez con la lista de modos PLL. Hay tres modos PLL. El primero PLL interno usado para sincronizar señales de video. Aunque aun no se comentan en esta práctica usted puede verlo aplicado en el objeto TV de la Librería Propeller. Como con los modos DUTY y NCO hay opciones de modo PLL de terminación sencilla y diferencial. Los valores CTRMODE para dirigir las señales PLL a los pins E/S son %00010 para terminación sencilla y %00011 para diferencial. Figura 7-20: Modo PLL Extractos de la Tabla de Modos Contadores del Objeto CTR Acumulado APIN BPIN CTRMODE Descripción 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 terminación sencilla 1 PLL 0 %00011 PLL diferencial 1 PLL !PLL . . . %11111 LOGIC siempre 1 0 0 * debe activar el bit correspondiente 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



El bit de campo PLLDIV del Registro CTR Para programar frecuencias de pin E/S en modo NCO se hizo directamente a través 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 todavía 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 señal el bit 31 de PHS se multiplica por 16 y luego se divide por potencia dos de su elección (20 = 1, 21 = 2, 22 = 4, … 26 = 64, 27 = 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 código 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 = 232

(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 27−PLLDIV por la frecuencia VCO:

Frecuencia VCO Frecuencia PLL = 27-PLLDIV

Ejemplo: Dado una frecuencia de reloj de sistema (clkfreq) de 80 MHz y el código 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 = 232 = 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 27−PLLDIV por la frecuencia VCO: 95_999_984 Frecuencia PLL = 27-2 = 2_999_999 MHz ≈ 3 MHz

Calculando FRQ y PLLDIV dando una Frecuencia PLL Calcular la frecuencia PLL dando algunos código 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 código 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 más 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 cálculos de la frecuencia NCO para determinar el valor del registro FRQ para la frecuencia del bit 31 de PHS. 232 Registro FRQ = Frecuencia bit 31 PHS × clkfreq

Ejemplo: clkfreq está corriendo a 80 MHz y quiere generar una señal 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: 232 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 pequeña diferencia entre la frecuencia medida y la frecuencia calculada manualmente discutida previamente. Si los cálculos delay := clkfreq + cnt en el objeto TestPllParameters.spin se coloca inmediatamente después de phsb~, el conteo de frecuencia será ligeramente menor a la actual. Si se mueve después de phsb~, la medición será ligeramente mayor que la actual. Se puede obtener una medición 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 módulos contadores. Esto coincide con el rango de muestreo de Nyquist, el cual debe ser dos veces más rápido que la frecuencia más alta. También si considera que el modo detector NEGEDGE suma FRQ a PHS cuando detecta una señal alta durante un ciclo y una señal baja en el siguiente necesita al menos dos ciclos para detectar un ciclo completo de la señal.



Calcule el registro FRQ y el bit de campo de PLLDIV para varias frecuencias en el rango de 500 kHz a 40MHz.

Cargue TestPllParameters.spin en EEPROM (F11) a inmediatamente después presione el botón Enable de la Terminal Serial Parallax.

Ingrese los valores FRQ y PLLDIV en la ventana de transmisión 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 _clkmode = xtal1 + pll16x ' Reloj de sistema → 80 MHz _xinfreq = 5_000_000 ' Constantes para la Terminal Serial Parallax. CLS = 16, CR = 13 OBJ SqrWave : "SquareWave" debug : "FullDuplexSerialPlus" PUB TestFrequency | delay, cycles Debug.Start(31, 30, 0, 57600) waitcnt(clkfreq * 2 + cnt) Debug.tx(CLS) ' Configura módulos contadores. ctra[30..26] := %00010 ' Modulo ctra a PLL modo ' terminación 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))



Detección 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 energía. Se usan en muchas aplicaciones una de las cuales es detección de metal. Hay diferentes instrumentos de detección de metales además 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 metálicas y mide precisamente la distancia de una superficie de metal desde un instrumento. Aun pensando que no hay ningún inductor en el kit PE hay muchos cables que pueden enredarse para formar pequeños inductores. Esta parte de la práctica demuestra como un cog puede usar dos contadores, uno PLL de terminación sencilla y el otro en modo POS para enviar señales de alta frecuencia a una entrada de circuito LC (Inductor Capacitor) y deducir la presencia o ausencia de metal examinando la señal 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 pequeñas y las altas frecuencias este circuito puede ser fastidioso. Para mejores resultados alámbrelo 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 también requiere ajustes. La Figure 7-23 empieza con R1 a 100 Ω, y R2 (100 Ω) y R3 (470 Ω) están en paralelo. El detalle es que estas prácticas 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 Ω.

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 Apéndice C: Lista de Componentes kit PE en la página 219

Figure 7-23: Detector de Metal Partes y Esquemático Lista de Partes Esquemático (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



Asegúrese 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 están perpendiculares.

Figura 7-24: Cableado del Detector de Metales

Detectando Frecuencia Resonante El circuito LC mostrado en la Figure 7-23 comúnmente se llama rechazo de banda, paro de banda o filtro. El Filtro atenúa ciertas frecuencias de onda senoidal de una señal de entrada, idealmente baja a nada en ciertas frecuencias. La frecuencia que se filtra se llama el centro de la frecuencia o también frecuencia resonante del circuito LC. La Figura 6-1 muestra una grafica de simulación 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

Mas acerca de filtros y programas de simulación:

Si cambia R y C || L, tendrá un filtro pasa bandas. La frecuencia de respuesta es la versión invertida de lo que muestra la Figura 7-26. Para más información en Filtros LC vea los términos de circuitos de frecuencia selectiva, filtros, pasa-bajas, pasa-altas, pasa-bandas y rechazo de banda en un libro de electrónica.

Las simulaciones en esta sección 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 ecuación 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

fR π21

=

Eq. 6

Reacomodando los términos es posible calcular la inductancia basada en la respuesta de frecuencia de las pruebas.

Cf

LR

2)2(1

π=

Eq. 7

En esta práctica la entrada del circuito LC será una onda cuadrada de P15. Aun cuando la salida está relacionada a las características de filtrado del circuito, su comportamiento tendrá más 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 típica es hacer que la salida del circuito responda rápido y preciso a la entrada. La respuesta de paso más deseable se llama amortiguación critica porque alcanza su objetivo rápidamente sin rebasarlo. Algunos diseños pueden obtener respuestas rápidas con un circuito su amortiguado pero con alguna penalidad de oscilación sobre y debajo del nuevo objetivo de voltaje antes de que la señal se estabilice. Otros diseños necesitan una respuesta de paso sobre amortiguado, lo cual es más 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 drástico de una señal su amortiguada. V(P15Step) en la grafica de arriba es la entrada de señal del circuito LC. V(P13) es la señal de salida, y V(Threshold) es una señal DC de disparo en el chip Propeller de 1.65V. La simulación no es realmente una respuesta típica porque una onda cuadrada de 50 MHz se aplico por 960 ns antes de



que la llamada de paso (señal alta) se aplicara. El resultado fue que el inductor y el capacitor acumularon alguna energía lo que hace la respuesta de V(P13) un pseudo-paso a la derecha de la marca de 960 ns más 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. También observe la línea V(P13) entre 930 y 960 ns con cada cambio de la señal de V(P15Step) 50MHz, V(P13) comienza una reacción de onda senoidal que es inicialmente opuesta a la entrada V(P15Step). Como la señal V(P13) pasa por la mitad de la onda senoidal de 50MHz antes de que la señal 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 más de ½ de su ciclo, parte de la cual paso por encima de 1.65V (marcado por la línea con el carácter +). A 49.02 MHz la onda senoidal está repitiendo mas del ciclo completo, pero no tanto, así que la señal tarda más 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 señal nuevamente pasa tiempo encima del 1.65 V de disparo, esta vez porque la señal de entrada cambia antes de que la onda senoidal ha completado su ciclo. La parte más importante de la Figura 7-27 es que la señal de salida, la cual puede monitorearse por P13, pasara más tiempo sobre él la línea de disparo lógica de 1.65 V cuando la señal 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 módulos contadores y un pequeño código para cambiar la frecuencia PWM en P15 a través 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 metálico cercano interactúa electromagnéticamente 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 también 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 mínimo en de frecuencias resonantes diferentes como resultado de un objeto metálico cercano.

Como la Corriente Eddy Afecta el Ciclo de Frecuencia Resonante Cerca de Objetos Metálicos La Figura 7-28 muestra la interacción entre un objeto metálico cerca del alambre de inductancia. Las corrientes alternas a través del ciclo crean efectos electromagnéticos. Estos campos magnéticos 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 magnético opuesto al del cable. Figura 7-28: Corrientes Eddy Causando Campos Magnéticos Opuestos

Las Corrientes Eddy mostradas en la Figura 7-28 nos da un ejemplo de cómo se transmite la potencia en líneas AC. Una espiral conectada a la línea de potencia es acoplada magnéticamente con un espiral de pocas vueltas. La corriente alterna en el primario induce un campo magnético 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 también 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 ecuación de resonancia, cambiara la frecuencia resonante del circuito LC. También 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 señal de salida del circuito cuando esta encima del punto de disparo, la aplicación puede detectar presencia o ausencia de metales.

Probando una Frecuencia Resonante El objeto Calibrate Metal Detector proporciona una conexión para probar la respuesta del circuito LC con el chip Propeller.. Como se menciono anteriormente los pequeños valores y relativa alta frecuencia usada en este circuito pueden hacerlo fastidioso. Por ejemplo si el capacitor es más que 90º del ciclo, la frecuencia resonante cae, si es menos de 90º la frecuencia resonante se incrementa. También las partes tendrán diversas características así que tomara algo de práctica para dejar el circuito a punto para que la resistencia divisora haga que la señal de salida del circuito LC se mantenga debajo del disparo el pin E/S y se mueva sobre este límite cuando la frecuencia cambie muy por encima o debajo. La Figura 7-30 muestra la salida de CalibrateMetalDetector.spin después 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 todavía hay una frecuencia resonante pero cambia alrededor de 50.6 MHz. Como el ciclo inductivo también incrementa su resistencia puede evitar atenuar la señal 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 detección automática se deja para la sección de proyectos.

Cargue CalibrateMetalDetector.spin en la EEPROM (F11) e inmediatamente después presione el botón Enable de la Terminal Serial Parallax. (Recuerde que ni siquiera tiene que esperar a que el programa termine de cargarse).

Cuando el cursor esté listo ingrese la frecuencia comenzando por 48,000,000 Ingrese una nueva frecuencia de 200,000 Compare su pantalla con la de la izquierda en la Figura 7-30, observando no tanto para que

coincidan los números pero viendo que los perfiles sean similares, lo cual muestra una frecuencia resonante centrada cuando el contador es = 0.

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.

Si la pantalla cambia significativamente como el de la derecha en la Figura 7-30 su detector medidor aparentemente no necesita mayor calibración.

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.



Si aparentemente no hay respuesta del filtro (ya sea todos ceros o valores mayores) intente las sugerencias que se muestran a continuación.

Quizá el circuito en vez de necesitar algún ajuste muestre respuestas similares a la Figura 7-30. Si en cambio ve números que están muy altos, ceros o valores muy bajos, el divisor de voltaje quizá necesite ajustarse. Está diseñado para hacer una salida justo debajo del punto de disparo.

Si ve puros ceros, el divisor de voltaje necesita estar menos distanciado de la señal. Primero intente sucesivamente resistencias mayores en lugar de R3, Intente 1 kΩ, 2 kΩ, 10 kΩ.

Si el divisor de voltaje esta aun tomando mucho de la señal 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.

Si no hay respuesta del filtro, en otras palabras, ningún grupo de valores como en la Figura 7-30 quizá necesite buscar valores de menores o mayores frecuencias después de ajustar el divisor de voltaje. Esto implica comenzar el cambio a valores bajos como 46 MHz en vez de 48 y usar incrementos más pequeños como 100,000 en vez de 200,000 y seleccionar M o Enter cuando se coloque el cursor en pantalla.

Una vez que ha tenido frecuencias resonantes buenas, puede usted también diferenciar la distancia del objeto metálico entre 1mm, 5mm y 10mm?

'' CalibrateMetalDetector.spin CON _clkmode = xtal1 + pll16x ' 80 MHz Reloj Interno _xinfreq = 5_000_000 CLS = 16, CR = 13 OBJ Debug : "FullDuplexSerialPlus" frq : "SquareWave" PUB Init | count, f, fstart, fstep, c 'Inicia FullDuplexSerialPlus Debug.start(31, 30, 0, 57600) waitcnt(clkfreq*2 + cnt) 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 detección 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 waitcnt(clkfreq/10000 + cnt) count := phsb - count Debug.Str(String(CR, "Freq = ")) Debug.Dec(f) Debug.Str(String(" count = ")) Debug.Dec(count) waitcnt(clkfreq/20 + cnt) 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) ¿Cuántos módulos contadores tiene un Cog y como son etiquetados? 2) ¿Qué términos usa esta práctica para referirse a los tres registros del modulo contador sin

especificar cual modulo se está usando? En otras palabras ¿Qué términos genéricos se usan para referirse a los tres registros del modulo contador?

3) ¿Cuáles son los tres nombres usados para referirse al contador A en código Spin? 4) ¿Cuáles son los tres nombres usados para referirse al contador B en código 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) ¿Cómo afecta el registro PHS los pins E/S con ciertos bits? 8) ¿Como indica la medición 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 medición.

¿Cual valor de CTRMODE debería tener para ser usada para medir este tipo de circuito? 11) ¿Cómo 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) ¿Cuáles 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 medición de descarga RC, ¿Que tiene que hacerse para iniciar la medición?

18) ¿Porque pueden tomarse simultáneamente mediciones RC? 19) ¿En que difiere un contador con pin E/S de la descarga RC y aplicaciones de conversión

D/A? 20) ¿Cómo controla el registro FRQ una señal D/A en modo DUTY? 21) ¿Qué componente del modulo contador controla el pin E/S? 22) ¿Qué propósito tiene scale = 16_777_216 en LedDutySweep.spin? 23) ¿Cómo se direccionan los registros de propósito especial 8 a 13? 24) ¿Qué registros de propósito especial pueden usarse para controlar el valor de ctrb? 25) ¿Qué registros de propósito especial pueden usarse para activar el valor de frqa? 26) ¿Qué tiene myVariable después de ejecutar el comando myVariable := spr[13]? 27) ¿Cuáles son las dos formas de asignar el valor almacenado en myVar a ctrb? 28) ¿Cómo puede afectar ciertos bits con spr[8] o spr[9], y porque es tan útil? 29) ¿Qué elemento del contador de registro de propósito especial controla un pin E/S en modo

NCO? 30) ¿Cuál es la condición para sumar FRQ a PHS en modo NCO? 31) ¿Qué relación 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é relación 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 señal de frecuencia? 37) ¿Son POSEDGE y NEGEDGE incrementados basándose en el límite de una señal? 38) Hay un comando escrito repeat while phsb[31] en BetterCountEdges.spin en la sección de

detección rápida de límites en la pagina 157. ¿Sera posible sustituir un registro de propósito 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 señal? 42) ¿Cuáles son los pasos para calcular la frecuencia PLL dando los valores almacenados en los

registros FRQ, PLLDIV y CLKFREQ? 43) ¿Cuáles 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 terminación sencilla para conversión D/A a 1V usando contador modulo

B y los nombres de registros del modulo contador. 3) Inicie un modo Duty terminación sencilla para conversión D/A a 1V usando contador modulo

B y registros de propósito especial. Tenga cuidado al usar elementos del arreglo de registro de propósito 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 máscara del bit 7 puesto a 1.

4) Calcule las celdas vacías 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 código 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 envíe la señal central a un servo. Esto hará

que el servo estándar se mantenga en la posición del centro de su rango de movimiento o que un servo de rotación continua se quede sin movimiento. La señal 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 estándar de 180 grados, la duración 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 práctica es bueno asegurarse que el servo no trate de moverse más allá de sus topes mecánicos. Para los servos estándar 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 terminación sencilla que le

permita crear y reclamar canales contadores DAC (Contador A y Contador B). Cada canal DAC deberá tener su propia resolución en términos de bits. El DAC deberá soportar el código prueba y documentación 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 automáticamente reducida a 128 waitcnt(clkfreq/100 + cnt) 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 ______________________________________ PUB Init(channel, ioPin, bits, level)



Inicia un DAC. • channel - 0 o 1 • ioPin - Escoge pin E/S DAC • bits - Resolución (8 bits, 10 bits, etc.) bits • level - Nivel voltaje inicial = 3.3 V * level ÷ 2 ___________________________ PUB Update(channel, level) 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 método Init usando lsb[channel] := |<

(32 - bits). Por ejemplo si bits es 8, el operador encode asigna 24 del elemento del arreglo bits. ¿Cuál 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 resultaría en 1.65 V.

2) La solución del ejercicio 12 (mostrado abajo) controla dos servos usando dos módulos

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 máximo 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 módulos contadores corren independientemente, así que tendrá que insertar retrasos para completar cada par de pulsos antes de moverse al siguiente par.

TestDualPWM.spin Demuestra cómo usar dos contadores para enviar una señal doble PWM. El tiempo de ciclo es el mismo para ambas señales, 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 terminación 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 señal PWM phsa := -tHa ' Define e inicia el pulso A phsb := -tHb ' Define e inicia el pulso B 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 conversión D/A de acuerdo a la documentación 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 módulos contadores de otro cog para conversión D/A Como usar este objeto en la aplicación ------------------------------------------ 1) Declare variables los canales D/A. Ejemplo: VAR ch[2] 2) Declare el objeto DualDac. Ejemplo: OBJ dac : DualDac 3) Llame al método 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. dac.Config(1,6,8,@ch[1]) 'Como ch[1] se activo a 180 en el paso 4, la salida P6 de DAC será ' 3.3V * (180/256) 6) Métodos y características en este objeto harán posible también:



- remover un canal DAC - cambiar un canal DAC: o Pin E/S o Resolución o Dirección variable de control o Valor almacenado por la variable control Ver también ----------- TestDualDac.spin para un ejemplo de aplicación. 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 método Config para activar un dac en un pin dado. _________ PUB Stop Detiene el proceso DAC y libera el cog. ____________________________________________________ PUB Config(channel, dacPin, resolution, dacAddress) Configura un DAC. Bloquea la ejecución 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 conversión D/A (8 = 8 bits, 12 = 12 bits, etc.) dacAddress Dirección de la variable que tiene el nivel de conversión 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 ejecución del programa hasta que otro cog completa el comando. ______________________________________ PUB Update(channel, attribute, value) Actualiza la configuración de un canal DAC. Bloquea la ejecución 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

Apéndice A: Lista de Códigos de Objetos


Apéndice A: Lista de Objetos Código

FullDuplexSerialPlus.spin '' De Parallax Inc. Kit Educativo Propeller Practica de Objetos Archivo: FullDuplexSerialPlus.spin Versión: 1.1 Derechos Reservados (c) 2008 Parallax, Inc. Ver al final del archive para términos de uso. Este es el objeto FullDuplexSerial v1.1 de la carpeta de la Librería de la Herramienta Propeller con documentación modificada y métodos para convertir cadenas de texto en valores numéricos 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/identificación cog long rx_head '9 longs próximos 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 Códigos de Objetos


PUB start(rxpin, txpin, mode, baudrate) : okay Inicia controlador serial en un cog nuevo rxpin entrada recibe señales del pin periférico de TX txpin salida envía señales al pin periférico de RX mode - bits en esta variable configuran la señal 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) '' Envía 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) '' Envía cero terminal de cadena que inicia en la dirección de memoria stringptr repeat strsize(stringptr) tx(byte[stringptr++]) PUB getstr(stringptr) | index '' Obtiene cero terminal de cadena y lo almacena, inicia en la dirección de memoria stringptr index~ repeat until ((byte[stringptr][index++] := rx) == 13) byte[stringptr][--index]~ PUB dec(value) | i '' Imprime un número 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 representación de carácter 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 representación 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) '' Envía representación de carácter de un numero binario a la terminal. value <<= 32 - digits repeat digits tx((value <-= 1) & 1 + "0") PUB GetBin : value | tempstr[11] '' Obtiene representación de carácter binario de un numero de la terminal '' Regresa el valor correspondiente GetStr(@tempstr) value := StrToBin(@tempstr) PUB StrToBin(stringptr) : value | char, index '' Convierte representación de cero terminal de cadena de un numero binario a un valor value := index := 0 repeat until ((char := byte[stringptr][index++]) == 0) if char => "0" and char =< "1" value := value * 2 + (char - "0") if byte[stringptr] == "-" value := - value PUB hex(value, digits) '' Imprime un número hexadecimal value <<= (8 - digits) << 2 repeat digits tx(lookupz((value <-= 4) & $F : "0".."9", "A".."F")) PUB GetHex : value | tempstr[11] '' Obtiene representación de carácter hexadecimal de un numero de la terminal '' Regresa el valor correspondiente GetStr(@tempstr) value := StrToHex(@tempstr) PUB StrToHex(stringptr) : value | char, index '' Convierte una representación de cero terminación de cadena de un numero hexadecimal a un valor value := index := 0 repeat until ((char := byte[stringptr][index++]) == 0) if (char => "0" and char =< "9") value := value * 16 + (char - "0") elseif (char => "A" and char =< "F") value := value * 16 + (10 + char - "A") elseif(char => "a" and char =< "f") value := value * 16 + (10 + char - "a") if byte[stringptr] == "-" value := - value DAT '******************************************* '* Controlador serial lenguaje ensamblador * '*******************************************



org ' ' ' Entry ' entry mov t1,par 'obtiene dirección 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 código 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 código 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 código rx, luego regresa mov t1,txcnt 'verifica si termino periodo transmisión 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 documentación asociados (el "Software"), para trabajar con el Software sin restricción, incluyendo sin limitación 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 GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO PERO NO LIMITADO A LAS GARANTÍAS DE COMERCIALIZACIÓN, ADECUACIÓN A UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES SERAN RESPONSABLES DE CUALQUIER RECLAMACIÓN, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN 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 módulos contadores del cog ''para transmitir ondas cuadradas PUB Freq(Module, Pin, Frequency) | s, d, ctr '' Determina parámetros CTR para síntesis 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 división long binaria. Esto es más rápido que la librería de punto flotante y toma menos espacio de código. Este método es una adaptación del método fracción 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 división long de a/b f <<= 1 if a => b a -= b f++ a <<= 1

Apéndice B: Estudio de Soluciones


Apéndice 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 código Spin se almacena en la RAM global del chip Propeller y el cog corriendo un

programa interprete obtiene y ejecuta el código. 5) En vez de ejecutar código Spin que obtiene y ejecuta de la RAM global, el código 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 más concreta y centrada en Propeller seria que un método en un bloque de código con un mínimo de reglas de accesos declarados y nombre; mientras que un objeto es u n bloque comprimido de todos los códigos en un archivo .spin. Cada objeto contiene uno o más métodos.

7) Es el objeto que proporciona un punto de inicio para una aplicación 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 aplicación.

8) Cada bit en dira active la dirección (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 condición while especifica mantener corriendo el ciclo mientras una condición es verdadera. La condición until se uso para mantener el código 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 indentación.

12) El objetivo del valor del comando waitcnt fue típicamente calculado al sumar alguna fracción 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 práctica _clkmode se uso para definir la retroalimentación del cristal del chip Propeller y activar el PLL. Para más información revisar los términos en el Manual Propeller.

14) Multiplica la frecuencia por un valor. Las opciones de múltiplos 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 dirección 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 Máximo<#=,

Limite mínimo #>=, 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 comparación 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 práctica el valor que regresa ina para un bit fue 1 o 0 lo cual funciona bien para bloques if porque el código se ejecuta si una condición es no cero o no se ejecuta si la condición es cero (-1 es no cero)

26) Global y Local. Variables globales se declaran en una sección VAR del objeto. Variables locales solo se usan por un método según se ejecuta.

27) Los tres tamaños 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 automáticamente tamaño long mientras que las variables globales pueden declararse como byte, Word o long.

28) Un carácter pipa |se usa para declarar variables locales a la derecha de la declaración de método. A la derecha de la pipa, puede declararse más de un nombre de variable separando por comas.

Soluciones a Ejercicios de la Practica de E/S y Tiempo 1) Solución:

outa[8..12] := dira[8..12] := %1111

2) Solución: dira[9] := outa[9]:= 1 outa[13..15] := %000 dira[13..15] := %111

3) Solución:

dira[0..8] :=%111000000

4) Solución: outa[8]~~ outa[9]~ repeat !outa[8..9] waitcnt(clkfreq/100 + cnt)

5) Solución:

repeat outa[0..7]!= ina[8..15]



6) Solución: CON _xinfreq = 5_000_000 _clkmode = xtal1 + pll2x 7) Solución:

waitcnt(clkfreq*5 + cnt)

8) Solución: outa[5..11]~~ waitcnt(clkfreq*3 + cnt) outa[5..11] := %1010101

9) Solución:

PUB LightsOn | counter dira[4..9] := %111111 repeat counter from 4 to 9 outa[counter] := 1 waitcnt(clkfreq + cnt) repeat

10) Solución: PUB method dira[27] := 1 repeat if ina[0] outa[27]~~ waitcnt(clkfreq*5 + cnt) outa[27] ~

11) Solución:

PUB SecondCountdown dira[9..4]~~ repeat outa[9..4] from 59 to 0 waitcnt(clkfreq + cnt)

12) Solución:

PUB SecondCountdown dira[9..4]~~ repeat repeat outa[9..4] from 59 to 0 waitcnt(clkfreq + cnt)

13) Solución:

PUB PushTwoStart dira[4]~~ repeat until ina[23..21] == %101 outa[4]~~

14) Solución:

PUB PushTwoCountdown dira[9..4]~~ repeat until ina[23..21] == %101 outa[4]~~ repeat outa[9..4] from 59 to 0 waitcnt(clkfreq + cnt)



Soluciones a Proyectos de la Practica E/S y Tiempo 1) Ejemplo de Solución:

''File: NonActuatedStreetlights.spin ''Un prototipo alta velocidad de semáforo controlador N/S E/O. PUB StreetLights dira[9..4]~~ ' Activa pins E/S a salida repeat ' Ciclo principal 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 waitcnt(clkfreq * 3 + cnt) ' 3 s outa[4..9] := %100001 ' N/S rojo, E/O Verde waitcnt(clkfreq * 8 + cnt) ' 8 s outa[4..9] := %100010 ' N/S rojo,E/O amarillo waitcnt(clkfreq * 3 + cnt) ' 3 s

2) Ejemplo de Solución:

''File: ActuatedStreetlightsEW.spin ''Un prototipo alta velocidad de semáforo controlador N/S E/O. PUB StreetLightsActuatedEW dira[9..4]~~ ' Activa pins E/S a salida repeat ' Ciclo Principal outa[4..9] := %001100 ' N/S verde, E/O rojo repeat until ina[21] ' Auto en calle E/O waitcnt(clkfreq * 3 + cnt) ' 8 s outa[4..9] := %010100 ' N/S amarillo,E/O rojo waitcnt(clkfreq * 3 + cnt) ' 3 s outa[4..9] := %100001 ' N/S rojo, E/O verde waitcnt(clkfreq * 8 + cnt) ' 8 s outa[4..9] := %100010 ' N/S rojo,E/O amarillo waitcnt(clkfreq * 3 + cnt) ' 3 s


''File: LedFrequenciesWithoutCogs.spin ''Experimente la molestia de desarrollar procesos que de otra ''manera podrían 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] if count // T_LED_P5 == 0 !outa[5] if count // T_LED_P6 == 0 !outa[6] if count // T_LED_P7 == 0 !outa[7] if count // T_LED_P8 == 0 !outa[8] if count // T_LED_P9 == 0 !outa[9]


''File: MinuteSet.spin ''Imita botones de alarma de reloj. PUB SetTimer | counter, divide dira[9..4]~~ ' Activa pins E/S a salida repeat ' Ciclo principal 'Retrasa por 1 ms. waitcnt(clkfreq/1000 + cnt) ' Retrasa 1 ms Si se presiona un botón... NOTA: Reiniciar el contador a -1 hace posible presionar y soltar rápidamente el botón y avanzar la pantalla minuto sin ningún retraso aparente. if ina[21] or ina[23] ' si se presiona botón 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 duración de tiempo ms if counter > 2000 ' Si contador > 2000 (10 incrementos) divide := 50 ' 50 ms entre incrementos else ' de lo contrario divide := 200 ' 200 ms entre incrementos 'Si uno de los ciclos de ms han pasado if counter // divide == 0 ' si paso un tiempo



if ina[21] ' si botón P21 se presiona outa[9..4]++ ' incrementa outa[9..4] elseif ina[23] ' si botón 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 ' Ciclo principal repeat until ina[22] ' Quiebra si 'Retraso de 1 ms. waitcnt(clkfreq/1000 + cnt) ' Retraso 1 ms Si se presiona un botón... NOTA: Reiniciar el contador a -1 hace posible presionar y soltar rápidamente el botón y avanzar la pantalla minuto sin ningún retraso aparente. if ina[21] or ina[23] ' Si se presiona un botón 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 duración de tiempo if counter > 2000 ' Si contador > 2000 (10 incrementos) divide := 50 ' 50 ms entre incrementos else ' de lo contrario divide := 200 ' 200 ms entre incrementos 'Si uno de los tiempos ha pasado if counter // divide == 0 ' si uno de los tiempos ha pasado if ina[21] ' si botón P21 se presiona outa[9..4]++ ' incrementa outa[9..4] elseif ina[23] ' de otra forma si botón 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 Métodos y Cogs

Soluciones a las Preguntas de la Práctica Métodos y Cogs 1) Automáticamente regresa el control del programa y un valor a la llamada de método. 2) Eso depende de cuantos parámetros de variables locales aparezca en la lista de parámetros de

las definiciones de método. La llamada a método pasa un valor a cada parámetro. 3) Uno 4) Si no hay valor especificado el método regresa el valor almacenado en su resultado variable,

el cual es iniciado a cero cuando el método se llama. Un apodo para la variable resultante se puede declarar a la derecha del parámetro seguida por dos puntos. Por ejemplo un método declarado PUB MyMethod(parameter1, parameter2) : returnAlias regresara el valor almacenado por la variable returnAlias.

5) Una llamada de método y la dirección 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 automáticamente inicia un método en el siguiente cog disponible y

regresa el numero de cog, mientras coginit permite especificar cual cog se va a usar para iniciar un método

8) Usar el comando cogstop. 9) Regresa información de dirección, regresa resultado, valor de parámetros 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 cálculos y operaciones de ciclo. 11) Un Segundo grupo de valores (dirección de regreso, resultado regresado…) se agrega a la

pila. Cuando el método regresa el espacio de pila se reclama. 12) Declarar más espacio de pila de la que se piensa se va a usar. 13) El comando cognew regresa el valor del cog donde el método se inicio 14) Si, Se demostró en la sección Indexando Identificaciones de Cog

Soluciones a los Ejercicios de Métodos 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]) swCog[2] := cognew(SquareWave(9, clkfreq/2000, clkfreq/500), @swStack[80])

Soluciones a los Proyectos de la Practica Métodos y Cogs 1) Ejemplo de Método:

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)

2) Ejemplo de Solución: ''File: TestSquareWaveMethod.spin CON _xinfreq = 5_000_000 _clkmode = xtal1 + pll16x VAR long swStack[120] byte swCog[3] PUB TestSquareWave swCog[0] := cognew(SquareWave(5, clkfreq/20, clkfreq/10), @swStack) swCog[1] := cognew(SquareWave(6, clkfreq/100, clkfreq/5), @swStack[40]) swCog[2] := cognew(SquareWave(9, clkfreq/2000, clkfreq/500), @swStack[80])

3) No se da solución, diviértase experimentando!



Soluciones al Estudio de la Practica de Objetos

Soluciones a las Preguntas de la Practica de Objetos 1) Una llamada de método en el mismo objeto usa el nombre del método. Una llamada a un

método en otro objeto usa un apodo que fue dado objeto en el bloque OBJ, luego un punto y luego el nombre de método. Así la diferencia es en vez de usar el NombreMetodo es ApodoObjeto.NombreMetodo

2) No, los parámetros se pasan y regresa de la misma forma que se haría en un método 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 información (F8) y también 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 documentación de texto puede definirse con dobles llaves Comentarios de documentación

6) Presionando el botón de Documentación sobre el código. 7) Nombres de Método Start y Stop. 8) Declare múltiples copias del objeto en la sección OBJ, y llame cada uno de sus métodos

Start. 9) Si el proceso que administra el objeto está corriendo en otro cog, la llamada al método Stop

lo termina antes de iniciar el proceso en un cog nuevo. 10) Presionando en los caracteres de la Herramienta Propeller 11) Métodos públicos se declaran con PUB, privados con PRI. Métodos públicos pueden llamarse

por comandos en otros objetos; métodos privados solo pueden llamarse del mismo objeto. 12) Declare múltiples 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 código objeto. Cada instrucción utiliza la misma copia de código 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 información de interface del objeto presione el botón de documentación y la

herramienta Propeller automáticamente genera esa información y la muestra junto con los comentarios de documentación.

15) En los códigos de programa. 16) Dada una dirección de inicio en RAM el método Str del Objeto FullDuplexSerial obtiene y

transmite caracteres hasta que obtiene un cero. 17) Comentarios de documentación deben explicar que hace el método, sus parámetros (si hay) y

sus valores de regreso. 18) Cadenas de caracteres y otras listas de valores pueden almacenarse en una sección del objeto

DAT 19) Se usan para (1) declarar variables en bloques VAR, (2) Declarar tamaños 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 números 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 códigos byte del programa. El comando a := 1.5 copia el valor en una variable

23) Una dirección de variable se pasa a un parámetro de método 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 método del objeto.

25) El objeto usara long, word o byte y las direcciones. Por ejemplo, si la dirección se pasa a un parámetro 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 automáticamente basado en ese valor.

27) Si, Esto se usa cuando un proceso está corriendo en otro cog y el objeto padre necesita uno o más de sus variables para actualizarse automáticamente por otros procesos,

Soluciones a los Ejercicios de la Practica de Objetos 1) Solución:

led : "MyLedObject"

2) Solución: led.On(4)

3) Con la ayuda del mapa de Caracteres de la Herramienta Propeller: 102, 32, 61, 32, 84, 22.

4) Solución:

PRI calcArea(height, width) : area

5) Solución: Uart[5] : "FullDuplexSerial"

6) Solución:

uart[2].str(String("Hello!!!"))

7) Solución: DAT Hi byte Hello!!!, 0

8) Solución:

c := f.fmul(d, pi)

9) Solución: address := fst(c)

Soluciones a los Proyectos de la Practica de Objetos 1) Objeto Ejemplo:

Bs2IoLite.spin Las características de esta llamada a método 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 señal 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 código debajo del objeto/código probándose para uso de pila se reemplazo con el código del objeto Blinker. La variable de pila de objeto Stack se incremento a 32 longs. Así en el código temporal para probar la sección de uso de pila la llamada a método start se modifico para trabajar con el objeto Blinker. Corra el objeto StackLenghtDemo para probar la pila requerida por el método Blink para iniciar otro cog. Después 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 método en la práctica, este proyecto expone un error en la sección titulada “Cuanto espacio de pila se necesita para iniciar un cog?” La variable local time se elimino del método Blink pero no de la discusión de cuanto espacio de pila necesita el método Blink.

StackLengthDemoModified.spin Esta es una versión modificada del Objeto StackLengthDemo de la carpeta de librería demos del Propeller. Esta versión modificada prueba el método Blink del objeto Blinker de la Práctica de Objetos del Kit Educativo Propeller para requerimientos de espacio de pila. Ver proyecto #2 en la práctica de Objetos para más información.



••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• Código Temporal para uso de Pila ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• CON _clkmode = xtal1 + pll16x 'Usa cristal * 16 para serial rápida _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 código/objeto bajo prueba waitcnt(clkfreq * 3 + cnt) 'Espera tiempo para uso máx. de pila Stk.GetLength(30, 19200) 'Transmite resultados salida serial P30 a 19,200 baud ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• Probando Código/Objeto para uso de pila ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• File: Blinker.spin Ejemplo administración de cog para proceso LED blinking. SCHEMATIC 100 ω LED pin GND VAR long stack[32] 'Cog Espacio de pila byte cog 'Cog ID PUB Start(pin, rate, reps) : success Inicia Nuevo proceso blinking en Nuevo cog; Regresa verdadero si tiene éxito. Parámetros: pin la E/S conectada al circuito LED → ver esquemático rate Ciclo encendido/ Apagado definido por ciclos de reloj reps el número de ciclos encendido/apagado Stop success := (cog := cognew(Blink(pin, rate, reps), @stack) + 1) PUB Stop ''Detiene proceso Blinking, si hay. if Cog cogstop(Cog~ - 1) PUB Blink(pin, rate, reps)



Parpadea un circuito LED conectado a un pin a una frecuencia dada por rep repeticiones Parámetros: pin la E/S conectada al circuito LED → ver esquemático rate Ciclo encendido/ Apagado definido por ciclos de reloj reps el número de ciclos encendido/apagado dira[pin]~~ outa[pin]~ repeat reps * 2 waitcnt(rate/2 + cnt) !outa[pin]

3) Esta solución usa variables globales para days, hours, minutes, y seconds, y el método

GoodTimeCount actualiza los cuatro valores. También es posible solo seguir segundos y usar otros métodos para convertir a días, 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. Parámetros valores de inicio para: setDay - día 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 parámetros del método Parámetros: dayAddr - dirección variable día hourAddr - dirección variable horas minAddr - dirección variable minutos secAddr - dirección 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 Módulos Contadores y Aplicaciones de Circuitos

Soluciones a Preguntas de Módulos Contadores y Aplicaciones de Circuitos 1) Cada cog tiene dos módulos 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

terminación 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 medición 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) Después de que el capacitor se carga completamente, su voltaje tomara un tiempo en

descargarse mientras drena a través de una Resistencia. Como resultado el voltaje tarda cierto tiempo arriba del límite lógico 1.65V. Por cada ciclo de reloj que el voltaje está por encima del disparo lógico del pin E/S suma el valor de FRQ a PHS. Después de que se descargo el voltaje FRQ ya no se suma a PHS, así PHS continua almacenando el número de ciclos que la seña estaba en alto.

12) En bits 30..26 de un registro dado CTR. 13) El modo de una operación 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 medición, 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 después 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 están descargando pero que están por encima del disparo lógico. 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 conversión D/A el modulo contador está controlando un pin E/S.

20) El rango de FRQ a 232determina 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 código para seleccionar de 256 diferentes niveles en vez de 232

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 condición de acuerdo a CTR.spin as Siempre, quiere decir que el registro FRQ se suma al

registro PHS con cada ciclo de reloj. 31) 232/clkfreq 32) clkfreq/232 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 señal 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 número de transiciones

en un determinado tiempo para almacenar frecuencia. Detectores positivos y Negativos también se pueden usar para rastrear el tiempo alto y bajo el cual puede usarse para calcular frecuencia de una señal.

37) No, comparan el estado del estado actual lógico del pin E/S con el estado lógico del ciclo previo. Si por ejemplo el estado lógico previo del pin fue 0 y el estado actual es 1, en modo POPSEDGE sumara FRQ a PHS porque ocurrió una transición positiva.

38) No, mientras spr[13] refiere a phsb, no es bit direccional. El comando repeat while esta refiriéndose a un bit en el registro phsb. Sería posible determinar el valor de ese bit usando varias operaciones, tomaría más 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 27-PLLDIV.

43) (1) Calcula el PLLDIV, lo cual es la potencia de 2 que la frecuencia VCO tendrá para este cálculo. (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 Módulos Contadores y Aplicaciones de Circuitos 1) Solución:

... ' 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) Solución: 'El duty para esta señal es 1/3.3. Como duty = FRQ/232, podemos resolver 1/3.3 = 'FRQ/232 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) Solución: 'El duty para esta señal es 1/3.3. Como duty = FRQ/232, podemos resolver 1/3.3 = 'FRQ/232 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 × 232 / (clkfreq = 80 MHz) redondeado al entero más 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 × 232 / (clkfreq = 20 MHz) = 224_734 (redondeado al entero más 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) Solución: ... '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 sería 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 método TestPwm. Cambie repeat a repeat tHa from (700 * us) to (2200 * us).

12) Solución:

TestDualPWM(Exercise 12).spin Usando dos módulos contadores demuestra como enviar una señal PWM. El ciclo de tiempo es el mismo para ambas señales pero los tiempos en alto son independientes uno del otro. CON _clkmode = xtal1 + pll16x ' Reloj sistema → 80 MHz _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 terminación sencilla ctra[5..0] := 4 ' Activa 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 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 t := cnt ' Marca tiempo actual. repeat tHa from (700 * us) to (2200 * us) ' <- Cambia señal Repeat PWM phsa := -tHa ' Define e inicia el pulso A phsb := -tHb ' Define e inicia el pulso B t += tC ' Calcula ciclo repeat waitcnt(t) ' Espera por ciclo

Soluciones a Proyectos de Módulos Contadores y Aplicaciones de Circuitos 1) Solución: Versiones comentadas y no comentadas de DAC 2 Channel.spin se muestran

abajo. Note en la versión no comentada que realmente no toma mucho código para llevar a cabo la especificación del proyecto.

''DAC 2 Channel.spin



''Objeto 2 channel DAC. Cada canal se puede configurar para pin E/S y resolución (bits) VAR ' Almacena valores que funcionan como escaleras LSB para los registros FRQ. long lsb[2] PUB Init(channel, ioPin, bits, level) Inicia un DAC. • channel - 0 o 1 • ioPin - Escoge pin E/S DAC • bits - Resolución (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 PUB Update(channel, level) '' 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 módulo 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 (versión no comentada) VAR long lsb[2] PUB Init(channel, ioPin, bits, level) dira[ioPin]~ spr[8 + channel] := (%00110 << 26) + ioPin lsb[channel] := |< (32 - bits) Update(channel, level) dira[ioPin] ~~ PUB Update(channel, level) spr[10 + channel] := level * lsb[channel PUB Remove(channel) dira[spr[8+channel] & %111111]~ spr[8+channel]~



2) Solución: Líneas sumadas están marcadas abajo. Vamos a asumir que los servos están conectados a P5 y P7. En el ciclo repeat los campos PIN de ctra y ctrb tendrán que activarse a 4 y 6 por el primer par de pulsos, luego cambiar a 5 y 7 por el segundo grupo de pulsos. También un waitcnt tiene que agregarse después de cada par de pulsos para que los pulsos puedan terminar antes de moverse al siguiente par de pulsos A este punto el código todavía 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 módulos contadores demuestra como enviar una señal dual PWM. El tiempo de ciclo es el mismo para ambas señales 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 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 terminación sencilla ctra[5..0] := 4 ' Activa pins 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 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 t := cnt ' Marca tiempo actual. repeat tHa from (700 * us) to (2200 * us) ' <- Cambia señal 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 phsb := -tHb ' Define e inicia el pulso B 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 phsa := -tHa ' Define e inicia el pulso A phsb := -tHb ' Define e inicia el pulso B 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) Solución Objeto DAC: (Trabaja pero tenga en cuenta que no es la única solución posible)

''DualDac.spin ''Proporciona dos canales de módulos contadores de otro cog para conversión D/A Como usar este objeto en la aplicación ------------------------------------------ 1) Declare canales D/A variables. Ejemplo: VAR ch[2] 2) Declare el objeto DualDac. Ejemplo: OBJ dac : DualDac 3) Llame el método start. Ejemplo: PUB MethodInMyApp '... dac.start 4) Active salidas D/A. Ejemplo: ch[0] := 3000 ch[1] := 180 5) Configure 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 paso 4, la salida DAC P4 será '3.3V * (3000/4096) 'Canal 1, pin 6, 8-bit DAC, ch[1] almacena el valor DAC. dac.Config(1,6,8,@ch[1]) 'Como ch[1] se activo a 180 en paso 4, la salida DAC P6 será ' 3.3V * (180/256) 6) Métodos y características en este objeto también hace posible: - remover un canal DAC - cambiar en canal DAC: o pin E/S o Resolución o Dirección de Control variable o Valor almacenado por la variable control ver también -------- TestDualDac.spin para un ejemplo de aplicación. 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 método 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) PUB Config(channel, dacPin, resolution, dacAddress) '' Configura un DAC. Bloque ejecución de programa hasta que otro cog completa el comando. '' channel - 0 = canal 0, 1 = canal 1 '' dacPin - número pin E/S que desarrolla el D/A '' resolution - bits de conversión D/A (8 = 8 bits, 12 = 12 bits, etc.) '' dacAddress dirección de la variable que tiene el nivel de conversión D/A, un valor entre 0 y (2^resolucion) - 1. ch := channel ' Copia parámetros 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 ejecución hasta que se completa cmd. PUB Remove(channel) '' Remueve un canal. Activa canales pin E/S a entrada y limpia el modulo contador. '' Bloque ejecución de programa hasta que otro cog completa el comando. ch := channel ' Copia parámetro a variable global cmd := 5 ' Activa comando para PRI DacLoop. repeat while cmd ' Bloque ejecución hasta completar cmd. PUB Update(channel, attribute, value) '' Actualiza configuración de canal DAC. '' Bloquea ejecución 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 parámetro 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 resolución.



2 : dacAddr[channel] := value ' 2 = Cambia dirección variable de control. 3 : long[dacAddr] := value ' 3 = Cambia valor de variable de control. repeat while cmd ' Bloquea ejecución 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 configuración DAC basada ' en cmd. temp := cmd >> 16 ' Si attribute = 0, temp obtiene pin. case cmd & $FF ' Mascara cmd y evalúa caso por caso. 4: ' 4 -> Configura DAC. spr[8+ch] := (%00110 << 26) + pin[ch] ' Almacena mode y pin en registro CTR. dira[pin[ch]]~~ ' Dirección 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 dirección pin E/S -> salida cmd := 0 ' limpia cmd para detener bloqueo en otro cog. Solución – 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 debug : "FullDuplexSerialPlus" dac : "DualDAC" PUB TestPwm | channel, dacPin, resolution, ch[2], menu, choice debug.start(31, 30, 0, 57600) waitcnt(clkfreq * 2 + cnt) 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(@_Channel) channel := debug.getdec debug.str(@_Value) ch[channel] := debug.getdec "U", "u": debug.str(@_Update) case choice := debug.rx "P", "p": debug.str(@_Channel) channel := debug.getdec debug.str(@_Pin) dacPin := debug.getdec dac.update(channel, 0, dacPin) "B", "b": debug.str(@_Channel) channel := debug.getdec debug.str(@_Resolution) resolution := debug.getdec dac.update(channel, 1, resolution) "R", "r": debug.str(@_Channel) channel := debug.getdec 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

Apéndice C: Lista de Componentes


Apéndice C: Lista de Componentes kit PE Partes, cantidades y estilos de están sujetos a cambios sin previo aviso.

Tabla C-1: Kit Educativo Propeller – Versión 40-Pin DIP (#32305)

# Parte Cant. Descripción

130-32305 1 Propeller DIP Plus Kit, ver Tabla 3-3 en página 25

130-32000 1 Kit de partes Proyecto Propeller, ver Tabla C-2 abajo

700-00077 1 Breadboard Set, ver Tabla 3-1 en página 24

32201 1 Propeller Plug con Cable retráctil USB A a Mini-B, ver Tabla 3-2 en página 24

110-32305 1 Caja de plástico

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 (1µF)

201-01062 2 Capacitor 10 µF, electrolítico (10µF)

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

Apéndice D: Diagrama de Bloque del Microcontrolador


Apéndice D: Diagrama de Bloque del Micro controlador


Apéndice E: LM2940CT-5.0 Límite de Corriente A pesar de que el regulador de voltaje LM2940CT-5.0 marca una temperatura comercial de 0 °C a 125 °C el diseño 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 máxima salida de corriente a una temperatura dada. Tenga en mente que las placas del kit PE están diseñadas para utilizarse en temperatura ambiente y que el plástico 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 máxima unión admisible a la resistencia térmica del ambiente (θJA) para el empaque TO220 utilizado en el kit PE es 53 °C/W. Esta cantidad puede describirse en términos del máximo pico permitido (TRMAX) y la potencia disipada (PD) como:

W

CP

T

D

MAXRJA °≥= 53)(θ

...donde TR(MAX) es la diferencia entre la máxima unión posible de temperatura (TJ(MAX)) y la máxima temperatura ambiente TA(MAX). La unión máxima de temperatura es 125 °C para el LM2940CT-5.0 )()()()( 125 MAXAMAXAMAXJMAXR TCTTT −°=−= PD también está relacionada a la entrada de voltaje (VIN), salida de voltaje (VOUT), carga de corriente (IL), y corriente estática (IG) por: GINLOUTIND IVIVVP )()( +−= Para el kit PE, VIN = 9 V, VOUT = 5 V, y de la hoja de datos, IG no excederá 20 mA. Resolviendo para la carga de corriente en términos de las otras variables y contantes tenemos:

OUTIN

GINJA

MAXAMAXJ

L VV

IVTT

I−

−−

≤

)()()(

θ

Substituyendo las constantes proporcionadas por la hoja de datos, la carga de corriente como una función de la temperatura máxima de ambiente para un voltaje de entrada fijo de 9V.

VV

mAVWC

TC

I

MAXA

L 59

)20()9(/53

125 )(

−

−°

−°

≤

)(

3 )1072.4(545.0 MAXAL TI −×−≤

Apéndice D: Diagrama de Bloque del Microcontrolador


Para una temperatura ambiente máxima de 80 °F ≈ 26.7 °/C, la máxima carga de corriente IL = 419 mA.

Salida ESR de Capacitor La hoja de datos LM2940 tiene requerimientos de estabilidad para la salida capacitancia (mínimo 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 especificación del catalogo para este capacitor estipula que la perdida de disipación (tan δ) es 0.16 a 120KHz para un capacitor de 1000 µF, 25V. De acuerdo a Nichicon’s General Description of Aluminum Electrolytic Capacitors, la pérdida por disipación en el reciproco de la impedancia, lo cual puede usarse para determinar el ESR (NOTAS TECNICAS CAT.8101E, Pagina 6) )(21tan ESRfC

XCπδ ==

Ω=== 212.0

)1000(120216.0

2tan

μππδ

fCESR

Las especificaciones de la serie VR también establecen que el rango de la máxima impedancia de (Z-25°C)/(Z+20°C) es 2. Este rango de impedancia junto con el cálculo 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 electrolítico pueden incrementarse drásticamente 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. fundamentos

Documents