PROYECTO FINAL DE CARRERA

TTULO:

Programacin de un Registrador de Datos Ssmicos Autnomo de Bajo Consumo

AUTOR: Josep Guillem Rodrguez Astol TITULACIN: Ingeniera en Automtica y Electrnica Industrial DIRECTOR: Joaqun del Ro Fernndez DEPARTAMENTO: 710, Ingeniera Electrnica FECHA: 11 de Febrero de 2010

Este proyecto tiene en cuenta aspectos medioambientales:

S No

PROYECTO FINAL DE CARRERA

RESUMEN:
Hoy en da, con el continuo avance del ser humano en la rama de la ingeniera, cada vez es ms comn el diseo por especialistas, de sistemas automticos y electrnicos capaces de proporcionar la informacin necesaria para poder predecir catstrofes naturales y evitar de este modo miles de muertes. Por este motivo, el proyecto que se ha llevado a cabo tiene como finalidad la adquisicin y registro en una tarjeta de memoria MicroSD de los datos obtenidos por un Gefono y un Hidrfono, para el posterior estudio de los posibles movimientos entre las placas tectnicas que se encuentran bajo el fondo marino, que pueden finalmente originar en un tsunami. El sistema creado tiene como principal caracterstica su autonoma, ya que consta de dispositivos de bajo consumo de energa, pudiendo alimentar el sistema durante un gran periodo de tiempo a travs de una batera. sta autonoma hace que el sistema pueda ser ubicado a grandes distancias de la costa, porque no implica la utilizacin de cables de fibra ptica submarinos para su alimentacin y envo de datos recopilados. As pues, la primera parte del proyecto se ha empleado para conocer el funcionamiento de todos los mdulos que componen de la placa de evaluacin LM3s8962 de Stellaris. Esta placa ha sido elegida porque rene las caractersticas bsicas del proyecto propuesto: Bajo consumo, Mdulo SPI (Serial Peripheral Interface) para comunicarse con la tarjeta de adquisicin y filtrado de datos ADC CS5376A y ranura para introducir una tarjeta de memoria MicroSD. En la segunda parte se ha diseado el software que ejecuta sucesivamente las dos funciones principales del sistema: la adquisicin de los datos que provienen de los sensores (Gefono e Hidrfono) y el registro de los mismos en la tarjeta de memoria no voltil MicroSD. Una vez comprobado el buen funcionamiento de los tres dispositivos que componen el sistema (Gefono/Hidrfono, ADC CS5376A, LM3s8962) se ha creado un programa con LabVIEW que permite la visualizacin de los datos registrados a travs de una simple interface, donde el usuario tiene la posibilidad de elegir si quiere ver los datos mediante grficas o tablas numricas. Finalmente se han realizado mltiples pruebas de funcionamiento con diferentes tiempos de adquisicin y registro de datos que han sido plasmados en los resultados experimentales.

Palabras clave:
Prediccin Gefono/Hidrfono ADC CS5376A Tsunamis Ssmica Bajo consumo MicroSD Autonoma LM3s8962

Contenido
PROYECTO FINAL DE CARRERA ......................................................................................................................1 1. Introduccin: Objetivos y justificacin del PFC. ....................................................................................6 1.1. 1.2. 2. Estado del arte...............................................................................................................................7 Arquitectura del sistema ...............................................................................................................8

Seleccin del Microcontrolador ............................................................................................................9 2.1. Caractersticas Tcnicas.............................................................................................................. 10 Placa de evaluacin LM 3s8962.......................................................................................... 10 Microcontrolador ............................................................................................................... 11 Depurado y volcado de las aplicaciones............................................................................. 13

2.1.1. 2.1.2. 2.1.3. 2.2.

Mdulos necesarios para el desarrollo de la aplicacin ............................................................ 13 General-Purpose Input/Outputs (GPIOs) ........................................................................... 13 Universal Asynchronous Receivers/Transmitters (UARTs) ................................................. 14 Synchronous Serial Interface (SSI) ...................................................................................... 16 General-Purpose Timers (GPTM)........................................................................................ 16 Interrupt Controller (NVIC)................................................................................................. 17

2.2.1. 2.2.2. 2.2.3. 2.2.4. 2.2.5. 3.

SOFTWARE.......................................................................................................................................... 19 3.1. Entorno de programacin .......................................................................................................... 19 IAR Embedded Workbench IDE .......................................................................................... 19 Luminary Micro Flash Programmer .................................................................................... 21 HyperTerminal de Windows ............................................................................................... 22 National Instruments LabVIEW 8.5.1 ................................................................................. 24

3.1.1. 3.1.2. 3.1.3. 3.1.4. 3.2.

Aplicacin ................................................................................................................................... 25 Parte 1: Inicializacin y Programa Principal ....................................................................... 26 Parte 2: Funcin Interrupcin Timer .................................................................................. 35 Parte 3: Arbitraje del bus de datos SPI ............................................................................... 36 Parte 4: Adquisicin y Procesado de datos ........................................................................ 38 Parte 5: Registro de datos en MicroSD .............................................................................. 41 Parte 6: Visualizacin de datos a travs de LabVIEW......................................................... 47

3.2.1. 3.2.2. 3.2.3. 3.2.4. 3.2.5. 3.2.6. 4.

HARDWARE......................................................................................................................................... 52 4.1. 4.2. Comunicacin entre los dispositivos del sistema ....................................................................... 52 Seleccin y especificaciones tcnicas del sensor ....................................................................... 53 Gefono .............................................................................................................................. 53 Hidrfono ........................................................................................................................... 54

4.2.1. 4.2.2. 4.3.

Convertidor Analgico-Digital ADC CS5376A ............................................................................. 55

4.4. 4.5. 5.

Tarjeta de memoria MicroSD ..................................................................................................... 56 Eleccin de la batera ................................................................................................................. 57

RESULTADOS EXPERIMENTALES ......................................................................................................... 58 5.1. 5.2. 5.3. 5.4. Prueba 1 ..................................................................................................................................... 59 Prueba 2 ..................................................................................................................................... 59 Prueba 3 ..................................................................................................................................... 60 Prueba 4 ..................................................................................................................................... 60

6. 7. 8.

PRESUPUESTO .................................................................................................................................... 61 CONCLUSIONES Y PERSPECTIVAS ....................................................................................................... 62 BIBLIOGRAFA ..................................................................................................................................... 63

ANEXOS ...................................................................................................................................................... 64 Anexo I. Familiarizacin con el entorno de desarrollo Luminary Micro ................................................ 65 Anexo II. Esquema de conexiones .......................................................................................................... 86 Anexo III. Listado de cdigo de la aplicacin .......................................................................................... 88

1.

Introduccin: Objetivos y justificacin del PFC.

Este proyecto final de carrera ha sido realizado en el laboratorio del Centre Tecnolgic de Vilanova i la Geltr (CTVG), y en colaboracin con el equipo del Centro de Desarrollo de Sistemas de Adquisicin Remota y Tratamiento de la Informacin (SARTI), encargados de llevar a cabo el proyecto OBSEA (Observatorio Submarino Expandible) [1]. Mediante el tutor del proyecto, se ha propuesto realizar un sistema basado en un Microcontrolador de bajo consumo, para el diseo de un sistema autnomo de adquisicin y registro de datos utilizado para ssmica activa y pasiva en el fondo marino. El sensor y los dispositivos usados estarn situados en el fondo del mar mediante un peso de anclaje, a una profundidad aproximada de 20 metros y a una distancia de 4 km de la costa de Vilanova y la Geltr [2]. Los datos adquiridos por el sensor ssmico deben ser almacenados en una memoria no voltil tipo MicroSD, que ser extrada cada cierto tiempo para el posterior estudio de Prospecciones Geofsicas, que puedan surgir en la zona elegida. Segn el Ministerio de Fomento del Gobierno Espaol [3], la Geofsica se puede definir como la ciencia cuyo objeto es el estudio cientfico de la Tierra y su aplicacin a la bsqueda de recursos naturales, reduccin de efectos causados por desastres naturales y la preservacin del medio ambiente. Los objetivos principales del sistema diseado son los siguientes: Bajo Consumo: El sistema es alimentado a bateras para su posterior uso en diferentes localizaciones sin tener que estar conectado a un equipo externo mediante cables de fibra ptica submarinos y tiene una autonoma suficiente para la recopilacin de datos aproximada de 2 meses. Adquisicin de datos: Se ha utilizado una tarjeta de adquisicin y filtrado de datos ADC de 4 canales (3 acelermetros - 1 Hidrfono) y 24 bits para cada uno, diseada especialmente por el equipo de SARTI para sensores ssmicos de alta sensibilidad. Protocolo de comunicacin: El protocolo utilizado para el envo de los datos adquiridos por el sensor entre el convertidor analgico-digital (ADC) y el Microprocesador, es del tipo SPI (Serial Peripheral Interface) [4]. Registro de datos: Los datos de los cuatro canales adquiridos son almacenados en una tarjeta de memoria no voltil de tipo MicroSD, y guardados en un archivo .txt para su posterior visualizacin. Visualizacin-Interface: Los datos guardados en el archivo de texto son extrados mediante el programa LabView a una interface, donde el usuario puede visualizar con grficos y tablas numricas el estado de los elementos que componen el sensor utilizado (Gefono-Hidrfono).

Uno de los mtodos de Prospeccin Geofsica ms empleado es la ssmica, donde se miden las anomalas mediante la reflexin y refraccin de ondas ssmicas en diversos ambientes: terrestres, marinos, fluviales o lacustres. As pues, el Gefono proporciona el registro de las refracciones que se produzcan y el Hidrfono el de las reflexiones. La ssmica de reflexin consiste en emitir ondas de sonido en la superficie del terreno, en este caso, con caones de aire en el mar, las cuales se transmiten a travs de las capas del subsuelo y son reflejadas nuevamente hacia la superficie cada vez que haya un cambio importante en el tipo de roca. 6

Las ondas recibidas en superficie se miden por el tiempo que tardan en llegar a sta, de lo que se deduce la posicin en profundidad y la geometra de las distintas capas que componen el terreno. El producto final es una imagen del subsuelo. Como afirma el organismo Osinergmin [5], los mtodos Geofsicos son generalmente la forma ms rpida, econmica y de menor impacto ambiental, que debe emplearse para obtener informacin detallada del subsuelo; profundidad, extensin, naturaleza, estructura de las formaciones, etc. Por lo general es necesario emplear ms de un mtodo para obtener informacin confiable y precisa. Los mtodos geofsicos tambin sirven para encontrar impactos ambientales negativos no detectados en la superficie y ayuda a calcular las reas contaminadas por derrames, la contaminacin de los acuferos, ubicar materiales y elementos contaminantes enterrados, etc. Una vez se obtienen los datos Geolgicos (geologa de campo, estudios anteriores, mapas, fotos areas, imgenes satelitales, etc.) y los Geofsicos (gravimetra, magnetometra, geoqumica, ssmica, etc.) se deriva al procesamiento de los datos anteriormente descritos por especialistas en Geociencias. Estos especialistas, Geofsicos y Gelogos o especialistas en ambas ramas son quienes interpretarn los resultados y determinarn las ubicaciones para la perforacin de los pozos exploratorios. Estas recomendaciones y estudios se encomiendan a los especialistas en Ingeniera de Petrleo.

1.1. Estado del arte

Hoy en da, la primordial caracterstica que deben tener los proyectos en el rea de la Electrnica y Automtica en general es el uso eficiente de la energa. Para ello, es necesario que el sistema a implementar tenga como requisito fundamental el bajo consumo de energa, ya que muchos de los proyectos diseados son alimentados a travs de bateras. Por esta razn, los principales fabricantes de Microcontroladores estn utilizando nuevas tecnologas del silicio, que permiten aumentar la velocidad del Bus de datos, disminuir el consumo y reducir el tamao de los encapsulados, bajando de este modo tambin el costo final del producto. Otro gran adelanto para reducir el consumo y los costes del sistema es el uso de un circuito PLL, ya que permite utilizar un cristal de cuarzo de baja frecuencia para generar frecuencias en mltiplos enteros y programar de esta forma la velocidad del Bus de datos. Por ejemplo, usando el PLL se puede proporcionar hasta una frecuencia de bus de 8.2 MHz usando un cristal de 32 kHz. El uso del PLL tambin reduce la generacin de ruido (EMI), en comparacin con otros cristales de frecuencias ms altas. Una mejora considerable ha sido la utilizacin de la tecnologa Flash en la memoria del programa, ya que permite que mltiples posiciones de memoria sean escritas o borradas en una misma operacin de programacin mediante impulsos elctricos, frente a las anteriores que slo permite escribir o borrar una nica celda cada vez. Por ello, la memoria Flash permite funcionar a velocidades muy superiores cuando los sistemas emplean lectura y escritura en diferentes puntos de esta memoria al mismo tiempo. Con los mdulos de depuracin internos, se han logrado crear nuevas herramientas de desarrollo mucho ms econmicas, donde se puede obtener una emulacin de la aplicacin en tiempo real.

Existen muchos fabricantes de Microcontroladores de ltima generacin; los principales y a la vez ms utilizados por la industria electrnica y automtica se citan a continuacin: Stellaris, Analog Devices, Cypress, Hitachi, Renesas, Texas Instrument y Freescale.

1.2. Arquitectura del sistema

De la Figura 1 se puede observar los tres dispositivos principales que componen el sistema de adquisicin y registro de datos autnomo: Los Sensores, el convertidor ADC CS5376A y la placa de evaluacin Luminary Micro LM3s8962. El Gefono y el Hidrfono son los sensores que proporcionan los datos analgicos y son conectados directamente a los cuatro canales de entrada del convertidor ADC CS5376A (3 canales del Gefono y 1 canal del Hidrfono). La comunicacin entre la placa ADC CS5376A y la placa Luminary Micro LM3s8962 se realiza a travs del protocolo SPI, mediante un cable cinta construido especialmente para la aplicacin. Un extremo del cable tiene un conector DB15 hembra para ser conectado a la placa ADC, y el otro extremo un conector plano de 20 pines para ser acoplado a los pines exteriores de la placa Luminary Micro. La tarjeta de memoria MicroSD donde se almacenarn los datos procesados que provienen de los sensores, es insertada en el slot que posee la placa Luminary Micro. La comunicacin entre el Microprocesador y el slot de la tarjeta se produce mediante el bus SPI interno de la placa.

Figura 1. Arquitectura del sistema para la adquisicin y registro de datos en una MicroSD

2.

Seleccin del Microcontrolador

El Microcontrolador seleccionado para llevar a cabo el sistema de adquisicin y registro de datos debe tener fundamentalmente tres caractersticas bsicas para cumplir con los objetivos del proyecto: 1. Bajo consumo 2. Bus SPI para la adquisicin de datos del convertidor ADC 3. Soporte para el registro de datos en una tarjeta de memoria MicroSD La placa de Stellaris Luminary Micro LM3s8962 Ethernet+CAN Evaluation Kit (Vase Figura 2), ofrece todas las caractersticas anteriormente descritas, adems de tratarse de una plataforma compacta y verstil que permite la evaluacin rpida de prototipos de desarrollo y la creacin de mltiples aplicaciones especficas. El kit tambin incluye una amplia fuente de ejemplos de cdigo y libreras, lo que le permite empezar la creacin de aplicaciones en cdigo C de manera simple y sencilla.

Figura 2. Stellaris LM3S8962 Ethernet+CAN Evaluation Kit

Todos los miembros de la familia de productos Stellaris , incluyendo el Microcontrolador LM3S8962, estn diseados en base al ncleo ARM Cortex-M3. El procesador ARM Cortex-M3 satisface las necesidades de la aplicacin, ya que ofrece un alto rendimiento, a un bajo coste y consumo de energa [6].

2.1.
2.1.1.

Caractersticas Tcnicas
Placa de evaluacin LM 3s8962

La placa de evaluacin Luminary Micro Lm3s8962 ofrece mltiples posibilidades para aplicaciones relacionadas con la electrnica y la automtica en general. En la Figura 3 se puede observar una imagen real de la placa de evaluacin empleada, con todos los perifricos que la componen [7]. Las caractersticas tcnicas ms importantes de la placa se citan a continuacin: Voltaje de alimentacin: 4.375.25 Vdc desde un conector USB Intensidad de alimentacin: 240 mA typ (pleno rendimiento, CPU a 50 MHz) Voltaje e intensidad de los pines exteriores: 3.3 Vdc (60 mA max), 15 Vdc (15 mA max) Dimensiones: 4.55 x 2.45 x 0.7 (L x W x H)

Figura 3. Placa Luminary Micro Lm3s8962 de Stellaris

10

En la Figura 4 se puede apreciar una imagen a modo de diagrama de bloques extrada del datasheet del fabricante con el Microcontrolador y los perifricos que componen la placa de evaluacin. Los ms utilizados por la aplicacin diseada han sido el OLED Display, la MicroSD card slot, los Leds, los Switches de navegacin, los pines de entrada y salida exteriores, el Dual USB Device Controller y por supuesto el Microcontrolador con sus mdulos.

Figura 4. Diagrama de bloques de la placa de evaluacin Luminary Micro LM3s8962

2.1.2.

Microcontrolador

La placa Luminary Micro Lm3s8962 de Stellaris utiliza el primer Microcontrolador ARM Cortex M3 de la familia Analog Devices basado en un procesador (Vase Fig.5). Es pionera en ofrecer a los clientes un rendimiento de 32 bits y un mnimo consumo a un coste equivalente al de un Microcontrolador de 8 o 16 bits.

Figura 5. Encapsulado del Microcontrolador LM3s8962 de ARM

11

Las caractersticas tcnicas y los mdulos principales de los que consta el Microcontrolador Lm3s8962 son los siguientes: 32-bit RISC usando la arquitectura de ARM Cortex-M3 v7M 50-MHz operation Unidad de proteccin de memoria (MPU) Control del Vector de Interrupciones Integrado (NVIC) 42 canales de interrupciones con ocho niveles de prioridad 256-KB single-cycle Flash 64-KB single-cycle SRAM 4 Timers de 32 bits Mdulo CAN 2 UARTs del tipo 16C550 Convertidor ADC de cuatro canales Mdulo I2C Mdulo SSIs 0 a 42 GPIOs

La Figura 6 se muestra la arquitectura interna del Microcontrolador y sus diferentes mdulos perifricos (serie, control, sistema y analgicos) interconectados a travs del Bus principal Advanced Peripheral Bus (APB).

Figura 6. Diagrama de bloques de la arquitectura interna del Microcontrolador ARM

12

2.1.3.

Depurado y volcado de las aplicaciones

El cable USB proporcionado por el Kit de Evaluacin se utiliza para la alimentacin y transmisin bidireccional de datos entre el PC y la placa Luminary Micro. De este modo el usuario tiene la posibilidad de depurar las aplicaciones en tiempo real con el programa IAR Embedde Workbech IDE, viendo reflejado paso a paso el resultado de las funciones ejecutadas por el Microcontrolador hacia los perifricos de la placa. Una vez se obtiene el resultado satisfactorio de la aplicacin, se crea un archivo con extensin .bin que puede ser cargado directamente a la placa con el programa LM Flash Programmer. (Vase el apartado 3.1.2).

Figura 7. Conexin PC-Placa de evaluacin Luminary Micro mediante cable USB

2.2.

Mdulos necesarios para el desarrollo de la aplicacin

Para llevar a cabo la aplicacin es necesario conocer el funcionamiento y caractersticas de algunos mdulos que integran la placa de evaluacin y el Microcontrolador. Estos mdulos sern utilizados posteriormente para el desarrollo de la misma. A continuacin se detallan cuales son los mdulos y sus principales caractersticas:

2.2.1.

General-Purpose Input/Outputs (GPIOs)

Los pines de entradas y salidas para uso general (GPIO), ofrecen una gran flexibilidad para el diseo de mltiples aplicaciones. El mdulo GPIO de Stellaris est compuesto por siete bloques fsicos GPIO, cada uno correspondiente a un puerto individual (Puerto A, Puerto B, Puerto C, Puerto D, Puerto E, Puerto F y Puerto G). Algunos de los pines de los puertos son utilizados como pines exteriores para la comunicacin con otros dispositivos externos. Hay 42 pines de entrada/salida y toleran un voltaje mximo de 5V. Pueden configurarse como fuentes de interrupcin o entradas de disparo y ser programados para diferentes intensidades y resistencias.

13

En la Figura 8 se puede observar los bloques y registros internos que componen el mdulo GPIO.

Figura 8. Diagrama de bloques del mdulo GPIO

2.2.2.

Universal Asynchronous Receivers/Transmitters (UARTs)

El Receptor/Transmisor Asncrono Universal (UART) es un circuito integrado que se utiliza para comunicaciones va serie con el estndar RS-232C. Es un protocolo sencillo y universal utilizado para comunicaciones entre perifricos y un PC. La denominacin de asncrono, en este caso no significa que no necesite un sincronismo, al contrario, al no llevarlo explcitamente en una lnea debe tenerlo implcitamente en su funcionamiento y por tanto es mucho ms rgido. Este mdulo contiene una lnea transmisora Tx (convertidor paralelo-serie) y una lnea receptora Rx (convertidor serie- paralelo) de forma independiente, es decir, que puede transmitir y recibir datos simultneamente ya que consta de una comunicacin full-duplex. El Microprocesador LM3s8962 incluye dos 16C550 (UART0 y UART1) totalmente programables, con una velocidad de transferencia de hasta 3,125 Mbps. La UART0 es utilizada internamente para el envo y recepcin de datos en el depurado de las aplicaciones. Este mdulo se ha utilizado para realizar diversas pruebas y visualizar los datos a travs del HyperTerminal de Windows.

Figura 9. Formato de trama del protocolo UART para el envo de datos

14

Caractersticas principales del Mdulo UART: FIFO recepcin de 16x12 bits y FIFO transmisin de 16x8 bits Programmable baud rate generator Generacin automtica de los bits start, stop, y parity Interface serie programable 5, 6, 7, o 8 bits de datos Generacin y deteccin de bits even, odd, stick, o no parity 1 o 2 bits de stop IrDA serial-IR (SIR) encoder/decoder DMA interface

En la Figura 10 se puede ver los diferentes bloques y registros internos que componen el mdulo UART.

Figura 10. Diagrama de bloques del mdulo UART

15

2.2.3.

Synchronous Serial Interface (SSI)

El Microcontrolador LM3s8962 incluye un mdulo SSI que proporciona la funcionalidad para comunicaciones serie sncronas con dispositivos perifricos. Este mdulo realiza la conversin de serieparalelo de los datos recibidos (SSIRx) desde un dispositivo perifrico, y la conversin de paralelo-serie de los datos transmitidos (SSITx) a un dispositivo perifrico. Tambin incluye una lnea de Clock (SSICLK) y una de Chip Select (SSIFSS). Puede operar como Master o Esclavo y programarse la velocidad de transmisin de datos. El tamao de las tramas de datos puede ser entre 4 y 16 bits, y admite diferentes interfaces de programacin como Freescale SPI, MICROWIRE o Texas Instrument. En la Figura 11 se muestra el diagrama interno con los bloques y registros que componen el mdulo SSI.

Figura 11. Diagrama de bloques del mdulo SSI

2.2.4.

General-Purpose Timers (GPTM)

El mdulo General-Purpose Timer contiene cuatro bloques autnomos programables (Timer 0, Timer 1, Timer 2, y Timer 3). Cada uno de ellos puede ser configurado como un temporizador de 32 bits o dos temporizadores independientes de 16 bits cada uno (TimerA y TimerB). Los temporizadores pueden ser configurados independientemente en modo disparo, en modo continuo, como contador de eventos, como un reloj en tiempo real, o para el disparo de conversiones analgicasdigitales. Si es configurado como un temporizador de disparo, al llegar a cero el contador se parar, sin embargo si se configura como un temporizador de continua, el temporizador volver cargar el valor inicial una vez llegue a cero y as sucesivamente. 16

En la Figura 12 se muestra el diagrama de bloques y los registros internos utilizados por el mdulo GPTM.

Figura 12. Diagrama de bloques del mdulo GTPM

2.2.5.

Interrupt Controller (NVIC)

Las interrupciones son utilizadas para minimizar los recursos del sistema, es decir, la aplicacin est a la espera de que se produzca un determinado evento para interrumpir la misma y realizar una serie de funciones especficas. El controlador de interrupciones de la API proporciona un conjunto de funciones para trabajar con el vector de interrupcin Controller (CNTV). Las funciones se proporcionan para habilitar y deshabilitar las interrupciones, para el registro de los controladores de interrupcin y para establecer su prioridad. Esta familia de Stellaris soporta treinta y dos fuentes de interrupcin y tiene ocho niveles de prioridad. El CNTV est estrechamente unido con el microprocesador Cortex-M3. Cuando el procesador responde a una interrupcin, el NVIC suministra directamente la direccin de la interrupcin al procesador, por lo que se elimina la necesidad de un controlador de interrupciones global que consulte al controlador de interrupciones la causa de la misma y el desvi de sta hacia el controlador adecuado, ahorrando as, tiempo de respuesta del sistema. Todas las interrupciones por defecto tienen asignada la prioridad 0, que equivale a la mxima prioridad. Si se asigna el mismo nivel de prioridad a dos o ms interrupciones, su prioridad ser dada de forma hardware, es decir, segn su posicin en el vector de interrupciones. Por ejemplo, si el GPIO del Puerto A y B estn configuradas con el mismo nivel de prioridad 1, entonces el GPIO del Puerto A ser considerado como la de mayor prioridad. En el Stellaris LM3S8962 existen mltiples posibilidades de interrupciones, a travs de los mdulos GPIOs, de los mdulos GPTMs, de los mdulos UART, CAN, SSI, ADC, etc. 17

A continuacin se puede observar en la tabla de la Figura 13 las distintas interrupciones posibles en el Microprocesador LM3s8962 de la placa Stellaris:

Figura 13. Vector de interrupciones CNTV

18

3.

SOFTWARE

En este captulo se explica los diferentes apartados que integran la aplicacin diseada, desde que tipo de software se utiliza para la programacin y visualizacin de la aplicacin, hasta la configuracin e integracin de cada mdulo usado.

3.1. Entorno de programacin

Para el desarrollo de la aplicacin ha sido necesario el uso de los siguientes programas: IAR Embedded Workbench IDE, Luminary Micro Flash Programmer, HyperTerminal y LabVIEW.

3.1.1.

IAR Embedded Workbench IDE

El programa IAR Embedded Workbench ha sido proporcionado por el Kit de evaluacin de Stellaris. Se compone de un conjunto de herramientas de desarrollo para crear y depurar aplicaciones integradas usando ensamblador, C y C++, independientemente del Microcontrolador que se utilice. IAR Embedded Workbench aporta un entorno de desarrollo sencillo, intuitivo e integrado que incluye un administrador de proyectos, un editor, herramientas de construccin y la opcin de depurar la aplicacin mediante simulacin o hardware (Vase Figura 14).

Figura 14. Ventana IAR Embedded Workbench IDE

19

Una vez la aplicacin est finalizada se debe crear un archivo con extensin .bin para cargar el programa en la placa de evaluacin de Stellaris a travs del programa Flash. Para crear el archivo se han de seguir los siguientes pasos: 1. Seleccionar la pestaa de Proyect, y clicar en Options:

Figura 15. Paso 1 para crear el archivo de la aplicacin ".bin"

2. Seleccionar el tipo de conversin de salida y el formato, en este caso binary:

Figura 16. Paso 2 para crear el archivo ".bin"

20

3.1.2.

Luminary Micro Flash Programmer

El Luminary Micro Flash Programmer es una herramienta proporcionada por el Kit Stellaris que permite cargar directamente la aplicacin al Microcontrolador a travs del archivo .bin con el cable USB.

Figura 17. Configuracin para cargar la aplicacin en Flash Programmer

En primer lugar se debe configurar la interface utilizada, en este caso JTAG FTDI Interface y la fuente de reloj (Clock Source) implementada en la aplicacin (Vase Fig.18).

Figura 18. Seleccin del archivo

As pues, se selecciona la ruta donde se encuentra el archivo .bin creado anteriormente con el IAR, y se pulsa el botn Program. En unos instantes la aplicacin es cargada en el Microcontrolador y ya puede ser utilizada. 21

3.1.3.

HyperTerminal de Windows

La aplicacin HyperTerminal de Windows ha sido empleada para realizar diferentes pruebas de visualizacin de datos adquiridos y enviados para la comunicacin serie con el PC, a travs del mdulo UART de la placa de evaluacin de Stellaris. Tambin se ha utilizado para crear y leer los archivos .txt almacenados en la tarjeta de memoria MicroSD. A continuacin se detalla como se debe configurar para su correcto funcionamiento: 1. Ejecutar HyperTerminal y poner nombre a una nueva conexin:

Figura 19. Crear nueva conexin

2. Seleccionar el puerto serie del PC al que est conectado el Microcontrolador Luminary:

Figura 20. Conectar al puerto serie del PC

22

3. Configurar la conexin seleccionando la velocidad de transferencia, el nmero de bits de datos a enviar/recibir, la paridad y el control de flujo como muestra la Figura 21:

Figura 21. Configuracin del puerto

4. Pulsar el icono de conectar para visualizar los datos enviados por el Microcontrolador a travs del puerto serie del PC:

Figura 22. Visualizacin de los datos con HyperTerminal

23

3.1.4.

National Instruments LabVIEW 8.5.1

El programa LabVIEW de National Instruments se utiliza para crear una interface en la que el usuario pueda visualizar de manera sencilla y prctica los datos registrados en la tarjeta de memoria MicroSD mediante grficos y tablas. LabVIEW es una herramienta grfica para pruebas, control y diseo mediante programacin. El lenguaje utilizado se llama lenguaje G. Los programas desarrollados con LabVIEW se les nombra como Instrumentos Virtuales, o VIs, lo que da una idea de su uso en origen: el control de instrumentos. Un programa en LabVIEW se divide en un Panel Frontal y en un Diagrama de Bloques. El Panel Frontal es la interface con la que interacciona el usuario y donde se definen los controles e indicadores que se muestran por pantalla. El Diagrama de Bloques es el programa propiamente dicho, donde se define su funcionalidad, y se colocan los iconos que realizan una determinada funcin interconectados a travs de hilos. En el apartado 3.2.6 se explica detalladamente la aplicacin que permite importar los datos guardados por el Microcontrolador en un archivo de texto .txt y separarlos en arrays para su futura visualizacin mediante grficos e histricos.

Figura 23. Programa LabVIEW de National Instruments

24

3.2. Aplicacin

La aplicacin creada en cdigo C y encargada de recoger los datos de los sensores, procesarlos, guardarlos en un archivo de texto y visualizarlos se puede dividir en seis partes diferenciadas (Vase Fig.24).

Figura 24. Partes que componen la aplicacin de adquisicin y registro de datos

En la primera parte de la aplicacin se inicializan y configuran todos los mdulos necesarios de la placa de evaluacin Luminary Micro LM3s8962 para su futura utilizacin. Tambin es configurado el ADC CS5376A encargado de convertidor los datos analgicos de los sensores a digitales. El sistema queda a la espera de que se produzcan las interrupciones del temporizador para realizar la adquisicin o registro de los datos. La segunda parte es la ms importante y se ejecuta cada vez que se produzca una interrupcin del temporizador. Dentro de esta funcin se ha realiza un arbitraje del bus SPI (Parte 3) para que se configure automticamente segn el modo que este activo, modo Adquisicin y procesado de datos (Parte 4) o modo Registro de datos (Parte 5). Por ltimo, la parte 6 se encarga de que el usuario pueda visualizar los datos adquiridos y registrados en la Micro SD a travs de una interface creada con la versin 8.5 del programa LabVIEW.

25

3.2.1. Parte 1: Inicializacin y Programa Principal

La primera parte de la aplicacin lo compone la inicializacin de los mdulos perifricos de la placa Stellaris y el Programa Principal, vase en el flujograma de la Figura 25 los pasos que se han seguido para su implementacin:

Figura 25. Flujograma del Programa Principal

Una vez realizados los pasos que se explican a continuacin, el programa quedar en un bucle sin fin a la espera de que se produzcan las interrupciones reiteradas del temporizador segn el periodo de muestreo usado para la adquisicin de los datos que provienen de los sensores (Parte 2).

Paso 1: Activar Reloj Sistema En este primer paso se ha configurado y activado el reloj del sistema para que el Microcontrolador de la placa LM3s8962 trabaje a su mxima velocidad. Para ello ha sido necesario recurrir al circuito PLL que posee la placa, para aumentar su velocidad hasta los 50MHz utilizando un cristal de cuarzo interno de 8MHz. La funcin utilizada para ello es la siguiente: SysCtlClockSet (SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);

26

Paso 2: Habilitar Perifricos Los mdulos perifricos del Microprocesador LM3s8962 utilizados para la aplicacin son los siguientes: SSI0: Transmisin y Recepcin de datos con la placa ADC CS5376A y escritura de datos en la MicroSD GPTM1: Temporizador peridico para realizar el muestreo de los sensores mediante interrupciones GPIOA: Pines exteriores utilizados por el Protocolo SSI (SSI0Rx,SSI0FSS,SSI0Tx,SSI0CLK) GPIOC: Pines exteriores para el sincronismo con la placa ADC CS5376A (PC5) y para seal de datos listos DataReady (PC7) GPIOF: Puesta en marcha de la aplicacin con Switch Select (PF1) y sealizacin de Stop mediante LED (PF0) Para habilitar los perifricos se han usado las siguientes funciones, indicando el mdulo al que corresponden: SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

Paso 3: Configurar Pines Para saber que puerto y pines son los necesarios para la comunicacin a travs del mdulo SSI0 entre la placa de evaluacin Luminary Micro y el ADC CS5376A, se ha consultado el manual proporcionado por el fabricante Luminary Micro. Tambin ha sido necesario configurar dos pines auxiliares que permitirn el sincronismo de los datos recibidos con el ADC y la seal de que los datos estn listos para ser adquiridos. As pues, los pines utilizados son los siguientes: Pines del mdulo SSI0 para la comunicacin con el ADC CS5376A: PA2/SSI0CLK: Clock SPI PA3/SSI0FSS: Chip Select SPI PA4/SSI0Rx: Receptor PA5/SSI0Tx: Transmitter

Pines auxiliares para sincronizar los datos recibidos por la placa de evaluacin LM3s8962 y el ADC: Pin de salida PC5: 250 Hz Pin de entrada PC7: Dataready (seal datos listos)

27

En la Figura 26 se muestran los 30 primeros pines exteriores que tiene la placa de evaluacin Luminary Micro LM2s8962, donde se puede observar el puerto al que pertenecen para su configuracin.

Figura 26. Pines exteriores (1-30) placa Stellaris

Para configurar los pines del mdulo SSI se ha utilizado la siguiente funcin, donde se indica el puerto al que pertenecen y el nmero de los pines que se usan: GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3| GPIO_PIN_4 | GPIO_PIN_5 );

Para configurar los pines auxiliares se han utilizado las siguientes funciones, donde se indica si los pines son configurados de entrada o salida, el puerto al que pertenecen y el nmero de los pines usados: GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_5); GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_7);

Paso 4: Configurar ADC CS5376A La placa que se utiliza para convertir los datos digitales en analgicos adquiridos por el sensor, debe ser configurada mediante el envo de una serie de comandos a sus registros internos por el protocolo SPI. En primer lugar se debe configurar el SSI de la placa Stellaris, para ello se utiliza la funcin predefinida SSIConfigSetExpClk ( ), indicando la direccin base del mdulo SSI, la frecuencia con la que trabaja el reloj del sistema, el protocolo de transferencia de datos, el modo de operacin, la velocidad de transferencia y finalmente el nmero de bits transferidos por trama. SSIConfigSetExpClk (SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_1 ,SSI_MODE_MASTER, 500000, 8); 28

Donde: SSI0_BASE: 0x40008000, direccin predefinida del mdulo perifrico. SysCtlClockGet ( ): 50Mhz, uncin que obtiene la frecuencia con la que trabaja el reloj del sistema, configurada al principio de la aplicacin. SSI_FRF_MOTO_MODE_1: Protocolo de transferencia de datos elegido (Vase Figura 27-28). SSI_MODE_MASTER: Modo de operacin como Master. 500000: 500KHz de velocidad de transferencia. 8: 8 bits transferidos por trama.

Figura 27. Modos de funcionamiento del Protocolo SSI

Figura 28. Freescale SPI Frame Format con SPO=0 y SPH=1

Una vez configurado el mdulo SSI de la placa LM3s8962 y los pines correspondientes para su comunicacin con la placa ADC (Paso 3), se han de realizar una serie de envos de datos hacia el ADC para configurar su funcionamiento y prepararlo para la adquisicin de los datos de los sensores. En la Figura 29 se pueden observar con la ayuda de un osciloscopio, el envo de 6 bloques independientes de datos con un retardo entre ellos de 1 milisegundo.

Figura 29. Muestra de los 6 envos necesarios para configurar la placa ADC

29

En la tabla 1 se ha detallado el nombre, la direccin en cdigo hexadecimal, el tipo, el nmero de bits y la descripcin de cada registro:
Nombre WR_ROM_COEFF CONFIG FILTCFG GPCFG0 GPCFG1 FILTER_START Direccin 05 00 20 0E 0F 08 Tipo R/W R/W R/W R/W R/W R/W # Bits 24 24 24 24 24 24 Descripcin Seleccin de los Filtros Digitales Configuracin Hardware Configuracin Filtro Digital GPIO[7:0] Direccin, Pull-UP Habilitado, y Dato GPIO[11:8] Direccin, Pull-UP Habilitado, y Dato Inicializacin del Filtro digital

Tabla 1. Direccin y descripcin de los registros de la placa ADC

En la tabla 2 se indican los pasos que se han seguido para su configuracin desde un Microcontrolador, as como el valor en hexadecimal enviado a travs del protocolo SPI:
Paso 01 02 03 04 05 06 07 08 09 10 11 Dato SPI 02 03 00 00 05 Delay 1ms 02 03 00 00 01 00 00 00 06 04 31 Delay 1ms 02 03 00 00 01 00 00 20 00 04 31 Delay 1 ms 02 03 00 00 01 00 00 0E 0F 00 00 Delay 1 ms 02 03 00 00 01 00 00 0F 00 00 00 Delay 1 ms 02 03 00 00 08 Filter Start Write GPCFG1 Register Write GPCFG0 Register Write FILTCFG Register Write CONFIG Register Descripcin Write ROM coefficients

Tabla 2. Pasos para configurar la placa ADC desde Microcontrolador

En la tabla 3 se muestra la conversin del valor de los datos Hexadecimales a cdigo Binario para su comprobacin a travs de las imgenes obtenidas con el osciloscopio:
Envo 1 2 3 4 5 6 Valor Hexadecimal 02 03 00 00 05 02 03 00 00 01 00 00 00 06 04 31 02 03 00 00 01 00 00 20 00 04 31 02 03 00 00 01 00 00 0E 0F 00 00 02 03 00 00 01 00 00 0F 00 00 00 02 03 00 00 08 Valor Binario 0010 0011 0000 0000 0101 0010 0011 0000 0000 0001 0000 0000 0000 0110 0100 110001 0010 0011 0000 0000 0001 0000 0000 100000 0000 0100 110001 0010 0011 0000 0000 0001 0000 0000 1110 1111 0000 0000 0010 0011 0000 0000 0001 0000 0000 1111 0000 0000 0000 0010 0011 0000 0000 1000

Tabla 3. Conversin cdigo Hexadecimal-Binario

30

Las siguientes imgenes muestran de manera individual los 6 envos realizados. Las lneas de color ocre son los datos enviados a travs del SSI0Tx y las lneas de color rosa son los pulsos del SSI0CLK: 1. Write ROM Coefficients

Figura 30. Envo de datos al registro Write ROM Coefficientes

2. Write CONFIG Register

Figura 31. Envo de datos al registro Write CONFIG

31

3. Write FILTCFG Register

Figura 32. Envo de datos al registro Write FILTCFG

4. Write GPCFG0 Register

Figura 33. Envo de datos al registro GPCFG0

32

5. Write GPCFG1 Register

Figura 34. Envo de datos al registro Write CPCFG1

6. Filter Start

Figura 35. Envo de datos al registro Filter START

33

Paso 5: Configurar Timer Para realizar el muestreo de los datos que provienen del sensor, se ha creado mediante la interrupcin de un temporizador peridico, una seal cuadrada de salida con una frecuencia de 250Hz. Esta seal es conectada a la placa ADC a travs de un pin de salida auxiliar (PC5), y se encarga de marcar el tiempo en la adquisicin de datos. Cuando esta seal se encuentra en estado activo, es decir, a 1 lgico, es cuando se produce la adquisicin de datos de los sensores, y cuando est a 0 lgico cuando los datos son guardados en el archivo .txt de la tarjeta de memoria MicroSD. Generacin de una seal cuadrada de 250Hz mediante interrupciones de un temporizador: La siguiente funcin configura el modo de funcionamiento del temporizador, para ello es necesario indicar la direccin base del temporizador que se utiliza (TIMER0), y su modo de funcionamiento. En este caso es necesario un temporizador de 32 bits peridico para que una vez llegue a cero, vuelva a cargarse el valor inicial de forma automtica. TimerConfigure (TIMER1_BASE, TIMER_CFG_32_BIT_PER);

La funcin TimerLoadSet ( ) activa el TIMER1A con el valor cargado. El clculo del valor cargado en el temporizador es el siguiente [ec.1]: TimerLoadSet (TIMER1_BASE, TIMER_A, 2ms);

Entonces, sabemos que el periodo (T) de la seal ha de ser de 4 milisegundos, 2 milisegundos en 1 lgico y 2 milisegundos en 0 lgico, por lo que el valor cargado en el temporizador ha de ser equivalente a 2ms.

Figura 36. Diagrama de tiempos de la seal cuadrada de 250Hz

Por ltimo, insertamos en el vector de interrupciones el nombre de la interrupcin creada y la habilitamos con la funcin: TimerIntEnable (TIMER1_BASE, TIMER_TIMA_TIMEOUT);

34

3.2.2.

Parte 2: Funcin Interrupcin Timer

En esta segunda parte se explica la funcin que es llamada cada vez que s produce una interrupcin del temporizador, y como se obtiene la seal cuadrada de salida de 250Hz hacia el convertidor ADC. Esta es la funcin bsica de interrupcin del temporizador (Vase Fig.37). Cada vez que el valor del temporizador sea cero, se producir una interrupcin y entrara en dicha funcin. Se ha implementado un pequeo cdigo para que vaya alternando de activo a inactivo el estado de un pin exterior de salida (Pin 5 del Puerto C), generando de este modo la seal cuadrada de 250Hz. Entonces, cuando el PC5 est en 1 entraremos en modo Adquisicin y Procesado de datos (Parte 4), y cuando est a 0 en modo Registro de datos (Parte 5).

Figura 37. Flujograma inicial para generar una onda cuadrada a partir de un pin de salida exterior

Con la ayuda de un osciloscopio se ha confirmado que la onda cuadrada tiene una frecuencia de 250Hz:

Figura 38. Imagen real de la onda cuadrada de 250Hz

35

3.2.3.

Parte 3: Arbitraje del bus de datos SPI

El Microcontrolador LM3s8962 de Stellaris tan slo consta de un bus de datos SPI, y ste es el utilizado internamente para la escritura- lectura hacia el slot de la MicroSD, y para la adquisicin de los datos recibidos por el convertidor ADC a travs del los pines externos de la placa Stellaris. De este modo, la dificultad principal que se presenta es realizar un correcto arbitraje del Bus SPI, para que los datos de cada modo (Adquisicin-Registro) no se vean interferidos y puedan presentar futuros errores en la lectura o registro de los datos del Gefono-Hidrfono. Lneas que componen el Bus de SPI de la placa Luminary Micro LM3s8962:

Figura 39. Esquema de las lneas usadas para la adquisicin y registro de datos a travs de SPI

En la Figura 39 se observa que las tres lneas principales del bus coloreadas de negro (SSI0CLK, SSI0Rx y SSI0Tx), son comunes para los dos perifricos utilizados, el convertidor analgico-digital ADC CS5376A (modo Adquisicin) y el slot de la MicroSD card (modo Registro). La lnea verde (CARDCSn) y la azul (SSI0FSS), trabajan como Chip Select y son las encargadas de habilitar o deshabilitar la comunicacin con la MicroSD card Slot y la placa ADC respectivamente segn convenga, realizando de este modo el arbitraje del bus. As pues, en el momento de la adquisicin de los datos del sensor, la lnea SSI0FSS est activa y la lnea CARDCSn inactiva, y en el momento del registro de los datos viceversa (Vase Figura 40).

36

Figura 40. Estado de las lneas CS en la Adquisicin y Registro de datos

Existe otro inconveniente con el bus SPI, su configuracin debe ser diferente en el momento de adquirir los datos y en el registro de los mismos. Para ello se han elaborado dos funciones que se irn alternando segn este activo el modo adquisicin o el modo registro de datos. La siguiente funcin prepara la configuracin SPI para adquirir los datos de la placa ADC. Configura el bus SPI para que pueda enviar y recibir paquetes de datos de 16 bits, adems de habilitar el pin SSI0FSS y deshabilitar el pin CARDSn. ConfigSSIADC (void)

Con la siguiente funcin se prepara el bus SPI para el registro de los datos procesados. Es configurado para el envo y lectura de datos con tramas de 8 bits, a parte de habilitar el pin CARDSn y deshabilitar el pin SSI0FSS. ConfigSSISD (void)

A continuacin (Vase Fig.41) se muestra el flujograma final de funcin Timer1IntHandler:

Figura 41. Flujograma final de la funcin Timer1IntHandler para la adquisicin y registro de datos

37

3.2.4.

Parte 4: Adquisicin y Procesado de datos

Adquisicin de datos: Los datos que recibe el Microcontrolador de la tarjeta ADC CS5376A siguen el siguiente formato:

Figura 42. Formato de los datos enviados por la placa ADC CS5376A al Microcontrolador Lm3s8962

La tarjeta ADC tiene 4 canales de 32 bits cada uno, para poder recibir los 128 bits por el pin Rx del mdulo SSI0 de la placa Stellaris, es necesario realizar 8 adquisiciones de 16 bits cada una, ya que es el mximo nmero de bits que puede recibir. Para ello se ha optado por hacer una funcin llamada Obtenerdatos ( ), reclamada cada vez que la seal de 250 Hz est en estado activo.

Figura 43. Flujograma diseado para la funcin Obtenerdatos

Una vez el programa entra en la funcin Obtenerdatos ( ) y se envan 128 a 0, el programa est a la espera de que el bit Dataready (TP3) de la placa ADC se encuentre en 0 lgico, momento en el cual indica que los datos se encuentran disponibles para ser adquiridos por la placa de evaluacin LM3s8962 (Vase Figuras 43-44).

Figura 44. Seal de datos listos (TP3)

38

Para poder obtener datos a travs del protocolo SSI (SPI), antes es necesario el envo de una trama de bits con valor cero lgico. Por lo tanto, en nuestro caso se envan 128 bits a 0 en ocho paquetes de 16 bits cada uno. A continuacin se muestra como ejemplo la funcin para un slo envo de 16 bits a 0: SSIDataPut (SSI0_BASE, (unsigned long )0x0000);

Llegados a este punto tan slo se realiza la obtencin de los datos para guardarlos en diferentes variables auxiliares para ser tratadas posteriormente. Con la funcin SSIDataGet ( ) se reciben los 128 bits en paquetes de 16 que se reciben de la placa ADC: SSIDataGet (SSI0_BASE, &canal1a);

Procesado de datos: La parte de procesado de datos es la que permite clasificar, separar y transformar los 128 bits recibidos, una vez se haya terminado la adquisicin de los cuatro canales. Luego, sern enviados para almacenarlos en la memoria no voltil MicroSD. Para ello se ha creado una funcin llamada procesadodatos ( ), la cual se explica a continuacin. Como ya se ha comentado en el apartado anterior, se han de realizar 8 adquisiciones de 16 bits para completar los 128 que componen la trama de los cuatro canales, guardando cada una de ellas en una variable auxiliar de la siguiente manera (Vase tabla 4):
Adquisicin 1 2 3 4 5 6 7 8 Variable auxiliar (16 bits) canal1a canal1b canal2a canal2b canal3a canal3b canal4a canal4b

Tabla 4. Variables auxiliares para el procesado de datos

Ahora se necesita juntar los datos en cuatro nuevas variables auxiliares de 32 bits, una por canal, ya que cada 2 adquisiciones corresponden a un canal de adquisicin. Con la siguiente instruccin se logra juntar el canal1a y el canal1b en una nueva variable auxiliar llamada canal1 de 32 bits como muestra la Figura 45: canal1=(canal1a<<16)|(canal1b);

Figura 45. Fusin de la variable Canal1a y Canal1b en Canal1

39

Como se puede observar en la Figura 46, el valor del dato del canal1 se encuentra en los primeros 23 bits de la variable, los siguientes 8 bits son de Status, los cuales proporcionan informacin sobre si se ha realizado correctamente la adquisicin del canal.

Figura 46. Formato de trama por canal

Para conseguir el valor real del dato y desprendernos de la informacin complementaria se realiza una mscara como se ve en la Figura 47: dato1=canal1&(0x00FFFFFF);

Figura 47. Mscara para obtener los primeros 23 bits del canal

Una vez almacenados los datos de cada canal en una variable independiente, se transforman en cdigo ASCII para que puedan ser guardados en una hoja de texto, y sea un lenguaje legible por el PC. Para ello se ha usado la funcin usprintf ( ) predefinida en las libreras del sistema, que guarda todo el bloque formado por los datos de los cuatro canales en una variable auxiliar llamada totvalor.

40

Teniendo en cuenta que los datos una vez registrados en el archivo de texto, han de ser de nuevo extrados para visualizarlos en grficas independientes, se ha optado por separarlos introduciendo entre ellos el carcter correspondiente al tabulador \t, logrando de este modo tener los datos del mismo canal en una misma columna. Al final de todo el bloque tambin se han introducido dos caracteres para que se produzca un salto de lnea \n y un retorno de carro \r cada vez que se realice una nueva escritura en el archivo de texto. usprintf(totvalor, "%d\t%d\t%d\t%d\r\n",canal1,canal2,canal3,canal4);

3.2.5.

Parte 5: Registro de datos en MicroSD

El registro de datos se produce en una hoja de texto con extensin .txt, as pues, en la tarjeta de memoria MicroSD que se introduce en el Slot de la placa Stellaris se ha creado un archivo en blanco con el nombre RDSA.txt (Registrador de Datos Ssmicos Autnomo) donde se irn guardando progresivamente los valores adquiridos de los cuatro canales del Gefono-Hidrfono (Vase Fig.48).

Figura 48. Archivo donde se guardan los datos del los canales

Para llevar a cabo la escritura y guardar los datos en el archivo de texto se ha implementado una funcin llamada Cmd_write ( ), que debe ser llenada con el nombre del fichero (name) donde se quiere guardar la informacin y el valor de los datos adquiridos (totvalor). Cmd_write (name,totvalor);

La funcin anterior est compuesta por otras funciones predefinidas por el FATS. Se trata del sistema genrico de archivos del estndar FAT, utilizado para pequeos sistemas embebidos.

41

Los pasos seguidos y funciones utilizadas para lograr una correcta escritura en el archivo creado cada vez que es llamada la funcin Cmd_write ( ), son los siguientes: 1. Apertura del archivo f_open (&g_sFileObject, g_cTmpBuf, FA_WRITE); 2. Posicionamiento en el fichero para la futura escritura f_lseek(&g_sFileObject,g_sFileObject.fsize) 3. Escritura de los datos f_write(&g_sFileObject, g_cTmpBuf, sizeof(g_cTmpBuf) - 1, &usBytesRead); 4. Cierre del archivo f_close(&g_sFileObject);

Tiempos de registro: El principal obstculo que se ha encontrado en el momento de realizar la escritura de los datos en el archivo .txt ha sido el tiempo, ya que la adquisicin de datos se produce cada 4 milisegundos como se ha explicado en la parte dos de la aplicacin. Con el siguiente cronograma (Vase Fig.49) se puede observar todas las funciones que se han de ejecutar en dicho intervalo de tiempo:

Figura 49. Funciones que se han de ejecutar en la Adquisicin y Registro de datos

42

En el momento de la adquisicin de datos no existe ningn problema, ya que el tiempo es de 1ms e inferior al requerido para configurar el SPI y obtener los datos que provienen de la placa ADC (Vase Fig.50).

Figura 50. Tiempo empleado por ConfigSSIADC y Obtenerdatos.

Sin embargo, en el instante del registro de datos el tiempo empleado por el Microcontrolador supera ampliamente los 2 milisegundos necesarios para realizar todas las funciones requeridas. Por este motivo se ha realizado un estudio especfico para conocer el tiempo que tarda en realizar las diferentes funciones a la hora del registro de los datos adquiridos en un archivo de texto. En la Figura 51 nos muestra que el tiempo empleado para la apertura del fichero (f_open) es de 86 milisegundos. Por lo que supera ampliamente el intervalo total del registro.

Figura 51. Tiempo empleado por la funcin f_open.

43

En la Figura 52 se distingue que el tiempo de posicionamiento y escritura en el fichero de texto es inferior a 1 milisegundo. Este tiempo es el empleado cuando el buffer interno Buff de 512 bytes esta lleno, sino el tiempo que tarda en buscar la posicin es tan slo de 0,2 milisegundos.

Figura 52. Tiempo empleado por las funcione f_sleek y f_write.

La figura 53 se percibe que el tiempo de cierre del fichero es de 19 milisegundos. Al igual que el tiempo utilizado por la funcin f_open, supera el intervalo de 2 milisegundos requerido.

Figura 53. Tiempo empleado por la funcin f_close.

44

En la siguiente tabla se muestran los tiempos que tardan las funciones de las Fats en ejecutarse empleadas para el registro de los datos en la tarjeta MicroSD: Funcin f_open f_lseek f_write f_close Tiempo empleado 86 ms 0,2 ms 1 ms 19 ms

Tabla 5. Tiempos de ejecucin de las funciones

En la tabla 6 se puede observar el tiempo total en ejecutarse las funciones creadas para cada modo: Modo Adquisicin Registro Funciones Configurar ADC, Adquisicin y Procesado de datos Configurar SD, Registro de datos en MicroSD (f_write)
Tabla 6. Tiempo de cada modo

Tiempo 1ms 1ms

Cabe destacar que todas las mediciones con el osciloscopio se han realizado con la mxima velocidad de transmisin de datos permitida por el bus SSI (SPI) del Microcontrolador de la placa Luminary Micro LM3s8962, la cual es de 12.5MHz. Existen diferentes soluciones al problema, pero casi todas tienen como denominador comn la prdida de datos del sensor, con el inconveniente de desaprovechar la sensibilidad y precisin del muestreo realizado. Una de las propuestas para solucionar el problema era la de ir guardando sucesivamente en memoria SRAM de la placa Luminary Micro los mximos datos posibles adquiridos por el sensor, y una vez se llenara, realizar las funciones de abrir, escribir y cerrar el fichero. De este modo se asegurara que los datos quedasen registrados de forma fiable, ya que al cerrar el fichero los datos no se pierden en su formato original. Pero el inconveniente est en el momento del registro, ya que al quedar inhabilitada la adquisicin de nuevos datos la prdida de stos seria notable. La placa Stellaris de Luminary Micro tiene una memoria flash interna de 64KB de memoria SRAM, y cada bloque con el valor de los datos adquiridos por el sensor es de 80 bytes, por lo tanto, tan slo podramos guardar 800 muestras seguidas en memoria. Tambin se vera incrementado el tiempo de escritura ya que en la Figura 52, slo se muestra el tiempo utilizado para la escritura de 512 bytes, por lo cual se necesitara realizar unas 125 escrituras seguidas perdiendo aproximadamente un 1 milisegundo por cada una de ellas. Despus de realizar diferentes pruebas y observar que el tiempo empleado por las funciones f_sleek y f_write entran en los mrgenes necesarios para el correcto funcionamiento del sistema, se ha decidido que la mejor opcin es realizar un algoritmo que permita al usuario obtener las muestras que desee sin prdida de datos. Entonces, el usuario podr decidir despus de cuantas muestras quiere que se produzca el cierre y la nueva apertura del fichero, teniendo en cuenta que se pierden algunos datos en ese pequeo intervalo de tiempo.

45

En la Figura 54 se muestra la solucin adoptada, realizando la primera apertura del fichero antes de la primera adquisicin de datos, y el cierre del fichero despus de n muestras que se quieran obtener y as sucesivamente.

Figura 54. Solucin adoptada a la problemtica de tiempos

46

3.2.6.

Parte 6: Visualizacin de datos a travs de LabVIEW

Para la visualizacin de los datos registrados en la tarjeta de memoria MicroSD se ha creado un pequeo programa en LabVIEW, donde el usuario tiene la posibilidad de elegir los datos del sensor que quiera visualizar de una forma prctica y sencilla. A continuacin se muestra el diagrama de bloques que se ha seguido para implementar la interface:

Figura 55. Pantallas que componen la Interface de usuario

Men Principal Todo programa necesita una pantalla principal que sea intuitiva para que ayude al usuario a navegar por la aplicacin. A travs de este men el usuario tiene la posibilidad de elegir que datos y como visualizarlos, grficamente o mediante tablas. El programa LabVIEW permite la propia creacin de una barra de men en la pantalla de la aplicacin que se va a implementar, en este caso se han creado cuatro opciones, cada una asignada a un Item (Fig.56).

Figura 56. Editor de Men

47

Esta es la pantalla principal de la aplicacin (Vase Fig.57, Front Panel), donde el usuario debe seleccionar una de las opciones que se encuentran en la barra superior de la misma para llamar a las diferentes sub pantallas.

Figura 57. Pantalla del Men Principal

En la Figura 58, se puede observar el Bloc Diagram del Men Principal. Cuando el usuario pulsa en una de las opciones de la barra superior, se enva el Item asociado a una case structure, ejecutando de este modo el subprograma que le corresponda.

Figura 58. Diagrama de bloques del Men Principal

.
48

Gefono Hidrfono Estas dos sub pantallas (Figuras 59-60) tienen la misma funcin, la de mostrar los datos del archivo de texto mediante grficas. Una vez el usuario seleccione el tipo de sensor y pulse el botn Cargar fichero, aparecer una ventana emergente donde deber elegir el fichero de texto en el que se encuentran los datos que quiera visualizar (Vase Fig.62). Interface grfica para los canales X, Y, Z del Gefono:

Figura 59. Interface Gefono

Interface grfica para el canal del Hidrfono:

Figura 60. Interface Hidrfono

49

Ventana para que el usuario pueda buscar y seleccionar el fichero de texto a visualizar:

Figura 61. Bsqueda del fichero ".txt"

En el diagrama de bloques de la subpantalla Gefono (Fig .62), se observa como el programa est a la espera de que se pulse el boton OK (Cargar Fichero). Una vez pulsado, el fichero de texto es transformado en tres columnas de arrays para que puedan ser visualizadas de forma independiente mediante Waveforms. El diagrama de bloques de la sub pantalla Hidrfono es practicamente igual , con la diferencia de transformar y visualizar la cuarta columna del fichero de texto elegido.

Figura 62. Diagrama de bloques de la sub pantalla Gefono

50

Datos Numricos La sub pantalla Datos Numricos permite al usuario la posibilidad de visualizar los datos de los cuatro canales a travs de tablas numricas de manera individual. Tambin en este caso el usuario debe pulsar en Cargar Fichero y elegir el que quiera visualizar.

Figura 63. Sub pantalla Datos Numricos

Ayuda La opcin de ayuda tan slo indica al usuario a travs de una ventana emergente, que debe elegir una opcin de la barra de herramientas de la pantalla principal. Cuando es pulsada aparece la siguiente ventana (Vase Fig.64):

Figura 64. Ventana de ayuda al usuario

51

4.

HARDWARE

4.1. Comunicacin entre los dispositivos del sistema

En la Figura 65 se muestra el esquema bsico con la comunicacin de los tres dispositivos principales que componen el sistema de adquisicin y registro de datos ssmicos. El convertidor ADC recibe los datos adquiridos por los sensores ssmicos a travs de 4 entradas analgicas, las tres primeras (A1, A2 y A3) corresponden al Gefono y la cuarta (A4) al Hidrfono. Para la comunicacin con la placa Luminary Micro LM3s8962, la placa ADC CS5376A utiliza 6 pines digitales, dos de ellos de salida, y otros cuatro de entrada. El primer pin de salida digital es el DataReady (TP3), que proporciona al Microcontrolador la informacin de que los datos ya han sido convertidos y estn listos para ser recogidos por ste. El segundo pin de salida digital es el MISO, encargado del envo de los datos por el protocolo SPI. Como pines de entrada digitales tiene tres que son utilizados para su propia configuracin a travs del bus SPI, se tratan del Chip select (CS), el Clock (CLK) y la recepcin de datos (MOSI). Por ltimo est el pin al que se conecta la seal cuadrada de 250Hz (SYNC) para el sincronismo entre la adquisicin y envo de los datos, generada por el Microcontrolador LM3s8962 a travs del pin 5 del puerto GPIOC.

Figura 65. Esquema de las seales entre los tres dispositivos

52

4.2. Seleccin y especificaciones tcnicas del sensor

Los sensores utilizados para medir las anomalas ssmicas mediante la refraccin y reflexin de ondas en ambientes acuticos son el Gefono y el Hidrfono. 4.2.1. Gefono

Los Gefonos son transductores de desplazamiento, velocidad o aceleracin que convierten el movimiento del suelo en una seal elctrica que puede ser medida con precisin [8]. En este proyecto se ha utilizado para medir las ondas ssmicas de refraccin que se produzcan al chocar contra el suelo marino y para medir los posibles movimientos terrestres. El Gefono utilizado para la aplicacin (Vase Figura 66) ha sido construido especialmente por el CTVG para su proyecto OBS. Consta de tres acelermetros magnticos tipo SM-6 cuya sensibilidad es de y trabajan en un margen de frecuencia entre 4.5 y 100Hz. Los acelermetros estn ubicados de tal forma que proporcionan informacin sobre los tres ejes del espacio; uno vertical (eje Z), y dos horizontales (ejes X, Y).

Figura 66. Gefono basado en 3 acelermetros SM-6

En el siguiente grfico se puede observar la sensibilidad frente a la frecuencia de los acelermetros usados extrada mediante una mesa de vibracin por los tcnicos del CTVG.

Figura 67. Respuesta en Frecuencia del acelermetro SM6

53

4.2.2.

Hidrfono

Los Hidrfonos son transductores que transforma el sonido que captan a una magnitud elctrica. Su principio de funcionamiento es el mismo al de un micrfono en el aire [8]. En este proyecto es utilizado para medir las ondas de reflexin que puedan producirse en el fondo marino. El Hidrfono HTI-90-U SERIES (Vase Figura 68), es de la casa Higt Tech Inc, especialmente construido para aplicaciones ssmicas y acsticas. Posee una sensibilidad mxima de 1778 V/Bar y mnima de 0.1 V/Bar, y su respuesta en frecuencia est entre los 2 Hz y los 20 kHz.

Figura 68. Hidrfono HTI-90-U

54

4.3. Convertidor Analgico-Digital ADC CS5376A

La placa ADC CS5376A es una tarjeta de adquisicin y filtrado de datos de bajo consumo para la conversin analgica-digital de cuatro canales de entrada analgicos para aplicaciones geofsicas y de sonar. Esta tarjeta fue diseada en un proyecto anterior por los tcnicos de SARTI [9].

Figura 69. Diagrama con los bloques que componen la placa ADC CS5376A

Las caractersticas principales del CS5376A son las siguientes: 1 - 4 Canales Filtros Digitales Mltiple configuracin de los filtros FIR y IIR Programacin de los filtros para aplicaciones personalizadas Sincronismo de operaciones

Seleccionable Output Word Rate 4000, 2000, 1000, 500, 333, 250, 200, 125, 100, 50, 40, 25, 20, 10, 5, 1 SPS

Correccin de ganancia y offset Bajo consumo 9 mW por canal a 500 SPS

Voltajes I/O interface: 3.3V o 5.0V Digital logic cuore: 3.0 V, 3.3V o 5.0V

55

4.4. Tarjeta de memoria MicroSD

La tarjeta de memoria MicroSD empleada para el registro de los datos ssmicos es fabricada por la empresa Kinsgston Technology. Se trata de una tarjeta con una capacidad de 2 GigaBytes de memoria Flash utilizada para guardar informacin en mltiples aplicaciones por sistemas de pequeas dimensiones. Incluye un adaptador de MicroSDHC a SD para poder ser conectada directamente en la ranura de un PC.

Figura 70. Tarjeta de memoria MicroSD

El siguiente clculo se ha realizado para comprobar el tiempo que puede ser utilizada la tarjeta MicroSD elegida por el sistema creado sin tener que ser extrada. Cabe destacar que estos clculos estn sujetos a posibles variaciones ya que han sido extrados en base a los resultados experimentales realizados en el laboratorio mediante una seal de entrada que simula los datos recogidos por los sensores. Durante el transcurso de 1 hora se han recogido 900.000 muestras por cada canal, siendo de 28Mbytes el tamao del fichero de texto registrado. Entonces, sabiendo que la capacidad de la tarjeta seleccionada es de 2Gbytes, realizando un simple clculo [ec.2] se puede llegar a conocer el tiempo mximo de adquisicin.

De la [ec.2] se obtiene:

Con una tarjeta MicroSD de 2Gbytes el mximo tiempo que puede ser utilizada por el sistema sin extraer los datos es de 2 das y 23 horas, por lo que ser necesaria la utilizacin de una tarjeta con mayor capacidad para llegar a los 2 meses propuestos. Segn los expertos programadores de Luminary Micro las libreras utilizadas para las funciones de registro de datos en tarjetas de memoria MicroSD, slo admiten tarjetas de memoria de hasta 4Gbytes de capacidad.

56

4.5. Eleccin de la batera

Para alimentar todo el sistema se propone el uso de bateras de Litio EEMB 3.7V, Rechargeable Lithium Polymer Battery Pack (3P1S) (Vase Fig.71). Se trata de una variacin de las bateras de iones de litio (Li-ion). Sus caractersticas son muy similares, pero permiten una mayor densidad de energa, as como una tasa de descarga bastante superior. Tienen un tamao reducido para equipos pequeos que requieran potencia y duracin [10].

Figura 71. Rechargeable Lithium Polymer Battery Pack (3P1S)

Las caractersticas principales de la batera escogida son las siguientes [11]:

Voltaje nominal: 3.7V Capacidad: 11,400mAh Ciclos de vida: 500 cargas Intervalo de temperaturas: -20 a 60 C

Sabiendo que el consumo de la placa de evaluacin Luminary Micro LM3s8962 y la tarjeta de adquisicin ADC CS5376A es de 210mAh (Apartado 5.3), y que el tiempo mximo de adquisicin y registro para una tarjeta de memoria MicroSD de 2Gb es de 71,42 horas (Apartado 4.4), se calcula de manera ideal la capacidad mnima que debe de tener la batera [ec.3].

Como la capacidad de la batera seleccionada es de 11,400mAh por unidad, es necesaria la conexin en paralelo de dos Rechargeable Lithium Polymer Battery Pack (3P1S).

57

5.

RESULTADOS EXPERIMENTALES

Las pruebas efectuadas para obtener los resultados experimentales del sistema de adquisicin y registro de datos smicos, se han realizado mediante la simulacin de los sensores con una seal de entrada sinusoidal creada con el generador de funciones Hewlett Packard mod.33120A (Fig.72). La seal es idntica para los cuatro canales de entrada (3 del Gefono y 1 del Hidrfono).

Figura 72. Onda sinusoidal del generador de funciones HP 33120A

Los otros instrumentos utilizados para realizar los resultados experimentales se citan a continuacin y se pueden observar en la Figura 73: Promax Power Supply mod.FAC-662B para suplir a la placa de evaluacin Luminary Micro LM3s8963 Promax Triple DC Power Supply mod.FA665 para suplir al convertidor ADC CS5376A Stanford Research Systems mod.CG635 para generar una seal de 32.768 MHz como reloj maestro del convertidor ADC CS5376A

Figura 73. Alimentaciones del ADC CS5376A y LM3s8962

58

5.1. Prueba 1

En esta primera prueba, el tiempo de adquisicin ha sido de 8 segundos y se han obtenido 2000 muestras por canal. Se ha realizado con el algoritmo que implementa una sola apertura y cierre del fichero, por lo que la seal adquirida es idntica a la generada.

Figura 74. Imagen de la onda sinusoidal registrada

5.2. Prueba 2
En la segunda prueba, el tiempo de adquisicin ha sido de 32 segundos y se han obtenido 8000 adquisiciones por canal. En este caso la aplicacin realiza cada 1000 muestras el cierre y apertura del fichero. En la Figura 60 se observa la prdida de algunos datos durante el tiempo necesario para que se ejecuten las funciones f_close y f_open.

Figura 75. Imagen de onda sinusoidal realizando la apertura y cierre del fichero cada 1000 muestras

59

5.3. Prueba 3

La prueba nmero tres se ha realizado para conocer el consumo del sistema. Para ella se ha programado la aplicacin para que configure todo el sistema y espere a ser pulsado el Switch Select de la placa Luminary Micro para empezar con la adquisicin y registro de datos. Se ha alimentado la placa Luminary Micro con una fuente de 5V DC, el convertidor ADC con dos fuentes de 3.3V y 2.5V DC, y se ha calculado la potencia que consumen a partir de la intensidad. Placa de evaluacin LM3s8962 Intensidad Consumo 129mA a 5V 645mW 150mA a 5V 750mW ADC CS5376A Intensidad Consumo 0 0 40mA a 2.5V 100mW 20mA a 3.3V 66mW

Estado En espera ON

Tabla 6. Consumo del sistema

El consumo total del sistema con la placa de evaluacin LM3s8962 y la tarjeta ADC para la adquisicin y registro de datos es de 916mw. Cabe destacar que este consumo es el de toda la placa de evaluacin por lo que existen mdulos de la misma que estn gastando energa sin ser utilizados. La siguiente tabla 7 muestra el consumo de los dos nicos elementos que se necesitaran para la aplicacin: Microprocesador LM3s8962 Tarjeta MicroSD Estado Intensidad Consumo Intensidad Consumo 52mA a 2.5V 130mW 0,3mA a 3V 1mW En espera ON 108mA a 2.5V 270mW 6,7mA a 3V 20mW

Tabla 7. Consumo Micro LM3s8962 y Slot MicroSD

5.4. Prueba 4

En la cuarta prueba realizada, se ha dejado que el sistema diseado estuviera adquiriendo y registrando datos durante 1 hora para verificar su funcionamiento en largos periodos de tiempo. Se ha efectuado con el algoritmo que implementa una sola apertura y cierre del fichero de texto, y se han obtenido 900.000 muestras por canal. En la Figura se puede ver un pequeo intervalo de los datos registrados.

Figura 76. Imagen de la Interface del Hidrfono mostrando la Prueba 4

60

6.

PRESUPUESTO

El presupuesto se ha divido en dos partes: el material utilizado y la mano de obra empleada: Material Elemento LUMINARY MICRO EKC-LM3S8962 Convertidor ADC CS 5376A KINGSTO Micro SD Cable cinta Conector DB15 Conector plano 20 pines Cable elctrico Batera Unid. 1 1 1 1 1 2 1 2 16 GB TF High capacity CL2 + ADP Flat Poli 26 hilos Conector hembra 15 pines Conector macho 20 pines Cable conexin BLS/10 Rechargeable Lithium Polymer Battery Pack (3P1S) descripcin LM3S8962 Ethernet+CAN Eval Kit w/ CodeSourcery G++ GNU Precio/Unid. 231,70 No dado 44,70 1,63 1,2 0,9 2,4 80,50 Subtotal 1: Total () 231,70 No dado 44,70 1,63 1,2 1,8 2,4 161 444,43

Mano de obra Tipo Familiarizacin LM3s8962 Programacin Pruebas Memoria Tcnica Nmero de horas 100 300 50 70 Precio/Hora () 15 30 30 30 Subtotal 2: Total () 1.500 9.000 1.500 2.100 14.100

Material Mano de obra

Subtotal 1 Subtotal 2 TOTAL:

444,43 14.100 14.544,43

El presupuesto total del proyecto de un sistema Registrador de Datos Ssmicos Autnomo de Bajo Consumo asciende a un total de 14.544,43 Euros.

61

7.

CONCLUSIONES Y PERSPECTIVAS

Una vez completados y analizados los resultados experimentales del sistema de adquisicin y registro de datos autnomo utilizado para ssmica activa y pasiva en el fondo marino, se puede afirmar que se han alcanzado los objetivos principales propuestos por el tutor del proyecto. As pues, se ha logrado implementar un sistema que tenga un consumo reducido para ser alimentado a travs de bateras durante un largo periodo de tiempo. Con la utilizacin de la placa de evaluacin Luminary Micro LM3s8962 y el convertidor ADC CS5376A el consumo total del sistema es de 916mW, pero si se construye una placa con tan slo los elementos necesarios, el consumo puede ser reducido hasta los 350mW. Adems, se ha conseguido que los datos analgicos obtenidos por el Gefono y el Hidrfono sean convertidos a digitales por medio de la tarjeta de adquisicin y filtrado de datos ADC CS5376A y enviados a la placa de evaluacin LM3s8963 a travs del Bus SPI. Luego, los datos han sido registrados en un archivo de texto y almacenados en una tarjeta de memoria no voltil del tipo Micro SD con una capacidad de 2Gb. Con esta tarjeta de memoria el sistema es capaz de trabajar durante 2 das y 23 horas sin que la tarjeta haya de ser extrada. Para la visualizacin de los datos se ha creado una interface donde el usuario tiene la posibilidad de elegir a travs de un men, el fichero donde se encuentran los datos, el tipo de sensor y la forma de verlos. El inconveniente principal de este sistema ha sido la doble utilizacin del Bus SPI para ejecutar las dos funciones esenciales del sistema, por una parte la adquisicin y por otro el registro de los datos. Este problema se ha solventado realizando un correcto arbitraje del Bus SPI entre los dos modos, cambiando su configuracin y habilitando o deshabilitando los pines de seleccin en cada caso. El problema de utilizar el mismo Bus SPI para la adquisicin y registro de datos, ha derivado en no poder realizar las acciones sucesivas de apertura, escritura y cierre del fichero donde se almacenan los datos por cada adquisicin, por lo que se ha optado para evitar la prdida de los mismos, en una nica apertura y cierre del fichero despus de n muestras elegidas por el usuario. Como perspectivas de futuro est la implementacin de todo el sistema en una misma placa con slo los elementos necesarios (Microcontrolador, Slot Card MicroSD y ADC CS5376A), y utilizar un Microcontrolador que posea dos Buses SPI, para realizar en dos procesos independientes la adquisicin y registro de los datos en la tarjeta de memoria MicroSD. En el caso de tener conexin directa mediante cables submarinos a un laboratorio de observacin marina, existe la posibilidad de utilizar diferentes mdulos de los que consta la placa de evaluacin LM3s8962. Por ejemplo el uso de mdulo Ethernet para conectar la placa de evaluacin Luminary Micro a una red local, o el uso del mdulo UART para el envo a travs del puerto serie de los datos de forma directa, sin tener que desplazarse a extraer la tarjeta de memoria MicroSD. Este proyecto final de carrera me ha dado la oportunidad de aprender como se programa un Microcontrolador y sus mdulos perifricos, la utilizacin del protocolo SPI para la comunicacin con distintos dispositivos, as como ir buscando soluciones a los inconvenientes surgidos en el desarrollo de la aplicacin.

62

8.

BIBLIOGRAFA

[1] Laboratorio Observacin martima [En lnea]. [Consulta: 15 septiembre 2009]. Disponible en: <http://sites.upc.edu/~www-sarti/OBSEA/info/intro/intro_cat.php> [2] Artculo tcnico OBS [En lnea]. [Consulta: 2 Noviembre 2009]. Disponible <http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?tp=&arnumber=1604353&isnumber=33711> [3] Ministerio de fomento Espaol [En lnea]. <http://www.ign.es/ign/es/IGN/SisIndice.jsp> en:

[Consulta: 12 Diciembre 2009]. Disponible en:

[4] Protocolo SPI [En lnea]. [Consulta 25 Noviembre 2009]. Disponible en: <http://www.i-micro.com/pdf/articulos/spi.pdf> [5] Organismo Supervisor de la Investigacin de la Minera y Energa [En lnea]. [Consulta: 20 Noviembre 2009]. Disponible en: <http://www.osinerg.gob.pe/newweb/pages/GFH/1652.htm> [6] Microcontroladores ARM [En lnea]. [Consulta 7 Diciembre 2009]. Disponible en: <http://www.capel-electronica.com/pdf/2008-10-30Microcontroladores_ARM.pdf> [7] Placa de evaluacin Luminary Micro LM3s8962 [En lnea]. [Consulta: 25 septiembre 2009]. Disponible en: <http://www.luminarymicro.com/products/lm3s8962_can_ethernet_evaluation_kit.html> <http://www.luminarymicro.com/home/app_notes.html> <http://www.luminarymicro.com/products/LM3S8962.html#Datasheet> <http://www.luminarymicro.com/forums> [8] Wikipedia. Gefono, Hidrfono, Geofsica [En lnea]. Disponible en: <http://es.wikipedia.org/wiki/Geofono> <http://es.wikipedia.org/wiki/Hidr%C3%B3fono> [Consulta: 29 Octubre 2009].

[9] Tarjeta de adquisicin y filtrado de datos [Consulta: 16 Noviembre 2009]. Disponible en: <http://part.aboutsemi.com/pdfview/CIRRUS-LOGIC/CS5376A-IQ> [10] Wikipedia Bateria Polimero de Litio [En lnea]. [Consulta: 20 Enero 2010]. Disponible en: <http://es.wikipedia.org/wiki/Bater%C3%ADa_(electricidad)#Bater.C3.ADas_de_pol.C3.ADmero_de_lit io_.28Li-poli.29> [11] Pack bacteria [En lnea]. [Consulta: 9 Enero 2010]. http://eemb.manufacturer.globalsources.com/si/6008801123301/pdtl/Lithiumpolymer/1022823722/Rechargeable-Lithium-Polymer-Battery-Pack.htm> Disponible en:

63

ANEXOS

64

Anexo I. Familiarizacin con el entorno de desarrollo Luminary Micro

65

APLICACIN 1: Encender y apagar LED STATUS mediante pulsadores En esta primera aplicacin se logra encender el LED STATUS pulsando cualquier pulsador de navegacin (UP/DOWN/LEFT/RIGHT) o el Switch Select. En primer lugar se debe saber a que puertos estn asociados los pulsadores de navegacin y Select, as como el LED STATUS. Para ello se ha consultado el manual proporcionado por el fabricante (Vase Fig.1).

Figura 4.Descripcin de los pines

Observamos que los switches de navegacin estn asociados al Puerto E y el LED STATUS y el switch Select al puerto F, con sus respectivos pines para poderlos activar y desactivar. Cabe destacar que los pulsadores o switches utilizan una lgica inversa, es decir, que sus respectivos pines estn siempre a 1 lgico cuando no estn pulsados y a 0 viceversa. El Kit de evaluacin nos ofrece la posibilidad de utilizar unas libreras que contienen unas funciones API predefinidas que se pueden usar de forma rpida y sencilla. Para esta aplicacin debemos incluir las siguientes driverlib/gpio.c, con driverlib/gpio.h y driverlib/sysctl.c, con driverlib/sysctl.h.

Funciones predefinidas utilizadas en la aplicacin 1: Para configurar los puertos y leer o escribir un valor: GPIODirModeSet (unsigned long ulPort, unsigned char ucPins, unsigned long ulPinIO) GPIOPadConfigSet (unsigned long ulPort, unsigned char ucPins, unsigned long ulStrength, unsigned long ulPinType) GPIOPinRead (unsigned long ulPort, unsigned char ucPins) GPIOPinWrite (unsigned long ulPort, unsigned char ucPins, unsigned char ucVal)

Para habilitar los puertos: SysCtlPeripheralEnable (unsigned long ulPeripheral)

66

Una vez tenemos claro los puertos que se deben utilizar y su configuracin, se ha diseado un pequeo flujograma que facilita la implementacin posterior en cdigo C:

Habilitamos los perifricos Puertos E y F

Configuramos los perifricos

Mientras=1

S Leemos valor de los switches

No Pulsador=0 Apagamos el Led

S Encendemos el Led

67

1 //////////////////////////////////////////////////////////////////////////////// 2 ///// programa encender led STATUS con los pulsadores SELECT o UP o DOWN o ///// 3 ///// RIGHT o LEFT ///// 4 //////////////////////////////////////////////////////////////////////////////// 5 6 // librerias necesarias 7 #include "inc/hw_gpio.h" 8 #include "inc/hw_memmap.h" 9 #include "inc/hw_types.h" 10 #include "driverlib/debug.h" 11 #include "driverlib/gpio.h" 12 #include "driverlib/sysctl.h" 13 14 // programa principal 15 main(void) 16 { 17 SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | 18 SYSCTL_XTAL_8MHZ); 19 20 // variables globales 21 char a=0,b=0,c=0,d=0; 22 23 // habilitacin de perifericos PUERTOS F y E 24 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 25 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); 26 27 // Configuramos los pines utilizados y su modo de funcionamiento 28 //(entrada o salida) 29 GPIODirModeSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1| GPIO_PIN_2 30 | GPIO_PIN_3, GPIO_DIR_MODE_IN); 31 GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT); 32 GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_DIR_MODE_IN); 33 34 35 // Configuramos el tipo de pulsador y la intensidad 36 GPIOPadConfigSet(GPIO_PORTE_BASE,GPIO_PIN_0| GPIO_PIN_1| GPIO_PIN_2 37 | GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); 38 GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0, GPIO_STRENGTH_8MA_SC, 39 GPIO_PIN_TYPE_STD); 40 GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); 41 42 43 while(1){ 44 // guardamos en variables auxiliares el valor leido por los switches 45 a=GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_0| GPIO_PIN_1 46 | GPIO_PIN_2| GPIO_PIN_3); 47 c=GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1); 48 // Multiplicamos con una mscara para quedarnos con los bits que nos 49 // interesan 50 b=a&0x0F; 51 d=c&0x02; 52 // si no pulsamos 53 if((b==0x0F)&&(d==0x02)){ 54 // Ponemos el led a "0" 55 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,0); 56 }else // si pulsamos 57 // Ponemos el led a "1" 58 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,1); 59 } 60 }

APLICACIN 2: Encender y apagar LED STATUS mediante TIMER1 Esta aplicacin se ha diseado para conocer el funcionamiento de los mdulos TIMERS, para ello se ha configurado el timer1 como un temporizador de 32 bits con modo de disparo peridico. Entonces, se encender el LED Status el tiempo cargado en el temporizador, y una vez transcurrido se apagar para volver a encenderse otra vez el tiempo establecido y as sucesivamente. A continuacin se detalla el flujograma propuesto para implementar esta aplicacin 2:

Habilitamos los perifricos Timer1 y Puerto F Configuramos PF y Timer1 Cargamos valor en T1 y lo activamos

Mientras=1 S Obtenemos valor Timer 1

No Timer1!=0 S Encendemos el Led Apagamos el Led

69

1 ////////////////////////////////////////////////////////////////////////////// 2 // programa timers encender led transcurrido el tiempo del timer1 /////////// 3 ///////////////////////////////////////////////////////////////////////////// 4 5 // librerias necesarias 6 #include "inc/hw_ints.h" 7 #include "inc/hw_memmap.h" 8 #include "inc/hw_types.h" 9 #include "driverlib/debug.h" 10 #include "driverlib/gpio.h" 11 #include "driverlib/sysctl.h" 12 #include "driverlib/timer.h" 13 14 // variable auxiliar 15 unsigned long tiempo=0x00000000; 16 17 // programa principal 18 main(void) 19 { 20 // activamos el clock del sistema 21 SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | 22 SYSCTL_XTAL_8MHZ); 23 24 // habilitamos timer1 y el Puerto F(LED Status) 25 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); 26 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 27 28 // configuramos el LED Status como salida 29 GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT); 30 GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0, GPIO_STRENGTH_8MA_SC, 31 GPIO_PIN_TYPE_STD); 32 33 // configuramos el Timer1 como un temp de 32 bits peridico 34 TimerConfigure(TIMER1_BASE, TIMER_CFG_32_BIT_PER); 35 36 // cargamos valor en el timer1 37 TimerLoadSet(TIMER1_BASE, TIMER_BOTH, 0x7A1200); 38 39 // habilitamos el timer1 40 TimerEnable(TIMER1_BASE, TIMER_BOTH); 41 42 while(1){ 43 // guardamos en variable auxiliar el tiempo del timer 44 tiempo=TimerValueGet(TIMER1_BASE,TIMER_BOTH); 45 // si el tiempo es diferente a 0 encendemos LED, sino apagamos LED 46 if( tiempo != 0) 47 { 48 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,1); 49 }else 50 { 51 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,0); 52 } 53 } 54 }

APLICACIN 3: Muestreo del switch UP para encender led STATUS En esta aplicacin 3 el programa principal espera que el timer0 sucesivamente llegue al final del tiempo cargado para interrumpir el programa y leer si se ha pulsado el switch de navegacin UP. En caso afirmativo se encender el Led Status, de lo contrario permanecer apagado. A continuacin se detalla el flujograma propuesto para implementar esta aplicacin 3: Programa principal: Habilitamos los perifricos Timer0, Puertos F y E Configuramos PF PE y Timer0

Cargamos valor en T1, habilitamos interrupciones y lo activamos

S Mientras=1

Subprograma Timer0: No Timer0=0

S Se ha producido una Interrupcin en el timer0

No Switch UP=1 S Encendemos el Led Apagamos el Led

71

1 /////////////////////////////////////////////////////////////////////////////// 2 //Gracias al timer logramos que se produzcan interrupciones succesivamente //// 3 //todo el tiempo est leyendo el estado del pulsador UP para encender el LED/// 4 //si es pulsado //// 5 /////////////////////////////////////////////////////////////////////////////// 6 7 // librerias necesarias 8 #include "inc/hw_ints.h" 9 #include "inc/hw_memmap.h" 10 #include "inc/hw_types.h" 11 #include "driverlib/debug.h" 12 #include "driverlib/gpio.h" 13 #include "driverlib/interrupt.h" 14 #include "driverlib/sysctl.h" 15 #include "driverlib/timer.h" 16 17 // variable auxiliar para leer Pulsador UP 18 long c=0; 19 20 // Subprograma Timer0 al producirse una interrupcion 21 void 22 Timer0IntHandler(void) 23 { 24 // Limpiamos interrupcion Timer0 25 TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT); 26 27 // Deshabilitamos la interrupcin principal 28 IntMasterDisable(); 29 30 // Lectura el valor del pulsador UP 31 c=GPIOPinRead(GPIO_PORTE_BASE,GPIO_PIN_O); 32 33 // Si no pulsamos el Led est OFF, si pulsamos esta a ON 34 if(c==0x01) 35 { 36 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,0x00); 37 }else GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,0x01); 38 39 40 // habitamos la interrupcion principal 41 IntMasterEnable(); 42 } 43 44 // Programa principal 45 main(void){ 46 47 //activamos el reloj del sistema 48 SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | 49 SYSCTL_XTAL_8MHZ); 50 51 // habilitamos los perifericos TIMER0, PUERTO C 52 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); 53 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 54 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); 55 56 // Habilitamos la interrupcion principal 57 IntMasterEnable(); 58 59 // Configuramos el PIN0 DEL PUERTO E como entrada y el PIN0 del Puerto F 60 // como salida 61 GPIODirModeSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_DIR_MODE_IN); 62 GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT);

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 }

// Configuramos el tipo de entrada y salida GPIOPadConfigSet(GPIO_PORTE_BASE,GPIO_PIN_0, GPIO_STRENGTH_2MA_SC, GPIO_PIN_TYPE_STD_WPU); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD); // Configuramos el timer O como uno de 32 bits periodico TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); // Cargamos en el timer O el tiempo del sistema entre 10 TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet()/10); // Activamos la interrupcion para el timer timeouts IntEnable(INT_TIMER0A); // habilitamos la interrupcion del timer O como timeouts TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); // activamos el timerO TimerEnable(TIMER0_BASE, TIMER_A); // bucle sin fin while(1) { }

APLICACIN 4: Lectura del voltaje de un potencimetro Para poder realizar esta aplicacin ha sido necesario conectar un potencimetro en la entrada del AD0, en la Figura 2 se puede observar como se ha realizado la conexin.

Figura 5. Conexin potencimetro - Pines I/O Stellaris

Una vez se ha conectado una entrada analgica en el ADC0, se ha efectuado una pequea aplicacin para leer el valor del potencimetro y visualizarlo en el OLED de la placa Luminary Micro de Stellaris. Se ha optado como fuente de interrupcin para leer los datos peridicamente cada segundo, el timer0, utilizando parte del cdigo de la aplicacin 3.

74

A continuacin se detalla el flujograma propuesto para implementar la aplicacin 3: Programa principal: Habilitamos los perifricos Timer0, ADC0 Configuramos ADC0 y Timer0

Cargamos valor en T1, habilitamos interrupciones y lo activamos

Mientras=1

Subprograma Timer0: No Timer0=0

S Se ha producido una Interrupcin en el timer0

Leemos valor Del ADC0

Mostramos valor en OLED

75

1 //////////////////////////////////////////////////////////////////////////////// 2 ////// Adquisicin de datos a traves de un potencimetro conectado////////////// 3 /////////////////en el ADC0 de la placa LM3S8962//////////////////////////////// 4 //////////////////////////////////////////////////////////////////////////////// 5 6 // librerias necesarias para la aplicacin 7 8 #include "inc/hw_ints.h" 9 #include "inc/hw_memmap.h" 10 #include "inc/hw_types.h" 11 #include "driverlib/debug.h" 12 #include "driverlib/gpio.h" 13 #include "driverlib/adc.h" 14 #include "driverlib/interrupt.h" 15 #include "driverlib/sysctl.h" 16 #include "utils/ustdlib.h" 17 #include "drivers/rit128x96x4.h" 18 #include "driverlib/timer.h" 19 20 21 // variables declaradas como globales para recibir y para escribir en OLED 22 unsigned long poten[1]; 23 static char valor[1]; 24 25 // Subprograma TIMER0 (el timer interrumpe cada x tiempo y va leyendo el ADC0) 26 // declarada tambien en starup_ewarm 27 void 28 Timer0IntHandler(void) 29 { 30 // Limpiamos interrupcion Timer0 31 TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT); 32 33 // Deshabilitamos la interrupcin principal 34 IntMasterDisable(); 35 36 // Obtenemos el valor de la secuencia 1 y lo guardamos en variable poten 37 ADCSequenceDataGet(ADC_BASE, 1, poten); 38 39 // convertimos la variable poten para cargar en OLED usprintf(valor, "Voltaje: %d ", poten[0]); 40 41 42 // cargamos valor en OLED 43 RIT128x96x4StringDraw(valor, 30, 55, 15); 44 45 // habitamos la interrupcion principal 46 IntMasterEnable(); 47 } 48 49 // Programa principal 50 51 int 52 main (void) 53 { 54 55 //habilitamos clock 56 SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC 57 | SYSCTL_OSC_MAIN |SYSCTL_XTAL_8MHZ); 58 59 //habilitamos perifrico ADC y el TIMER0 60 SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC); 61 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); 62

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 }

// configuramos la velocidad de 125 muestras por segundo SysCtlADCSpeedSet(SYSCTL_ADCSPEED_125KSPS); //Deshabilitamos todas las secuencias por si acaso ADCSequenceDisable (ADC_BASE,0); ADCSequenceDisable (ADC_BASE,1); ADCSequenceDisable (ADC_BASE,2); ADCSequenceDisable (ADC_BASE,3); // inicializamos OLED RIT128x96x4Init(1000000); //Configuramos la secuencia 1, activado por timer0, max prioridad ADCSequenceConfigure(ADC_BASE, 1, ADC_TRIGGER_TIMER,0); // Configuramos la secuencia 1, paso 0, canal 0 ADCSequenceStepConfigure(ADC_BASE, 1, 0, ADC_CTL_CH0); // habilitamos la secuencia 1 ADCSequenceEnable(ADC_BASE, 1); // Configuramos el timer O como uno de 32 bits periodico TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); // Cargamos en el timer O-A el valor obtenido por el reloj del sistema TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet() ); // Activamos la interrupcion para el timer timeouts IntEnable(INT_TIMER0A); // habilitamos la interrupcion del timer O como timeouts TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); // activamos el timerO TimerEnable(TIMER0_BASE, TIMER_A); // activamos el disparo siempre TimerControlTrigger(TIMER0_BASE,TIMER_A,true); // bucle sin fin while(1){ }

APLICACIN 5: Enviar datos por UART1 y visualizarlos En esta aplicacin se programa el mdulo UART1 para el envo de datos a travs del puerto serie (RS232) y visualizarlos por el Hiperterminal de Windows. Para ello ha sido necesaria la confeccin de una pequea placa para convertir el voltaje transmitido por el Microprocesador (TTL, 0-5V) a un voltaje que entienda el ordenador (RS-232, -10/+10V). Implementacin de la placa con MAX232 de la casa MAXIM:

Figura 6. Datasheet integrado MAX222

Conexiones entre el Microcontrolador y el MAX222 (Fig.4):

Figura 7.Conexiones Micro-Rs232

78

A continuacin se detalla el flujograma propuesto para implementar la aplicacin 5:

Habilitamos los perifricos UART1, PUERTO A Configuramos UART1

Habilitamos UART1

Llamada a la funcin enviar Funcin enviar

No Letras? Fin

S Enva

79

1 /////////////////////////////////////////////////////////////////////////////// 2 // PROGRAMA ENVIAR DATOS DESDE UART1 AL PUERTO SERIE //// 3 /////////////////////////////////////////////////////////////////////////////// 4 5 #include "inc/hw_ints.h" 6 #include "inc/hw_memmap.h" 7 #include "inc/hw_types.h" 8 #include "driverlib/debug.h" 9 #include "driverlib/gpio.h" 10 #include "driverlib/interrupt.h" 11 #include "driverlib/sysctl.h" 12 #include "driverlib/uart.h" 13 #include "drivers/rit128x96x4.h" 14 15 //***************************************************************************** 16 // Funcin enviar DATOS 17 //***************************************************************************** 18 void 19 UARTSend(const unsigned char *pucBuffer, unsigned long ulCount) 20 { 21 // 22 // bucle hasta que acabe de enviar toda la frase 23 // 24 while(ulCount--) 25 { 26 // Envio por la Uart1 27 UARTCharPut(UART1_BASE, *pucBuffer++); 28 } 29 } 30 31 //***************************************************************************** 32 // Programa principal 33 //***************************************************************************** 34 int 35 main(void) 36 { 37 38 // Activamos reloj del sistema 39 SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | 40 SYSCTL_XTAL_8MHZ); 41 42 // habilitamos los perifericos utilizados UART y PUERTO A 43 SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1); 44 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); 45 46 // activamos los bits U1TX=PD2 y U1RX=PD3. 47 GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_2 | GPIO_PIN_3); 48 49 // Configuramos la UART para 115,200, 8-N-1 50 UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 115200, 51 (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | 52 UART_CONFIG_PAR_NONE)); 53 54 // habilitamos la UART1. 55 UARTEnable(UART1_BASE); 56 57 // llamada a la funcin enviar 58 UARTSend((unsigned char *)"AbCDEFGHIJKLMNOPQRSTUVWXYZ: \n\r", 32); 59 }

APLICACIN FINAL Se trata de visualizar continuamente por el Hiperterminal de Windows el voltaje en mili voltios que adquiere el potencimetro ubicado en una placa externa. Sabiendo el funcionamiento de los diferentes mdulos utilizados anteriormente, tan slo se debe de realizar un programa que agrupe los mismos. Programa principal: Una vez activado el reloj del sistema se habilitan y configuran los perifricos utilizados de la siguiente manera, y el programa queda a la espera a que se produzcan la interrupcin del convertidor analgicodigital: a) UART1 y PUERTO D:

Se ha configurado la UART1 para una velocidad de transmisin de 115200 baudios y una trama formada por 8-N-1 bits. Para habilitar la transmisin y envo de datos es necesario configurar sus pines correspondientes que se encuentran en el PUERTO D de la placa. PUERTO D 4 X

7 X

6 X

5 X

3 X

2 U1Rx

1 U1Tx

0 X

b)

ADC:

Para adquirir los datos analgicos del potencimetro se ha configura el ADC0, con la secuencia 1, y el paso 0 activada cada segundo por el Timer0. As pues, el ADC0 es disparado cada segundo realizando un muestreo discreto de la seal de entrada. Tambin se ha configurado el ADC para que cuando la seal de entrada vare, se produzca una interrupcin y entre en la funcin Adc0IntHandler.

Figura 5. Pasos para configurar el ADC

81

c)

TIMER:

El temporizador es utilizado para realizar el muestreo discreto de adquisicin del potencimetro. Es configurado para realizar la funcin de temporizador peridico de 32 bits y es cargado con el valor del reloj del sistema para que se interrumpa cada segundo.

1 segundo

Funcin Adc0IntHandler El programa entra en esta funcin cuando se produce una interrupcin en el ADC0. En este instante se adquiere el dato digital y se convierte a milivoltios. Conversin del valor digital obtenido por el ADC0 a mili voltios:

Figura 6. Conversin de Bits a milivoltios

Una vez tenemos el voltaje, utilizamos una funcin predefinida para pasar la variable voltaje de unsigned long a unsigned char para prepararla para el envo por puerto serie y por el OLED de la placa. Todo seguido se llama a la funcin enviar (UARTSend). Funcin UARTSend: Esta funcin es la encarga de enviar bit a bit el valor del potencimetro al pin TX (PD1) de la UART1.

82

1 2 //////////////////////////////////////////////////////////////////////////////// 3 ////// Adquisicin de datos a traves de un potencimetro conectado////////////// 4 //////////en el ADC0 de la placa LM3S8962 y envio por puerto serie////////////// 5 //////////////////////////////////////////////////////////////////////////////// 6 7 // librerias necesarias para la aplicacin 8 9 #include "inc/hw_ints.h" 10 #include "inc/hw_memmap.h" 11 #include "inc/hw_types.h" 12 #include "driverlib/debug.h" 13 #include "driverlib/gpio.h" 14 #include "driverlib/adc.h" 15 #include "driverlib/interrupt.h" 16 #include "driverlib/sysctl.h" 17 #include "utils/ustdlib.h" 18 #include "driverlib/uart.h" 19 #include "drivers/rit128x96x4.h" 20 #include "driverlib/timer.h" 21 22 23 // variables declaradas como globales para recibir y para escribir en OLED 24 unsigned long poten[1]; 25 float volt; 26 unsigned long volt1; 27 static char valor[19]; 28 29 //***************************************************************************** 30 ////////////////////////////////////////////////////////////////////////////// 31 // Subprograma enviar por el puerto RS232 (COM4) 32 ////////////////////////////////////////////////////////////////////////////// 33 //***************************************************************************** 34 void 35 UARTSend(const unsigned char *pucBuffer, unsigned long ulCount) 36 { 37 38 while(ulCount--) 39 { 40 UARTCharPut(UART1_BASE, *pucBuffer++); 41 } 42 } 43 44 ////////////////////////////////////////////////////////////////////////////////// 45 // Subprograma Adc0 (el programa interrumpe cuando se produce un cambio de valor// 46 // del potencimetro y va leyendo el ADC0) 47 // declarada tambien en starup_ewarm 48 ////////////////////////////////////////////////////////////////////////////////// 49 void 50 Adc0IntHandler(void) 51 { 52 // Limpiamos interrupcion ADC0 53 ADCIntClear(ADC_BASE, 1); 54 55 // Deshabilitamos la interrupcin principal 56 IntMasterDisable(); 57 58 // Obtenemos el valor de la secuencia 1 y lo guardamos en variable poten 59 ADCSequenceDataGet(ADC_BASE, 1, poten); 60 61 // convertimos el valor guardado en poten a voltaje en mV 62 volt=(0.0032*poten[0]);

63 volt1=volt*1000; 64 65 // convertimos la variable poten para cargar en OLED 66 usprintf(valor, "voltaje:%d mV\n\r",volt1 ); 67 68 // cargamos valor en OLED 69 RIT128x96x4StringDraw(valor, 30, 55, 15); 70 71 // llamamos a la funcin enviar "send" 72 UARTSend((unsigned char *)valor, 19); 73 74 // habitamos la interrupcion principal 75 IntMasterEnable(); 76 } 77 78 //////////////////////////////////////////////////////////////////////////////// 79 //////// Programa principal //////// 80 //////////////////////////////////////////////////////////////////////////////// 81 int 82 main (void) 83 { 84 85 //habilitamos clock 86 SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC 87 | SYSCTL_OSC_MAIN |SYSCTL_XTAL_8MHZ); 88 89 //habilitamos perifrico ADC , TIMER0, UART1 y PUERTO "D" 90 SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC); 91 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); 92 SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1); 93 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); 94 95 // activamos los bits U1TX=PD2 y U1RX=PD3. 96 GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_2 | GPIO_PIN_3); 97 98 // Configuramos la UART para 115,200, 8-N-1 99 UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 115200, 100 (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | 101 UART_CONFIG_PAR_NONE)); 102 103 // habilitamos la UART1. 104 UARTEnable(UART1_BASE); 105 106 // configuramos la velocidad de 125 muestras por segundo 107 SysCtlADCSpeedSet(SYSCTL_ADCSPEED_125KSPS); 108 109 //Deshabilitamos todas las secuencias por si acaso 110 ADCSequenceDisable (ADC_BASE,0); 111 ADCSequenceDisable (ADC_BASE,1); 112 ADCSequenceDisable (ADC_BASE,2); 113 ADCSequenceDisable (ADC_BASE,3); 114 115 // inicializamos OLED 116 RIT128x96x4Init(1000000); 117 118 //Configuramos la secuencia 1, activado por timer0, max prioridad 119 ADCSequenceConfigure(ADC_BASE, 1,ADC_TRIGGER_TIMER,0); 120 121 // Configuramos la secuencia 1, paso 0, canal 0 122 ADCSequenceStepConfigure(ADC_BASE, 1, 0, ADC_CTL_CH0|ADC_CTL_IE); 123 124 // habilitamos la secuencia 1

125 ADCSequenceEnable(ADC_BASE, 1); 126 ADCProcessorTrigger(ADC_BASE, 1); 127 ADCIntRegister(ADC_BASE, 1,Adc0IntHandler); 128 129 // Activamos la interrupcion para el timer timeouts 130 IntEnable(INT_ADC0); 131 132 ADCIntEnable(ADC_BASE,1); 133 134 /////////////////////////////////////////////////////////////// 135 // Configuracin del timer0 para que el muestreo sea ms lento// 136 //////////////////////////////////////////////////////////////// 137 138 // Configuramos el timer O como uno de 32 bits periodico 139 TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); 140 141 // Cargamos en el timer O-A el valor obtenido por el reloj del sistema 142 TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet() ); 143 144 // activamos el timerO 145 TimerEnable(TIMER0_BASE, TIMER_A); 146 147 // activamos el disparo siempre 148 TimerControlTrigger(TIMER0_BASE,TIMER_A,true); 149 150 // bucle sin fin 151 while(1){ 152 } 153 }

Anexo II. Esquema de conexiones

86

Anexo III. Listado de cdigo de la aplicacin

88

1 //////////////////////////////////////////////////////////////////////////////// 2 // Programacin de un Registrador Autnomo de Datos Ssmicos // 3 // Autor: Josep Guillem Rodrguez Astol // 4 // Proyecto: PFC Ingeniera Automtica y Electrnica Industrial // 5 /////////////////////////////////////////////////////////////////////////////// 6 7 // Listado de librerias incluidas para la aplicacin 8 #include <string.h> 9 #include "inc/hw_memmap.h" 10 #include "inc/hw_types.h" 11 #include "driverlib/gpio.h" 12 #include "driverlib/interrupt.h" 13 #include "driverlib/sysctl.h" 14 #include "driverlib/systick.h" 15 #include "utils/cmdline.h" 16 #include "utils/uartstdio.h" 17 #include "third_party/ff007e/src/ff.h" 18 #include "third_party/ff007e/src/diskio.h" 19 #include "utils/ustdlib.h" 20 #include "inc/hw_ints.h" 21 #include "driverlib/adc.h" 22 #include "driverlib/timer.h" 23 #include "driverlib/ssi.h" 24 #include "driverlib/includeadc.h" 25 #include "inc/hw_ssi.h" 26 27 // Definiciones para los pines SPI card 28 #define SDC_SSI_CLK GPIO_PIN_2 29 #define SDC_SSI_TX GPIO_PIN_5 30 #define SDC_SSI_RX GPIO_PIN_4 31 #define SDC_SSI_FSS GPIO_PIN_3 32 #define SDC_SSI_PINS (SDC_SSI_TX | SDC_SSI_RX | SDC_SSI_CLK) 33 #define SDC_CS_GPIO_PORT_BASE GPIO_PORTG_BASE 34 #define SDC_CS_GPIO_SYSCTL_PERIPH SYSCTL_PERIPH_GPIOG 35 #define SDC_CS GPIO_PIN_0 36 37 // Variables auxiliares 38 int a=0,b=0,c=0,d=0,e=0,f=0; 39 unsigned long nada1,nada2, limp; 40 char totvalor[76]; 41 unsigned long dato1a,dato1b,dato1,canal1,c1; 42 unsigned long dato2a,dato2b,dato2,canal2,c2; 43 unsigned long dato3a,dato3b,dato3,canal3,c3; 44 unsigned long dato4a,dato4b,dato4,canal4,c4; 45 char flag=0, flag2=0, flag3=0; 46 char var; 47 48 //////////////////////////////////////////////////////////////////////////////// 49 // Variables a introducir por el usuario 50 //****************************************************************************** 51 // Nmero de muestras que se quieran obtener 52 int nummuestras=50000; 53 // Nombre txt creado en la tarjeta MicroSD 54 char name[10]={"3" "3" "3" "3""." "t" "x" "t"}; 55 //****************************************************************************** 56 57 // Variables necesarias para configurar placa ADC 58 char FILT_CFG_H=NOP; 59 char FILT_CFG_M=0x02; 60 char FILT_CFG_L=0x20; 61 char CONFIG_H=0x06; CONFIG_M=0x04; 62 char

63 char CONFIG_L=0x31; 64 65 //***************************************************************************** 66 // Buffer empleado para guardar el valor de los cuatro canales adquiridos 67 //***************************************************************************** 68 #define PATH_BUF_SIZE 76 69 70 //***************************************************************************** 71 // Buffer empleado para el tipo de accin a usar 72 //***************************************************************************** 73 #define CMD_BUF_SIZE 64 74 75 //***************************************************************************** 76 // Incluir separador entre Paths 77 //***************************************************************************** 78 static char g_cCwdBuf[PATH_BUF_SIZE] = "/"; 79 80 //***************************************************************************** 81 // Buffer temporal para el manejo de los Paths 82 //***************************************************************************** 83 static char g_cTmpBuf[PATH_BUF_SIZE]; 84 85 //***************************************************************************** 86 // 87 // Variables necesarias para usar las funciones FAts 88 // 89 //***************************************************************************** 90 static FATFS g_sFatFs; 91 static FIL g_sFileObject; 92 93 //***************************************************************************** 94 // Estructura necesaria para deteccin de errores Fresult 95 //***************************************************************************** 96 typedef struct 97 { 98 FRESULT fresult; 99 char *pcResultStr; 100 } 101 tFresultString; 102 103 //***************************************************************************** 104 // Definicin del Fresult de entrada 105 //***************************************************************************** 106 #define FRESULT_ENTRY(f) { (f), (#f) } 107 108 //***************************************************************************** 109 // Tabla con los posibles errores de la tarjeta MicroSD 110 //***************************************************************************** 111 tFresultString g_sFresultStrings[] = 112 { 113 FRESULT_ENTRY(FR_OK), 114 FRESULT_ENTRY(FR_DISK_ERR), 115 FRESULT_ENTRY(FR_INT_ERR), 116 FRESULT_ENTRY(FR_NOT_READY), 117 FRESULT_ENTRY(FR_NO_FILE), 118 FRESULT_ENTRY(FR_NO_PATH), 119 FRESULT_ENTRY(FR_INVALID_NAME), 120 FRESULT_ENTRY(FR_DENIED), 121 FRESULT_ENTRY(FR_EXIST), 122 FRESULT_ENTRY(FR_INVALID_OBJECT), 123 FRESULT_ENTRY(FR_WRITE_PROTECTED), 124 FRESULT_ENTRY(FR_INVALID_DRIVE),

125 FRESULT_ENTRY(FR_NOT_ENABLED), 126 FRESULT_ENTRY(FR_NO_FILESYSTEM), 127 FRESULT_ENTRY(FR_MKFS_ABORTED), 128 FRESULT_ENTRY(FR_TIMEOUT) 129 }; 130 131 //***************************************************************************** 132 // Nmero de Fresult codes 133 //***************************************************************************** 134 #define NUM_FRESULT_CODES (sizeof(g_sFresultStrings) / sizeof(tFresultString)) 135 136 //***************************************************************************** 137 // Tiempo de 10ms requerido por el Handler de las interrupciones 138 //***************************************************************************** 139 void 140 SysTickHandler(void) 141 { 142 // 143 // Call the FatFs tick timer. 144 // 145 disk_timerproc(); 146 } 147 148 /////////////////////////////////////////////////////////////////////////////// 149 //**************** Funcin de escritura en el Fichero Txt********************// 150 /////////////////////////////////////////////////////////////////////////////// 151 152 int 153 Cmd_write(char filename[], char dato[]) 154 { 155 // Variales locales 156 FRESULT fresult; 157 UINT usBytesRead; 158 char tamany; 159 tamany=0; 160 161 if(strlen(g_cCwdBuf) + strlen(filename) + 1 + 1 > sizeof(g_cTmpBuf)) 162 { 163 return(0); 164 } 165 // 166 // Copiamos el Path en un buffer temporal para ser manipulado 167 // 168 strcpy(g_cTmpBuf, g_cCwdBuf); 169 // 170 // Insertamos separador 171 // 172 if(strcmp("/", g_cCwdBuf)) 173 { 174 strcat(g_cTmpBuf, "/"); 175 } 176 strcat(g_cTmpBuf, filename); 177 // 178 // Funcin para buscar el ltimo dato escrito 179 // 180 fresult = f_lseek(&g_sFileObject,g_sFileObject.fsize); 181 182 if(fresult != FR_OK) 183 { 184 return(fresult); 185 } 186

187 // Bucle para quitar ltimos ceros del dato adquirido 188 while(dato[tamany]!=0x00) tamany++; 189 190 // Copiamos dato con su tamao en el buffer temporal 191 strncpy(g_cTmpBuf, dato, tamany); 192 193 // Funcin de escritura 194 fresult = f_write(&g_sFileObject, g_cTmpBuf,tamany, &usBytesRead); 195 196 // variable que cuenta el nmero de escrituras correctas 197 a++; 198 if(fresult != FR_OK) 199 { 200 return(fresult); 201 } 202 return(0); 203 } 204 205 /////////////////////////////////////////////////////////////////////////////// 206 //**************** Funcin de Apartura del fichero Txt***********************// 207 /////////////////////////////////////////////////////////////////////////////// 208 209 int 210 Cmd_open(char filename[]) 211 { 212 FRESULT fresult; 213 214 if(strlen(g_cCwdBuf) + strlen(filename) + 1 + 1 > sizeof(g_cTmpBuf)) 215 { 216 return(0); 217 } 218 // 219 // Copiamos el Path en un buffer temporal para ser manipulado 220 // 221 strcpy(g_cTmpBuf, g_cCwdBuf); 222 // 223 // Insertamos separador 224 // 225 if(strcmp("/", g_cCwdBuf)) 226 { 227 strcat(g_cTmpBuf, "/"); 228 } 229 //esta funcin guarda en la variable el nombre del archivo 230 strcat(g_cTmpBuf, filename); 231 232 // Funcin de apertura del archivo para ser escrito 233 fresult = f_open(&g_sFileObject, g_cTmpBuf, FA_WRITE); 234 235 if(fresult != FR_OK) 236 { 237 return(fresult); 238 } 239 return(0); 240 } 241 242 //***************************************************************************** 243 // Esta funcin retorna el error en un string 244 //***************************************************************************** 245 const char * 246 StringFromFresult(FRESULT fresult) 247 { 248 unsigned int uIdx;

249 250 // 251 // Enter a loop to search the error code table for a matching 252 // error code. 253 // 254 for(uIdx = 0; uIdx < NUM_FRESULT_CODES; uIdx++) 255 { 256 // 257 // If a match is found, then return the string name of the 258 // error code. 259 // 260 if(g_sFresultStrings[uIdx].fresult == fresult) 261 { 262 return(g_sFresultStrings[uIdx].pcResultStr); 263 } 264 } 265 266 // 267 // At this point no matching code was found, so return a 268 // string indicating unknown error. 269 // 270 return("UNKNOWN ERROR CODE"); 271 } 272 273 /////////////////////////////////////////////////////////////////////////////// 274 //**************** Configuracin Timer ***********************// 275 /////////////////////////////////////////////////////////////////////////////// 276 277 void ConfigTimer(void){ 278 279 // Configuramos el timer O como uno de 32 bits periodico 280 TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); 281 282 // Cargamos en el timer O-A el valor obtenido para 2ms 283 TimerLoadSet(TIMER0_BASE, TIMER_A, 101000); 284 285 // Activamos la interrupcion para el timer timeouts 286 IntEnable(INT_TIMER0A); 287 288 // habilitamos la interrupcion del timer O como timeouts 289 TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); 290 291 // activamos el timerO 292 TimerEnable(TIMER0_BASE, TIMER_A); 293 294 // activamos el disparo siempre 295 TimerControlTrigger(TIMER0_BASE,TIMER_A,true); 296 297 } 298 299 /////////////////////////////////////////////////////////////////////////////// 300 //**************** Configuracin ADC CS5376A ***********************// 301 /////////////////////////////////////////////////////////////////////////////// 302 303 void filter_config(char reg, char data_H, char data_M, char data_L){ 304 305 // Segn la variable reg se ejecuta un caso y se envian los datos 306 switch(reg){ 307 308 case WR_ROM_COEFF: 309 310 SSIDataPut(SSI0_BASE, WR);

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372

SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, break; case CONFIG: SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, break; case FILT_CFG: SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, break; case GPCFG0: SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, break; case GPCFG1: SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE, SSIDataPut(SSI0_BASE,

SPI1CMD_H); NOP); NOP); reg);

WR); SPI1CMD_H); NOP); NOP); WR_REG); NOP); NOP); reg); data_H); data_M); data_L);

WR); SPI1CMD_H); NOP); NOP); WR_REG); NOP); NOP); reg); data_H); data_M); data_L);

WR); SPI1CMD_H); NOP); NOP); WR_REG); NOP); NOP); reg); 0xF0); NOP); NOP);

WR); SPI1CMD_H); NOP); NOP); WR_REG);

373 SSIDataPut(SSI0_BASE, NOP); 374 SSIDataPut(SSI0_BASE, NOP); 375 SSIDataPut(SSI0_BASE, reg); 376 SSIDataPut(SSI0_BASE, NOP); 377 SSIDataPut(SSI0_BASE, NOP); 378 SSIDataPut(SSI0_BASE, NOP); 379 380 break; 381 382 case FILTER_START: 383 384 SSIDataPut(SSI0_BASE, WR); 385 SSIDataPut(SSI0_BASE, SPI1CMD_H); 386 SSIDataPut(SSI0_BASE, NOP); 387 SSIDataPut(SSI0_BASE, NOP); 388 SSIDataPut(SSI0_BASE, reg); 389 390 break; 391 392 case FILTER_STOP: 393 SSIDataPut(SSI0_BASE, WR); 394 SSIDataPut(SSI0_BASE, SPI1CMD_H); 395 SSIDataPut(SSI0_BASE, NOP); 396 SSIDataPut(SSI0_BASE, NOP); 397 SSIDataPut(SSI0_BASE, reg); 398 399 break; 400 } 401 } 402 403 /////////////////////////////////////////////////////////////////////////////// 404 //**************** Funcin Obtener datos de los sensores*********************// 405 /////////////////////////////////////////////////////////////////////////////// 406 407 void obtenerdatos() 408 { 409 410 // Este bucle esta a la espera de que el DataReady de la placa ADC 411 // se ponga a "0", momento que nos indica que los datos estan listos 412 do{ 413 flag2=GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_7); 414 flag2=(flag2&0x80); }while(flag2==0x80); 415 416 417 // enviamos 128 bits a cero para poder obtener el valor 418 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 419 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 420 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 421 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 422 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 423 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 424 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 425 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 426 427 428 // obtenemos el valor de los cuatro canales con 429 // 8 adquisiciones de variables de 16 bits 430 SSIDataGet(SSI0_BASE, &dato1a); 431 SSIDataGet(SSI0_BASE, &dato1b); 432 SSIDataGet(SSI0_BASE, &dato2a); 433 SSIDataGet(SSI0_BASE, &dato2b); 434 SSIDataGet(SSI0_BASE, &dato3a);

435 SSIDataGet(SSI0_BASE, &dato3b); 436 SSIDataGet(SSI0_BASE, &dato4a); 437 SSIDataGet(SSI0_BASE, &dato4b); 438 439 //////////////////////////////////////////////////////////////////////////////// 440 // Procesado de datos // 441 //////////////////////////////////////////////////////////////////////////////// 442 443 // En el Procesado de datos se juntan las dos variables de 16 bits que 444 // pertenecen al mismo canal en una de 32 bits, y se extraen los 24 bits 445 // de menor peso. Tambien se cogen los bits que nos dan la informacin del 446 // al canal que corresponden. 447 448 // Datos canal 1 449 dato1=(dato1a<<16)|(dato1b); 450 canal1=dato1&(0x00FFFFFF); 451 c1=dato1&(0x30000000); 452 453 // Datos canal 2 454 dato2=(dato2a<<16)|(dato2b); 455 canal2=dato2&(0x00FFFFFF); 456 c2=dato2&(0x30000000); 457 458 // Datos canal 3 459 dato3=(dato3a<<16)|(dato3b); 460 canal3=dato3&(0x00FFFFFF); 461 c3=dato3&(0x30000000); 462 463 // Datos canal 4 464 dato4=(dato4a<<16)|(dato4b); 465 canal4=dato4&(0x00FFFFFF); 466 c4=dato4&(0x30000000); 467 468 // Funcin que permite juntar los cuatro canales y transformalo para ser 469 // enviado para la escritura 470 usprintf(totvalor, "%d\t%d\t%d\t%d\r\n",canal1,canal2,canal3,canal4); 471 472 } 473 474 /////////////////////////////////////////////////////////////////////////////// 475 //**************** Configuracin SPI para MicroSD ***********************// 476 /////////////////////////////////////////////////////////////////////////////// 477 478 void 479 ConfigSSISD(void){ 480 481 // Deshabilitamos el mdulo SPI 482 SSIDisable(SSI0_BASE); 483 484 // volvemos a configurar SSI como modo 0, master, max velocidad y 8 bits 485 SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, 486 SSI_MODE_MASTER,12500000, 8); 487 // Configuramos pines SD card 488 GPIOPinTypeSSI(GPIO_PORTA_BASE, SDC_SSI_PINS); 489 GPIOPadConfigSet(GPIO_PORTA_BASE, SDC_SSI_PINS, GPIO_STRENGTH_4MA, 490 GPIO_PIN_TYPE_STD_WPU); 491 GPIOPinTypeGPIOOutput(SDC_CS_GPIO_PORT_BASE, SDC_CS); 492 GPIOPadConfigSet(SDC_CS_GPIO_PORT_BASE, SDC_CS, GPIO_STRENGTH_4MA, 493 GPIO_PIN_TYPE_STD_WPU); 494 GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_3); 495 496 // Habilitamos el mdulo SPI

497 SSIEnable(SSI0_BASE); 498 } 499 500 /////////////////////////////////////////////////////////////////////////////// 501 //**************** Configuracin SPI para ADC ***********************// 502 /////////////////////////////////////////////////////////////////////////////// 503 504 void 505 ConfigSSIADC(void) { 506 507 // Deshabilitamos el mdulo SPI 508 SSIDisable(SSI0_BASE); 509 // volvemos a configurar SSI como modo 0, master y 16 bits 510 SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_1 , 511 SSI_MODE_MASTER, 500000, 16); 512 // Configuramos Pines necesarios 513 GPIOPinTypeSSI(GPIO_PORTA_BASE, SDC_SSI_PINS | GPIO_PIN_3 ); 514 515 // Habilitamos el mdulo SPI 516 SSIEnable(SSI0_BASE); 517 518 // El siguiente cdigo se ejecuta un sola vez, y sirve para limpiar 519 // los buffers de la placa de evaluacin LM3s8962 520 521 if(b==0){ 522 523 while(d<=15){ 524 SSIDataPut(SSI0_BASE, (unsigned long )0x0000); 525 d++; 526 } 527 SysCtlDelay(16666000); 528 while(e<=7){ 529 SSIDataGet(SSI0_BASE, &limp); SysCtlDelay(166660); 530 531 e++;} 532 533 b=1; 534 } 535 } 536 537 /////////////////////////////////////////////////////////////////////////////// 538 //**************** Funcin Interrupcin Timer 0 *****************************// 539 /////////////////////////////////////////////////////////////////////////////// 540 541 void 542 Timer0IntHandler(void) 543 { 544 // Limpiamos interrupcion Timer0 545 TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT); 546 547 // Deshabilitamos la interrupcin principal 548 IntMasterDisable(); 549 550 // cuando el nmero de escrituras (variable a, es mayor o igual al nmero 551 // de muestras elegidas por el usuario, se llama a la funcin de cierre 552 // de fichero y se enciende el LED STATUS para avisar de que se ha terminado 553 // la adquisicin y registro de datos en la MIcro SD. Luego entra en un 554 // bucle sin fin 555 if(a >= nummuestras){ 556 f_close(&g_sFileObject); 557 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,1); 558 while(1){

559 } 560 } 561 562 // Con el siguiente cdigo se genera la onda cuadrada de 250Hz y 563 // se realizan las funciones pertinentes cuando esta a "1" o a "0" 564 565 // Momento que est a "1" (Adquisicin) 566 if(flag==0) 567 { 568 569 // Ponemos el PIN 5 del puerto C a "1" 570 GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5,0x20); 571 // Llamada a la funcin Configurar SPI para ADC 572 ConfigSSIADC(); 573 // Llamada a obtener datos 574 obtenerdatos(); 575 // cambio de estado 576 flag=1; 577 // Momento que esta a "0" (Registro) 578 }else 579 { 580 // Ponemos el PIN 5 del puerto C a "0" 581 GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5,0x00); 582 // Deshabilitar chip select del SPI externo 583 GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3,GPIO_PIN_3); 584 // Llamada a la funcin configurar SPI para la MicroSD 585 ConfigSSISD(); 586 // LLamada a la funcin escritura a la MicroSD 587 Cmd_write(name,totvalor); 588 // Cambio de estado 589 flag=0; 590 } 591 592 // habitamos la interrupcion principal 593 IntMasterEnable(); 594 } 595 596 //***************************************************************************** 597 // Rutina de error si no encuentra las librerias 598 //***************************************************************************** 599 #ifdef DEBUG 600 void 601 __error__(char *pcFilename, unsigned long ulLine) 602 { 603 } 604 #endif 605 606 //***************************************************************************** 607 // 608 // PROGRAMA PRINCIPAL 609 // 610 //***************************************************************************** 611 612 int 613 main(void) 614 { 615 FRESULT fresult; 616 617 // Activamos el reloj del sistema usando PLL a 50 MHz 618 619 SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | 620 SYSCTL_XTAL_8MHZ);

621 622 // 623 // Habilitamos los mdulos necesarios para la aplicacin 624 // 625 SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0); 626 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); 627 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); 628 SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); 629 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); 630 631 // 632 // Configuramos SysTick para interrumpir a 100Hz . El driver de FatFs 633 // quiere 10 ms tick. 634 // 635 SysTickPeriodSet((0x7A1200) / 100); 636 SysTickEnable(); 637 SysTickIntEnable(); 638 639 640 //////////////////////////////////////////////////////////////////////////////// 641 // CONFIGURACIN DE PINES 642 //////////////////////////////////////////////////////////////////////////////// 643 644 // LED STATUS 645 GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT); 646 GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_0, GPIO_STRENGTH_8MA_SC, 647 GPIO_PIN_TYPE_STD); 648 GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,0); 649 650 // PIN SALIDA PC5 hacia ADC (250Hz) 651 GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_5); 652 653 // PIN ENTRADA PC7 hacia LM3s8962 (DataReady/TP3) 654 GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_7); 655 656 // PULSADOR SELECT 657 GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_1 , GPIO_DIR_MODE_IN); 658 GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_1, GPIO_STRENGTH_2MA, 659 GPIO_PIN_TYPE_STD_WPU); 660 661 662 //////////////////////////////////////////////////////////////////////////////// 663 // Configurar SPI para configurar ADC 664 //////////////////////////////////////////////////////////////////////////////// 665 666 // Deshabilitamos mdulo SSI 667 SSIDisable(SSI0_BASE); 668 // configuramos SSI como modo 0, master y 8 bits 669 SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_1 , 670 SSI_MODE_MASTER, 500000, 8); 671 // configuramos pines del SSI (clock, /CS, y recibir) 672 GPIOPinTypeSSI(GPIO_PORTA_BASE, SDC_SSI_PINS | GPIO_PIN_3 ); 673 // habilitamos el puerto SSI 674 SSIEnable(SSI0_BASE); 675 676 // Envios para configurar el ADC 677 SysCtlDelay(83332); //DelayMiliSecs(5); 678 filter_config((char)WR_ROM_COEFF,(char)0,(char)0,(char)0); 679 SysCtlDelay(16666);//DelayMiliSecs(1); 680 filter_config((char)CONFIG,(char)CONFIG_H,(char)CONFIG_M,(char)CONFIG_L); 681 SysCtlDelay(16666);//DelayMiliSecs(1); 682 filter_config((char)FILT_CFG,(char)FILT_CFG_H,(char)FILT_CFG_M,(char)FILT_CFG_L);

683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 }

SysCtlDelay(16666);//DelayMiliSecs(1); filter_config((char)GPCFG1,(char)0,(char)0,(char)0); SysCtlDelay(16666);//DelayMiliSecs(1); filter_config((char)GPCFG0,(char)0,(char)0,(char)0); SysCtlDelay(16666);//DelayMiliSecs(1); filter_config((char)FILTER_START,(char)0,(char)0,(char)0); SysCtlDelay(16666);//DelayMiliSecs(1); SysCtlDelay(16666000); SysCtlDelay(16666000); SysCtlDelay(16666000);//DelayMiliSecs(3000); // Cdigo utilizado para limpiar buffers de la placa ADC while(c<=7){ SSIDataGet(SSI0_BASE, &limp); SysCtlDelay(166660); c++; } IntMasterEnable(); // Mount del sistema de archivos,(using logical disk 0) fresult = f_mount(0, &g_sFatFs); if(fresult != FR_OK) { return(1); } // El siguiente cdigo est a la espera de que sea pulsado el // Switch Select para que ela aplicacin continue continue // Encendemos LED STATUS GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,1); do{ flag3=GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1); flag3=(flag3&0x02); }while(flag3==0x02); // Apagamos LED STATUS GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0,0); // Llamada para la apertura del fichero Cmd_open(name); // Llamada para configurar SPI para el ADC ConfigSSIADC(); // LLamada para configurar timer como temporizador peridico ConfigTimer(); // Bucle sin fin a la espera de las interrupciones while(1) { }