Memoria de Proyecto - fing.edu.uy
46
Proyecto de Laboratorio de Sistemas Embebidos para tiempo real ABEJÍMETRO Memoria de Proyecto Instituto de Ingeniería Eléctrica – Facultad de Ingeniería – Universidad de la República Grupo: Nro. 6 Autores: Alejandro Draper Nicolás Obrusnik Pablo Zinemanas Tutor: Conrado Rossi Fecha: 30/6/2014
Transcript of Memoria de Proyecto - fing.edu.uy
Proyecto de Laboratorio de Sistemas Embebidos para tiempo real
ABEJÍMETRO
Memoria de Proyecto
Instituto de Ingeniería Eléctrica – Facultad de Ingeniería – Universidad de la República
Grupo: Nro. 6
Autores: Alejandro Draper
Nicolás Obrusnik
Pablo Zinemanas
Tutor: Conrado Rossi
Fecha: 30/6/2014
2
RESUMEN
ABEJÍMETRO es un proyecto de laboratorio del curso Sistemas
Embebidos del IIE. Su objetivo es construir un dispositivo que registra
una señal de audio, calcula su Transformada Rápida de Fourier (FFT) y
almacena el resultado en una memoria externa.
El sistema está constituido por un micrófono, un circuito analógico
para adaptar la señal y una placa de desarrollo con un
microcontrolador (Stellaris EKI-LM4F232 de Texas Instruments). El
software se programó en el ambiente de desarrollo IAR Embedded
Workbench y en lenguaje C.
Interesa estudiar el espectro de las frecuencias menores a 1KHz. El
algoritmo FFT utilizado es Radix 2 no recursivo y con coeficientes
calculados en tiempo real. La memoria externa es una tarjeta micro
SD, y en ella se crean archivos que contienen los módulos de las FFT
calculadas.
CONTENIDO
INTRODUCCIÓN ....................................................................................................................................................... 4
OBJETIVOS ............................................................................................................................................................... 4
ALCANCE .................................................................................................................................................................. 5
ESPECIFICACIONES DE DISEÑO ................................................................................................................................. 5
DISEÑO DE HARDWARE ........................................................................................................................................... 6
ESQUEMA GENERAL ............................................................................................................................................. 6
AMPLIFICACIÓN Y FILTRADO ................................................................................................................................. 6
PLACA DE DESARROLLO STELLARIS ........................................................................................................................ 8
ARQUITECTURA DE SOFTWARE ............................................................................................................................. 10
IMPLEMENTACIÓN ................................................................................................................................................. 12
SOFTWARE ......................................................................................................................................................... 12
MUESTREO ......................................................................................................................................................... 13
FFT ..................................................................................................................................................................... 13
ALGORITMO FFT ................................................................................................................................................. 13
ALMACENAMIENTO EN MEMORIA SD ................................................................................................................. 15
OTROS MÓDULOS .............................................................................................................................................. 15
INTERRUPCIONES Y DATOS COMPARTIDOS ........................................................................................................ 18
PRUEBAS ................................................................................................................................................................ 19
CONCLUSIONES ...................................................................................................................................................... 23
ANEXOS.................................................................................................................................................................. 24
I. FFT................................................................................................................................................................... 24
II. SISTEMAS DE ARCHIVOS – MEMORIA SD ......................................................................................................... 26
III. LISTA DE ARCHIVOS ........................................................................................................................................ 27
IV. CONCEPTOS DEL CURSO APLICADOS .............................................................................................................. 29
V. ESPECIFICACIÓN DE PROYECTO ....................................................................................................................... 30
VI. PLANIFICACIÓN DE PROYECTO Y ANÁLISIS ...................................................................................................... 34
VII. DOCUMENTACIÓN DOXYGEN ....................................................................................................................... 36
BIBLIOGRAFÍA ........................................................................................................................................................ 46
4
INTRODUCCIÓN
Abejímetro se enmarca dentro del proyecto de grado PESTIBEE realizado por los mismos
estudiantes y cuyo objetivo es identificar distintos comportamientos en las colmenas de abejas
mediante el estudio de algunas variables en las mismas.
Alineado con investigaciones actuales del Grupo de Ingeniería Aplicada a los Procesos Agrícolas y
Biológicos (GIAPAB), PESTIBEE diseñará un dispositivo que registre señales de audio, temperatura
y niveles de tensión, realice las transformadas FFT a las señales de audio y transmita la
información hacia un servidor a través del canal de datos de la red GSM de ANTEL. Además,
deberá ser programable de forma remota por la misma vía.
Abejímetro es una maqueta del proyecto de grado, que registra señales de audio en un canal,
calcula su Transformada rápida de Fourier y almacena los datos en una memoria externa. Algunas
de las especificaciones del presente proyecto, como la frecuencia máxima que interesa estudiar,
son consecuencia directa del fin para el cual se diseñó.
OBJETIVOS
Objetivo general:
El objetivo del presente proyecto es desarrollar un sistema embebido capaz de adquirir señales
de audio, calcular su FFT y guardar el resultado en una memoria externa.
Objetivos específicos:
Programar módulo de muestreo.
Programar módulo para el procesamiento de FFT.
Programar almacenamiento en una tarjeta micro SD.
Desarrollar el Hardware necesario para el correcto acondicionamiento de la señal.
Desarrollar las funcionalidades necesarias de forma lo más independiente de hardware
posible, para tener en cuenta la portabilidad hacia otros microcontroladores.
5
ALCANCE Los siguientes aspectos quedan estrictamente dentro del proyecto:
Desarrollar una aplicación que utilice el ADC del microcontrolador para muestrear una
señal de audio analógica en un canal.
Realizar la FFT de las señales adquiridas.
Guardar los resultados obtenidos en una tarjeta de memoria micro SD.
La alimentación se realizará por puerto USB.
No formarán parte del presente proyecto:
Las siguientes funcionalidades: transmisión por señal de celular, alimentación, sensores de
temperatura.
La utilización de varios canales de audio.
Muestreo de señales en campo.
ESPECIFICACIONES DE DISEÑO Las especificaciones que deben cumplir las FFTs calculadas son:
Frecuencia máxima: 1024 Hz.
Resolución: 1 Hz.
Promediado de cierta cantidad de FFTs.
La primera restricción responde a que según estudios previos el sonido de la colmena no tiene
componentes en frecuencia significativas por encima de 1KHz. La especificación sobre la
resolución se fijó para tener una visión suficientemente detallada del resultado. Por último, lo que
se necesita estudiar es el comportamiento general de las señales de audio, para no tener en
cuenta posibles eventos anómalos. Por lo tanto, no interesará almacenar todos los coeficientes de
la FFT, sino que se trabajará con un sistema de ventanas. Se obtendrá un promedio de los módulos
de las Transformadas de Fourier de intervalos de tiempo de un segundo.
6
DISEÑO DE HARDWARE
ESQUEMA GENERAL Para la implementación del proyecto se utilizará la placa de desarrollo Stellaris EKI-LM4F232. Esta
es unas de las placas disponibles en el Instituto de Ingeniería Eléctrica (IIE) y se eligió por sus
capacidades, especialmente porque permite cálculos en punto flotante y cuenta con una
biblioteca para la comunicación con la memoria SD.
Para el acondicionamiento de la señal se construyó un circuito que consta de un amplificador y un
filtro pasa bajos. En la Figura1 se puede observar un diagrama de bloques general del sistema.
FIGURA 1 – DIAGRAMA DEL ESQUEMA GENERAL DEL SISTEMA ABEJÍMETRO.
AMPLIFICACIÓN Y FILTRADO La Figura 2 muestra el circuito construido para la etapa de amplificación y filtrado de las señales
del micrófono.
FIGURA 2 – ESQUEMÁTICO DEL CIRCUITO DE AMPLIFICACIÓN Y FILTRADO.
XFG1
U1B
LM358AD
5
6
4
8
7
VCC
5V
C20.0075µF
C4
0.015µF
R4
10kΩ
R5
10kΩ
U1A
LM358AD
3
2
4
8
1
VCC
5V
R1
100kΩ
R2
10kΩ
C1
100µF
U2B
LM358AD
5
6
4
8
7
VCC
5VR370kΩ
R630kΩ
VCC
5V
1.5V
1.5V
1.5V
MIC
R733kΩ
VCC
5V
OUT
C3100µF
Memoria
Flash Stellaris
Micrófonos Amplificación
y
Filtrado
TENSIÓN DE REFERENCIA
AMPLIFICACIÓN FILTRADO
7
La fuente VCC es obtenida de la placa Stellaris, que es alimentada por el puerto USB de la
computadora.
El amplificador operacional U2B funciona como seguidor y tiene el rol de establecer un voltaje fijo
de 1.5V. Se busca generar un offset de 1.5V para que la señal a la salida esté en el rango de 0 a 3V
(rango de operación del conversor analógico digital de la placa). La fuente de alimentación en este
caso es de 5 V, por lo que fue necesario un circuito que generara el offset requerido.
La primera etapa del circuito, implementada con el operacional U1A, se encarga de amplificar la
señal con ganancia que puede variar entre 10 V/V hasta 30 V/V, según la posición de un preset en
serie con la resistencia de 100kΩ.
La segunda etapa es un filtro Butterworth de segundo orden. Se decidió utilizar un filtro de este
tipo para tener la respuesta en frecuencia lo más plana posible hasta la frecuencia de corte. Esta
frecuencia de corte se fija por
fc = 2
2πRC
(1)
Donde se cumple que: R4 = R5 = R y C2 =C4
2= C.
Se busca que la respuesta al filtro sea plana hasta frecuencias de 1KHz por lo que se fija
fc = 1.5KHz. Entonces se toma: R = 10KΩ y C = 0.0075μF.
1 Circuito Butterworth obtenido de (Díaz)
8
PLACA DE DESARROLLO STELLARIS
En la Figura 3 se muestran los principales componentes de hardware de la placa de desarrollo
Stellaris LM4F232.
FIGURA 3 – COMPONENTES DE LA PLACA DE DESARROLLO STELLARIS LM4F232
Especificaciones de la placa de desarrollo:
6 terminales de tornillo, donde 4 son entradas analógicas (0-20V), una salida Vcc y otra a tierra.
2 sensores de temperatura analógicos, uno externo y otro interno al microcontrolador.
Display color OLED 96x64.
Conector USB para alimentación y conexión In CircuitDebug Interface.
Slot para tarjeta micro SD.
6 botones: 5 de uso configurable y 1 de reset.
1 LED para uso del usuario.
Conector para batería.
Pines I/O mediante cabezales 0,1”.
9
La Figura 4 muestra un esquema de interconexión de estos componentes en un diagrama de
bloques.
FIGURA 4 - DIAGRAMA DE BLOQUES PLACA DE DESARROLLO STELLARIS LM4F232.
Especificaciones del microcontrolador Stellaris LM4F:
Procesador ARM Cortex-M4F 80 MHz
Arquitectura de 32 bits
Unidad de punto flotante
Arquitectura Harvard
Memoria Flash 256KB
32 KB memoria SRAM
2KB EEPROM
2 controladores CAN 2.0 A/B
USB 2.0 OTG/Host/Device
8 UARTs
10
6 módulos I2C
4 módulos SSI
Controlador DMA
6 timers de 32 bits, configurables como uno de 32 bits o dos de 16 bits (TIMER A y TIMER
B).
Modulo Hibernación soportado mediante batería
Real Time Clock en modo hibernación
Hasta 105 pies GPIO
2 conversores ADC de 12 bits con 24 canales analógicos
3 comparadores analógicos
16 comparadores digitales
ARQUITECTURA DE SOFTWARE
Se utilizó la arquitectura Round Robin con interrupciones, que verifica el encendido de ciertas
banderas en un bucle infinito. En todo el sistema, quienes interrumpen son:
Conversor ADC cuando tiene un dato listo. Bandera termina_muestreo.
Botón 4 (“Select”) para iniciar un muestreo. Bandera comienza_muestreo.
UART cuando recibe un “Enter” desde PC. Bandera msj_completo.
Botón 2 para frenar el muestreo. Bandera canceló_muestreo.
MATCH_0 del RTC para determinar el momento de entrar en bajo consumo
Las primeras tres son las interrupciones que participan del Round Robin. En cada interrupción se
enciende una bandera que será verificada en el bucle principal. Por otro lado, las interrupciones
del botón 2 se habilitan solamente después de que se inició el muestreo. En cualquier otro caso no
están habilitadas pues no tendría sentido cancelar. Su correspondiente ISR enciende una bandera
canceló_muestreo que es inspeccionada después de calcular cada FFT.
También forma parte del Round Robin una cláusula que detecta si se está en condiciones de entrar
en modo bajo consumo (deepsleep del microcontrolador). Se está en condiciones de entrar en el
modo bajo consumo después de 20 segundos de inactividad. Se abandonará mediante una
interrupción dada por el botón “Select”.
11
A continuación se detalla un pseudocódigo del programa principal.
(Inicialización)
while(1)
if (comienza_muestreo)
EncenderADC();
if (termina_muestreo)
ApagarADC();
CalcularFFT();
if (fin_ventana OR canceló muestreo)
GuardarEnSD();
else
EncenderADC();
if (msj_completo)
procesar_mensaje();
if (condiciones_dormir)
dormir_entrar();
12
IMPLEMENTACIÓN
SOFTWARE Para escribir el programa se hizo uso de la biblioteca “StellarisWare” que provee Texas
Instruments para los microcontroladores Stellaris.
Se construyeron 9 módulos. Estos están organizados según la parte del hardware que controlan,
con la excepción de los módulos fft.c y main.c; los dos únicos destinados íntegramente a software.
Los módulos son los siguientes:
1. main.c
2. fft.c
3. puertos.c
4. rtc.c
5. muestreo.c
6. modulodormir.c
7. display.c
8. sd.c
9. uartcom.c
Se buscó que todos los módulos fueran lo más independientes entre sí y auto contenidos posible.
En la Figura 5 se muestra un esquema de la relación entre los módulos desarrollados.
FIGURA 5 – DIAGRAMA DE BLOQUES DEL SOFTWARE
modulosleep display
muestreo puertos sd fft uartcom
rtc
main
13
MUESTREO
MÓDULO MUESTREO.C
Como se vio en el capítulo de diseño, se desea obtener una FFT con frecuencia máxima 1.024KHz.
Se sabe del Teorema del Muestreo de Nyquist que para obtener la frecuencia deseada se debe
muestrear al doble de la frecuencia máxima, entonces:
fs = 2048Hz
Se necesita que el conversor analógico-digital del microcontrolador muestree a la frecuencia fs.
Esto se logra configurando el conversor para que se dispare con el TIMER 2 (32 bits) del
microcontrolador cada Ts =1
2048s.Se hizo uso de funciones de las bibliotecas ADC y timer de
StellarisWare.
En este caso se usó el canal analógico CHANNEL 1 para adquirir la señal. El ADC se enciende y
apaga mediante dos funciones que se desarrollaron, y así se controla cuándo muestrear.
Las interrupciones son manejadas por una ISR que cuenta la cantidad de muestras, hasta alcanzar
las 2048. Almacena los valores muestreados en un arreglo de complejos de parte imaginaria nula,
que después será usado para el cálculo de la FFT. También transforma los valores a un número
entre 0 y3 (Voltaje de referencia); esto es porque los ADC son de 12 bits y por lo tanto tiene 4096
valores posibles.
FFT
MÓDULO FFT.C
La Transformada Rápida de Fourier (FFT) es una es una forma de cálculo rápido de la
Transformada Discreta de Fourier (DFT). En el contexto del audio, esta transformada lleva señales
del dominio del tiempo al dominio de la frecuencia. De esta forma se puede obtener el espectro
de una señal para estudiar su comportamiento. Su funcionamiento se estudia a fondo en el Anexo
I, pero en este capítulo se dejarán claros algunos conceptos.
ALGORITMO FFT En una búsqueda por un algoritmo para calcular la FFT a una tira de muestras, se estudiaron varios
códigos y pseudocódigos. Los mismos se pueden clasificar en recursivos y no recursivos,
implementados tanto como bibliotecas completas, como simplemente un solo archivo .c capaz de
realizar el cálculo. Se encontró que la principal limitante en este proyecto es la memoria RAM del
microcontrolador, y no el tiempo que se demora en el cálculo, ya que el proyecto no cuenta con
requerimientos de tiempos muy restrictivos.
14
Si se muestrea a 2048Hz, en un segundo se obtienen 2048 muestras. Si bien en este caso son
señales reales, la FFT trabaja con números complejos, y por lo tanto se necesitan otros 2048
valores, que serán las partes imaginarias (nulas para estos datos) asociadas a estos reales.
Los algoritmos FFT calculan la DFT pero con una reducción en la cantidad de operaciones
necesarias, en un orden de N2 a N*log(N), de ahí la ventaja de usarlos. La forma en que se reduce
la cantidad de operaciones es dividiendo todas las muestras en secuencias de la mitad de valores,
y repitiendo el proceso hasta obtener secuencias de 2 valores. Este método se llama comúnmente
Radix 2, porque en cada etapa se divide la secuencia en 2. Otros algoritmos dividen en distinta
cantidad de secuencias. Cada vez que se obtiene una secuencia, se considera que se realizó una
etapa. Para el caso de 2048 valores, se contará con 11 etapas y al final se obtendrán 1024
secuencias de 2 valores. A cada una de estas secuencias de 2 valores se les realiza la DFT, y luego
se opera para re combinar los resultados hasta obtener la DFT del valor total de muestras.
La consideración más importante para los algoritmos FFT es si la implementación se hace recursiva
o in place.
Si la implementación es recursiva, y el algoritmo es óptimo, necesitará de 2 registros del tamaño
de las muestras de valores complejos. En el peor caso, por cada etapa de recursión se creará un
registro del tamaño de las muestras.
En el caso de 2048 muestras, el método recursivo es de 11 etapas. Cada registro es de 2048
valores reales y la misma cantidad de complejos. Cada valor ocupa 32 bits, por lo que cada registro
ocupa en memoria 16kBytes.Al tener 2 registros se alcanza el valor de la memoria RAM total
disponible (32 KBytes), haciendo imposible que estos algoritmos funcionen con el
microcontrolador utilizado.
En cambio los algoritmos de cálculos in place, utilizan solo un registro para realizar los cálculos. La
forma en que este tipo de algoritmos funcionan es mediante un reordenamiento del registro que
almacena los valores. Se hace de tal manera que el cálculo de los valores p-ésimo y q-ésimo de la
etapa m, solo requiere de los mismos valores de la etapa m-1. Este reordenamiento se llama bit
reversal.
Por lo tanto el algoritmo FFT implementado en este proyecto es el Radix 2 no recursivo. Se tiene
una función que hace el reordenamiento bit reversal, y otra que divide en secuencias, multiplica
por factores para calcular la DFT y re combina los resultados.
El script utilizado se puede encontrar en la bibliografía. Se trata de un código en C++ que
modificaciones mediante, fue reducido e implementado para el proyecto.
15
ALMACENAMIENTO EN MEMORIA SD
MÓDULO SD.C Para manipular la memoria SD se utiliza la biblioteca “ff.c” que es la encargada de controlar el
sistema de archivos y de comunicarse con la memoria. Esta biblioteca implementa las típicas
funciones de un sistema de archivos, algunas de ellas son:
fmount: utilizada para montar la memoria SD.
fopen: utilizada para crear o abrir archivos existentes.
fwrite: utilizada para escribir archivos existentes.
fclose: utilizada para cerrar los archivos luego de su manipulación.
Una característica importante de nuestro sistema es que en cada archivo se debe guardar la fecha
y hora del momento en el cual se tomaron las muestras. Para ello se decidió utilizar el timestamp
de los archivos. No hay una función implementada para editar este timestamp, por lo que se tuvo
que estudiar el funcionamiento de la funciones fopen y fclose para entender cómo fijar la hora de
forma manual.
Otro detalle a recalcar es que en el caso de que se cancele un proceso de muestreo es de interés
saber cuántos segundos se promediaron, por lo que en el nombre del archivo guardado se
especifica la cantidad de FFTs que se utilizaron para calcular el promedio.
OTROS MÓDULOS
MÓDULO DISPLAY.C En este módulo se desarrollaron todas las funciones relacionadas con el manejo del display de
96x64 pixeles 16 bits CrystalFontz.
En este módulo se escribieron funciones para inicializar el display, escribir frases, dibujar la fft,
prender y apagar el mismo para cuando se entra al modo bajo consumo.
En la inicialización del display se dibuja un rectángulo azul con la frase “ABEJIMETRO”.
Con la función PrintfDisplay se escriben frases para mostrar el proceso que se está realizando,
como “FFT”, “MUESTREO”, “CANCELANDO”, “HOLA” y “ERROR SD”.
Con la función DibujarFFT se muestra en pantalla una gráfica de la FFT promediada. Para esto se
dividen los 1024 puntos obtenidos de la FFT en intervalos de 10 puntos, en los cuales el valor de
cada intervalo es el promedio de estos 10. Se grafica punto a punto los módulos en relación al
máximo. También se muestra la frecuencia donde se encuentra el máximo valor de la FFT.
16
MÓDULO PUERTOS.C
Inicializa y maneja los periféricos USERLED, botón 2 y 4.
El botón 4, se puede encontrar como el botón “Select/Wake” en la placa. Se configuró este
periférico para que al ser pulsado inicialice la secuencia de muestreo, FFT y almacenamiento en
memoria.
En tanto el botón 2, se puede encontrar como el botón “Flecha Izquierda”. Debido a que la
secuencia de muestreo puede demorar varios segundos dependiendo del tamaño de la ventana
que se requiera, se configuró este botón para detener la secuencia. Al pulsarse, el programa
termina con la muestra actual, le realiza la FFT y detiene la secuencia. Se promedian las FFTs
obtenidas hasta el momento que se cancela la secuencia, y se almacenan los valores en la
memoria SD.
Se escribieron funciones para cambiar el estado de LED, habilitar y deshabilitar las interrupciones
de los botones y la ISR con control de rebotes.
MÓDULO UARTCOM.C
El microcontrolador que se está usando dispone de 8 puertos UART. En este módulo se programó
uno de ellos, el UART0 para realizar la comunicación con la PC.
Las funcionalidades desarrolladas son:
Recibir la fecha y hora para configurar el RTC mediante el programa Realterm.
Enviar los resultados de la FFT por UART para recibir por Matlab.
La comunicación por UART se configuró con un baudrate de 115.200, 8 bits, 1 bit de parada y sin
paridad.
También se escribieron funciones para habilitar y deshabilitar la UART, para evitar interrupciones
mientras se procesa lo recibido y se establecer la hora.
MÓDULO RTC.C
El módulo RTC (real time Clock), es el encargado de manejar la fecha y hora. Esta información es
necesaria para identificar los archivos, por lo que cuando se guardan en la memoria SD, esta
información se agrega en el timestamp de los mismos.
Haciendo uso del módulo hibernate.h, se configura el oscilador externo de 32kHz para que lleve la
cuenta de los segundos transcurridos. Si el microprocesador está en el modo de bajo consumo,
este oscilador continúa funcionando. Se implementaron funciones para ingresar una nueva hora y
17
para consultar la hora actual. Esta última es quien realiza la conversión de segundos a una
estructura con los campos: segundos, minutos, horas, día de la semana, día del mes y año.
También se cuenta con una función que realiza la conversión en el sentido contrario, para poder
transformar fecha y hora en segundos y guardar ese valor en el RTC.
Para entrar en el modo bajo consumo, se determinó que la condición sea detectar 20 segundos de
inactividad, es decir, 20 segundos en el bucle principal chequeando las banderas. Cuando se
cumple la condición, este módulo interrumpe y en esa ISR se levanta la bandera dormir que será
revisada en el Round Robin del bucle principal.
Cuando se detecta actividad, se llama a una función que lee el valor del RTC y le aumenta 20
segundos. De esta manera se cuenta con una especie de temporizador, que cada vez que se
detecte actividad reinicia este temporizador. Cuando este llega a 0, se produce la interrupción.
MÓDULO MODULODORMIR.C
El microcontrolador ARM Cortex M4F tiene 5 modos de consumo, modo activo, modo sleep, modo
deepsleep, modo hibernación con VDD y con batería.
Se optó por el modo DeepSleep porque es el que permite el menor consumo sin entrar en modo
hibernación, ya que este modo está pensado para un ahorro máximo, cortando la alimentación al
microcontrolador y todos los periféricos.
En el modo DeepSleep el reloj del sistema pasa a estar dado por un oscilador interno de 30 KHz y
se apagan los relojes de las memorias flash y SRAM. Los periféricos pueden apagarse o
mantenerse funcionando pero con ese reloj interno. En este caso se mantienen encendidos
solamente los pines del bloque GPIO M.
Este módulo implementa específicamente las funciones independientes de hardware para
manipular el estado de bajo consumo, por ejemplo una para “dormir” y otra para “despertar”. Si
estando dormido se presiona el botón “Select”, en la rutina de atención al botón se llama a la
función para volver a modo activo.
18
INTERRUPCIONES Y DATOS COMPARTIDOS
Las interrupciones a manejar son cuatro: interrupciones del ADC cuando tiene una muestra lista,
del RTC cuando la cuenta llega al valor del MATCH_0, de los botones y de la UART cuando recibe
mensajes.
INTERRUPCIONES ADC
Esta interrupción debe durar menos que el período de muestreo para funcionar correctamente.
Esto se cumple ya que el período de muestreo es de 488 µs y atender la interrupción lleva unos
pocos ciclos de reloj, que a una frecuencia de 50MHz, significan un tiempo del orden de 1 a 2µs.
Cuando se presiona el botón que inicia la secuencia de muestreo se deshabilitan las otras
interrupciones. Por lo tanto, hasta que no finalice el muestreo y se active la bandera
termino_muestreo, el programa estará verificando las banderas del ciclo Round Robin. Se
concluye que no hay problemas de datos compartidos con esta interrupción.
INTERRUPCIONES RTC
Esta es la interrupción que se da cuando la cuenta del RTC alcanza al valor establecido en el
MATCH_0 del RTC. Cuando se produce solo se activa la bandera dormir, por lo que no hay
problemas de datos compartidos.
INTERRUPCIONES GPIO
Interrupciones de los botones. Activan las banderas botón y botoncancelar. En el caso de que la
bandera dormir esté activa, ejecuta funciones para prender el display y salir del modo de bajo
consumo. No tiene problemas de datos compartidos.
INTERRUPCIONES UART
Cuando se reciben datos por la UART, se entra en esta ISR mientras haya caracteres para recibir y
finalmente se reciba un enter. En ese momento se activa la bandera msj_completo.
No hay problemas de datos compartidos, pues los caracteres recibidos se guardan en una variable
global que se lee luego de recibidos los mensajes. Mientras se reciben datos por la UART se
deshabilitan otras interrupciones y mientras se procesa el mensaje recibido, la UART está
deshabilitada.
19
PRUEBAS
MUESTREO Para probar el módulo muestreo se reprodujeron señales de audio conocidas. Se recuperó la señal
en la entrada del muestreador con un osciloscopio, y a su vez se envió el resultado de la
conversión por UART hacia Matlab. En las figuras 6 y 7 se ven la señal en el osciloscopio y la señal
muestreada respectivamente, para una onda sinusoidal de 210Hz. Se confirma que el módulo
funciona correctamente, pues los períodos son iguales. Es importante aclarar que el osciloscopio
toma más muestras por segundo y por tanto la señal es más aproximada a una sinusoide real.
FIGURA 6 – SEÑAL ANALÓGICA A LA ENTRADA DEL CONVERSOR ADC– PRUEBA DE MUESTREO
FIGURA 7 - SEÑAL MUESTREADA – PRUEBA DE MUESTREO
20
FFT La prueba consistió en guardar en el arreglo de entrada una señal sinusoidal de 100Hz, luego se
calculó la FFT y se comparó con la FFT calculada en Matlab. Las Figuras 8 y 9 muestran estos dos
gráficos. Se concluye que este módulo funciona correctamente.
FIGURA 8 – FFT DE UN SENO DE 100HZ EN MATLAB – PRUEBA FFT
FIGURA 9 – FFT DE UN SENO DE 100HZ EN EL MICROCONTROLADOR – PRUEBA FFT
21
SD Se ensayó creando archivos nuevos y sobrescribiendo archivos existentes. Para saber si la escritura
de la información era correcta se abrieron los archivos en Matlab utilizando las siguientes
funciones:
f = fopen(‘fft.bee’);
fread(f, ‘float’);
De esta forma se lee el contenido del archivo sabiendo que son números en punto flotante.
En una segunda etapa se probó que la fecha del RTC fuera correctamente almacenada en el
timestamp del archivo.
PRUEBAS GLOBALES Se reprodujeron señales de audio conocidas y se probó el sistema completo. Para verificar el
correcto funcionamiento, desde un PC se abrieron los archivos de la tarjeta SD y se graficaron los
datos en Matlab. Las Figuras 10 y 11 muestran los resultados para una señal sinusoidal (610Hz) y
una onda cuadrada (210Hz). En la primera se ve claramente el tono en 610Hz. En la segunda se
observa la importancia de los picos en la frecuencia fundamental y en los armónicos impares.
Con el fin de testear también la correcta implementación del display, se hizo una prueba similar
con un tono de 631Hz. La foto de la Figura 12 muestra la gráfica de la FFT correspondiente y así se
verifica que está funcionando de manera adecuada.
FIGURA 10 – FFT DE UNA ONDA CUADRADA DE 210HZ CALCULADA EN EL MICROCONTROLADOR –
PRUEBAS GLOBALES
22
FIGURA 11 – FFT DE UN SENO DE 610 CALCULADA EN EL MICROCONTROLADOR – PRUEBAS
GLOBALES
FIGURA 12 - FOTO DE LA GRÁFICA DEL ESPECTRO EN EL DISPLAY – PRUEBAS GLOBALES.
23
CONCLUSIONES Lo primero que se concluye es que se finalizaron todas las tareas marcadas en los objetivos. Se
diseñó e implementó un sistema capaz de muestrear una señal de audio, calcular su FFT y
almacenarla en una memoria externa. Se implementaron además otras funcionalidades como
comunicación por UART, manejo del display, reloj de tiempo real, e interacción con el usuario a
través de los botones de la placa. Si bien el sistema no tiene restricciones de consumo, el
dispositivo ingresa a un modo de funcionamiento de bajo consumo en períodos de inactividad.
Se conocieron y estudiaron las bibliotecas de StellarisWare, que fueron de suma utilidad para el
desarrollo del proyecto. Se trata de una serie de drivers de los periféricos del microcontrolador. Se
utilizaron bibliotecas para controlar la UART, el display, la comunicación con la memoria externa,
los botones y el módulo de hibernación. Por otro lado se destaca que el ambiente de desarrollo
utilizado (IAR Embedded Workbench) resultó muy conveniente dadas la herramientas que provee
para la depuración del código.
Las limitaciones de memoria RAM jugaron un papel importante en la elección del algoritmo FFT.
De haber desarrollado el proyecto con una frecuencia de muestreo más alta, la implementación se
habría complicado y el algoritmo seleccionado dejaría de funcionar sobre el hardware utilizado. En
tal caso la solución sería optar por un algoritmo más complejo o migrar a algún otro dispositivo,
como puede ser un DSP.
En lo que respecta al programa, los autores concluyen que no resultó excesivamente complejo en
cuanto a los procesos que realiza. Dicho de otro modo, se trata de eventos relativamente
“secuenciales”, por lo que la arquitectura Round Robin resultó adecuada sin necesidad de recurrir
a sistemas más sofisticados como RTOS. Se evitaron los problemas de datos compartidos y los
tiempos de ejecución no fueron un problema gracias a la alta frecuencia de operación del sistema.
El trabajo resultó ser una muy útil maqueta del proyecto de grado PESTIBEE, puesto que significó
un primer acercamiento a la placa de desarrollo y a las bibliotecas StellarisWare y motivó una
profundización en el ambiente IAR. A la luz del proyecto PESTIBEE, algunos posibles trabajos
futuros serían mejorar la eficiencia de la FFT, hacer un análisis más exhaustivo respecto al
consumo y evaluar la migración a otro microcontrolador que se adecúe más a la aplicación.
24
ANEXOS
I. FFT Se le llama Transformada Rápida de Fourier (FFT) a un algoritmo computacional para calcular de
forma rápida una Transformada Discreta de Fourier (DFT). La misma se define como una serie de
muestras equiespaciadas de la Transformada de Fourier de la señal. De esta forma, una DFT de n
puntos será idéntica a tomar n muestras de la transformada de Fourier de la señal, separadas
entre sí 𝑤𝑘 = 2 ∗ 𝑝𝑖 ∗𝑘
𝑁
2.
Así, la DFT de una serie finita de longitud N es:
𝑋 𝑘 = 𝑥 𝑛 𝑊𝑁𝑘𝑛
𝑁−1
𝑛=0
𝑘 = 0,1, . . . , 𝑁 − 1.
Donde 𝑊𝑁𝑘= 𝑒−𝑗
2𝜋𝑘
𝑁 .
Hacer el cálculo de la DFT puede llevar una gran cantidad de operaciones, por lo que se han
desarrollado varios algoritmos para reducir la cantidad de operaciones necesarias.
Hacer el cálculo de la DFT de 2048 muestras como es este caso llevaría 4.194.304 multiplicaciones
de valores complejos (proporcional a N2) y un número similar de sumas complejas. Para el caso de
una FFT la cantidad de operaciones rondan las 22.528 (proporcional a N*log2(N)), esto muestra la
necesidad de implementar estos algoritmos.
El algoritmo usado es el Radix-2 no recursivo. En este caso un algoritmo de decimación en el
tiempo, el cual divide el cálculo de la DFT en pequeñas transformadas, aprovechando la simetría y
periodicidad del número complejo 𝑊𝑁, se puede lograr hacer en vez de calcular la DFT de 2048
muestras, calcular 1024 DFT de muestras de 2 datos, y luego recombinarlas para obtener la DFT de
2048 muestras.
Este método parte de una cantidad de datos N, con N potencia de dos. Así, para el cálculo de la
DFT se separan las N muestras en dos tiras de N/2: por un lado los puntos de índice par y por otro
lado los impares. De esta forma se tiene:
X[k] = ΣN−1m=0 (x[2m]WM
m∗k ) + ΣN−1m=0 (x[2m + 1]WM
m∗k )
Es decir, se tienen ahora dos sub-FFT, de N/2 puntos cada una. Como N es potencia de 2, N/2 será
par, y por tanto cada una de estas sub-FFT se puede subdividir en otras dos. A cada subdivisión se
le considera como una etapa. Este razonamiento se aplica hasta tener que calcular la DFT de una
pareja de puntos, que se resuelve rápidamente sustituyendo N=2 en la primera ecuación de X[k].
En la Figura13se muestra un diagrama que muestra el método para 8 datos. (Oppenheim, 1999)
25
FIGURA 13 - ALGORITMO PARA RADIX-2 (OPPENHEIM, 1999)
La consideración más importante para este tipo de algoritmos es si la realización se hace recursiva
o in place (no recursiva).
Si la implementación es recursiva, y el algoritmo está bien implementado, necesitará 2 registros
del tamaño de las muestras de valores complejos, uno que tendrá los valores de la etapa actual y
otro para almacenar los de la etapa siguiente. En el peor caso, por cada etapa se creará un registro
del tamaño de las muestras.
Este método puede ser más rápido que el no recursivo, pero tiene la desventaja de que requiere
más memoria RAM. En el caso de 2048 muestras, el método recursivo es de 11 etapas. Cada
registro de 2048 valores reales y la misma cantidad de complejos. Cada valor ocupa 32 bits, por lo
que cada registro ocupa en memoria 16kbytes, al tener 2 registros se alcanza el valor de la
memoria RAM total disponible (32 KBytes), haciendo imposible que estos algoritmos funcionen
con el microcontrolador utilizado.
En cambio los algoritmos de cálculos in placeo no recursivos, utilizan solo un registro para guardar
los valores de las etapas y realizar los cálculos. La forma en que este tipo de algoritmos funcionan
es mediante un reordenamiento del registro que guarda o accede a los datos. Se hace de tal
manera que permite que el cálculo de los valores p-ésimo y q-ésimo de la etapa m, solo requiera
de los mismos valores de la etapa m-1.Se puede ver de forma gráfica en la figura 14.
26
FIGURA 144 - ALGORITMO NO RECURSIVO (OPPENHEIM, 1999)
De esta manera no es necesario contar con otro registro auxiliar. La forma en que se produce este
reordenamiento se llama bit reversal (inversión de bits), en el que se invierten los valores de los
bits de los índices de cada valor.
En este documento no se va a entrar en más detalles sobre bit reversal, para más información
consultar bibliografía. (Oppenheim, 1999)
Otro aspecto a considerar en estos algoritmos son los factores 𝑊𝑁𝑘= 𝑒−𝑗
2𝜋𝑘
𝑁 . Estos valores se
pueden calcular cada vez que se requieran o pueden estar almacenados en una tabla. Si son
almacenados en una tabla se puede hacer el algoritmo más rápido al costo de más uso de
memoria. En el caso de la implementación actual, se optó por calcular los valores a medida que se
requieran debido a las restricciones de memoria.
II. SISTEMAS DE ARCHIVOS – MEMORIA SD El sistema de archivos es el componente encargado de administrar y facilitar el uso de las
memorias periféricas. Sus principales funciones son la asignación de espacio a los archivos, la
administración del espacio libre, y la administración del acceso a los datos.
Para el manejo del sistema de archivos en la memoria SD se utilizó la biblioteca FatFs que
implementa un sistema de archivos FAT. Este sistema de archivos se caracteriza por la tabla de
asignación de archivos (FAT), que es realmente una tabla que reside en la parte "superior" del
volumen. Para proteger el volumen, se guardan dos copias de la FAT por si una resultara dañada3.
(Support)
3http://support.microsoft.com/kb/100108/es
27
III. LISTA DE ARCHIVOS
BIBLIOTECA STELLARISWARE
"inc/hw_memmap.h"
Macros para definir el mapa de memoria de la Stellaris.
"inc/hw_ints.h"
Macros para las asignaciones de las interrupciones.
"inc/lm4f232h5qd.h"
Definiciones de los registros del microprocesador.
"driverlib/fpu.h"
Provee métodos para la manipulación de la unidad de punto flotante del procesador Cortex M4F.
"inc/hw_types.h"
Define tipos de datos comunes y macros.
"driverlib/gpio.h"
Provee funciones para el control de todos los pines GPIO.
"driverlib/pin_map.h"
Funciones para configurar de forma fácil los pines periféricos.
"driverlib/systick.h"
Es un timer que se configura para producir tics, en la mayoría de los casos para generar una
interrupción periódica. En este caso el módulo SD requiere de tics cada 100 ms.
"driverlib/uart.h"
Configura, controla y maneja las interrupciones de los 8 puertos UART.
"driverlib/interrupt.h"
Funciones para manejar el NestedVectoredInterruptController (NVIC). Provee las funciones para
habilitar y deshabilitar las interrupciones, registrar las ISR y establecer sus prioridades.
"driverlib/sysctl.h"
Manejo de la operativa del dispositivo, controla el clocking, periféricos habilitados, configuración e
información sobre el dispositivo.
"grlib/grlib.h"
Contiene los drivers del display, y primitivas para dibujar elementos.
"drivers/cfal96x64x16.h"
Manejo del display.
28
"driverlib/adc.h"
Provee un conjunto de funciones para manejar los ADC.
"driverlib/timer.h"
Provee un conjunto de funciones para manejar los timers.
"driverlib /hibernate.h"
Maneja el módulo de hibernación del microcontrolador, en particular el RTC con oscilador externo
utilizado.
"utils/ustdlib.h"
Biblioteca para el manejo de la fecha y hora, incluye las funciones que transforman de segundos a
fecha y hora, y viceversa.
BIBLIOTECAS EXTERNAS "fatfs/src/ff.h" y "fatfs/src/diskio.h"
Estos módulos no pertenecen a Texas Instruments ni fueron escritos para el proyecto. Es parte de
un proyecto experimental para implementar el sistema de archivos FAT en pequeños sistemas
embebidos. Biblioteca de código abierto4.
BIBLIOTECAS ESTÁNDAR DE C. <stdio.h>
Contiene operaciones de entrada y salida.
<math.h>
Implementa operaciones matemáticas básicas.
<stdlib.h>
Propósito general.
MÓDULOS IMPLEMENTADOS main.c
Programa principal con Round Robin.
fft.c
Módulo para calcular FFT a una tira de datos complejos.
4http://elm-chan.org/fsw/ff/00index_e.html
29
puertos.c
Abarca todo el manejo de puertos y sus interrupciones.
rtc.c
Lleva la cuenta de segundos, minutos, horas, días, meses y años.
muestreo.c
Encargado de manejar el conversor ADC.
moduloDormir.c
Implementa las funciones para dormir y despertar el microcontrolador.
display.c
Módulo para encender, apagar, dibujar y escribir en el display.
sd.c
Implementa las funciones para grabar y leer en la memoria.
uartcom.c
Maneja la comunicación por UART.
"tipos.h"
Archivo de cabecera que contiene definición de tipos de datos nuevos y constantes de uso
general.
IV. CONCEPTOS DEL CURSO APLICADOS Round Robin.
Interrupciones.
Programación independiente y dependiente de Hardware.
Entorno IAR.
Conceptos de C:
Punteros a funciones.
Variables estáticas, globales, locales.
30
V. ESPECIFICACIÓN DE PROYECTO
DESCRIPCIÓN
El principal fin de este proyecto es diseñar y construir un dispositivo capaz de muestrear una
señal de audio, calcular su FFT según ciertas especificaciones y almacenar la información
resultante en una memoria flash.
ANTECEDENTES El proyecto se enmarca dentro del proyecto de fin de carrera homónimo y por los mismos
estudiantes. Alineado con investigaciones actuales de GIAPAB (Grupo de Ingeniería Aplicada a los
Procesos Agrícolas y Biológicos), el proyecto de grado PESTIBEE diseñará un dispositivo que
registre audio, temperatura y niveles de tensión, realice las transformadas FFT a las señales de
audio y transmita la información hacia un servidor a través del canal de datos de la red GSM de
ANTEL. Además, deberá ser programable de forma remota por la misma vía.
Para el proyecto de fin de carrera se utilizará un módulo de hardware que registrará las señales a
estudiar, y que se encargará de la amplificación y filtrado. Este módulo ya está diseñado y se
realizó una implementación de prueba en protoboard que se utilizará para el proyecto presente y
que no formará parte de las especificaciones del mismo.
Para la implementación del proyecto se utilizará la placa de desarrollo Stellaris EKI-LM4F232. Esta
es unas de las placas disponibles en el Instituto de Ingeniería Eléctrica (IIE) y se eligió por sus
capacidades, especialmente porque permite el cálculo en punto flotante y ya tiene implementado
el hardware para la comunicación con tarjetas SD y cuenta con una librería para la comunicación.
Para el proyecto ya se cuenta con comunicación con la tarjeta SD implementada.
OBJETIVOS Objetivo general:
El objetivo del presente proyecto es desarrollar una maqueta de un sistema embebido que
implemente algunas de las funcionalidades que serán necesarias para el proyecto de fin de
carrera PESTIBEE, aprovechando las herramientas adquiridas en el curso de Sistemas Embebidos
y la guía que pueden ofrecer los profesores del curso.
Objetivos específicos: Programar sobre la placa Stellaris EKI-LM4F232 los módulos necesarios para realizar el muestreo,
procesamiento de FFT y almacenamiento en memoria externa.
Desarrollar las funcionalidades necesarias de forma lo más independiente de hardware posible
teniendo en cuenta la portabilidad hacia otros microcontroladores.
31
ALCANCE Los siguientes aspectos quedan estrictamente dentro del proyecto:
Desarrollar una aplicación que utilice el ADC del microcontrolador para muestrear una
señal de audio en un canal.
Realizar la FFT de las señales adquiridas.
Guardar en memoria SD los resultados obtenidos.
No formarán parte del presente proyecto:
Todos aquellos bloques que forman parte del proyecto de grado pero no del presente, a
saber: transmisión por señal de celular, alimentación, sensores de temperatura,
multiplicidad de canales de audio. La alimentación se realizará por puerto USB.
Muestreo de señales en campo. Para las pruebas se utilizarán señales ya digitalizadas,
transmitidas por parlantes.
DESCRIPCIÓN Descripción funcional
Programación inicial de la ventana de tiempo de muestreo.
El sistema muestreará señales de audio a una frecuencia de muestreo de 8,192
KHz, usando el ADC del microcontrolador de 12bits.
Se muestrearán las señales durante 0,5 segundos.
Se guardarán las muestras generadas en la memoria flash interna a la vez que se
muestrea.
Se tomarán a lo sumo 45 muestras de 0,5 segundos consecutivas, que se
promediarán a medida que se generan y su resultado es modificado en la
memoria flash.
Al final se obtendrá una muestra promediada, a la cual se le realizará la FFT.
Se guardará el resultado en un archivo en la memoria SD.
La ventana de muestreo es de a lo sumo 45 segundos.
Se podrá programar la duración de las ventanas, y la hora de inicio y de fin de
muestreo.
32
DIAGRAMA DE BLOQUES
DESCRIPCIÓN DEL SISTEMA
Procesamiento: la parte más demandante de procesamiento del sistema es cuando se realiza la
FFT. La cantidad de operaciones necesaria estimada es de 106.000 operaciones complejas.
Memoria: También para la memoria, el requerimiento más alto es cuando se realiza la FFT.
Según el algoritmo de FFT que terminemos implementando y la frecuencia de muestreo, serán
los requerimientos de memoria.
Tiempos de respuesta:
El sistema debe ser capaz de muestrear a 8,192 KHz, guardar resultados en la
memoria flash y promediar dentro de 1 segundo.
El tiempo que requiere realizar la FFT de una muestra debe ser menor a 15
segundos, para permitir que se pueda volver a iniciar el proceso.
CONFIGURAR VENTANAS DE
TIEMPOMUESTREO PROMEDIADO
REALIZAR LA FFT
GUARDAR EN MEMORIA SD
SI NO TERMINÓ DE
MUESTREAR
REPITE SEGÚN
PROGRAMACIÓN
33
REQUERIMIENTOS Y RESTRICCIONES DEL SISTEMA
Plataforma de Hardware: se utilizará la placa de desarrollo Stellaris EKI-LM4F232 la cual cuenta
con las siguientes características:
Procesador ARM Cortex 80 MHz
Unidad para calculo en punto flotante
256 kB de memoria flash
32 Kb de memoria RAM
2kB EEPROM
Oscilador 16 MHz
6 timers de 32 bits
ADC 12 bits
8 UARTS
No será necesario para el proyecto diseñar un módulo de hardware. Para la adquisición
de las señales se contará con un prototipo ya implementado.
Arquitectura de Software: Round Robin con interrupciones
Se prefirió esta arquitectura porque el sistema no tiene restricciones importantes de respuesta
a eventos, y esta arquitectura permite una rápida respuesta a interrupciones con simplicidad. La
interrupción más importante a atender es la de los timers para determinar cuándo es momento
de muestrear.
34
VI. PLANIFICACIÓN DE PROYECTO Y ANÁLISIS
Se dividió al proyecto en las tareas especificadas en la Tabla 1 con sus horas de duración por
persona.
NOMBRE DURACIÓN COMIENZO FIN
1 Arquitectura de software y diagrama de flujo 10 7/5/2014 21/5/2014
2 Programa módulo muestreo 20 7/5/2014 28/5/2014
3 Programa módulo FFT 20 7/5/2014 28/5/2014
4 Programa memoria SD 20 7/5/2014 28/5/2014
5 Programa principal e integración de módulos 10 14/5/2014 4/6/2014
6 Pruebas de software 30 4/6/2014 11/6/2014
7 Documentación y presentación final 20 11/6/2014 18/6/2014
TABLA15 - – TAREAS, DURACIÓN POR PERSONA Y FECHAS.
Programa módulo muestreo: se encarga del manejo del ADC, inicialización del ADC, programación
de timers, manejo de las interrupciones de los timers y ADC.
Programa módulo FFT: levanta los valores de las muestras a transformar, realiza la FFT, guarda los
resultados en la memoria SD.
Programa principal e integración de módulos: guarda datos en la memoria flash, realiza el
promediado de las muestras
Pruebas de software:
Muestreo: se probará realizar el muestreo a 8,192 KHz de una señal de audio grabada de
zumbido de abejas, reproducida mediante parlantes, y adquirida mediante el prototipo de
hardware. Luego se guardarán las muestras generadas en la memoria SD y se reproducirán
las muestras generadas mediante un programa de computadora.
FFT: en una primera etapa se probará este módulo usando tonos a frecuencias específicas
adquiridas usando el módulo de muestreo. Luego se muestrearán señales conocidas que
se muestrearán utilizando todo el módulo implementado, y se muestrearán a su vez en
una computadora. Se compararán los espectros en ambos casos.
Programa principal: se probarán todas las modalidades integradas. Se programarán las
ventanas de muestreo para que en cada una se pueda muestrear una señal distinta
conocida a priori, luego se compararán los resultados obtenidos con los esperados.
35
ENTREGABLE HITO 1
Fecha: 4/6/2014
Tareas esperadas: programa principal con los módulos de muestreo y cálculo de la
FFT implementados
Avance esperado: contar con una primera implementación de todas las
funcionalidades del proyecto, admitiendo que falta la etapa de debugging.
ANÁLISIS DE LA PLANIFICACIÓN Se calculó un total de 43 horas por persona y en los hechos cada estudiante le dedicó un promedio
de 102 horas. A priori se podría decir que la planificación fue errada por la gran diferencia en la
dedicación.
Sin embargo hay que destacar que las siguientes funcionalidades no estaban contempladas dentro
de la planificación inicial, y no estaban cubiertas por los objetivos ni el alcance:
Desarrollo del Hardware de adaptación de la señal de entrada.
Reloj de tiempo real y archivos con “marca de tiempo”.
Modo de bajo consumo.
Comunicación con PC por UART.
Botón para cancelar el muestreo.
Manejo del display.
Si se mira el detalle de las horas dedicadas específicamente a los objetivos iniciales del proyecto,
se encuentra que fue un total de 65 horas (incluyendo la etapa de documentación). Si bien sigue
estando por encima de la planificación original, es un número razonable considerando que este
proyecto forma parte de un proyecto de fin de carrera.
36
VII. DOCUMENTACIÓN DOXYGEN
A continuación se presenta una versión reducida de la documentación generada en Doxygen. Se
muestran los archivos, los módulos que incluyen, sus variables y funciones. La versión completa
con el código y comentarios se encuentra en la carpeta “Documentación Doxygen”.
DOCUMENTACIÓN DE LAS ESTRUCTURAS DE DATOS
REFERENCIA DE LA ESTRUCTURA COMPLEX_T
#include "tipos.h"
CAMPOS DE DATOS float re
float im
La documentación para esta estructura fue generada a partir del siguiente fichero:
tipos.h
REFERENCIA DE LA UNIÓN FLOAT_BYTE
#include "tipos.h"
CAMPOS DE DATOS float f
char c [4]
La documentación para esta unión fue generada a partir del siguiente fichero: tipos.h
37
DOCUMENTACIÓN DE ARCHIVOS
REFERENCIA DEL ARCHIVODISPLAY.C #include "display.h"
FUNCIONES void IncializarDisplay ()
void PrintfDisplay (const char *texto, int n)
voidDibujarFFT (float *datos_graf)
void ApagarDisplay ()
void PrenderDisplay ()
REFERENCIA DEL ARCHIVO DISPLAY.H #include "inc/hw_memmap.h" #include "inc/hw_types.h" #include "driverlib/gpio.h" #include "driverlib/sysctl.h" #include "grlib/grlib.h" #include "drivers/cfal96x64x16.h" #include <stdio.h> #include <math.h>
'DEFINES' #define DISPLAY_ENV_PORT GPIO_PORTG_BASE
#define DISPLAY_ENV_PIN GPIO_PIN_0
FUNCIONES void IncializarDisplay ()
void PrintfDisplay (const char *texto, int n)
voidDibujarFFT (float *datos_graf)
void ApagarDisplay ()
void PrenderDisplay ()
REFERENCIA DEL ARCHIVO FFT.C #include "fft.h"
FUNCIONES double complex_magnitud (complex c)
void CalcFFT ()
38
REFERENCIA DEL ARCHIVO FFT.H #include<math.h> #include <stdlib.h> #include "tipos.h"
'DEFINES' #define PI 3.141592
FUNCIONES double complex_magnitud (complex c)
void CalcFFT ()
VARIABLES complexmuestras [FSAMPLING]
REFERENCIA DEL ARCHIVO HIBERNAR.C #include "hibernar.h"
FUNCIONES void HibernateHandler (void)
void InicializarHib ()
void ResetSleepTimer ()
void DeshabilitaIntRTC ()
void HabilitaIntRTC ()
REFERENCIA DEL ARCHIVOHIBERNAR.H #include "inc/hw_types.h" #include "tipos.h" #include "driverlib/hibernate.h" #include "inc/hw_hibernate.h"
FUNCIONES void InicializarHib ()
void ResetSleepTimer ()
void DeshabilitaIntRTC ()
void HabilitaIntRTC ()
VARIABLES tBooleandormir
39
REFERENCIA DEL ARCHIVO MAIN.C #include "rtc.h" #include "sd.h" #include "muestreo.h" #include "fft.h" #include "uartcom.h" #include "puertos.h"
FUNCIONES void main (void)
VARIABLES float * dir
tBooleanmsj_completo =0
tBooleantermino_muestreo = 0
tBooleanseteo_listo =0
tBooleandormir =0
char buffer_recepcion [TAM]
char buffer_transmision [TAM]
complexmuestras [FSAMPLING]
float data [FSAMPLING/2]
tTimefecha_hoy
REFERENCIA DEL ARCHIVOMODULODORMIR.C #include "modulodormir.h"
FUNCIONES void SleepEntrar ()
void SleepSalir ()
REFERENCIA DEL ARCHIVO MODULODORMIR.H #include "inc/hw_types.h" #include "hibernar.h"
FUNCIONES void SleepEntrar ()
void SleepSalir ()
40
VARIABLES tBooleandormir
REFERENCIA DEL ARCHIVOMUESTREO.C #include "muestreo.h"
FUNCIONES void ADCIntHandler (void)
void InicializarADC ()
void ApagarADC ()
void PrenderADC ()
REFERENCIA DEL ARCHIVOMUESTREO.H #include "inc/hw_types.h" #include "driverlib/adc.h" #include "driverlib/timer.h" #include "driverlib/sysctl.h" #include "inc/hw_memmap.h" #include "tipos.h"
FUNCIONES void InicializarADC ()
void ApagarADC ()
void PrenderADC ()
VARIABLES tBooleantermino_muestreo
complexmuestras [FSAMPLING]
REFERENCIA DEL ARCHIVOPUERTOS.C #include "puertos.h"
FUNCIONES void IntGPIOM (void)
void InicializarGPIO ()
void PrenderLed ()
void BotonSelHabilitar ()
41
void BotonSelDeshabilitar ()
void BotonPararHabilitar ()
void BotonPararDeshabilitar ()
VARIABLES intboton = 0
intbotoncancelar =0
REFERENCIA DEL ARCHIVO PUERTOS.H #include "modulodormir.h" #include "inc/hw_ints.h" #include "inc/lm4f232h5qd.h" #include "driverlib/interrupt.h" #include "display.h"
FUNCIONES void InicializarGPIO ()
void PrenderLed ()
void BotonSelHabilitar ()
void BotonSelDeshabilitar ()
void BotonPararHabilitar ()
void BotonPararDeshabilitar ()
VARIABLES intboton
intbotoncancelar
tBooleandormir
REFERENCIA DEL ARCHIVORTC.C #include "rtc.h"
FUNCIONES void HibernateHandler (void)
void InicializarRTC ()
void ResetSleepTimer ()
void DeshabilitaIntRTC ()
void HabilitaIntRTC ()
42
void SetearTiempo (tTimeset_tiempo)
tTimeDevuelveTiempoActual ()
REFERENCIA DEL ARCHIVO RTC.H #include "inc/hw_types.h" #include "driverlib/sysctl.h" #include "inc/hw_memmap.h" #include "driverlib/hibernate.h" #include "inc/hw_hibernate.h" #include "utils/ustdlib.h" #include "tipos.h"
FUNCIONES void InicializarHib ()
void ResetSleepTimer ()
void DeshabilitaIntRTC ()
void HabilitaIntRTC ()
void InicializarRTC ()
void SetearTiempo (tTimeset_tiempo)
tTimeDevuelveTiempoActual ()
VARIABLES tBooleandormir
tTimefecha_hoy
REFERENCIA DEL ARCHIVOSD.C #include "sd.h"
FUNCIONES void SysTickHandler (void)
intWriteFile (char *file, float *data, unsigned short usBytesWrite, DWORD hora)
unsigned short ReadFile (char *file)
float * InicilizarSD (void)
REFERENCIA DEL ARCHIVO SD.H #include "inc/hw_memmap.h" #include "inc/hw_types.h"
43
#include "driverlib/fpu.h" #include "driverlib/gpio.h" #include "driverlib/sysctl.h" #include "driverlib/systick.h" #include "fatfs/src/ff.h" #include "fatfs/src/diskio.h"
'DEFINES' #define PATH_BUF_SIZE 80
FUNCIONES float * InicilizarSD (void)
intWriteFile (char *file, float *data, unsigned short usBytesWrite, DWORD hora)
unsigned short ReadFile (char *file)
VARIABLES float data [1024]
REFERENCIA DEL ARCHIVO STARTUP_EWARM.C
ESTRUCTURAS DE DATOS union uVectorEntry
FUNCIONES void SysTickHandler (void)
void __iar_program_start (void)
VARIABLES __root constuVectorEntry
__vector_table[] intvec
REFERENCIA DEL ARCHIVO TIPOS.H
ESTRUCTURAS DE DATOS union float_byte
structcomplex_t
'DEFINES' #define FSAMPLING 2048
#define TEMPORIZADOR 20
#define FOSCEXT 32768
44
#define VENTANAS 5
'TYPEDEFS' typedefstructcomplex_tcomplex
REFERENCIA DEL ARCHIVOUARTCOM.C #include "uartcom.h"
FUNCIONES void UartIntHandler (void)
void InicializarUART ()
void UARTSend (char *pucBuffer, unsigned long largo_mens)
tTimeDevuelveTiempoSeteado ()
void procesa (char *buffer)
void transmitir (char *p, int n)
void UARTDeshabilitar ()
void UARTHabilitar ()
REFERENCIA DEL ARCHIVO UARTCOM.H #include "modulodormir.h" #include "inc/hw_memmap.h" #include "driverlib/gpio.h" #include "driverlib/uart.h" #include "tipos.h" #include <stdlib.h> #include "utils/ustdlib.h" #include "display.h"
'DEFINES' #define TAM 50
FUNCIONES void InicializarUART ()
void procesa (char *p)
void transmitir (char *p, int n)
tTimeDevuelveTiempoSeteado ()
void UARTHabilitar ()
void UARTDeshabilitar ()
45
VARIABLES tBooleanmsj_completo
char buffer_recepcion [TAM]
char buffer_transmision [TAM]
tBooleanseteo_listo
tBooleandormir
46
BIBLIOGRAFÍA Chan. (n.d.). FatFs Generic FAT File System Module. Retrieved from http://elm-
chan.org/fsw/ff/00index_e.html
Díaz, C. (n.d.). Amplificador Operacional Doble Para Audio.Retrieved from
http://electronica.webcindario.com/componentes/lm833.htm
Instruments, T. (n.d.). Stellaris ARM Cortex M4F Training - Peripheral Overiew.
Instruments, T. (2011). Stellaris LM4F232H5QD Microcontroller Data Sheet. Austin, Texas: Texas
Instruments Incorporated.
Instruments, T. (2011). Stellaris® LM4F232 Evaluation Board User´s Manual. Austin, Texas: Texas
Instruments Incorporated.
Luminary Micro. (2007). Stellaris® Peripheral Driver Library User Guide. Austin, Texas: Luminary
Micro, Inc.
Mosi_62. (n.d.). Quick FFT. Retrieved from http://www.codeproject.com/Articles/619688/Quick-
FFT
Oppenheim, S. B. (1999). Discrete-Time Signal Processing. New Jersey: Prentice Hall.
Support, M. (n.d.). Introducción a los sistemas de archivos FAT, HPFS y NTFS. Retrieved from
http://support.microsoft.com/kb/100108/es
