• Author / Uploaded
• Jhoel Huachaca Benites

• Categories
• Entorno de desarrollo integrado
• Programa de computadora
• Compilador
• Archivo de computadora
• Memoria del ordenador

Citation preview

  Digital Signal Processor ­ DSP. 

 

2

Nota:

Guía del Usuario Digital Signal Processor 

Todos los ejemplos de esta guía fueron desarrollados y probados especialmente para el DSP TMS320 F28016, utilizando la placa de desarrollo creada por OLIMEX (TMS320-P280161). Por lo tanto, los proyectos, sugerencias y comentarios pueden no necesariamente funcionar en otros modelos DSP. Para aprovechar mejor esta guía, se recomienda al lector tener conocimientos básicos de programación en C/C++ (struct, funciones, main(), #define, etc.) y de microcontroladores y periféricos (direccionamiento, registros, interrupciones, etc.). La información entregada en esta guía es referencial y es suficiente para tener un concepto general del modo de uso de un DSP. En ningún caso representa una guía completa sobre cómo utilizar cualquier elemento del mismo. Para mayor detalle descargar la documentación desde www.ti.com o las guías más importantes y proyectos de ejemplo desde www.olimex.cl en la sección Tarjetas Olimex->DSP.

3

Guía del Usuario Digital Signal Processor 

Tabla de Contenidos. 1 2

3

4

5 6

Introducción. ................................................................................................................... 7 Detalles técnicos. ............................................................................................................ 9 2.1 Procesador DSP. ..................................................................................................... 9 2.2 Tarjeta de Desarrollo para el DSP. ....................................................................... 14 Programación. ............................................................................................................... 17 3.1 Flujo de un programa............................................................................................ 17 3.2 CodeComposer Studio. ......................................................................................... 18 3.2.1 Características............................................................................................... 19 3.3 ¿Cómo Programar? Hola Mundo! ........................................................................ 20 3.3.1 Instalación y Configuración CCS. ................................................................ 20 3.4 Blinking Led. ........................................................................................................ 24 3.5 Debuggear............................................................................................................. 29 3.5.1 Escribir datos en un Archivo de Salida ........................................................ 35 3.5.2 Leer Datos en un Archivo de Salida ............................................................. 37 3.5.3 Graficar datos en tiempo real........................................................................ 37 3.6 Conversor ADC. ................................................................................................... 40 3.7 Uso de Archivos GEL .......................................................................................... 45 3.8 Ejemplo Echo Back usando SCI........................................................................... 48 Ejemplo......................................................................................................................... 50 4.1 ¿Cómo crear un nuevo Proyecto? ......................................................................... 50 4.2 Uso de librería FFT y otras modificaciones. ........................................................ 55 4.3 Filtrado de Señales. .............................................................................................. 60 Resumen Atajos Teclado. ............................................................................................. 64 Manuales de Referencia de TI.COM ............................................................................ 65

4

Guía del Usuario Digital Signal Processor 

Índice de Figuras. Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura

1-1 Esquema del uso de un DSP. ............................................................................... 7 2-1 Mapa de memoria del DSP. ............................................................................... 11 2-2 Diagrama de bloques del DSP. .......................................................................... 13 2-3 Tarjeta de desarrollo para el DSP TMS320 F28016. ......................................... 14 2-4 Esquemático de la tarjeta de desarrollo TMS320 F28016. ................................ 15 3-1 Flujo de un Programa Tipo. ............................................................................... 17 3-2 Selección de Configuración de la Tarjeta. Emulador XDS100. ........................ 21 3-3 Nombre de la Conexión. .................................................................................... 22 3-4 Elección de modelo del DSP. ............................................................................ 22 3-5 Propiedades del Procesador. .............................................................................. 23 3-6 Presionar el Botón Save & Quit......................................................................... 23 3-7 Botones para Compilar. ..................................................................................... 24 3-8 Placa Conectada o no Conectada. ...................................................................... 25 3-9 Cargar un Programa. .......................................................................................... 25 3-10 Modo de Booteo del ejemplo. M0 SARAM. ................................................... 26 3-11 Cambio valor BLINK_TIME. ......................................................................... 27 3-12 Cambio para apagar el LED al presionar el botón. .......................................... 27 3-13 Colocación de un Breakpoint........................................................................... 29 3-14 Valor de una variable en tiempo de ejecución. ................................................ 30 3-15 Step-over (F10) y Step-into (F11). .................................................................. 30 3-16 Watch Window. ............................................................................................... 31 3-17 Agregar variables Globales.............................................................................. 33 3-18 Elección de Variables Globales. ...................................................................... 34 3-19 Parte del esquemático de la tarjeta. Botón de GPIO 9. .................................... 34 3-20 Administrador de Breakpoints. ........................................................................ 35 3-21 Menú contextual de Action. ............................................................................. 35 3-22 Parámetros para escribir datos en un archivo. ................................................. 36 3-23 Indicador de largo de las variables. ................................................................. 36 3-24 Leer datos desde un archivo............................................................................. 37 3-25 Parámetros para graficar una señal. ................................................................. 38 3-26 Gráfico realizado con los datos. ....................................................................... 39 3-27 Diagrama de Bloques del ADC. ...................................................................... 41 3-28 Diagrama Simple del Bloque ADC. ................................................................ 42 3-29 Trimmer AN_TR, botón GPIO9 y Led GPI11. ............................................... 43 3-30 Ejemplo Conversor ADC. ................................................................................ 44 3-31 Menú desplegable para archivo GEL............................................................... 46 3-32 Programa EchoBack con Hyperterminal. ........................................................ 49 4-1 Creación de un proyecto. ................................................................................... 50 4-2 Guardar Código Fuente...................................................................................... 51 4-3 Opciones par incluir archivos de cabecera. ....................................................... 52 4-4 Carpetas del proyecto. ....................................................................................... 53 4-5 Configuración Build_Option. ............................................................................ 54

5

Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura

Guía del Usuario Digital Signal Processor 

4-6 Configuración de botones. ................................................................................. 55 4-7 Función Gpio_Select(). ...................................................................................... 56 4-8 Inclusión de librerías usando “” o . ............................................................... 56 4-9 Forma de incluir una librería al CCS. ................................................................ 57 4-10 Código básico para utilizar la FFT. ................................................................. 58 4-11 Funciones disponibles para la FFT. ................................................................. 59 4-12 Comand Linker de ejemplo para ocupar la librería FFT. ................................ 60 4-13 Comand Linker mínimo para librería FFT. ..................................................... 60 4-14 Esquema de un Filtro FIR. ............................................................................... 61 4-15 Ejemplo código para Historial. ........................................................................ 62 4-16 Macro para definir filtro. ................................................................................. 62 4-17 Código para Convolución. ............................................................................... 62

6

Guía del Usuario Digital Signal Processor 

Índice de Tablas. Tabla 3-1 Configuración Jumpers para Booteo. ................................................................... 26 Tabla 3-2 Archivos principales de un proyecto. ................................................................... 28 Tabla 3-3 Funciones GEL disponibles. ................................................................................ 47 Tabla 5-1 Tabla resúmen de atajos. ...................................................................................... 64

Guía del Usuario Digital Signal Processor 

7

1 Introducción. Un DSP o Digital Signal Processor (Procesador Digital de Señales) es un microprocesador especializado en el análisis de señales en tiempo real. Se caracteriza por poseer un set de instrucciones que permiten manejar de manera eficiente el procesado de una señal.

Figura 1-1 Esquema del uso de un DSP.

Todo el diseño de un DSP se basa en el manejo eficiente de una señal digitalizada, ya que debido a la latencia típica de cualquier procesador, la operación matemática debe hacerse en un tiempo acotado, para que se pueda trabajar en tiempo real. Cuando se convierte una señal analógica en digital, ésta es muestreada cada cierto intervalo, por lo que cualquier operación matemática debe hacerse entre muestras, es decir, una vez que llegue una muestra se debe realizar la operación y debe estar lista antes de que llegue la otra. Un DSP proporciona una rapidez y baja latencia, que permite el procesado de señales en tiempo real, y aún así siendo una herramienta de bajo consumo.

Entre las aplicaciones que más utilizan un DSP se encuentran: • • • • •

Ámbito industrial (automatización, control, bombas, compresión, robótica, etc.). Automotriz (dirección electrónica, sensado de presión de torque y de inercia, sensor de colisión, etc.). Digital (AC/DC, UPS, DC/AC, displays LCD, etc.). Sensado Avanzado (RFID, medición óptica, lector de código de barras, sensado y análisis médico, medidor de flujo, control de pantallas Touch Screen, efectos de audio y control retroalimentado, etc.). Control de motores (fase simple, trifásicos, inducción AC, Brushless DC, etc.).

Las herramientas mínimas necesarias para comenzar a trabajar con el DSP son: el hardware, que consta de la placa de desarrollo fabricada por OLIMEX la TMS320 P28016 y el conector TMS320-JTAG para programar la tarjeta; y el software, que consta del Code Composer Studio (CCS) el cual es un IDE que permite programar, compilar y debuggear los programas realizados para el DSP. La tarjeta de OLIMEX además necesita de un driver

8

Guía del Usuario Digital Signal Processor 

que se instala en el CCS. Todo lo anterior se encuentra disponible en la página de Ingeniería MCI LTDA2 junto a todo lo necesario para su utilización. Esta guía constará de varios capítulos referentes a un DSP, pero se trabajará en detalle con la tarjeta de desarrollo del TSM320 P280163. Se explicará a grandes rasgos la arquitectura de un DSP y del esquemático de la tarjeta. Además se mostrarán algunos ejemplos prácticos para el uso de esta tarjeta y una ayuda básica para el uso de la herramienta Code Componer Studio (CCS) de Texas Instrument. De ahora en adelante, toda referencia a la palabra DSP, será para el modelo TMS32028016 utilizado en la placa de desarrollo TSM320 P28016.

Guía del Usuario Digital Signal Processor 

9

2 Detalles técnicos. Se mostrarán las características más importantes tanto del procesador del DSP como de la tarjeta de desarrollo.

2.1 Procesador DSP. El procesador del DSP es el TMS320F28016 y posee las siguientes características: •

•

•

•

•

Tecnología estática CMOS de altas-prestaciones (velocidad de reloj se ajusta con un PLL interno usado como multiplicador): o 100 MHz (10 ns tiempo de ciclo). Ciclo de trabajo avanzado. o 60 MHz (16.67 ns tiempo de ciclo). Ciclo de trabajo Normal. o Diseño de bajo consumo (1.8 V en el núcleo, 3.3 V I/O). CPU de 32-bit de altas prestaciones (TMS320C28x) o 16x16 y 32x32 operaciones MAC (permite multiplicar en un sólo ciclo dos números de 16 bit o dos de 32). o 16x16 Dual MAC (multiplica dos números de 16 bit y luego otros, todo en el mismo ciclo). o Arquitectura de Bus Harvard (buses separados para memoria de datos y memoria de programa). o Operaciones atómicas (lee y escribe en el mismo bus de operaciones, esto evita que se acceda a la memoria por error). o Rápida respuesta a interrupciones y procesamiento. o Modelo unificado de programación de memoria. o Codigo-Eficiente (en C/C++ y Ensamblador). Memoria en el Chip o 16Kx16 Flash, 6Kx16 SARAM (Single Access RAM – permite sólo un acceso en un sólo ciclo de instrucción). 16Kx16 significa que posee de memoria de 16 Kword (Word = 2 bytes) que se accede en bloques de 16 bits por cada ciclo de instrucción) o 1Kx16 OTP ROM (one-time programable ROM - memoria que se programa sólo una vez). Boot ROM (4Kx16) – memoria para código que el DSP lee al reiniciarse. Contiene las configuraciones iniciales. o Con modos de boteo por Software (via SCI, SPI, CAN, I2C, y I/O paralelo). o Tablas matemáticas estándar. Control de Sistema y Reloj. o Soporta cambios dinámicos en el radio PLL. o Oscilador dentro del Chip. o Módulo Watchdog Timer (reinicia el DSP cuando este timer se completa).

Guía del Usuario Digital Signal Processor 

10

• • • • •

•

•

• • •

•

Cualquier pin GPIO A, (General propose I/O) puede ser conectado a uno de las tres interrupciones externas del núcleo. Bloques PIE (peripheral Interrupt Expansion) que soportan todas las 43 interrupciones de periféricos. Llave/Bloqueo de Seguridad de 128-bit. o Protege bloques Flash/OTP/L0/L1. o Previene Firmware de ingeniería inversa. Tres CPU-timers de 32 bits. Control de periféricos mejorado o 8 salidas PWM, donde 4 son HRPWM con resolución de 150 ps MEP. o 2 entradas de capturas. o 3 timer de 32 bits. Periféricos de puerto serial. o Módulo SPI. o Módulo SCI (UART). o Módulo CAN. o Bus I2C (Inter-Integrated-Circuit). Conversores ADC de 12 bit, 16 canales. o Canales 2x8 entrada multiplexor. o Dos Sample-and-Hold (muestrea y retiene). o Conversión Simple/Simultánea. o Rápida tasa de Conversión: 267 ns – 3.75 MSPS. o Referencia externa o interna para comparar en el conversor. Hasta 35 pines GPIO programables individualmente, Multiplexadas con filtro de entrada. Avanzadas características de emulación o Funciones de análisis y Breakpoint. o Debugeo en Tiempo real via Hardware. Soporte de desarrollo incluye o ANSI Compilador C/C++/Enamblador/Linker o CodeComposer Studio IDE. o DSP/BIOS. o Control Digital de Motor y Librerías de Software digital de potencia. Modo de bajo consumo y Ahorro de energía. o Soporta los modos IDLE, STANDBY y HALT. o Deshabilita individualmente los relojes de periféricos. El mapa de memoria se compone de lo siguiente:

11

Guía del Usuario Digital Signal Processor 

Figura 2-1 Mapa de memoria del DSP.

12

Guía del Usuario Digital Signal Processor 

El mapa muestra las direcciones de memoria que el DSP es capaz de direccionar, así como también la distribución de la misma, es decir, qué dirección ocupan los diferentes dispositivos destinados a funciones diferentes. Se observa que el bus de datos es de 32 bit, esto se nota en el largo de las direcciones que logra acceder el DSP, ya que si el máximo fuera hasta FF, entonces el bus sería de 8 bit. Debido a la arquitectura Harvard, el espacio de memoria de programa y de datos se encuentran separados utilizando un bus independiente para cada memoria. Esto permite que mientras se accede a un espacio de memoria de programa, sea posible acceder a la memoria de datos al mismo tiempo, es decir, es posible acceder a ellos casi al mismo tiempo.

13

Guía del Usuario Digital Signal Processor 

El diagrama de bloques del DSP se compone de lo siguiente:

Figura 2-2 Diagrama de bloques del DSP.

14

Guía del Usuario Digital Signal Processor 

2.2 Tarjeta de Desarrollo para el DSP. La tarjeta de desarrollo y sus módulos principales se muestran en la siguiente figura:

Figura 2-3 Tarjeta de desarrollo para el DSP TMS320 F28016.

El esquemático de la tarjeta se muestra a continuación:

15

Guía del Usuario Digital Signal Processor 

Figura 2-4 Esquemático de la tarjeta de desarrollo TMS320 F28016.

Guía del Usuario Digital Signal Processor 

16

Las principales características que posee la tarjeta son: • • • • • • • • • • • • • • • • •

MCU: TMS320F28016 32KB Flash, 12KB RAM, 3.75 MPSP 2x8 Canales ADC, 8 PWM, CAN, SPI, RS232, I2C. Conector JTAG. Conversor USB-to-RS232 permite alimentar la tarjeta y además conectarse a la mayoría de notebooks sin la necesidad de un puerto serial RS232. Conector CAN y driver. Conector UEXT con SPI, RS232 y I2C para conectar a otros módulos OLIMEX. Conector para control de Motor. Botón de usuario. Potenciómetro Trimmer conectado a entrada analógica. LED indicador de alimentación. LED indicador de estado del usuario. Botón RST (Reset). Conector Jack para alimentación AC o DC externa. Regulador de Voltaje más filtro capacitivo en la fuente de poder. Headers de extensión para cada pin del DSP. Área de prototipo paso de 0.1” con bus GND y VCC. PCB: FR-4, 1.5 mm. Dimensiones 100x80 mm.

17

Guía del Usuario Digital Signal Processor 

3 Programación. Este capítulo mostrará la forma de programar el DSP. Se explicará cómo utilizar los periféricos de la placa además de indicar las herramientas más útiles para crear un programa complejo como por ejemplo el CodeComposer Studio (CCS), el administrador de recursos (memoria) y el Debugger.

3.1 Flujo de un programa Un programa cualquiera requiere algunas configuraciones mínimas para poder funcionar. Éstas pasan por estados definidos para mantener un orden y para que no permitan configurar erróneamente la tarjeta. La siguiente figura muestra este proceso:

Figura 3-1 Flujo de un Programa Tipo.

18

Guía del Usuario Digital Signal Processor 

Partiendo del Reset, se inicia un código de programa que indica el espacio de memoria que contiene la primera instrucción. Esta secuencia es la llamada Secuencia de Boteo. Posteriormente viene el CodeStartBranch que es usado para redirigir desde el boteo a la rutina C init. Éste puede ser configurado para deshabilitar el timer WatchDog si es que éste sobrepasa el límite dado antes de que se ejecute main(). El CodeStartBranch es asignado a la sección BEGIN por el linker. Luego viene la rutina C init la cual posee el archivo de boteo del compilador el cual es automáticamente incluido en la librería en tiempo de ejecución. Posteriormente en la función main() (Initialize System Control), se inicializa el sistema de control, se encienden los relojes de los periféricos y se ajustan las escalas de éstos. Además se puede deshabilitar el WatchDog Timer. Se configuran los pines de propósito general GPIO (Initialize GPIO) para las funciones periféricas o como entrada/salida. Se inicializa completamente el PIE Vector Table con punteros al Servicio de Rutina de Interrupciones (ISR) que se encuentran en DSP280x_DefaultIsr.c. Es útil para propósitos de debugeo tener inicializada esta tabla, incluso si no se va a utilizar el ISR. Antes de comenzar el main() con lo requerido por el usuario, faltaría inicializar los periféricos requeridos para el proyecto deseado. Esto es, configurar los bits según la forma en que se utilizarán las funciones de los pines GPIO. Finalmente se deben habilitar las interrupciones PIE y CPU requeridas por el programa, así como cualquier código adicional.

3.2 CodeComposer Studio. Code Composer Studio™ (CCS) es un IDE (Integrated Development Environment), es decir, un ambiente de desarrollo integrado para programar los DSP de Texas Instruments. CCS entrega todas las herramientas necesarias para soporte de software en tiempo real para el DSP TSM320. CCS permite un manejo rápido y sencillo para moverse en todas las fases del proceso de diseño de una aplicación, incluyendo código y compilación, debug, análisis y afinamiento. En lo siguiente se explicará lo básico para poder comenzar a utilizar el CCS y crear aplicaciones simples, que serán la base para programas más complejos posteriores. Es posible bajar una versión de prueba del CCS en este link4, o directamente de la página oficial www.ti.com. Luego para poder utilizar esta versión con la tarjeta de desarrollo de OLIMEX, se debe bajar una actualización llamada XDS100 la cual puede ser descargada de OLIMEX desde aquí5. Entre las principales propiedades del CCS se encuentran las siguientes:

4

http://dl-www.ti.com/lit/ml/sprc119d/sprc119d.zip 500MB aprox. Version de prueba de 120 dias.

5

http://www.olimex.cl/soft/DSP/XDS100pp_Beta2.exe

Guía del Usuario Digital Signal Processor 

19

• • • • • • •

•

Algoritmo TMS320 DSP estándar. Familiar y fácil de usar IDE con editor CodeWright integrado. Kernel DSP/BIOS™ escalable en tiempo real y herramientas de configuración. Herramientas para generación de código en lenguajes C/C++/Assembly. Debuggeador de código fuente con análisis en tiempo real. Variedad de simuladores preconfigurados y tarjetas para todas las plataformas. Variedad de Guías Rápidas. o Tutoriales para comenzar con el IDE CCStudio, Code Tuning, DSP BIOS, RTDX y emulación en tiempo real. o Códigos de ejemplo y librerias. Soporte para TMS320C2000™, TMS320C5000™ (incluyendo los procesadores OMAP™), y TMS320C6000™ (incluyendo procesadores the DaVinci™ ).

3.2.1 Características. Entre las características que posee el ambiente de desarrollo de CCS se encuentran las herramientas de trabajo que mejoran el tiempo de trabajo para desarrollo de software y optimizan el funcionamiento para todas las aplicaciones DSP en tiempo real. Las herramientas más importantes del Code Composer Studio incluyen: • • •

• • •

•

Herramientas para generación de código DSP TMS320: compilador C/C++, ensamblador y linkeador. Viene con Visual Proyect Manager con interfaz de control de código y soporte para multiproyectos que permite manejar sobre 100 archivos. Configuración Drag and Drop CCStudio que soporta: o Drivers XDS560 ™ de emulación de alta velocidad. o Drivers XDS510 ™ de emulación. o Simuladores para todos los dispositivos, solo para CPU y CPU más memoria para funcionamiento óptimo. o Opciones de definición configurable para tarjetas. Editor CodeWright totalmente integrado. Administrador de components soporta multiples versions de DSP/BIOS y de herramientas de generación de código dentro del IDE. Debugger posee las siguientes propiedades: o Debug Rewind: Retrocede en la simulación. o Simples breakpoints. o Breakpoints avanzados y de Hardware. o Puntos de prueba para inyección/extracción de datos. o Navegador para Símbolos y Watch Windows avanzado. o Administrador unificado de Breakpoints para configurar y administrar breakpoints por software y hardware desde una sola y simple interfaz. Connect/Disconnect; conexión robusta y resilente entre el cliente y la tarjeta.

Guía del Usuario Digital Signal Processor 

20

• •

Transmitidor de datos RTDX ™ para intercambio en tiempo real entre la tarjeta y el cliente. Un sin número de guías y códigos de ejemplo para hardware y software. Además de tutoriales y manuales.

El software Code Composer Studio además incluye: •

• • •

DSP/BIOS ™ Kernel para el TMS320 DSPs o Multihebras previamente vacías. o Comunicación entre hebras (threads). o Manejo de Interrupción. Algorimos estándar TMS320 DSP para poder volver a usar el software. Soporte de librerías para el Chip con el fin de simplificar la configuración del dispositivo. Librerías DSP para optimizar las funcionalidades del DSP.

3.3 ¿Cómo Programar? Hola Mundo! 3.3.1 Instalación y Configuración CCS. A continuación se explicará la configuración básica necesaria para el CCS. EL CCS se puede descargar desde la página www.ti.com, o directamente en el siguiente link6, donde luego de instalarlo aparecerán dos íconos. Dependiendo de la versión el nombre podría cambiar. Para la versión actual 3.3 será CCStudio v3.3 y Setup CCStudio v3.3. El primero corresponde al CCS en sí, mientras que el otro se debe correr antes de empezar cualquier proyecto. Este programa se encarga de la configuración básica del DSP así como también de sus librerías. Para el correcto funcionamiento con la placa, se debe actualizar la versión del CCS con el último Service Pack disponible en la página de Texas Instruments, luego bajar el driver XDS100 que se puede descargar desde el siguiente link7 o desde la página de www.olimex.cl. Este último se encarga de emular la tarjeta a través del JTAG de la tarjeta con el puerto paralelo del PC y éste a la vez con el CCS. Sin embargo varias de las capacidades del CCS no son compatibles usando este driver, entre ellas:

Guía del Usuario Digital Signal Processor 

21

• • • • •

Es más lento que otras versiones como las XDS510 o XDS560 que utilizan el JTAG en vez del puerto USB. Carece de soporte por hardware para adaptative clocking. Carece de RTDX (Real Time Data Exchange) y HSRTDX (High Speed RTDX). Carece de soporte por hardware para reloj TCLKR externo. Carece de soporte para detección en caso de quiebre del cable en donde lo interprete como pérdidad de poder de la tarjeta.

Una vez instalado todo lo anterior se ejecuta Setup CCStudio v3.3 donde aparecerá a siguiente ventana:

Figura 3-2 Selección de Configuración de la Tarjeta. Emulador XDS100.

Seleccionar Create Board y luego elegir la conexión TIXDS100pp Emulator y presionar el botón ADD. En la siguiente ventana escribir un nombre arbitrariamente presionar el botón NEXT y luego FINISH. Esto último se muestra en la siguiente ventana:

22

Guía del Usuario Digital Signal Processor 

Figura 3-3 Nombre de la Conexión.

Luego se marca la tarjeta creada y se escoge la tarjeta DSP modelo TSM320C2800 y se agrega a la conexión, tal como se muestra en la siguiente figura:

Figura 3-4 Elección de modelo del DSP.

23

Guía del Usuario Digital Signal Processor 

Para agregarla simplemente se presiona el botón ADD y aparecerá la siguiente ventana:

Figura 3-5 Propiedades del Procesador.

Posteriormente se presiona OK y se guarda desde el panel de configuraciones en la barra de herramientas o presionando el botón Save & Quit. Luego de ello, el CCS se iniciará automáticamente.

Figura 3-6 Presionar el Botón Save & Quit.

24

Guía del Usuario Digital Signal Processor 

3.4 Blinking Led. Para probar el correcto funcionamiento, se correrán algunos de los proyectos de ejemplo. Descargar el ejemplo Blinking_LED desde la página de OLIMEX y abrir el proyecto en el CCS. Para esto ir a Project->Open y buscar el archivo con el nombre Blinking_LED.pjt, luego presionar el botón Open. Primero que nada se debe compilar el programa. Para esto se debe presionar el botón señalado en la siguiente figura como Compilar todo o por medio de la barra de herramientas en Project->Rebuild All. Esta acción compilará todos los archivos, incluso aquellos referenciados desde el archivo principal (main).

Figura 3-7 Botones para Compilar.

El botón Compilar, compilará sólo los archivos que se hayan modificado desde la última vez que se compiló, si no se ha modificado ningún archivo, entonces no se compilará nada. Se puede usar también desde la barra de herramientas en Project->Build o simplemente presionando F7. El botón compilar todo mencionado anteriormente fuerza a que se compilen todos los archivos del proyecto, estén o no modificados. Una vez compilado el proyecto y sin errores, se procede a cargar el programa a la tarjeta. Se conecta la placa al PC por medio del JTAG (para compilar no es necesario que la placa esté conectada) y luego se alimenta la placa con una fuente continua de 6 a 9 V o usando el puerto USB. Posteriormente se ingresa a Debug->Connect o se presiona Alt+C para que el CCS reconozca la placa. Si está todo bien, aparecerá el mensaje Connected y luego Halted en la esquina inferior izquierda del CCS lo que indicará que se reconoció correctamente, de lo contrario aparecerá un error y el mensaje Disconnected.

25

Guía del Usuario Digital Signal Processor 

Figura 3-8 Placa Conectada o no Conectada.

Cuando la placa se encuentre conectada y reconocida, se procede a cargar el programa. Al momento de crear un proyecto, automáticamente se crea una carpeta llamada Debug, que es la que contiene el código final del programa que será cargado en la tarjeta. El archivo creado así, tiene el mismo nombre que el proyecto pero con la extensión *.OUT. Para cargar el programa se debe ingresar en File->Load Program o simplemente presionar CTRL+L. Dentro de la carpeta del proyecto, aparecerá una llamada Debug, y dentro de ella un archivo llamado Blinking_Led.out. Seleccionarlo y presionar Open y CCS comenzará automáticamente a cargar el programa en la tarjeta. Para poder realizar lo anterior, CCS debe haber reconocido previamente la tarjeta y debe mostrar el mensaje Connected (muestra Halted una vez conectado que es algo así como Pausado). Lo anterior se verá según la siguiente figura:

Figura 3-9 Cargar un Programa.

Una vez que el programa ha sido cargado correctamente, es posible ejecutarlo. Para esto se debe ingresar a Debug->Run o simplemente presionar F5 e inmediatamente el programa comenzará a funcionar. Para esto la tarjeta debe permanecer conectada al PC por medio del JTAG y alimentada correctamente. Además los jumper de configuración deben ser los adecuados. Esto de indica en lo siguiente. Si se desea que la tarjeta ejecute el programa al reiniciarse sin la necesidad de hacerlo mediante el JTAG, es necesario guardar el código del programa en la memoria FLASH, ya que la otra memoria es volátil, razón por la cual se pierde el programa al quitar

26

Guía del Usuario Digital Signal Processor 

la alimentación de la placa. Además se debe configurar correctamente los jumpers. Éstos, se indican mediante la etiqueta boot (autoarranque) en la Figura 2-3. La configuración de éstos se muestra en la siguiente tabla. Más adelante se explicará en detalle cómo hacer esto. Modo de Booteo FLASH/ROM SCI-A SPI-A I2C e-CAN-A M0 SARAM OTP I/O paralelo

Descripción

GPIO18

GPIO29

GPIO34

Salta a la dirección 0x33 7FF6 de la FLASH/ROM. Carga un Stream de datos desde la SCI-A. Carga la data desde una memoria serial EEPROM externa mediante SPI usando SPI-A. Carga la data desde una EEPROM externa, en la dirección 0x50 del bus I2C. Llama al CAN_BOOT para cargar desde la bandeja de entrada 1 del eCAN-A. Salta a la dirección 0x00 0000 de M0 SARAM. Salta a la dirección 0x3D 7800 de la memoria OTP. Carga la data desde GPIO0-GPIO15.

1 1 1

1 1 0

1 0 1

1

0

0

0

1

1

0 0 0

1 0 0

0 1 0

Tabla 3-1 Configuración Jumpers para Booteo.

La configuración del ejemplo Blinking_LED requiere que la tarjeta se encuentre en el modo de booteo M0 SARAM. Este modo se ilustra en la siguiente figura:

Figura 3-10 Modo de Booteo del ejemplo. M0 SARAM.

La funcionalidad el programa consiste en hacer parpadear un LED que se encuentra conectado al pin 70 (GPIO 11). El parpadeo se produce cada medio segundo, tiempo que está determinado por la variable BLINK_TIME dentro de la cabecera del código. Además cada vez que el botón de la placa es presionado (conectado al pin 61, GPIO 9) el LED se enciende y se mantiene así por el tiempo que dure presionado el botón. Cuando se suelta, el LED sigue parpadeando.

27

Guía del Usuario Digital Signal Processor 

Por ejemplo si se desea cambiar el tiempo de parpadeo se cambia el valor 500000 dado a la variable BLINK_TIME por otro elegido arbitrariamente. Si se coloca 1000000 el parpadeo se realizará cada un segundo, ya que la variable se encuentre medida en [useg]. Luego se cambia el valor del botón para que apague el LED cada vez que se presiona en vez de encenderlo. Estos cambios se muestran en las siguientes figuras:

Figura 3-11 Cambio valor BLINK_TIME.

Figura 3-12 Cambio para apagar el LED al presionar el botón.

Guía del Usuario Digital Signal Processor 

28

Al realizar estos cambios, luego compilar (F7) y finalmente ejecutar el programa (F5), se notará que el led ahora parpadeará cada un segundo, y que ahora cuando se presione el botón el led se apagará en vez de encenderse. Para detener un programa se debe presionar Debug->Halt (Shift+F5) o cual hará que el programa se pause. Para volver a ejecutarlo desde el principio se debe presionar Debug->Restart (CTRL+Shift+F5). Para reiniciar el emulador se debe ingresar Debug>Reset Emulator (CTRL+Shift+R). Entre los archivos principales que se observan en la Figura 3-12 se tienen: Nombre Archivo Blinking_LED_main.c

Descripción Código Fuente específico del Ejemplo.

DSP280x_CodeStartBranch.asm

Código fuente común (compartido). Contienen funciones genéricas para configurar los periféricos a un estado definido o funciones que se podrían reutilizar en diferentes aplicaciones.

DSP280x_CpuTimers.c DSP280x_DefaultIsr.c DSP280x_GlobalVariableDefs.c DSP280x_PieCtrl.c DSP280x_PieVector.c DSP280x_SysCtrl.c

Archivo requerido para utilizar los archivos de cabecera (Header Files). Código Fuente compartido. Se utiliza para ajustar y configurar algunos periféricos.

28016_RAM_lnk_cmd

DSP280x_Headers_nonBIOS.cmd

Permite asignar secciones a los bloques de memoria específicos de un dispositivo. Archivo linker requerido por los archivos de cabecera específicos de los periféricos. Asigna una sección de datos de los registros de los periféricos a una apropiada locación de memoria.

Tabla 3-2 Archivos principales de un proyecto.

Entre las carpetas mencionadas en la misma figura se encuentra la carpeta Include que contiene todos los archivos de cabecera que serán incluidos en el proyecto (generalmente de extensión *.h), esto es, los archivos incluidos en el código fuente del usuario (por ejemplo, los que tienen #include en Blinking_LED_main.c). Entre estos está: DSP280x_Device.h, que incluye los archivos de cabecera específicos para manejar algunos periféricos y algunas macros y typedef específicas para algunos dispositivos; y DSP280x_Examples.h que define parámetros que son usados en el código fuente de ejemplo, además es requerido por algunos archivos fuente comunes. En general al comenzar un nuevo proyecto, se deben incluir, a lo menos, los archivos mencionados en la Tabla 3-2 y los pertenecientes a la carpeta Include.

29

Guía del Usuario Digital Signal Processor 

Otra carpeta es la DSP/BIOS Config que contiene el archivo de configuración o script para poder trabajar en aplicaciones en tiempo real que requieran un manejo de memoria y recursos al límite. Además permite sincronización en tiempo real; comunicación cliente-tarjeta en tiempo real; e instrumentación en tiempo real. La carpeta GEL Files, contiene unos archivos llamados General Extension Language (GEL) que son usados para inicializar automáticamente el dispositivo cuando se inicia el CCS. Se encarga entre otras cosas de reconocer que la tarjeta se encuentra conectada; de compilar y cargar el programa con un solo click; y de configurarse apenas se inicia el CCS (por esto se debe quitar del proyecto este archivo si se va a utilizar otro dispositivo o ejemplo). Funciona por medio de un lenguaje interpretado similar a C lo que lo hace cómodo para trabajar. Del mismo modo posee una gran variedad de funciones donde además es posible crear las propias según la necesidad.

3.5 Debuggear. El debugeo (viene de Debugging en inglés - Limpieza) es un proceso metódico que permite reducir los bug o errores en un programa. Entre estos permite: colocar Breakpoints; ejecución instrucción a instrucción; y observar el valor de una variable en tiempo de ejecución. CCS tiene varias funcionalidades que permiten realizar estas tareas de manera simple. CCS permite colocar Breakpoints en alguna línea de código. Cuando el programa se ejecute y se encuentre con un breakpoint, éste se detendrá en esa línea y no continuará hasta que se le ordene (no ejecuta la línea que posee el breakpoint). En el tiempo en que se encuentre detenido, es posible observar los valores de las variables que el programa tiene en ese momento. Además es posible modificar esos valores y asignarles alguno arbitrariamente. Para colocar un breakpoint simplemente se debe hacer doble click al comienzo de la línea, a lo cual aparecerá un punto rojo, que indica que se ha colocado un breakpoint. Para sacarlo se debe volver a hacer doble-click. Esto se muestra en la siguiente figura:

Figura 3-13 Colocación de un Breakpoint.

30

Guía del Usuario Digital Signal Processor 

Para el ejemplo de la figura, se utilizó el mismo proyecto Blinking_led.pjt donde se agregaron las líneas que se muestran. Cuando se corre el programa, se verá que se detiene justo en esa línea y si se coloca el cursor del Mouse sobre la variable variable por unos segundos, aparecerá el valor que posee en ese momento. El valor mostrado en este caso es el que el compilador le asigna a las variables que no son inicializadas. Si luego se ejecuta la siguiente línea con Debug->Step over o simplemente presionando F10, la variable tendrá el valor de 24. Esto se muestra en la siguiente figura:

Figura 3-14 Valor de una variable en tiempo de ejecución.

Se observa ahora que la variable es igual a 24 y la flecha amarilla (que indica la línea en la que se encuentra la ejecución de instrucciones), ha avanzado. Si se vuelve a presionar F10, ahora la variable es igual a 124, y la flecha amarilla se colocará en la siguiente línea de instrucción válida (los comentarios no figuran como código ejecutable), tal como muestra la siguiente figura:

Figura 3-15 Step-over (F10) y Step-into (F11).

Ahora bien, si la línea de ejecución (flecha amarilla) en la que se encuentra corresponde a una función, se pueden realizar dos cosas. Realizar un Step-over (F10) con lo cual ejecutará la función completamente para luego saltar a la siguiente línea. O bien se puede hacer un Debug->Step-into (F11) que ejecuta la primera instrucción de la función, es decir, comienza a ejecutar la función línea a línea. Una vez dentro, es posible realizar lo mismo antes mencionado, como leer variables o ejecutar línea a línea. Si se desea que se

31

Guía del Usuario Digital Signal Processor 

complete la función y que se sitúe en la siguiente línea de código luego de ésta, se debe presionar Debug->Step-out (Shift+F11). Esto terminará de ejecutar la función y se colocará en la siguiente línea que corresponda antes de haber entrado a la función. También es posible saltar hasta cualquier línea deseada con Debug->Run to Cursor (CTRL+F10). Para que el programa siga ejecutándose normalmente luego de haber estado pausado por un breakpoint, se debe presionar Run (F5). Si existe otro breakpoint más adelante, el programa se detendrá ahí. Para ejecutar el programa instrucción a instrucción (en lenguaje ensamblador) en vez de línea en línea (línea de código), se utilizan las funciones presentes en Debug->Source Stepping. Otra forma de ver las variables en tiempo de ejecución es utilizando el llamado Watch Window. Esto es un ventana en la cual se van agregando variables simplemente haciendo click derecho sobre ella y presionando Add to Watch Window. Por cada variable agregada, se permite ver su nombre, su valor, su tipo y el formato en que se desea ver el valor. Esto se muestra en la siguiente figura:

Figura 3-16 Watch Window.

Por ejemplo en la figura anterior, se observa que se agregó la variable variable cuyo valor es 24, de formato INT y además se pide que su valor se muestre en decimal (Redix=dec). Para cambiar esto último se presiona donde dice Redix y aparecerá una lista con otros formatos, donde por ejemplo, si se elige HEX, el valor 24 aparecerá en hexadecimal (0x18) en vez de decimal. Los tab indican qué variables se verán. El tab Watch Locals permite ver las variables que actualmente se estén ejecutando en la función, mientras que Watch permite ver tanto las variables locales como globales. Además es posible agregar expresiones dentro Watch Windows. Por ejemplo se puede escribir en la columna Name lo siguiente: variable+500. Con lo anterior, cada vez que se actualice el valor de esta variable, también aparecerá el resultado de esa expresión. Si ahora se hace click derecho en el tab de Watch 1, y se presiona Add Globals to Watch, se podrán agregar variables globales. Por ejemplo si se agrega la variable

32

Guía del Usuario Digital Signal Processor 

GpioDataRegs según se observa en las siguientes imágenes, será posible ver cómo cambian los registros al momento de presionar el botón de la tarjeta. Por ejemplo se expande la estructura de la variable según GpioDataRegs->GPADAT->bit y se observa el registro del pin 61 llamado GPIO 9. Se observa que tiene un valor 0, pero si se mantiene presionado el botón de la tarjeta y luego se presiona Refresh (aparece en el mismo menú que Add Globals to Watch), se verá cómo este valor cambia a 1. Esto indica que el botón está presionado, o lo que es lo mismo, el pin está conectado a LOW (esto se observa en el esquemático de la tarjeta en la Figura 2-4, donde se ve que al presionar el botón, el pin 61 hace puente con tierra).

33

Guía del Usuario Digital Signal Processor 

Figura 3-17 Agregar variables Globales.

34

Guía del Usuario Digital Signal Processor 

Figura 3-18 Elección de Variables Globales.

Figura 3-19 Parte del esquemático de la tarjeta. Botón de GPIO 9.

Si se desea que las variables se actualicen en tiempo real en la Watch Windows, se debe ingresar a Debug->Real Time Mode. Luego en el tab de la ventana de Watch Windows, hacer click derecho y en el menú desplegable hacer click a Continuous Refresh. Con esto las variables se actualizarán apenas cambie su registro. Esto se debe hacer luego de haber compilado y cargado en la tarjeta el código fuente. En caso de que aparezca algún error y CCS no se pueda conectar a la tarjeta, se debe desactivar la opción Real Time. Para poder realizar los siguientes tres puntos, se debe haber compilado el código fuente y luego cargarlo en la tarjeta de desarrollo, antes de realizar los cambios, ya que el

35

Guía del Usuario Digital Signal Processor 

CCS verifica las variables y arreglos antes de visualizarlos o guardarlos. Además se debe tener la placa conectada al CCS (ATL+C).

3.5.1 Escribir datos en un Archivo de Salida Una vez compilado y cargado el código fuente, se ingresa un breakpoint en el punto en el cual se desee obtener algún dato. En este caso se ingresa en la línea 201 en donde se tiene una variable del tipo unsigned int16 (Uint16) Historial[BUF_SIZE]. Luego se ingresa a Debug->Breakpoints donde aparecerá una ventana en la parte inferior del CCS, tal como se muestra en la siguiente figura:

Figura 3-20 Administrador de Breakpoints.

Se observa que aparece el número de línea, así como otras características. Tiene especial importancia la columna Action, ya que si se presiona aparecerá un menú contextual con una opción llamada Write Data to a File. Esto se muestra en lo siguiente:

Figura 3-21 Menú contextual de Action.

Al presionar, aparecerá una ventana que se deberá llenar con la siguiente información:

36

Guía del Usuario Digital Signal Processor 

Figura 3-22 Parámetros para escribir datos en un archivo.

El primer campo File indica la dirección en donde se guardará el archivo creado con los datos del programa, cuya extensión será *.DAT. La forma del archivo consiste en la primera línea con información sobre el archivo y luego cada línea representa un dato con el formato dado por los parámetros indicados en el programa. En Format se indica el formato en el cual se representan los datos. Como la variable que se quería guardar es Uint16, entonces se elige Integer (INT). En Start Address se debe indicar la dirección de memoria del DSP en la cual se comenzará a leer para su posterior guardado dentro del archivo. Debe estar en formato hexadecimal, aunque es posible también incluir el nombre de la variable, como en este caso donde se colocó Historial. En Page se indica la sección de memoria que será leída. Como Historial se encuentra en la memoria de datos, entonces se elige Data. En Length se indica el largo o tamaño de la memoria a ser leída con el formato dado anteriormente. Como se tiene una variable que es un arreglo, en la figura anterior se observa que se guardarán los 20 primeros valores. Luego cada vez que el programa pase por la línea del breakpoint, guardará los 20 primeros valores del arreglo Historial en el archivo ArchivoSalida.dat. No borrará los datos sino que los escribirá a continuación de cada corrida siempre y cuando se mantenga la ventana que se muestra en la siguiente figura:

Figura 3-23 Indicador de largo de las variables.

No importa si el programa se detiene y luego continúa, los datos se seguirán escribiendo mientras esta ventana se mantenga. Si se presiona Stop (botón con un cuadrado) se dejará de escribir los datos en el archivo, y si se presiona Play (botón con un triángulo) se seguirá escribiendo desde la última ubicación en el archivo. Si se cierra esta ventana, el procedimiento debe hacerse de nuevo desde los ajustes de los parámetros.

37

Guía del Usuario Digital Signal Processor 

Cuando se guardan datos en un archivo, éste sigue creciendo y creciendo mientras corra el programa, por lo que se debe tener cuidado de no sobreestimar los recursos del computador, al crear un archivo excesivamente grande.

3.5.2 Leer Datos en un Archivo de Salida Para leer datos se realiza el mismo procedimiento anterior, pero con la diferencia de que en el menú contextual se debe presionar Read data from a File. Así aparecerá la siguiente figura:

Figura 3-24 Leer datos desde un archivo.

El campo File indica el archivo a ser leído donde cada línea representa el valor que se le asignará a la variable cada vez que el programa pase por esa línea. Wrap Around indica que si se llega al final del archivo, entonces se comenzará desde el principio. Si está desactivado y se llega al fin del archivo el programa será pausado (Halted) y aparecerá un mensaje. Los otros campos son los mismos que para escribir un archivo de salida. Cabe mencionar que tanto escribir como leer datos de un archivo consumen recursos del DSP, por lo que algunas operaciones podrían tardar más que si la tarjeta lo hiciera sola en tiempo real. Para maximizar la utilidad de estas aplicaciones se recomienda utilizar archivos cortos y variables auxiliares para que no tome demasiado tiempo en realizar estas acciones.

3.5.3 Graficar datos en tiempo real. Esta opción es bastante útil cuando se desean ver señales en tiempo real. Para poder hacerlo se debe haber compilado y cargado el código en el programa. Luego se ingresa a View->Graph->Time/Frequency donde aparecerá la siguiente ventana:

Guía del Usuario Digital Signal Processor 

38

Figura 3-25 Parámetros para graficar una señal.

Entre los parámetros más importantes se debe indicar: • •

•

Display time: Indica el tipo de gráfico. Puede ser de tiempo simple o doble, FFT, constelación, etc… Start Address: Igual que lo mencionado anteriormente al escribir y leer datos. Puede ser una dirección en formato hexadecimal o el nombre de alguna variable. Es recomendable colocar la dirección de la variable. Para saberla se presiona el botón derecho sobre la variable en el código fuente, y en el menú contextual emergente presionar View location of…, para lo cual aparecerá una ventana en la parte derecha del CCS, con el nombre de la variable y su dirección de memoria. Escribirla de la forma (por ejemplo) 0xF34F. Page: Indica la sección de memoria en la cual se leerá la dirección dada en el punto anterior.

Guía del Usuario Digital Signal Processor 

39

•

• • • •

•

Acquisition Buffer Size: Indica la cantidad de valores que serán leídos desde la dirección en un instante dado de tiempo. Es útil para cuando se desean leer frames en vez de un solo dato. Por ejemplo si importa sólo un dato en cada momento se coloca un 1, pero si la variable es un frame o arreglo de 100, entonces se indica el largo del frame igual a 100 en este campo. Index Increment: índice de incremento para el gráfico. Útil cuando se desea graficar dos variables en el mismo gráfico. Display Data Size: Tamaño de la ventana en la cual se mostrarán los datos. DSP Data Type: Tipo de datos del procesador. Esta opción afecta el valor con el que serán mostrados los datos. Si la variable es de 16 bits (int) se recomienda colocar la opción 16-bit unsigned integer. Sample Rate (Hz): Tasa a la que serán mostrados los datos. Esto sólo afecta los labels del eje del tiempo. Así los labels serán desde 0 hasta 1 DisplayDataSize • . Para el gráfico en el dominio de la frecuencia, este SampleRate campo contiene el número de muestras usadas para el análisis de la FFT. Autoscale: Si está activado, varía automáticamente el eje Y según el máximo valor mostrado en la ventana o display. Se recomienda desactivarlo para tener un mejor panorama de la señal.

Luego de haber configurado lo anterior y presionar OK, se tendrá lo de la siguiente figura. Pero antes de debe ingresar Debug->Real Time Mode.

Figura 3-26 Gráfico realizado con los datos.

40

Guía del Usuario Digital Signal Processor 

Para una correcta visualización se debe hacer un click derecho sobre el gráfico, y en el menú contextual presionar Continuous Refresh. Así el gráfico se irá actualizando automáticamente con cada dato. Para observar la señal que se desea simplemente se debe correr el programa (F5) y el gráfico comenzará a actualizar los datos que se están monitoreando.

3.6 Conversor ADC. Se sabe que el DSP TMS320F28016 posee 16 canales para un conversor ADC de 12 bit para transformar una señal analógica en digital, cada uno con S/H (Sample and Hold Muestrea y retiene). Cada resultado de conversión puede ser accesado individualmente a través de un único registro por canal. La conversión permite un rango entre 0 y 3 volts, cuya fórmula es:

IN ADCvalor = 4096 ADC 3

(3.1)

Donde IN ADC es el valor del voltaje del conversor y el 4096 equivale al valor máximo para un número de 12 bit. Cualquier voltaje menor a 0 volt será entregado como cero, y cualquiera mayor a 3 volt, será entregado como 4095. En el diagrama de bloques del módulo ADC que se muestra en la siguiente figura, se observa que sólo posee un conversor de 12 bit, el cual utilizando multiplexores (MUX) en dos bloques de 8 canales cada uno, permite obtener hasta 16 canales. Luego el módulo ADC se encarga de guardar los valores en sus registros correspondientes y sus respectivas direcciones. Utilizando los registros de control es posible utilizar los secuenciadores, los cuales permiten 16 ‘autoconversiones’ en una sola sesión (tiempo dado entre la conversión del primer canal y el último), donde cada conversión es guardada en cualquier registro previamente seleccionado.

41

Guía del Usuario Digital Signal Processor 

Figura 3-27 Diagrama de Bloques del ADC.

En la siguiente figura se muestra un diagrama de bloques simplificado. Se observa la funcionalidad de los secuenciadores, los cuales permiten realizar un muestreo simultáneo por medio de los S/H, que permiten obtener una lectura de dos canales al mismo tiempo, pero la conversión se realiza por orden. Por ejemplo en ADCINA5 se puede medir voltaje, mientras que en ADCINB5 se puede medir corriente, y así obtener la potencia instantánea en tiempo real. Por medio del autosecuenciamiento, se puede elegir el orden en el cual los canales ADC de conectan al núcleo del conversor, para así crear una secuencia simple de hasta 8 muestras, o de hasta 16, utilizando los secuenciadotes en cascada.

42

Guía del Usuario Digital Signal Processor 

Figura 3-28 Diagrama Simple del Bloque ADC.

Entre los principales bloques se encuentran dos bloques de multiplexores (MUX) de 8 canales que expanden la capacidad de conversión a 16 canales. Junto a estos se encuentran dos S/H (Sample and Hold) que permiten la conversión simultánea antes mencionada. El Sequence Arbiter (Árbitro del Secuenciador) mantiene la pista de las señales de entrada unidas al ADC, incluyendo el modo simultáneo. Autosecuenciadores duales dan flexibilidad seleccionando al azar la forma en que los canales de entrada se conectan al núcleo ADC. Cada secuenciador de 8-estados puede ser usado independientemente para convertir hasta ocho canales en una secuencia predeterminada o en cascada para formar un secuenciador simple de 16 estados. Por medio del registro ADCMACONV es posible ajustar el número máximo de conversiones por secuencia. Se observa además que es posible usar una de tres señales para

43

Guía del Usuario Digital Signal Processor 

disparar (trigger) el inicio de secuencia (SOC – Start of Sequence) en el Secuenciador 1 y dos señales para SOC en el Secuenciador 2. Existen 16 registros de resultados (ADCResult0-ADCResult15) que mantienen el conteo ADC antes de que sean transferidos a la memoria del sistema. Cuando se termina una secuencia (EOC – End of Sequence) se producen tres diferentes señales de interrupciones que son ADCINT, SEQ1INT y SEQ2INT las cuales pueden ser usadas para transferir los resultados al sistema de memoria. Las interrupciones son generadas cuando el secuenciador completa la última conversión del último canal de la secuencia. El Servicio de Rutina de Interrupción (ISR - Interrupt Service Routine) dispone de estas únicas señales de interrupción para las operaciones ADC. Ahora se verá el otro ejemplo provisto por OLIMEX8 que consiste en utilizar un conversor ADC. Para esto se utiliza el potenciómetro de la placa que se encuentra conectado al pin 34, llamado ADCINB7. Los elementos de los ejemplos que se verán se muestran en la siguiente figura:

Figura 3-29 Trimmer AN_TR, botón GPIO9 y Led GPI11.

La funcionalidad del ejemplo consiste en hacer parpadear el LED a cierta frecuencia, la cual está regulada por el trimmer (potenciómetro). Éste se encuentra conectado al conversor ADC del pin 34 (pin ADCB7) y en base a la medida obtenida, es como cambia la frecuencia de parpadeo del led. Entro lo principal del código del programa basado en la Figura 3-30, se observa dentro del while{} el siguiente código AdcRegs.ADCST.bit.INT_SEQ1== 0;. Este código pregunta por el registro que indica que el secuenciador 1 ha terminado la secuencia y es 8

Bajar este y otros ejemplos desde www.olimex.cl, sección Tarjetas Olimex->DSP.

Guía del Usuario Digital Signal Processor 

44

posible la lectura del conversor ADC, correspondiente al pin 34 (ADC B7 en la placa). Posterior a eso se resetea ese bit (AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;) para esperar por la nueva secuencia. De ahí se observa que guarda los datos de los 15 conversores en un arreglo llamado AdcSampleTable[]. Con el código ADC_Result = AdcRegs.ADCRESULT15>>4; guarda el valor que será usado en el ejemplo en esa variable. El símbolo >>4 divide el valor obtenido en la conversión por 24 , esto permite bajar la resolución a la lectura, puesto que como se mide entre 0 y 3, los bit menos significativos están de más para este tipo de experimento, pues se está utilizando un conversor de 12 bits sobre una variable de 16 bits. Luego el programa apaga el led y con el valor medido guardado en ADC_Result, se utiliza como entrada en una función llamada Delay(), que no es más que un for{} simple de ciclo variable dado por el parámetro de entrada de la función, el cual viene de la muestra obtenida del conversor. Posteriormente se vuelve a encender el led para luego volver a utilizar la función delay. Esto se muestra en la Figura 3-30 donde se observa que además de medir el valor de ADCB7, también mide todos los conversores, es decir los otros 15 (son 16 en total). En este caso ADCSampleTable[15] corresponde al pin 34 (ADCB7).

Figura 3-30 Ejemplo Conversor ADC.

Para poder utilizar los conversores ADC se deben configurar los siguientes registros: • •

Tasa de muestreo. Configurar/Seleccionar el Autosecuenciador.

Guía del Usuario Digital Signal Processor 

45

• • •

Modo de muestreo. Seleccionar la señal SOC (Star of Conversion – Comienzo de la Conversión). Asignar los canales para el(los) secuenciador(es) tal que los dieciséis resultados de los registros de 16-bit mantendrán el conteo de los canales de entrada según se desee y para un determinado número de conversiones por secuencia. • Configurar interrupción en EOS (End-of-Sequence – Fin de Secuencia). Para mayores detalles y especificaciones sobre cómo configurar las características del conversor ADC se debe dirigir al manual de referencia TMS320x280x, 2801x, 2804x DSPAnalog-to-Digital Converter (ADC) (spru716b.pdf) o a An Overview of Designing Analog Interface With TMS320F28xx/28xxx DSCs (spraap6a.pdf).

3.7 Uso de Archivos GEL CCS permite la utilización de unos archivos o script de extensión *.GEL, que permiten por medio de un menú desplegable, la compilación de un proyecto, carga de código o simplemente ajusta la ventana Watch Windows con las variables de consideración. Este archivo se carga una vez junto con el proyecto, y junto a éste aparece el menú GEL con las funciones disponibles. Cabe mencionar que el archivo GEL queda cargado en el CCS, por lo que al cambiar de proyecto, se debe quitar manualmente. Para dar una visión de lo que se puede hacer con este archivo, se mostrará el menú GEL del ejemplo ADC conversor. El archivo GEL viene ya creado con el ejemplo por lo que sólo bastará con cargarlo en el proyecto. Para esto ingresar a FILE->Load GEL y buscarlo en la misma carpeta del ejemplo. Para crear un archivo GEL propio se debe leer la ayuda de VII.- spraa74a.pdf - Creating Device Initialization GEL Files. disponible en www.ti.com. Un vez cargado el archivo GEL aparecerá el siguiente menú en la barra de herramientas. Además el archivo GEL aparecerá en el panel del proyecto en la carpeta GEL FILES.

46

Guía del Usuario Digital Signal Processor 

Figura 3-31 Menú desplegable para archivo GEL.

Antes de haber cargado el archivo GEL, en el menú mencionado anteriormente no aparece nada, pero luego se observará en el menú desplegable las funciones disponibles del archivo. En el menú se observa una opción llamada DSP280x ADC Seq_ovd Test y dentro de éste, tres funciones llamadas Load_and_Build_Project(); Load_Code(); y Setup_WatchWindow(). Si se observa el archivo GEL y se abre, se verán varios ítems. El primero llamado menuitem que tiene el nombre del menú GEL entre comillas en la barra de herramientas. Este menú corresponde a uno general para agrupar las funciones según utilidad o gusto del usuario. El otro ítem que se observa se llama hotmenu y corresponde a la función en sí. Se ven tres funciones hotmenu que son las que aparecen en el menú de la barra de herramientas. Los nombres de estas funciones se pueden crear arbitrariamente, para que hagan referencia a su utilidad. Por ejemplo la tercera función hotmenu Setup_WatchWindow() ajusta la ventana Watch Window con las variables de interés. Dentro de ésta se observa la función GEL_WatchReset() que borra todas las variables que se encuentren actualmente dentro de la ventana. La función GEL_WatchAdd() agrega una variable de interés. Con lo anterior es posible así agregar todas las variables deseadas, sin tener que buscarlas dentro del código una por una cada vez que se reinicia el CCS.

47

Guía del Usuario Digital Signal Processor 

Lo anterior permite crear una mezcla de funciones dentro de otras para realizar así las tareas más comunes en un solo paso. Las funciones base mostradas en el ejemplo son las que aparecen con el prefijo GEL y vienen dentro de la librería de CCS. A continuación se muestra una tabla con las funciones provistas. Para un mayor detalle de su uso dirigirse a la ayuda de CCS.

Funciones GEL GEL_AddInputFile()

GEL_AddOutputFile()

GEL_AdvancedReset()

GEL_Animate()

GEL_AsmStepInto()

GEL_AsmStepOver()

GEL break Statment

GEL_BreakPtAdd()

GEL_BreakPtDel()

GEL_BreakPtDisableGEL_BreakPtReset() GEL_CancelTimer

GEL_DisableRealtime()

GEL_Exit()

GEL_SymbolShowSection()

GEL_ProbePtAdd()

GEL_EnableClock()

OnHalt

GEL_EnableRealtime()

GEL_HWBreakPtDisable

GEL_IsInRealTimeMode

GEL_Go()

GEL_SharedMemHaltOnStepOff()

GEL_Halt()

GEL_Load()

GEL Grammar

GEL_HWBreakPtAdd()

GEL_HWBreakPtReset()

GEL_LoadGel()

GEL_MapDelete()

GEL_HWBreakPtDel()

GEL_MemoryFill()

GEL_MapReset()

GEL_MapAddStr()

GEL_SharedMemHaltOnStepOn()

GEL_MapOff()

GEL_MapOn()

GEL_PatchAssembly()

GEL_PinConnect()

GEL_PortConnect()

GEL_PortDisconnect()

GEL_SyncRun

GEL_ProjectCreateDefaultConfig()

GEL_ProjectLoad()

GEL_ProjectRebuildAll()

GEL_RemoveDebugState

GEL_RemoveInputFile()

GEL_RemoveOutputFile() GEL_Reset()

GEL_SetSimMode()

GEL_SetWaitInResetMode()

GEL_RefreshWindows

GEL_LowPowerRun()

GEL_SrcDirRemoveAll()

GEL_SrcStepInto()

GEL_SrcStepOver()

GEL_StopTransferToFile()

GEL_SymbolAdd()

GEL_SymbolAddRel()

GEL_SymbolHideSection() GEL_SymbolRemove()

GEL_TextOut()

GEL_TransferToFile

GEL_TransferToFileConfg GEL_UnloadAllSymbols()

OnFileLoaded()

Gel_LoadProfileConfiguration

OnPreFileLoaded()

GEL_ProjectClose()

GEL_ProjectRebuildAllConfig()

GEL_OpenWindow()

OnReset() GEL_MapAdd()

GEL_ProjectBuild()

GEL_ProjectRebuildAllConfig()

GEL_MemoryLoad()

GEL_MemorySave()

GEL_StepOver

GEL_ProbePtDel()

GEL_ProbePtDisable

GEL_ProbePtReset()

GEL_SyncStepOver

GEL_ProjectRemoveConfig()

GEL_ProjectSave()

GEL_ProjectSetActive()

GEL_Restart()

GEL_RestoreDebugState

GEL_SrcDirAdd()

GEL_RunF()

GEL_WatchAdd()

GEL_SharedMemHaltOnWriteOff()

GEL_StepInto

GEL_StepOut

GEL_SyncHalt

GEL_SharedMemHaltOnWriteOn()

GEL_SyncStepInto

GEL_SyncStepOut

GEL_SymbolLoad()

GEL_OpenMemoryWindow

GEL_SymbolLoadRel()

GEL_System() GEL_WatchReset()

GEL_UnloadGel()

GEL_ProjectSetActiveConfig()

GEL_WatchDel()

OnResetDetected()

GEL_SetBlockResetMode()

OnTargetConnect()

GEL_Run()

GEL_SetTimer

GEL_OpenDisassemblyWindow

GEL_TargetTextOut()

OnRestart()

GEL_ProjectCreateCopyConfig() GEL_ClearProfileConfigurationGEL_CloseWindow()

Tabla 3-3 Funciones GEL disponibles.

48

Guía del Usuario Digital Signal Processor 

3.8 Ejemplo Echo Back usando SCI. Este ejemplo, al igual que los anteriores, está disponible en la página de Ingeniería MCI LTDA9. Su función es la de utilizar el puerto SCI (Serial Communication Interface) comúnmente conocido como puerto UART, que consiste de una conexión de dos cables asíncrona. Se basa en el formato NRZ (non return to zero). Permite la autodetección de la velocidad de conexión. Cola FIFO de 16 niveles. Cada funcionalidad del SCI es configurable por software donde bytes dedicados son programados para inicializar el formato de comunicación deseado del SCI. Entre otras cosas permite configurar la velocidad de conexión, modo de operación y protocolo, paridad, largo de los caracteres, Bit de parada, y habilitar interrupciones y prioridades. La conexión se realiza utilizando los pines GPIO28 y GPIO29. Estos pines pueden utilizarse como de uso general en caso de que no se use el puerto SCI. El ejemplo funciona de la siguiente forma; cuando vienen datos a través de este puerto, el programa los envía de vuelta, produciendo lo que se conoce como Eco. Viene ya configurado y listo para usar y lo único externo que se necesita es la conexión desde el puerto SCI al PC utilizando el puerto serial. Una opción es utilizar el puerto USB disponible en la placa del DSP, instalar un driver para crear un enlace virtual entre el puerto USB y el puerto serial del PC y luego correr el programa. Este driver se encuentra disponible en la página oficial de FTDI10, que es la marca que provee el chip de la tarjeta que convierte de USB a serial. Si se desea utilizar el Hyperterminal se debe bajar el driver VCP (Virtual COM port). Este driver creará un enlace para el puerto USB, por lo que al utilizar el hyperterminal aparecerá un puerto adicional a los ya existentes. En caso de no disponer de lo anterior, se debe crear una conexión por medio de un circuito externo entre el puerto serial y la tarjeta (utilizando el conector UEXT). Se debe tener cuidado de los niveles de voltaje a tarjeta y el puerto serial del PC, por lo que se recomienda utilizar un chip adecuado (se recomienda MAX232). Para utilizar el ejemplo se debe utilizar el hyperterminal. Se debe crear una conexión y se debe configurar para una velocidad de 9600 baudios, 8N1. El puerto a elegir depende del tipo de conexión. Si se utiliza el puerto serial con el circuito externo, generalmente es el puerto COM1, si se utiliza el puerto USB, generalmente aparece un puerto con un número mayor a 30. Luego de iniciar la conexión, se compila y carga el programa en la tarjeta y al instante aparecerá lo siguiente en el hyperterminal, donde cada vez que se escriba algo, el programa lo enviará de vuelta.

9

www.olimex.cl http://www.ftdichip.com/FTDrivers.htm

10

49

Guía del Usuario Digital Signal Processor 

Figura 3-32 Programa EchoBack con Hyperterminal.

50

Guía del Usuario Digital Signal Processor 

4 Creando un ejemplo desde cero El siguiente ejemplo explicará desde cero la forma de crear un proyecto. Se partirá de una estructura básica a partir de la cual, se comenzarán a agregar librerías o código para realizar alguna tarea o satisfacer la necesidad del usuario. Si bien programar un DSP requiere bastante dedicación y grandes conocimientos en programación y procesadores, es posible aminorar esto partiendo desde una configuración básica basada en los ejemplos. Por ello se creará un esqueleto de proyecto el cual será la base para cualquier otro, logrando así para cada utilidad, la mínima cantidad de configuraciones.

4.1 ¿Por dónde partir? Lo primero a realizar será la creación del proyecto en sí. Para esto se comienza desde el CCS sin abrir nada y se ingresa Proyect->new. Aparecerá una ventana como la de la siguiente figura, en la cual se ingresa el nombre del proyecto (LucesRitmicasDSP), la carpeta donde se creará el proyecto, el tipo de proyecto (*.OUT) y el modelo de la tarjeta DSP.

Figura 4-1 Creación de un proyecto.

Con lo anterior se creará una carpeta con el nombre del proyecto en la carpeta seleccionada junto a dos archivos de extensión: *.PJT que contiene toda la información del proyecto; y *.SBL con información externa. Ahora se procede a agregar un código fuente. Esto se realiza ingresando File->New->Source File. Así se creará un archivo en blanco sin ninguna extensión. Para comenzar simplemente se copia el código del ejemplo del conversor ADC y guardamos el archivo con extensión *.C para que el CCS lo marque como lenguaje C. Luego se agrega al proyecto por medio de Proyect->Add Files to Project. Así la carpeta del proyecto contendrá el archivo LucesRitmicas.c.

51

Guía del Usuario Digital Signal Processor 

Figura 4-2 Guardar Código Fuente.

Con lo anterior, se necesita ahora agregar las librerías y archivos de cabecera. Para mantener el orden con respecto a esto y separar los códigos de lo que son cabeceras, se crearán dos carpetas al estilo de los ejemplos vistos. Así se crearán tres carpetas llamadas DSP280x_common; DSP280x_headers; y DSP280x_examples. Las dos primeras contendrán todas las cabeceras necesarias para poder correr los ejemplos, es decir, se copiarán de los mismos ejemplos. La última carpeta será la que contendrá al proyecto creado anteriormente. Así cuando se indique la carpeta en donde se creará el proyecto, se le debe indicar ../ DSP280x_examples, la cual debe estar completamente vacía. Ahora se debe agregar los directorios al proyecto para que incluya las cabeceras, ya que sino se hace, el compilador no es capaz de encontrar los archivos mencionados en #include. Esto se hace ingresando a Project->Build Options. Así aparecerá una ventana como la siguiente:

52

Guía del Usuario Digital Signal Processor 

Figura 4-3 Opciones par incluir archivos de cabecera.

En la pestaña Compiler se selecciona la categoría Preprocessor y se ingresa en Include Search Path (i): el siguiente comando para agregar una carpeta: ..\..\DSP280x_headers\include;..\..\DSP280x_common\include. Por la forma en cómo están creadas las carpetas, con el comando anterior incluirá las direcciones en donde se encuentran la mayoría de los archivos de cabecera. Así las carpetas deben quedar como:

Guía del Usuario Digital Signal Processor 

53

Figura 4-4 Carpetas del proyecto.

Luego dependiendo de las funciones usadas en el código, será la forma del árbol de carpetas del proyecto con los archivos a ser agregados. Para agregar un archivo o cabecera al proyecto de debe ingresar a Project->Add Files to Project o simplemente haciendo click derecho sobre el nombre del proyecto. Entre los archivos principales se deben incluir: • • • •

DSP280x_headers/source/DSP280x_GlobalVariableDefs.c DSP280x_headers/cmd/DSP280x_Headers_nonBIOS.cmd DSP280x_common/cmd/28016_RAM_lnk.cmd DSP280x_common/source/: o DSP280x_CodeStartBranch.asm o DSP280x_Adc.c o DSP280x_DefaultIsr.c o DSP280x_PieCtrl.c o DSP280x_PieVect.c o DSP280x_SysCtrl.c o DSP280x_usDelay.asm o DSP280x_Gpio.c

Dependiendo del tipo de proyecto que se desea crear, es posible ir agregando o quitando estos archivos. Por ejemplo si se desea usar SCI se debe incluir el archivo DSP280x_common/source/DSP280x_Sci.c. Algunos de estos archivos son excluyentes, por lo que debe tener cuidado de no definir algunas variables dos veces, lo que provoca un error de compilación. Todo lo anterior está definido exclusivamente para que funcione con el ejemplo del conversor ADC, pero aún así es suficiente como para comenzar a trabajar, sin la necesidad de partir completamente desde cero. La configuración de memoria con los archivos *.CMD también es básica, por lo que si se desea un uso de memoria más exigente, se debe modificar el archivo 28016_RAM_lnk.cmd.

54

Guía del Usuario Digital Signal Processor 

Antes de compilar se debe configurar el CCS. Para esto se debe ingresar a las opciones de compilación en Project->Build Options. En la pestaña Linker ingresar en la categoría Basic y en Stack Size (-stack) elegir 0x380 y en Code Entry Point (-e) escribir code_start. Esto indica el tamaño del stack y la dirección de memoria en la cual se guardará el comienzo del código del programa. Esto se indica en el archivo 28016_RAM_lnk.cmd y DSP280x_CodeStartBranch.asm. Luego en la misma pestaña Linker ingresar en la categoría Libraries y modificar el Search Path (i) a ..\..\DSP280x_headers\include y el Incl Libraries (-l) ingresar rts2800_ml.lib. Con todo lo anterior, la configuración debería verse como:

Figura 4-5 Configuración Build_Option.

Ahora se está listo para duplicar el ejemplo de los conversores ADC. Para crear el ejemplo de las luces rítmicas se partirá desde éste punto. Si se desea evitar lo anterior, simplemente se puede copiar en una nueva carpeta todo un ejemplo completo y partir desde ahí, pero con el problema de que ante cualquier cambio, pueda aparecer un error ante la falta de algún tipo de archivo. Se recomienda leer cuidadosamente los ejemplos para utilizar los periféricos.

55

Guía del Usuario Digital Signal Processor 

4.2 Uso de librería FFT y otras modificaciones. Este ejemplo es parte del proyecto LucesRitmicas el cual consiste en muestrear una señal de audio, calcular su espectro de frecuencias, y en base a los sonidos bajos, medios y altos, encender o apagar unos led. Se partirá del ejemplo visto anteriormente donde el programa se ejecuta idéntico al del conversor ADC, pero en este caso manejaremos otros pines para prender 3 led externos conectados en la placa, y se ajustará un conversor ADC diferente al conectado al potenciómetro de la tarjeta. Primero se activarán los LED para usarlos como luces. Se crearán 3 salidas idénticas a las usadas para el ejemplo del Blinking_LED. Se usarán #define para identificar los LED’s. Esto se muestra en lo siguiente:

Figura 4-6 Configuración de botones.

Ahora falta configurar esos pines como salida. Esto se realiza en la función Gpio_select(); donde el valor del registro es GpioCtrlRegs.GPADIR.all=0x00000800 (0000 1000 0000 0000). Este valor ( ‘1’ lógico) indica que el pin 11 funciona como salida (el pin conectado al led de estado de la placa). Su valor corresponde con cada pin, partiendo desde cero, donde si aparece un 1, indica que el pin funciona como salida. Por ejemplo si se desea que el pin 11 y el 3 funcionen como salida entonces se debe ingresar un 0x0000 0808 (0000 1000 0000 1000). Ahora como se desea que funcionen 3 pines como salida además del pin 11, se debe tener que configurar como 0x0000 040E (0000 1000 0000 1110), en donde se utilizarán el PIN 1, PIN 2 y PIN 3. La función Gpio_Select() se muestra en la siguiente figura. Por ahora el resto de los registros se debe dejar idéntico. Esta función también puede ser incluida manualmente, simplemente ingresándola en el código fuente, pero debe quitarse del proyecto el archivo DSP280x_Gpio.c ya que creará un error de compilación el tener dos veces la función definida. Luego de haber realizado los cambios, es posible usar los leds simplemente ingresando las macros dadas, del mismo modo que el ejemplo del Blinking_Led.

56

Guía del Usuario Digital Signal Processor 

Figura 4-7 Función Gpio_Select().

Ahora para el control en el dominio de la frecuencia se usarán unas librerías, disponibles en www.ti.com, para el manejo de la FFT (Fast Fourier Transform). Para agregar estas librerías simplemente se busca por el archivo sprc081.zip, se descomprime y luego se instala. El directorio de instalación es siempre el mismo y es C:\TIDCS\C28\DSP_TBOX\FFT. En esta carpeta aparecerán otras tres más llamadas clin; cstb y doc. Para poder utilizar esta librería simplemente se debe agregar el archivo .\clib\include\fft.h y .\clib\lib\fft.lib al mismo directorio en donde se encuentra el código fuente o en los directorios dados en el linker del compilador (como se muestra en la Figura 4-5 en la sección Search Path). Luego la librería fft.h se debe ingresar en esa misma figura, en la Categoría Libraries, en Include Libraries, ingresando fft.lib. Si existen más de una librería, simplemente se separan por punto y comas (;). Así esto debe quedar como en la Figura 4-9. En el código fuente se debe incluir explícitamente el archivo fft.h. Para ello se utiliza la macro #include junto a comillas (“”) o a parénteris (). Esto se ve de la siguiente manera:

Figura 4-8 Inclusión de librerías usando “” o .

En el caso del uso de comillas, el compilador buscará el archivo en el mismo directorio del código fuente, mientras que en el caso de paréntesis , el compilador buscará las librerías en los directorios agregados en las opciones del CCS.

57

Guía del Usuario Digital Signal Processor 

Figura 4-9 Forma de incluir una librería al CCS.

Luego para utilizar la librería FFT, se debe ingresar un conjunto de funciones, que entre otras cosas, maneja los cálculos y arregla de tal forma los datos, que permite ser lo más eficiente posible en el cálculo. Esto debido a que las funciones FFT están programadas en lenguaje ensamblador, al máximo de eficiencia por instrucción. Además es necesario modificar el archivo de memoria o *.cmd. Dentro del código fuente se debe incluir, donde corresponda (ya sea en la cabecera, dentro o fuera del main) lo siguiente:

58

Guía del Usuario Digital Signal Processor 

Figura 4-10 Código básico para utilizar la FFT.

La utilidad y función de cada línea de la figura anterior se explica con mayor detalle en la documentación de la librería. Básicamente se puede explicar que se toman los datos los cuales se guardan en una estructura llamada RFFT32 fft. En ésta se realizan los procesos de muestreo (número de puntos N=128 y ventana de Hamming), bit reverse y conversión, además de otros cálculos útiles como peak de frecuencia y de amplitud. Las

59

Guía del Usuario Digital Signal Processor 

operaciones disponibles de pueden ver ingresando fft. donde luego de unos momentos aparecerá un menú contextual con las funciones disponibles. Esto se ve a continuación:

Figura 4-11 Funciones disponibles para la FFT.

Luego es posible realizar cualquier acción que se desee en base a la potencia de la señal o en base a su frecuencia, por ejemplo se puede utilizar fft.peakmag que calcula el módulo de la FFT. En base a este valor se pueden manejar los LED en base a la potencia del audio o de una señal cualquiera. Para un mejor uso de estas funciones dirigirse al manual provisto por Texas Instruments. Para la ubicación de la memoria simplemente se agregan los comandos mostrados en las siguiente figuras en el archivo linker 28016_RAM_lnk.cmd. Se eliminaron algunas secciones, pero la versión completa se encuentra en la documentación de la FFT. Se debe agregar H0RAM en la página 0 de la memoria y la FFTtf en SECTIONS. Tambien es posible no especificar estas secciones y dejar que el linker las cree sola, pero se tiene la posibilidad de que no alcance el espacio de memoria, creando un error de compilación, o de que se pisoteen variables, creando un error en tiempo de ejecución. Para que el linker cree solo los espacios se deben agregar las siguientes líneas: #pragma DATA_SECTION(ipcb, "FFTipcb"); y #pragma DATA_SECTION(mag, "FFTmag"). Estas líneas se deben agregar debajo de la definición de la variable N = 128 al comienzo del código fuente.

60

Guía del Usuario Digital Signal Processor 

Figura 4-12 Comand Linker de ejemplo para ocupar la librería FFT.

Aún así lo anterior, la documentación provista por TI recomienda como mínimo tener las siguientes secciones para sus variables y operaciones:

Figura 4-13 Comand Linker mínimo para librería FFT.

4.3 Filtrado de Señales. Para el filtrado de señales se utilizará la herramienta más conocida, la Convolución. Con ello se procederá a manejar una señal por medio de un filtro FIR, que requiere pocas muestras de la señal y además es bastante eficiente. A continuación se muestra un esquema de la forma en que se aplica un filtro FIR utilizando convolución.

Guía del Usuario Digital Signal Processor 

61

Muestra De Entrada

Z0

Z-1

Z-2

Z-N+1

Filtro[0]

Filtro[1]

Filtro[2]

Filtro[N-1]

Salida Figura 4-14 Esquema de un Filtro FIR.

Para realizar esta operación se debe proceder de la siguiente manera. • • • • •

Guardar las muestras de la señal en una variable HISTORIAL[BUFFER] con un buffer dado por el usuario. El buffer dependerá de la calidad que se le quiera dar al filtrado y del tipo de filtro que se le quiera aplicar. Crear el filtro a aplicar utilizando los requerimientos necesarios para la señal, como frecuencia de corte, ganancia o factor de amortiguamiento. Realizar la operación de convolución entre la variable HISTORIAL[] y el filtro. En base a la respuesta obtenida, es el significado que se le dan a los resultados.

Lo más complicado de lo anterior es obtener un filtro. Sin embargo existen muchas páginas en la cuales entregando las características antes mencionadas, te entregan los valores del filtro. Generalmente sólo basta indicar la frecuencia de corte y el número de puntos del filtro el cual corresponde al tamaño del buffer para la variable Historial. Se supondrá que ya se tiene un filtro que realiza alguna operación del tipo pasa bajo para cierta frecuencia de corte fc. Se tiene en este caso un buffer obtenido arbitrariamente de 128 muestras. Supongamos que las muestras las obtenemos del conversor ADC (ADC_Results). Lo primero que se debe realizar es ir guardando las muestras en el buffer, pero con la condición de ir moviendo las muestras a medida que llegan, es decir, con el principio de que el primero en entrar es el último en salir. De esta forma se crea una variable donde las muestras más nuevas se encuentran al comienzo y las más antiguas al final. El código para hacer esto es:

62

Guía del Usuario Digital Signal Processor 

Figura 4-15 Ejemplo código para Historial.

Donde BUF_SIZE corresponde al número de valores del filtro que se quiera aplicar. Es importante recalcar que este valore debe ser lo más mínimo posible, para evitar llenar la memoria con valores innecesarios. Se recomienda un valor cercano a los 32 para una calidad de procesado mediana. Por ejemplo el filtro conviene escribirlo de la siguiente manera por medio de una variable global:

Figura 4-16 Macro para definir filtro.

Sin embargo existen varios programas o funciones que pueden correr en tiempo de ejecución, que crean automáticamente el filtro basándose en parámetros dados. Estas funciones pueden ser encontradas gratis en la web. Para la convolución se debe multiplicar la última muestra que llega con el último término del filtro. En muchos casos los filtros son simétricos por lo que esto no es de real importancia, pero se dejará lo más robusto posible para futuras aplicaciones. Otro punto importante, es que en la mayoría de las veces se utilizan filtros normalizados. Estos son útiles para evitar un cambio en la potencia de la señal y evitar distorsiones no deseadas. Ahora se procede a aplicar el filtro a la señal en tiempo real. Esto se realiza con el siguiente código:

Figura 4-17 Código para Convolución.

Se observa que se aplica el filtro a todas las muestras anteriores (32 muestras), para producir una variable resultante de salida. Esta es la que deberá ir como muestra para un arreglo de salida dependiendo del tipo de señal con la que se esté trabajando.

63

Guía del Usuario Digital Signal Processor 

Con lo anterior se tendrá la muestra resultante en la variable Salida. Si la señal fuera un archivo se sonido, entonces esta muestra (Salida) al final del ciclo for{;;} se deberá entregar como entrada para el dispositivo de audio o hacia algún amplificador para reproducirla. Este tipo de acción debe ser lo suficientemente rápida como para alcanzar a realizar todo el procesado de la señal, antes de que llegue la siguiente muestra, ya que de lo contrario, se corre el riesgo de que el audio quede dañado o se escuche mal. Por esta razón se recomiendan usar filtros de no más de 64 muestras.

Guía del Usuario Digital Signal Processor 

64

5 Resumen Atajos Teclado.

Atajo

Descripción

F5

Run

Shift+F5

Halt

F7

Build

Ctrl.+F7

Compile File

Alt+C

Connect

Ctrl.+L

Load Program

Ctrl+Shift+L Ctrl.+R

Reload Program Reset Cpu

Ctrl.+Shift+R

Reset Emulador

Tabla 5-1 Tabla resúmen de atajos.

65

Guía del Usuario Digital Signal Processor 

6 Manuales de Referencia de TI.COM Esta sección contiene los manuales de referencia para cada módulo disponible en el DSP TSM320F28016. Se incluye una hoja de datos (datasheet) general, una guía sobre cómo empezar a programar (Quick Start) y un manual de referencia por cada módulo, el cual explica en detalle sus registros y la forma de configurarlos. Para obtener estos archivos dirigirse a www.ti.com y buscarlos por el código dado al comienzo de cada referencia o directamente de www.olimex.cl en la sección Tarjetas Olimex->DSP.

I.II.III.IV.V.VI.VII.VIII.IX.X.XI.XII.XIII.-

TMS320F28016- Data Manual (Datasheet). spraam0a.pdf - Getting Started With TMS320C28x Digital Signal Controllers. spru716b.pdf - TMS320x280x, 2801x, 2804x DSPAnalog-to-Digital Converter (ADC). spraap6a.pdf - An Overview of Designing Analog Interface With TMS320F28xx/28xxx DSCs. spru361e.pdf - TMS320 DSP Algorithm Standard Demonstration Application. spru424c.pdf - TMS320 DSP Algorithm Standard Developer’s Guide. spraa74a.pdf - Creating Device Initialization GEL Files. C280x/C2801x C/C++ Header Files and Peripheral Examples Quick Start. spru566f.pdf - TMS320x28xx, 28xxx DSP Peripheral Reference Guide. spru258a.pdf - TMS320 DSP Product Family Glossary. spraa85a.pdf - Programming TMS320x28xx and 28xxx Peripherals in C/C++. spru712f.pdf - TMS320x280x, 2801x, 2804x DSP System Control and Interrupts. spru625.pdf - TMS320C28x DSP/BIOS Application Programming Interface (API) Reference Guide. XIV.- spraa88 Using PWM Output as a Digital-to-Analog Converter on a TMS320F280x. XV.spra958g.pdf - Running an Application from Internal Flash Memory on the TMS320F28xxx DSP. XVI.- spru051b.pdf - TMS320x28xx, 28xxx DSP Serial Communication Interface (SCI) Reference Guide. XVII.- spru059d.pdf - TMS320x28xx, 28xxx DSP Serial Peripheral Interface (SPI) Reference Guide.