estudio de modelos matemÁticos de...

..............

ESTUDIO DE

MODELOS MATEMÁTICOS DE

ACELERÓMETROS COMERCIALES

Tutor: Antonio Luque Estepa Autor: Alberto Manzanares del Moral

Alberto Manzanares del Moral 2

Gracias a la familia, por su apoyo y paciencia,

a mis amigos, que me han ayudado a seguir adelante

y a Antonio, mi tutor, por su guía durante el proceso


ÍNDICE

ÍNDICE ...................................................................................................................... 3

1. Objetivo de este proyecto........................................................................................ 6

2. Teoría de los acelerómetros .................................................................................... 8 2.1. Introducción ................................................................................................................................. 8 2.2. Principio básico de funcionamiento ............................................................................................ 9 2.3. Clases de acelerómetros ............................................................................................................. 12

2.3.1. Acelerómetros mecánicos............................................................................................................12 2.3.2. Acelerómetros piezoeléctricos ....................................................................................................12 2.3.3. Acelerómetros piezoresistivos ....................................................................................................14 2.3.4. Acelerómetros capacitivos...........................................................................................................14 2.3.5. Acelerómetros micromecanizados (MEMS).............................................................................16

2.4. Fabricación de MEMS ............................................................................................................... 18 2.4.1. Micromaquinado de silicio de cuerpo........................................................................................18 2.4.2. Micromecanizado de silicio superficial ......................................................................................19 2.4.3. Micromecanizado de silicio en volumen ...................................................................................20 2.4.4. Fotolitografía.................................................................................................................................21 2.4.5. Moldeado de Plástico (LIGA).....................................................................................................22 2.4.6. Mecanizado por Electro Descarga (EDM) ...............................................................................22 2.4.7. Proceso general de fabricación de MEMS ................................................................................23

2.5. Aplicaciones de los acelerómetros ............................................................................................. 24 2.6. Principales fabricantes ............................................................................................................... 27

2.6.1. Analog Devices .............................................................................................................................27 2.6.2. Acelerómetros ENTRAN ...........................................................................................................35 2.6.3. Acelerómetros METRA ..............................................................................................................35 2.6.4. Acelerómetros SEIKA.................................................................................................................36 2.6.5. Acelerómetros WILCOXON RESEARCH.............................................................................37

2.7. Criterios para la elección del acelerómetro adecuado............................................................... 37

3. Desarrollo del programa de simulación................................................................ 40 3.1. Matlab como herramienta principal........................................................................................... 40 3.2. Descripción del funcionamiento................................................................................................ 40 3.3. Desarrollo del programa de simulación..................................................................................... 52

3.3.1. Modelo en Simulink .....................................................................................................................52 3.3.2. Programación de la GUI .............................................................................................................53


3.4. Principales problemas encontrados .......................................................................................... 67

4. Validación del modelo de simulación.................................................................. 70 4.1. Montaje experimental en laboratorio ......................................................................................... 70 4.2. Pruebas experimentales para validar el modelo ........................................................................ 72

4.2.1. Obtención de la función de transferencia del modelo real .....................................................73 4.2.2. Comparación de la respuesta de ambos sistemas, real y simulación .....................................83

4.2.2.1. Comparación de ambos sistemas con péndulo.............................................................................83 4.2.2.2. Comparación de ambos acelerómetros, sin péndulo ...................................................................94

4.3. Resumen ....................................................................................................................................102

5. Conclusiones y desarrollos futuros ......................................................................104 5.1. Conclusiones..............................................................................................................................104

5.1.1. Conclusiones acerca del cálculo del volumen de la estructura .............................................104 5.1.2. Algunas simulaciones del modelo diseñado............................................................................105

5.2. Problemas encontrados en el desarrollo de la simulación .......................................................108 5.3. Desarrollos futuros y posibles mejoras .....................................................................................109

6. Bibliografía........................................................................................................... 113

7. Anexos .................................................................................................................. 115 7.1. Anexo A: código de programa de simulación y prueba............................................................ 116

7.1.1. Código del archivo interfaz.m ..................................................................................................116 7.1.2. Código archivo ADXL311_constants.m y pendulo_constantes.m .....................................127 7.1.3. Código archivo presentacion.m................................................................................................128 7.1.4. Código archivo ADXL311main_3prueba.m ..........................................................................130

7.2. Anexo B: data sheet ADXL311 ..................................................................................................132

CAPÍTULO 1

INTRODUCCIÓN Y

OBJETIVO DEL PROYECTO

Estudio de modelos de acelerómetros Introducción y objetivo


1. Objetivo de este proyecto

La idea principal de este proyecto es estudiar el comportamiento de un

acelerómetro desde dos puntos de vista diferentes: un estudio sobre el modelo físico, con el que podremos obtener conclusiones sobre el nivel de funcionamiento real del mismo; y una simulación con el programa Matlab, verdadero cuerpo del proyecto y cuyos resultados no se habían estudiado con detenimiento en las asignaturas dedicadas a los acelerómetros.

Con ello pretendemos proporcionar una herramienta útil y de fácil empleo, con

la que podremos obtener resultados a partir de datos básicos de la estructura que queramos analizar.

Para ello nos basamos en algunos acelerómetros comerciales, concretamente de

Analog Devices, cuyas características vienen expuestas a lo largo de esta memoria, y sabiendo las dimensiones que nos gustaría darle a nuestro dispositivo, el programa realiza la simulación. Obtenemos la respuesta correspondiente a la entrada elegida y valores del sensor como su masa y la constante de amortiguamiento de la estructura.

En el laboratorio de prácticas contamos con un modelo real del acelerómetro

empleado en la simulación, gracias al cual podremos comparar resultados y comprobar la veracidad de nuestra simulación.

La verificación del modelo se intentará llevar a cabo de varias formas,

explicadas detalladamente a lo largo de la memoria, y finalmente se muestran las conclusiones de cada una de ellas.

Por supuesto, es perfectamente posible utilizar otros acelerómetros, del

fabricante que sea, sólo es necesario un diagrama de bloques del dispositivo en cuestión, normalmente facilitados por los mismos fabricantes en su página web, y adecuar estos bloques a los datos de nuestro diseño.

A lo largo de la memoria pondremos al servicio del lector un amplio

conocimiento sobre la utilidad y elaboración de un acelerómetro, de forma que llegue a ser capaz de apreciar la importancia de este dispositivo y su aplicación en la sociedad actual.


CAPÍTULO 2

TEORÍA DE LOS ACELERÓMETROS

Estudio de modelos de acelerómetros Teoría de acelerómetros


2. Teoría de los acelerómetros

2.1. Introducción La medida de la aceleración, además de ser un elemento central en los sistemas de dirección inerciales, tiene aplicación en una amplia variedad de problemas tanto industriales como comerciales. Por ejemplo, la detección de choques en vehículos para la activación de los air-bags, análisis de vibración en maquinaria industrial, proporcionar señales de realimentación para estabilizar la imagen de una grabadora de vídeo, debido a la vibración producida por la mano, etc. Los acelerómetros son dispositivos para medir aceleración y vibración. Estos dispositivos convierten la aceleración de la gravedad o de movimiento en una señal eléctrica analógica proporcional a la fuerza aplicada al sistema, o mecanismo sometido a vibración o aceleración. Esta señal analógica indica en tiempo real la aceleración instantánea del objeto sobre el cual el acelerómetro está montado. Las técnicas convencionales para medir la aceleración se fundamentan en el primer principio descubierto por Newton y descritos en su Principio de Newton en 1687, el cual nos dice “que la fuerza neta aplicada sobre un cuerpo es proporcional a la aceleración que adquiere dicho cuerpo”.

La aceleración constante de una masa implica una fuerza F = m * a, donde F es la fuerza, a es la aceleración y m la masa. Tanto la fuerza como la aceleración son magnitudes vectoriales y, por lo tanto, tienen dirección y sentido.

Las unidades de medida de estas variables en el sistema internacional son:

Fuerza en Newtons [N] Masa en kilogramos [Kg] Aceleración en metros por segundo al cuadrado [m/s2]

Los primeros sensores de aceleración eran unos sistemas muy complejos y no muy fiables que se basaban en la medida de los desplazamientos de una masa inercial sujeta a la aceleración con resortes que contrarrestaban el efecto de la fuerza generada por la masa. Los acelerómetros son sensores inerciales que miden la segunda derivada de la posición. Un acelerómetro mide la fuerza de inercia generada cuando una masa es afectada por un cambio de velocidad. Esta fuerza puede variar la tensión de un muelle, deformar un elemento, o modificar la frecuencia de vibración de una masa. Los acelerómetros son direccionales, sólo miden la dirección en un eje. Para monitorear aceleración en tres dimensiones se emplean acelerómetros multi-ejes (ejes x, y, z), los cuales son ortogonales.



2.2. Principio básico de funcionamiento El principio básico de funcionamiento de los acelerómetros es la detección de la fuerza ejercida en una masa con limitación elástica.

Fig. 2.1: esquema básico del acelerómetro

Consideremos un sistema mecánico simple, que consiste en una masa fija m, con un muelle con una rigidez k (constante). Si la masa se desplaza una distancia x, la aceleración debido a la fuerza restauradora del muelle es F = k * x. Sustituyendo en la ecuación de Newton, encontramos que a = k*x/m y podemos derivar la magnitud de la aceleración observando el desplazamiento x de la masa fija.

Este principio fundamental se utiliza hasta en el más sofisticado y caro acelerómetro electromecánico, e incluso en modernos acelerómetros micromecanizados.

Veamos el modelo de un acelerómetro formado por masa y resorte, e incluyendo el ruido intrínseco debido al damping (disminución progresiva de la amplitud del movimiento del muelle).

Fig. 2.2: Modelo con masa y resorte elástico para un acelerómetro, con modelado del ruido

interno En la figura F representa la fuerza externa y Fn la fuerza del ruido equivalente al

ruido de Johnson en un resistor. La respuesta en velocidad de este sistema aplicando la transformada de Laplace sería:



nF Fdx sxdt ms b k s

+= =

+ + (2.1)

El desplazamiento característico de la fuerza resultante es:

2nF Fx

ms bs k+

=+ +

(2.2)

Este sistema tiene una frecuencia de resonancia ωo igual a k m y un factor de

calidad Q igual a mωo /b. Cuando se usa como acelerómetro, m es la masa de prueba y k la constante del

muelle. Un acelerómetro cuasi-estático es aquel en el que el movimiento de la masa de

prueba sigue la evolución en el tiempo de la fuerza inercial aplicada sin retardos o atenuaciones significativos. Por lo tanto, el acelerómetro se diseña para obtener frecuencias de resonancia mucho mayores que la máxima esperada en la componente de la señal de aceleración. En este caso, podemos usar la respuesta cuasi-estática:

nF Fxk+

= (2.3)

Examinemos en primer lugar el término de la señal. La fuerza inercial F es igual

a la masa de prueba m por la aceleración medida. Esto, junto con la definición de ωo, lleva a una de las características más importantes de los acelerómetros cuasi-estáticos: el desplazamiento y la aceleración son proporcionales al cuadrado de la frecuencia de resonancia:

20

axω

= (2.4)

Esta ecuación conlleva importantes implicaciones. La más obvia es que el factor

de escala depende sólo de la frecuencia de resonancia y no se ve afectada por la elección de una masa mayor y muelle poco flexible, o masa menor y un muelle más flexible. Sólo la razón interviene en la respuesta. La segunda implicación es que si se necesita fabricar un acelerómetro que responda rápidamente, por tanto tendrá una alta frecuencia de resonancia, entonces la amplitud de la señal de posición medida será pequeña. Por ejemplo, para un acelerómetro de 50 g (donde g es la aceleración de la gravedad) de la empresa Analog Devices, con una frecuencia de resonancia de 24.7 kHz, el máximo desplazamiento cuasi-estático de la masa de prueba es de 20 nm. De otro modo, si una frecuencia de resonancia de 1 kHz es admisible para la aplicación, el máximo desplazamiento llega a ser de 1.2 μm.

Consideremos ahora el ruido intrínseco debido al damping. La función de

densidad espectral del ruido es 4kBTb, exactamente igual al ruido de Jonson en un



resistor. Es conocido como ruido de movimiento Browniano, aunque de hecho, la forma de la función de densidad espectral no depende del mecanismo que produce el damping.

Lo normal es convertir esto en aceleración; lo hacemos en dos pasos. Primero,

hay que darse cuenta que en un ancho de banda de 1 Hz, la media del ruido es

04 Bk Tω . Para convertir esto en desplazamiento, dividimos por la constante del muelle k, y para convertir el desplazamiento en aceleración, multiplicamos por ωo

2. El resultado neto es que el ruido equivalente de la aceleración es:

0,

4 Bn rms

k TamQ

ω= (2.5)

Para un dispositivo con una frecuencia de resonancia de 24.7 kHz, una masa de

prueba de 2.2 x 10-10 kg, y un factor de calidad Q de 5, el ruido de aceleración rms sería 4.83x10-3 m/(sec2- Hz ), alrededor de 0.5mg/ Hz . Esto sugiere que es posible alcanzar grandes relaciones señal-ruido con acelerómetros.

En la práctica, la relación señal-ruido, y, por tanto, la sensibilidad de un

acelerómetro, se ve dominada por otros aspectos: la contribución al ruido del circuito encargado de medir la posición, especialmente en la primera etapa de amplificación; la necesidad de construir resortes adicionales en la estructura (incrementando su frecuencia de resonancia) para prevenir tanto el pegado de partes durante la fabricación como exceso de fragilidad; o errores de calibración y problemas de derivas.

Observando la ecuación en el dominio del tiempo se observa que la deformación

del resorte es aproximadamente proporcional a la aceleración. De esta forma, podemos medir la aceleración a partir de la deformación.

Igualmente podemos expresarlo con ecuaciones diferenciales. Partiendo de la

expresión de la segunda ley de Newton empleada en mecánica:

Bbk

=2

2 0rm Ft∂

− =∂

(2.6)

Y representando la fricción en el sistema como un pequeño amortiguador:



Fig. 2.3: representación sistema mecánico

Las ecuaciones quedarían:

2

2

x dxF m c kxt dt

∂= + +

∂ (2.7)

2.3. Clases de acelerómetros

Existen diferentes tipos de acelerómetros según la tecnología: mecánicos, capacitivos, piezoeléctricos, piezoresistivos y micromecanizados (MEMS).

2.3.1. Acelerómetros mecánicos Emplean una masa inerte y resortes elásticos. Los cambios se miden con galgas extensiométricos (matriz de bobinas o cable muy fino que varían sus resistencias linealmente en función de la carga aplicada al dispositivo), incluyendo sistemas de amortiguación que evitan la propia oscilación. También se emplean en sistemas rotativos desequilibrados que originan movimientos oscilatorios cuando están sometidos a aceleración (servoacelerómetros) o detectan el desplazamiento de una masa inerte mediante cambios en la transferencia de calor (acelerómetros térmicos).

2.3.2. Acelerómetros piezoeléctricos El principio de funcionamiento de estos acelerómetros se basa en las propiedades de los cristales piezoeléctricos. Al sufrir una deformación física el cristal, se modifica su estructura cristalina y así cambian también sus características eléctricas. Producen una corriente eléctrica al verse sometidos a la acción de una fuerza. Midiendo esta corriente podremos calcular la aceleración. Entre estos materiales se encuentran, por ejemplo, el cuarzo y la sal. El principal inconveniente radica en la frecuencia máxima de trabajo, no muy elevada, y en la incapacidad de mantener un nivel permanente de salida ante una entrada común.



Fig. 2.4: Sensor piezoeléctrico

En la siguiente figura se muestra el circuito equivalente para el acelerómetro piezoeléctrico indicando la sensibilidad del sistema a la aceleración en función de los parámetros del sistema:

Fig. 2.5: Circuito equivalente sensor piezoeléctrico

Actualmente podemos encontrar muchos tipos de acelerómetros según su

sensibilidad, frecuencia de uso, etc. Pero la principal distinción entre ellos viene dada por la incorporación o no de un amplificador de carga. Al incorporar una etapa amplificadora de carga tienen la ventaja que producen un valor de tensión proporcional a la excitación aplicada en la salida del amplificador, por tanto su comportamiento resulta independiente del conexionado exterior, puesto que carga y resistencia de entrada del amplificador se mantienen constantes siempre. A cambio, necesitan ser alimentados; de todas formas su empleo está muy extendido debido a sus ventajas y comodidad de uso.

Fig. 2.6: Sensor piezoeléctrico con etapa amplificadora

Los sensores que no incorporan dicha etapa amplificadora carecen de una salida tan cómoda precisamente porque sólo incorporan el sensor.



Fig. 2.7: Sensor piezoeléctrico sin etapa amplificadora

2.3.3. Acelerómetros piezoresistivos Su funcionamiento se basa en la propiedad de las resistencias eléctricas de cambiar su valor cuando el material se deforma mecánicamente. En lugar de tener un cristal piezoeléctrico, como los anteriores sensores, tienen sustrato formando parte de un circuito que mide la intensidad de corriente mediante un puente de Wheatstone. Según el tipo de material y su dopado, así variará el valor de la resistencia. La respuesta de frecuencia llega hasta los 0 Hz.

Fig. 2.8: sensor piezoresistivo

2.3.4. Acelerómetros capacitivos Estos dispositivos varían la posición relativa de las placas de un microcondensador cuando se encuentra sometido a aceleraciones. Están integrados en chips de silicio, que les proporcionan soluciones a diferentes tipos problemas, por ejemplo, cuestiones de humedad, temperatura, capacidades parásitas, número total de terminales, etc.). De todos los métodos existentes para realizar medidas de posición, la medida de los cambios en el valor de una capacidad es la más versátil. Algunos tipos de condensadores de empleo común:



Fig. 2.9: Variedad de estructuras de condensadores usados para medir posición

Estos sensores se encuentran formados por un conjunto de electrodos fijos (anclados al circuito) y una serie de placas unidas a la masa de prueba, que sólo están sujetas al sustrato por sus extremos de forma que tengan cierta libertad de movimiento. Con el siguiente dibujo lo vemos más claramente:

Fig. 2.10: Esquema de un sensor capacitivo

En reposo cada electrodo móvil se encuentra justo entre dos electrodos fijos, así todas las capacidades tienen el mismo valor. Al aplicar una fuerza externa, la masa central se moverá, desplazándose también los electrodos adheridos a ella y de manera que una de las capacidades aumente y la otra disminuya.



Fig. 2.11: Esquema exagerado del efecto que tendría una fuerza sobre el sensor

2.3.5. Acelerómetros micromecanizados (MEMS) Se denomina MEMS (MicroElectroMechanichal Systems) o microsistemas electromecánicos a una tecnología de base que se utiliza para crear dispositivos diminutos. Este tamaño puede oscilar en pocas micras pudiendo llegar hasta un milímetro de diámetro. Las primeras investigaciones con tecnología MEMS se realizaron en los años 60 pero no fue hasta los años 90 cuando se realizaron los primeros avances a lo que a comercialización y utilización se refieren. En este sentido la industria automovilística fue pionera. El fin era desarrollar e implementar detectores de colisiones mediante esta tecnología y de esta forma se pudo crear el famoso sistema de protección denominado “air bag” utilizado hoy en día en cualquier tipo de automóvil. En esta misma década otro tipo de industrias (de las que podemos destacar la médica entre todas ellas) vieron el potencial de la tecnología MEMS la cual permitía reducir de formar considerable las dimensiones de los sistemas como también el propio coste de los mismos.



Fig. 2.12: separación tecnología nanométrica con micrométrica

Para esta tecnología se utiliza un sistema de unidades reconocido a nivel internacional el denominado µMKSV. Este sistema de unidades esta formado por un conjunto sistemas de unidades ya conocidos, es decir, al integrar esta tecnología características eléctricas y mecánicas utiliza diferentes magnitudes de medida. Por tanto como unidad básica de medida de longitud tenemos el micrómetro de ahí la primera sigla “µM”, para las unidades de peso tenemos el kilogramo “K”, para las de tiempo el segundo “S” y para las unidades Eléctricas el voltio “V”. La fabricación de MEMS es muy compleja, a veces con cientos de diferentes medidas. Cada paso debe ser controlado por una docena o más de parámetros, como temperatura, presión y composición química. Una diferencia de cinco grados Celsius puede tener poco efecto en la producción



de chips de silicio, ya que sólo dependen de las propiedades eléctricas del material. MEMS, sin embargo, también tienen propiedades mecánicas. Una pequeña variación de cualquier parámetro en la fabricación en cualquier etapa podría alterar el rendimiento del producto final. Por lo general, estos mecanismos tienen un tamaño mayor al micrómetro (millonésima de metro) y menor al milímetro. Lo que los hace tan particulares es que, a estas escalas, el comportamiento físico que rige a las maquinas convencionales no siempre funciona como la intuición puede indicar. Efectivamente, el incremento en la relación entre la superficie y el volumen de las piezas de un MEMS hace que los efectos electrostáticos y térmicos predominen sobre la inercia o la masa térmica.

Fig. 2.13: chip de 2mm2, sensor MEMS de 400μm2, brazos de 1μm

Para fabricar las pequeñas piezas que conforman estas maquinas se utiliza una tecnología que, en esencia, es la misma que la empleada para la fabricación de los circuitos integrados. La posibilidad de “integrar” piezas móviles es lo que ha hecho posibles maquinas a escala nanométricas. Existen motores a vapor del tamaño de un grano de polen, engranajes y palancas cuyo tamaño de mide en diámetros atómicos, y hasta pequeños espejos montados sobre soportes móviles, con un tamaño mucho menor al diámetro de un cabello, capaces de enfocar o corregir una imagen.

2.4. Fabricación de MEMS

En principio estos dispositivos pueden fabricarse como cualquier tipo de semiconductor a partir de obleas de silicio o de vidrio, aunque existen métodos hoy en día mas avanzados de fabricación como son:

2.4.1. Micromaquinado de silicio de cuerpo Micromaquinado es la denominación del conjunto de técnicas usadas para

producir estructuras y partes móviles dentro de las MEMS. Existen tres técnicas básicas usadas para transferir o depositar patrones sobre la superficie de silicio estas son:



• Películas delgadas

Esta técnica consiste en el depósito o como su propio nombre indica la formación de películas muy delgadas de diferentes materiales sobre la oblea de silicio.

Estas películas pueden adquirir patrones geométricos usando técnicas fotolitográficas que serán explicadas más adelante. Los materiales que forman estas capas suelen ser silicio policristalino (poly), aluminio, nitruro de silicio y dióxido de silicio.

A continuación se muestra una serie de obleas creadas con silicio policristalino y vidrio:

Fig. 2.14: Obleas de silicio

• Grabado húmedo

Esta técnica consiste en la remoción de materiales mediante la inmersión de la

oblea en un compuesto químico que contiene el grabante. Los grabantes húmedos se conforman en dos categorías: isotrópicos y anisotrópicos.

El primero de estos grabantes se encarga de remover o mezclar el silicio a la misma velocidad en todas direcciones. Por el contrario los grabantes anisotrópicos atacan al silicio a diferentes velocidades en diferentes direcciones lo que nos permite tener un mayor control en el diseño geométrico y dimensional del patrón a transferir.

• Grabado Seco

La técnica de grabado seco mas conocida es la Reactive Ion Etching que consiste

en bombardear iónicamente los materiales a ser grabados.

2.4.2. Micromecanizado de silicio superficial

Esta técnica es utilizada en la realización de estructuras complejas y cuyas alturas no son demasiado elevadas dentro de esta tecnología. Las técnicas de grabado superficial se utilizan para la obtención de estructuras. Para ello deben crearse patrones sobre las películas que recubren la superficie de la oblea de silicio.



La creación de estas estructuras se basa en dos películas de diferentes materiales que conforman el bloque. La primera de ellas es la del material estructural, el material de la siguiente película se denomina de sacrificio. Ambos materiales son depositados mediante técnicas de grabado seco.

Finalmente el material de sacrificio (tal como indica su nombre) es removido o

sacrificado utilizado en este punto técnicas de grabado húmedo hasta obtener la estructura deseada.

2.4.3. Micromecanizado de silicio en volumen

El micromecanizado en volumen (bulk micromachining) es una técnica de substracción para la construcción de microestructuras a partir de la eliminación de parte del sustrato base, mediante el mecanizado de canales y carriles.

La tecnología de MEMS suele tener mecanizadas en volumen ambas caras de

una misma oblea o diversas obleas mecanizadas formando de esta forma una estructura mayor denominada multicapa.

Este proceso permite crear estructuras de mayor envergadura que las obtenidas

por mecanizado en superficie, permitiendo la creación y utilización de sensores de presión y acelerómetros. En la ilustración 2.15 se observan las diferentes partes que componen un acelerómetro creado con tecnología MEMS.

Fig. 2.15: estructura acelerómetro MEMS

Cabe decir que el empaquetado de estas estructuras creadas mediante bulk

micromachining es mucho más dificultoso que en el caso de las mecanizadas por superficie.

El primer paso de esta técnica consiste en transmitir el patrón sobre el sustrato (foto transmisión mediante luz) y posteriormente realizar ataques químicos anisotrópicos sobre el sustrato (típicamente obleas de silicio monocristalinas). Estos ataques químicos permiten crear cavidades profundas y verticales dentro del sustrato.



2.4.4. Fotolitografía

Esta técnica es básica para la definición de formas y realmente es la misma que la utilizada para la industria de la microelectrónica. La figura 2.16 muestra cada uno de los pasos a seguir mediante esta técnica.

Fig. 2.16: proceso de fotolitografía

Se trata de impresionar un motivo sobre la oblea con otro material. Para ello

primero se realiza un mascara (de cromo o de vidrio) con el patrón a realizar, posteriormente se recubre la oblea con una fotorresina ya sea positiva o negativa la elección depende de la mascara que hemos realizado y de sí la fotorresina es sensible o no a la luz ultravioleta.

Una vez recubierta la oblea se coloca la mascara sobre la misma y se hace incidir

sobre el conjunto luz ultravioleta. En el caso de la fotorresina positiva donde la luz ultravioleta incida (aperturas de la mascara) provocara la debilitación de la fotorresina, mientras que el resto de zonas quedaran intactas.

En caso de ser fotorresinas negativas en aquellas zonas donde no incida la luz

ultravioleta (zonas cerradas de la mascara) serán susceptibles de debilitación y eliminación del material.



2.4.5. Moldeado de Plástico (LIGA)

Es un acrónimo alemán y es usado para definir el proceso LIthographie, Galvanoformung y Abformung. La técnica fue desarrollada en los años 70 como método alternativo de producción de dispositivos con ranuras muy pequeñas.

Este proceso se basa, en la creación de moldes mediante la fotolitografía de

rayos X. El sustrato de la oblea se encuentra recubierto de una mascara sensible a los rayos X la cual nos permite imprimir el motivo a impresionar. El patrón obtenido se galvaniza con metal y finalmente a partir de esta última estructura se puede obtener el molde. Este molde puede ser rellenado con diferentes tipos de materiales (en nuestro caso Plástico) y obtener así la estructura MEM deseada con un coste relativamente más económico en su producción.

Otras ventajas son la mayor resolución lateral y la ausencia de efectos

difractivos y la inmunidad al polvo. Como contrapartida tenemos el elevado coste de fabricación del molde inicial.

2.4.6. Mecanizado por Electro Descarga (EDM)

Mecanizado por Electro Descarga (Electrical discharge Machining) es un método utilizado para metales pesados sobre los cuales las técnicas ya explicadas no son eficientes.

La técnica consiste en la eliminación del material (conductor) mediante

descargas de arco eléctrico. Estas descargas se realizan de forma repetida y muy rápida entre la herramienta de corte (electrodo) y el material, todo esto en presencia de un campo eléctrico energizado.

La única limitación de este método es que se deben utilizar materiales que sean

conductores de la electricidad, para poder crear el campo eléctrico entre el material y el electrodo, así de esta forma nos permite iniciar el conjunto de rafas eléctricas.

Sobre estos materiales se pueden realizar estructuras 3D realmente complejas que son difíciles y costas de conseguir mediante otras técnicas. Algunas de ellas se muestran en la ilustración 2.17.



Fig. 2.17: estructuras 3D

La principal diferencia que conlleva la fabricación especifica de MEMS es el

sacrificio de capas debajo de las estructuras mecánicas, de esta forma podemos crear características físicas en las obleas y con frecuencia a ambos lados de la misma.

Esta diferencia se ve claramente en el fabricado o procesamiento de obleas, es

decir, para este tipo específico de MEMS los grabados suelen ser más profundos y sobretodo más especializados, incluso nos permite llegar a fusionar varias obleas en una pila para crear un dispositivo multicapa de mayores dimensiones.

2.4.7. Proceso general de fabricación de MEMS

Fig. 2.18: proceso general de fabricación de MEMS



2.5. Aplicaciones de los acelerómetros La aceleración es una magnitud física fundamental, manifestada de muchas maneras (gravedad, vibración, actividad sísmica). La medición de la aceleración de forma continua, exacta y a bajo coste, abre numerosas aplicaciones para los acelerómetros. Los fabricantes de ordenadores portátiles, por ejemplo, constantemente buscan formas de hacer sus productos más seguros. Los elementos más dispuestos a dañarse son los dispositivos de almacenamiento masivo (con la consecuente pérdida de información), discos duros particularmente. El mecanismo que lee y escribe información a los discos flota sobre los discos; un movimiento repentino puede provocar fácilmente un problema, destruyéndose igualmente la información. Un acelerómetro puede detectar este movimiento y permitir contrarrestar los choques, salvando así la información. Similar aplicación podrían tener en el transporte de paquetes frágiles y delicados, en los que cualquier moviendo o golpe externo puede romper el contenido; prevenir estos golpes tal vez sea inevitable, pero así se podría saber con exactitud el momento en que se produjo y el porqué. Las aplicaciones militares incluyen sistemas de detonación para misiles y bombas. En este caso un acelerómetro forma parte del sistema difuso, la detección de impacto por la rápida desaceleración asociada. La continua variación de salida del acelerómetro sería rápidamente analizada, estableciendo el instante preciso en que la carga explosiva debe ser detonada y producir el daño máximo sobre el objetivo. También puede ser utilizado para monitorizar máquinas de salud, máquinas de rotación para mostrar las características de vibración; grietas o fatigas de las máquinas; monitorizando continuamente la vibración de una máquina es posible avisar de algún fallo inminente. Las aplicaciones varían según el tipo de máquina: aeronaves, sistemas de calentamiento, de ventilación y aire acondicionado. Este tipo de sensores es muy importante; la información de la aceleración sufrida por un objeto o parte de un robot es de vital importancia, ya que si se produce una aceleración en un objeto, este experimenta una fuerza que tiende a poner el objeto en movimiento. Los MEMS permiten cada día la creación de dispositivos sorprendentes. Por ejemplo, para evitar la falsificación de una firma, es posible incorporar acelerómetros en un bolígrafo o una pluma, para que además de escribir sea capaz de registrar las velocidades y aceleraciones que le imprimió la mano mientras se firmaba. Esto hace prácticamente imposible una falsificación. Veamos algunas de estas aplicaciones de manera algo más concreta:



Acelerómetros de baja frecuencia La medición en baja frecuencia es crítica en varias actividades industriales. Las industrias petroquímica, de máquinas de herramientas y de papel usan mediciones en baja frecuencia para monitorizar condiciones de funcionamiento y hacer mediciones de procesos.

Acelerómetros de alta frecuencia Los acelerómetros de alta frecuencia se utilizan en maquinaria con mecanismos de engranajes o pequeños rodamientos, tales como herramientas de alta velocidad o compresores.

Transductores sísmicos Combinan un acelerómetro piezoeléctrico súper sensible, un amplificador de ultra bajo ruido y un excelente aislamiento eléctrico/mecánico, son utilizados en baja frecuencia (menos de 100 Hz).

Acelerómetros submarinos Los acelerómetros subacuáticos son resistentes a la corrosión galvánica y son construidos para resistir las altas presiones propias de las profundidades.

Acelerómetros para helicópteros Un helicóptero, al fin y al cabo, es una aeronave con alas rotatorias. A diferencia de las aeronaves de ala fija, el rotor proporciona tanto la elevación como el desplazamiento. La empresa Wilcoxon fabrica sensores especialmente diseñados para monitorizar el correcto funcionamiento del helicóptero.

Acelerómetros 3D para ordenadores portátiles El sensor de aceleración 3D es un monitor de movimiento completo de 3 ejes capaz de detectar la caída libre en todas las direcciones con la misma intensidad. Esta capacidad de supervisión filtra con exactitud los pequeños movimientos de inclinación y detecta las vibraciones repentinas. Si se detecta una posible caída, se descarga el cabezal de la unidad de disco duro. En este proceso, el cabezal se aleja del soporte, lo que reduce la posibilidad de daños. Cuando el equipo portátil recupera la estabilidad, el cabezal vuelve a su posición normal.

El nivel de protección aumenta temporalmente 10 segundos después de que se produzcan acciones como cerrar la pantalla LCD o desconectar el aparato de CA, ya que se supone que se va a recoger en breve. La sensibilidad 3D también sube en cuanto aumenta el ángulo de inclinación.



Acelerometría dinámica En la valoración de los trastornos de movimiento en pacientes con enfermedades neurodegenerativas es esencial contar con un sistema que permita la descripción cuantitativa del movimiento en diversas condiciones. Una posible fuente de esta información es la acelerometría dinámica, basada en el uso de sensores capacitivos integrados del tipo MEMS, que detectan simultáneamente la posición espacial y el cambio de velocidad.

Ciertas familias de acelerómetros dinámicos, como la ADXL de Analog Devices, incluyen dispositivos de dos y tres ejes con salidas digitales en forma de pulsos cuadrados con modulación de anchura de pulso, donde el inicio del trabajo es proporcional a la aceleración detectada.

Otros ejemplos comerciales

• Nintendo Wii

Una de las consolas más revolucionarias de la historia de los videojuegos se basa en la utilización de un mando dotado de un acelerómetro que detecta los movimientos del usuario, dando una sensación de realismo al usuario que deja totalmente desfasado a los botones y joysticks.

Este acelerómetro en concreto es el ADXL330 de la empresa Analog Devices, elegido por su capacidad de capturar movimientos en tres dimensiones (acelerómetro triaxial), por su reducido tamaño (cabe en el mando de la consola) y por su bajo consumo, pues se alimenta con dos pequeñas pilas tipo AA.

• Crash test dummies

En los tests de accidente que se realizan a los automóviles se utilizan unos muñecos especiales que están diseñados para poder estudiar los daños que sufriría una persona normal, para ellos es vital saber la desaceleración a la que se somete el cuerpo en distintas partes. Aquí es donde entra en juego el uso de los acelerómetros.

Uno de los modelos de acelerómetro específicamente utilizados para esta tarea es fabricado por la empresa PCB Piezotronics, diseñado para medir impactos severos, puede medir una desaceleración de hasta 2000 G y de pequeño para poder ser insertado en cualquier parte del muñeco.

• Automoción

Los acelerómetros se utilizan ampliamente en la industria automovilística

hoy en día. Cualquier automóvil equipado con un control electrónico de tracción y estabilidad (EBTCM) se vale entre otros sensores de un acelerómetro que mide la aceleración lateral que sufre el vehículo.



El sistema lee la aceleración lateral, la posición del volante y la velocidad de las ruedas para calcular la reacción que debe dar el sistema para mantener la estabilidad del vehículo. Serían capaces de medir aceleraciones de -/+ 3G, y su resistencia a choques llega a ser de 20 000 G. Constan un sistema de detección de fallos constante, pues en este caso un fallo puede tener consecuencias fatales.

2.6. Principales fabricantes

2.6.1. Analog Devices Analog Devices (ADI) ha desarrollado una familia de acelerómetros capacitivos con superficie micromecanizada. Los dispositivos son monolíticos, constan de un único chip de silicio que contiene la masa de prueba, los resortes y toda la circuitería necesaria para implementar todas las funciones electrónicas requeridas para obtener una salida analógica proporcional a la aceleración. Posteriormente se ha mejorado la circuitería dando una salida digital.

Los acelerómetros de esta familia pueden ser utilizados en una gran variedad de aplicaciones de bajas g, entre ellas para mostrar la inclinación u orientación, vibración del sistema y detección de movimientos. Con el ADXL50, Analog Devices se convirtió en la primera compañía que fabricó en producción de alto volumen un acelerómetro para aplicaciones en automoción como son los sistemas de suspensión activos, cierre de puertas automática, sistema antibloqueo de frenos y airbag. Estos dispositivos tienen una estructura similar a los mostrados en la figura 2.10, con una importante diferencia: tienen también una región con electrodos semejantes pero conectados a un circuito capaz de aplicar una fuerza electrostática sobre la estructura, con propósito de prueba. Gracias a esta autocomprobación continua, se aseguran que el sistema funcionará en el instante necesario. La superficie micromecanizada es una técnica de procesamiento utilizada para fabricar estructuras mecánicas extremadamente pequeñas de silicio. En realidad, el movimiento del elemento micromecanizado en el acelerómetro es menor de 1 mm2. Utilizando los mismos pasos para hacer circuitos electrónicos convencionales, la superficie micromecanizada crea estructuras pequeñas que están cerca de la superficie del silicio, no obstante están libres para moverse.

La superficie micromecanizada no se debe confundir con el procesado del volumen micromecanizado utilizado para crear acelerómetros piezoresistivos que hay actualmente en el mercado.



Ancho de banda En estos sensores el límite de resolución viene delimitado por el ruido del ambiente y del propio acelerómetro. El nivel del ruido de floor varía directamente con el ancho de banda utilizado. El nivel de ruido en la salida de los sensores ADXL es directamente el valor de la raíz cuadrada del valor del ancho de banda seleccionado para cada sensor. El máximo valor de ruido de pico a pico que adquieren estos sensores es aproximadamente de 6’6 veces el valor del ruido en rms.

El valor del ancho de banda puede ser reducido a partir de la aplicación de técnicas de filtrado tanto paso banda como paso bajo; de esta manera se reduce en gran medida los valores de ruido.

Fig. 2.19: Nivel de ruido frente al ancho de banda para los modelos ADXL150, ADXL250

Como se observa en la figura, el ruido disminuye para valores de frecuencia bajos, mientras que aumenta para valores más elevados (relación lineal entre ruido y frecuencia). El ruido que resulta de todo este proceso es realmente pequeño ya que también aumenta con cada muestreo, pero lo hace a razón de la raíz cuadrada y, por tanto, la calidad señal-ruido resultante mediante esta técnica es superior, de ahí su utilización. Post filtrado El ancho de banda del acelerómetro puede ser reducido fácilmente mediante técnicas de post-filtrado, como se decía en el apartado anterior, aunque siempre dentro de un margen dado por el fabricante. En la siguiente figura se muestra cómo el buffer se conecta para proporcionar una etapa de filtrado, offset cero g y escalar la salida.



Fig. 2.20: Circuito con etapa de post-filtrado, factor de escala y cero g offset

El fabricante normalmente proporciona la fórmula que relaciona el ancho de banda con la capacidad que lo fija. En el caso puesto como ejemplo sería:

2.8)

Derivas del offset con la temperatura Al utilizar el sensor en corriente continua a cero g se apreciará una variación en las medidas referentes al ajuste del offset debido a las derivas de temperatura.

Cuando el acelerómetro mida valores de aceleración bajos (low g) entonces puede que se superen los márgenes de temperatura establecidos y por tanto para cero g podemos observar que la deriva referente a la temperatura exceda el valor del nivel de señal.

Para evitar las derivas térmicas en la medida de lo posible en aplicaciones de alta precisión (como inclinómetros especializados) se utiliza un horno de cristal de bajo coste con el fin de mantener el acelerómetro a una temperatura constante. Posteriormente el circuito es construido y su funcionamiento es del todo correcto.

Otra técnica utilizada para la compensación de derivas térmicas es la del uso de un sensor de temperatura mas conocido como AD590. Este sensor de temperatura elimina tanto las componentes lineales como no lineales de la deriva. Acoplamiento AC Si no se requiere una respuesta en continua (dc) puede utilizarse un acoplamiento en alterna entre la salida del acelerómetro y la entrada del amplificador operacional, como se indica en la figura:



Fig. 2.21: acoplamiento AC usando un op-amp externo

El uso de acoplamiento AC elimina virtualmente cualquier deriva a cero g y permite la máxima ganancia para el amplificador externo. El resistor R2 y la capacidad C3 juntos forman un filtro paso de alta cuya frecuencia de esquina es 1/(2 π R2 C3). Este filtro reduce la señal del acelerómetro 3 dB a la frecuencia de esquina, y continuará reduciéndola a n ritmo de 6 dB por octava (20 dB/década) para señales por debajo de la frecuencia de esquina. Si se está empleando el acoplamiento AC, la característica de autotestado de estos sensores será monitorizada a la salida del acelerómetro, y no a la salida del amplificador externo. Analog Devices tiene un gran número de modelos de uno, dos y hasta tres ejes por medio de los cuales se puede medir aceleración. A continuación pasamos a describir detalladamente algunos de los modelos de Analog Devices de los que nos hemos servido en este proyecto y sus características principales. Sensores ADXL de dos ejes

ADXL203 El ADXL203 es un sensor de aceleración capacitivo de dos ejes (X e Y) creado

sobre un único circuito integrado. Ambas salidas del sensor son tensiones analógicas proporcionales a la aceleración medida.

Este acelerómetro tiene unas dimensiones de 5 mm x 5 mm x 2 mm y una resolución de 1 mg (0.06º de inclinación) a 60 Hz. El margen de medida de aceleración de este sensor es de ±1.7 g es decir, tanto positivas como negativas. Mediante técnicas de demodulación que incorpora este acelerómetro podemos rectificar la señal medida y determinar la dirección de la aceleración.



Fig. 2.22: diagrama de bloques del ADXL203

La salida (una vez demodulada) es amplificada y extraída fuera del mismo por medio de una resistencia de 32kΩ. Es justo en este punto donde se puede fijar el valor del ancho de banda (BW) para cada eje mediante la utilización de una capacidad en cada uno de las resistencias de la salida (XOUT e YOUT).

El valor del ancho de banda será como máximo de 2.5 kHz para este dispositivo

implicando que la capacidad utilizada para obtener este valor de frecuencia será de 2000pF. Para obtener el resto de valores comprendidos entre 1 Hz y 2.5 kHz para cada salida Xout e Yout, tenemos la siguiente ecuación:

BW = 5µF / (CX ,CY ) (2.9) Donde → 5µF = 1 / (2 π 32kΩ) (2.10)

El ancho de banda nos da el valor mínimo de resolución de aceleración que puede detectar el dispositivo.

Los valores de alimentación de este sensor son de 3V (mínimo) y 6V (máximo). Al ser una salida radio métrica tendremos que el valor de tensión correspondiente en la salida para cero g de aceleración, será la mitad de valor escogido para alimentar el sensor. Para un valor de 3V de alimentación tendremos un valor de consumo corriente de 450µA.

La sensibilidad, cuando el dispositivo está totalmente perpendicular a las fuerzas

de gravitación, es de 17.5 mg, mientras que si se encuentra inclinado 45º con respecto a estas fuerzas su sensibilidad disminuye hasta los 12.2 mg y, por consiguiente, también se ve reducida su resolución.

Para una colocación óptima de ambos ejes (perpendiculares a la gravedad)

tendremos que los valores de las salidas, tanto XOUT e YOUT, serán de Vcc/2, es decir, 2.5 V.



El margen de temperatura que permite el correcto funcionamiento del sistema es para una alimentación de 5V de –40 ºC a +125 ºC.

ADXL320

El ADXL320 es un sensor de aceleración capacitivo de dos ejes (X e Y) creado

sobre un único circuito integrado. Ambas salidas del sensor son tensiones analógicas proporcionales a la aceleración medida.


Este acelerómetro tiene unas dimensiones de 4 mm x 4 mm x 1,45 mm y con una

resolución de 2 mg (0.1º de inclinación) a 60 Hz. El margen de medida de aceleración de este sensor es de ±5g. Es utilizado como sensor de bajo coste. Los bloques que forman el acelerómetro ADXL320 son idénticos a los expuestos en el acelerómetro ADXL203. El valor del ancho de banda será como máximo de 2.5 kHz para este sensor hecho que implica que la capacidad utilizada para obtener este valor de frecuencia será de 2000pF. El resto de valores comprendidos entre 1Hz – 2.5 KHz viene dados por:

BW = 5µF / (CX ,CY ) (2.11) donde → 5µF = 1 / (2 π 32kΩ) (2.12) El margen de valores de alimentación se encuentra entre los 2.4V de valor

mínimo y los 5.25V de valor máximo. Para una alimentación de 2.4V tendremos un valor de consumo corriente de 350µA y a 5V tendremos un consumo de 750µA.

La sensibilidad de las salidas de este dispositivo oscilan entre los valores de 156

mV / g a 192 mV / g y como valor típico a una alimentación de 3 V es de 174 mV / g.

Para una colocación óptima de ambos ejes (perpendiculares a la gravedad) tendremos que los valores de las salidas a cero g, tanto XOUT e YOUT, serán de Vcc/2, es decir, 1.5 V.



Los valores mínimo y máximo serán, 1.326 V y 1.674 V, aunque las

especificaciones aproximan estos datos a 1.3 V y 1.7 V. El margen de temperatura que permite el correcto funcionamiento del sistema es,

para una alimentación de 3V, de –20 ºC a +70 ºC.

ADXL311 El ADXL311 es un sensor de aceleración capacitivo de dos ejes (X e Y) creado sobre un único circuito integrado. Las salidas de este sensor son de tipo analógicas.

Este acelerómetro tiene unas dimensiones de 5 mm x 5 mm x 2 mm y con una resolución de 2 mg (0.1º) a 10 Hz. Su margen de medida de ±2 g. Al igual que para el ADXL203 el cálculo del ancho de banda se realiza de la misma forma para cada eje.

Fig. 2.24: Diagrama de bloques del ADXL311

El valor del ancho de banda será como máximo de 3 kHz hecho que implica que la capacidad utilizada para obtener este valor de frecuencia será de 1.6nF. Según la siguiente ecuación, podemos obtener el resto de valores entre 1 Hz y 3 KHz para cada salida XOUT e YOUT.

BW = 5µF / (CX ,CY ) (2.13) donde → 5µF = 1 / (2 π 32kΩ) (2.14)

El ancho de banda nos da el valor mínimo de resolución de aceleración que puede detectar el dispositivo.



Los valores de alimentación de este sensor son de 2,4 V (mínimo) y 5,25 V (máximo). Al ser una salida radiométrica tendremos que el valor de tensión correspondiente a la salida para “0 g” de aceleración será la mitad de valor escogido de alimentación. Para el valor de 5V de alimentación tendremos un valor de consumo corriente de 750µA.

La sensibilidad de este dispositivo es para una tensión de 3V de 174 mV/g, mientras que para una tensión de alimentación de 5V su sensibilidad es de 312 mV/g. Al igual que para el ADXL203 tenemos que en función de la colocación del sensor, una mayor o menor sensibilidad y este caso coincide exactamente al caso anterior.

El margen de temperatura que permite el correcto funcionamiento del sistema es,

para una alimentación de 3V, de 0 ºC a +70 ºC. Actualmente ha sido sustituido por el ADXL320, Analog Devices lo ha descatalogado y ya no se vende comercialmente.

Sensores de tres ejes Analog Devices también proporciona en un único integrado acelerómetros con

tres salidas o con tres ejes de funcionamiento. Para ello estos sensores utilizan la ubicación por orientación tridimensional 3D.

Al igual que para el caso de dos ejes contra mas perpendicular se encuentre el eje con respecto a la fuerza gravitacional (cualquiera que sea de los tres) mayor será su sensibilidad y por tanto mayor valor tendrá en la salida.

ADXL330 La mayoría de características físicas son idénticas al sensor ADXL320. El ancho

de banda es de 1,6 KHz para los ejes X e Y. Los valores de alimentación de este sensor son de cómo mínimo 2V y como máximo 3,6V. Al ser una salida radiométrica tendremos que el valor de tensión correspondiente a la salida para cero g de aceleración será la mitad de valor escogido de alimentación.

Para el valor de 3.6V de alimentación tendremos un valor de consumo corriente

máximo será de 375µA.




2.6.2. Acelerómetros ENTRAN

Los acelerómetros de la familia ENTRAN basan su funcionamiento en la tecnología de fabricación piezorresistiva, por tanto su fabricación es realmente sencilla y barata. Estos sensores se encuentran en una gran variedad de tamaños formas y estilos para satisfacer diferentes necesidades.

Los acelerómetros ENTRAN se han clasificado en seis grandes familias debido al gran número de modelos existentes teniendo en cuenta características comunes de los mismos.

Este tipo de sensores tienen un tamaño y peso mínimos y una alta sensibilidad. Destacan por su robustez y por su utilización en ambientes realmente hostiles como puede ser la industria aeroespacial.

Las principales aplicaciones de estos sensores son los ensayos para automóviles,

de vuelos y de control, industria ferroviaria y test de túneles de viento, además de la ya comentada industria aeroespacial.

2.6.3. Acelerómetros METRA

Los acelerómetros de la serie METRA funcionan a partir de la tecnología piezoeléctrica. Estos acelerómetros son fabricados de tres formas claramente diferenciadas por flexión, compresión y tijera.

Pueden alcanzar sensibilidades de hasta 3000 mV/g. Otro dato de relevancia

sería su frecuencia de resonancia donde el margen para estos sensores se encuentra entre



los 350 Hz hasta los 110 kHz. Los márgenes de aceleración de estos sensores están comprendidos hasta los 20000 g.

Las principales aplicaciones de estos acelerómetros se encuentran en medidas de

vibración, análisis modal, control predictivo en máquinas, ensayos en estructuras, aplicaciones médicas y control de ruido. Tipos de fabricación

• Por flexión (bender)

La utilización de acelerómetros creados a partir del método de flexión tiene como ventaja principal la elevada relación sensibilidad / masa, respecto a los otros métodos de fabricación. Por el contrario estos dispositivos son extremadamente frágiles y a elevadas temperaturas puede verse afectada la sensibilidad del sensor. Su principal utilización es en medidas de aceleración extremadamente bajas para pocas g de aceleración (inferiores a 10g).

• Por tijera (shear)

El método de fabricación Shear permite obtener acelerómetros cuya sensibilidad no se ve afectada en gran medida por la temperatura. La desventaja principal del este tipo de dispositivos es la no tan buena relación sensibilidad / masa.

• Por compresión (compression)

Mediante este método cuyas siglas son KD obtenemos acelerómetros con una alta relación sensibilidad/masa, robustos y tecnológicamente avanzados. Además son extremadamente variables o sensibles a los transitorios provocados por la temperatura. Otra desventaja es la variación con los cambios de tensión.

2.6.4. Acelerómetros SEIKA Empresa alemana fabricante de sensores y de integrados de alta precisión como inclinómetros y acelerómetros así como módulos específicos de medida.

Los sensores de la empresa SEIKA han sido desarrollados mediante tecnología capacitiva. Estos acelerómetros son de bajo coste con o sin electrónica incorporada. Sus márgenes de trabajo para la aceleración son entre 0 y ±3 g hasta 0 y ±100 g y su ancho de banda oscila entre los márgenes de 0 a 160 Hz y de 10 a 1500 Hz. Pueden alcanzar resoluciones de hasta 0,001 g.

Las principales aplicaciones de estos acelerómetros se encuentran en la industria, en sistemas de seguridad y de alarma, mediciones sísmicas, medidas de inclinación, etc.



2.6.5. Acelerómetros WILCOXON RESEARCH Caracterizada por fabricar acelerómetros para aplicaciones industriales, en Wilcoxon podemos encontrar robustos acelerómetros fabricados en acero inoxidable, con protección frente a emisiones RFI, ESD y EMI, aislamiento contra bucles de tierra, sellados herméticamente y, en definitiva, totalmente preparados para ser colocados en puntos inaccesibles con otro tipo de sensores. Sus principales aplicaciones se encuentran en industrias química, alimentaria, generación de energía eléctrica o industrias de proceso como plantas papeleras. Algunos de estos acelerómetros son puestos como ejemplo a continuación:

Fig. 2.26: WR784A Fig. 2.27: WR993B-7 La figura de la derecha nos muestra el acelerómetro WR784A, que lleva un conector cuyas especificaciones se ajustan a la norma militar MIL-C-5015. En la figura de la izquierda podemos ver un acelerómetro con un cable integral con revestimiento de teflón, que hace que el conjunto tenga una calificación IP68, muy útil para aplicaciones bajo el agua.

2.7. Criterios para la elección del acelerómetro adecuado En el mercado existen muchas posibilidades de sensores para medir la aceleración. La elección de uno de ellos depende de las características del sensor: los márgenes de valores de la aceleración que admite, capacidad para medir en continua o sólo en alterna, la máxima frecuencia a la que puede trabajar, los parámetros característicos del sensor, tales como márgenes de temperatura, sensibilidad, consumo, peso y precio… Comentemos con mayor detalle las principales de estas características: Sensibilidad La sensibilidad de los acelerómetros permite saber la cantidad de medida que percibe el sensor en función de la magnitud física que se aplica sobre el dispositivo. En



otras palabras, cuánto valor de tensión tendremos en función de la aceleración soportada por el acelerómetro. Las unidades que se utilizan y que los fabricantes nos facilitan son: mV / g. Ancho de banda

Para elegir el ancho de banda ideal debemos tener en cuenta diferentes hipótesis, la primera de ellas sería la necesidad de un gran ancho de banda, esto implica que la velocidad del dispositivo será mayor al captar datos ya que lo hará con más frecuencia. Por otro lado nos interesa que el ancho de banda sea a su vez lo más pequeño posible de esta forma la señal será más pura, contendrá menos errores y más ruido eliminaremos. En este punto deberá llegarse a un compromiso entre la velocidad del sistema y el nivel de ruido que deseamos tener.

Densidad de ruido y no linealidad Otro parámetro fundamental será la densidad del nivel de ruido que dependerá claramente del ancho de banda elegido. Este parámetro influirá claramente en la calidad de la señal obtenida y por tanto se debe intentar reducir al máximo posible siempre que se pueda. Alimentación y consumo de corriente Este factor en general suele desearse lo más bajo posible, aunque en ocasiones no es muy necesario. Por ejemplo, en caso de ser empleados en un automóvil, no importa demasiado porque siempre va a tener la alimentación que necesite. Igual ocurre con el peso del sensor, en función del dispositivo o maquinaria donde vaya a ser utilizado importará más o menos este detalle.


CAPÍTULO 3

DESARROLLO DEL

PROGRAMA DE SIMULACIÓN

Estudio de modelos de acelerómetros Desarrollo de la simulación


3. Desarrollo del programa de simulación

3.1. Matlab como herramienta principal MATLAB es un programa desarrollado para realizar cálculos numéricos con vectores y matrices, de hecho es el nombre abreviado de “MATrix LABoratory”. Una de las capacidades más atractivas es la de realizar una amplia variedad de gráficos en dos y tres dimensiones.

MATLAB es un gran programa de cálculo técnico y científico, que tiene su propio lenguaje de programación. Dicho lenguaje, es una herramienta de alto nivel para desarrollar aplicaciones técnicas fáciles de utilizar. Simulink es una herramienta software contenida en Matlab para el modelado, simulación y análisis de sistemas dinámicos. Soporta sistemas lineales y no lineales, en tiempo continuo, muestreo, e incluso una mezcla de ambos. GUIDE es un entorno de programación visual disponible en MATLAB para realizar y ejecutar programas que necesiten ingreso continuo de datos. Tiene las características básicas de todos los programas visuales como Visual Basic o Visual C++. En nuestro programa aprovechamos la posibilidad que ofrece MATLAB de desarrollar una interfaz gráfica, para que así un usuario pueda introducir los datos de diseño necesarios y el programa sea capaz de realizar una simulación de acuerdo a una serie de entradas. Los resultados se presentan en gráficas agregadas a la interfaz. La capacidad de cálculo y tratamiento numérico de MATLAB han sido determinantes en la elección de la plataforma para la implementación de este programa. Otros programas visuales carecen de esta capacidad de cálculo, aunque tengan otras virtudes.

3.2. Descripción del funcionamiento

El acelerómetro elegido para nuestro proyecto es el modelo de Analog Devices ADXL311. Este es un acelerómetro de carácter comercial, cuyas características, ya comentadas con detalle en el capítulo 2.6.1, permiten cumplir con gran número de especificaciones. A grandes rasgos, podemos decir que este acelerómetro de doble eje tiene un bajo consumo de potencia, alta resolución, ancho de banda ajustable con una simple capacidad y alta resistencia a choques.

El fabricante nos proporciona, a través de su página web, el modelo de Simulink del acelerómetro ADXL311. Simulink es una de las herramientas fundamentales en nuestro proyecto.



Simulink proporciona un entorno gráfico al usuario que facilita enormemente el análisis, diseño y simulación de sistemas dinámicos (de control, electrónicos, etc.), al incluir una serie de rutinas que resuelven los cálculos matemáticos de fondo, junto con una sencilla interfaz para su uso. Proporciona un entorno de usuario gráfico que permite dibujar sistemas como diagramas de bloques tal y como se haría sobre un papel, y gracias a él podemos ver qué ocurre con nuestro sistema en todo momento y ante cualquier evento que podamos diseñar. El conjunto de componentes incluidos junto al programa Simulink, incluye bibliotecas de fuentes de señal, dispositivos de presentación de datos, sistemas lineales y no lineales, conectores y funciones matemáticas. En caso de que sea necesario, el usuario puede crear nuevos bloques a medida.



Fig.3.1: Biblioteca de Simulink

El programa Simulink se inicia desde el botón “Simulink Library Browser” (Biblioteca de Simulink, como se ve en la figura 3.1), desde la ventana de comandos de Matlab mediante la orden simulink, o con el icono de la barra de herramientas .



El archivo que nos proporciona Analog Devices se muestra en la página siguiente; dado su tamaño, se ha preferido incluirlo en una página para que pueda apreciarse sin problemas.

Podemos observar los bloques correspondientes a los ejes x e y, completamente simétricos. A la entrada de cada cadena de bloques se suman las contribuciones de la aceleración de cada componente; a continuación se multiplica por una ganancia (para ajustar la sensibilidad), hay una limitación de tensión, el aporte de un ruido blanco (limitado en banda), filtros de demodulación, otro bloque para la ganancia que añade el amplificador DC y el filtrado de este mismo.

Con este archivo, Matlab es capaz de realizar una simulación del

comportamiento de este acelerómetro ante las entradas que se lo soliciten. En este diseño se van a proponer los tres ejemplos más comúnmente utilizados como señales de entrada: impulso, escalón y senoide.

En él se pueden observar dos partes simétricas, totalmente idénticas,

correspondientes a los ejes x e y de medida del acelerómetro.

Fig. 3.2: bloques correspondientes al eje x del ADXL311

Fig. 3.3: bloques correspondientes al eje y del ADXL311



Podemos observar cómo a la entrada recibe la aceleración expresada en g y pasa por el bloque que refleja el modelo mecánico del acelerómetro ilustrado en la figura 2.2.

Fig. 3.4: parte correspondiente al modelo mecánico del acelerómetro

A continuación vemos cómo se modelan las contribuciones de la aceleración medida en cada eje y su efecto en los demás ejes:

Fig. 3.5: contribución de cada eje en los demás

Por último tenemos el grupo de bloques necesarios para adaptar la señal a la salida:

Fig. 3.6: adaptación de la señal



GUIDE (Graphical User Interface Development Environment) es un juego de herramientas soportado por MATLAB, diseñadas para crear GUIs (Graphical User Interfaces) facilitando el diseño y presentación de los controles de la interfaz. GUIDE está diseñado para hacer menos tedioso el proceso de aplicación de la interfaz gráfica y obviamente para trabajar como herramienta de trazado de GUIs. Entre sus poderosos componentes esta el editor de propiedades (property editor), disponible en cualquier momento.

Fig. 3.7: Aspecto de una GUI en blanco

La figura 3.2 nos muestra el aspecto de una GUI lista para ser diseñada. En la parte izquierda de la pantalla se ubica la Paleta de Componentes, con todas las clases y tipos de botones, cuadros de texto, ejes para gráficas, menús, barras de desplazamiento y otros componentes que nos permite emplear.

Una aplicación GUIDE consta de dos archivos: .m y .fig. El archivo .m contiene el código con toda la programación de la interfaz y el archivo .fig contiene los elementos gráficos.

Cada componente de la interfaz (ya sea botón, menú, u otro) y la interfaz misma,

tiene una función asociada en el archivo .m. Estas funciones son denominadas callbacks, y controlan la interfaz o el comportamiento de sus componentes realizando una acción determinada como respuesta a un evento en ese componente. Cada vez que



se adiciona un nuevo elemento en la interfaz gráfica, se genera automáticamente código en el archivo .m.

GUIDE define unas directrices en cuanto a la sintaxis de los callback y sus

argumentos. Pongamos un ejemplo de esta sintaxis, con el callback correspondiente a un push button:

% --- Executes on button press in pushbutton1 function pushbutton1_Callback(hObject, eventdata, handles) % hObject handle to pushbutton1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)

La primera línea describe el evento que hace que se ejecute este callback; a continuación está la declaración de la función, con su nombre y argumentos. Por defecto, el nombre asignado es el tipo de componente (push button en este caso) y el número de orden en que fue añadido a la interfaz. Por supuesto, el nombre del callback se puede modificar para que sea más fácil su identificación, y darle un nombre más acorde con su función; esto se lleva a cabo con el parámetro Tag del inspector de propiedades de la interfaz. El inspector de propiedades permite modificar las propiedades más usadas de cada objeto o componente, tales como ajustar su posición en la interfaz, colores, tipo y tamaño de fuente, y muchos otros, como se observa en la figura 3.3. Las siguientes líneas del ejemplo nos ofrecen unos comentarios acerca de los manejadores de la interfaz y una orden reservada para futuras versiones de Matlab. Estos manejadores son una parte fundamental en el funcionamiento de la GUI. GUIDE crea una estructura de manejadores (handles) que contienen los manejadores de todos los objetos de la interfaz. GUIDE crea y conserva esta estructura como datos de la GUI. Cada callback recibe como argumento la estructura completa de la interfaz; de esta forma se hace posible que cada función comparta los valores de otros objetos. Para ello es necesario guardar los datos de la estructura al final de cada callback, con la instrucción guidata. Con hObject se tiene el manejador de cada objeto, es decir, el componente para el cual el callback ha sido llamado. GUIDE se inicia tecleando guide en la ventana de comandos de Matlab o haciendo clic sobre el icono de la barra de herramientas.



Fig. 3.8: Inspector de propiedades

Con una GUI, el flujo de cómputo está controlado por las acciones en la interfaz. Mientras que en un guión el flujo de operaciones está predeterminado, con una GUI no lo está. Los comandos para crear una interfaz con el usuario se escriben en un guión, la



interfaz invoca el guión que se ejecute, mientras la interfaz del usuario permanece en la pantalla aunque no se haya completado la ejecución del guión.

En la figura 3.4 se muestra el concepto básico de la operación del software con

una GUI. Cuando se interactúa con un control, el programa registra el valor de esa opción y ejecuta los comandos prescritos en la cadena de invocación. Los menús de interfaz con el usuario, los botones, los menús desplegables, los controladores deslizantes y los cuadros de texto (para introducir datos desde teclado) son dispositivos que controlan las operaciones del software. Al completarse la ejecución de las instrucciones de la cadena de invocación, el control vuelve a la interfaz para que puedan elegirse otra opción del menú. Este ciclo se repite hasta que se cierra la GUI.

Cada control guarda un string que describe la acción a realizar cuando se invoca;

puede consistir en un sólo comando de MATLAB o una secuencia de comandos o en una llamada a una función. Es recomendable utilizar llamadas a funciones, sobre todo cuando se requieren de más de unos cuantos comandos en la invocación.

Fig. 3.9: Diagrama de flujo de operaciones de una GUI

Toda la simulación se realiza de forma transparente al usuario. No es necesario

abrir el archivo de Simulink, ni modificar parámetros manualmente sobre el mismo. Todo esto se hace sin que el usuario se entere, gracias a la programación de la interfaz gráfica.

Una vez programada la interfaz, simplemente tenemos que ejecutarla y, tras

indicarle algunos datos sobre el diseño que deseamos simular, el programa se encarga de hacerlo todo y mostrarnos los resultados.



Para ejecutar una interfaz gráfica, si la hemos nombrado curso.fig, por ejemplo, simplemente ejecutamos en la ventana de comandos >> curso. O haciendo click derecho en el fig-file y seleccionando la opción RUN. El aspecto que presenta es el siguiente:

Fig. 3.10: interfaz para introducir parámetros de diseño del acelerómetro

Como podemos observar, consta de diversos botones y cuadros de texto en los que podremos introducir las dimensiones de diseño que deseemos simular, y un panel con las tres entradas más típicas ante las que comprobar el funcionamiento del programa: un impulso, una función escalón y una senoide. Para cada una de ellas podemos definir su amplitud y, en el caso de la senoide, también la frecuencia. Los cuadros de texto situados a la izquierda nos permiten introducir las dimensiones de la viga objeto de estudio. En la esquina inferior izquierda hay un esquema indicativo de estas dimensiones. Nos muestra la dirección de cada una de las tres dimensiones que queremos diseñar. En el centro disponemos del mencionado panel con las entradas impulso, escalón y senoide, y sus correspondientes cuadros de texto para introducir los valores de las amplitudes y frecuencia, esta última sólo en el caso de la senoide. Disponemos de una serie de botones que nos permiten realizar la simulación, resetear la interfaz (esto es, los datos introducidos por el usuario y los cálculos) o, simplemente, salir de ella.



A la derecha hemos diseñado unos ejes donde aparecerán las gráficas resultadas de la simulación, la entrada arriba y la salida en los ejes inferiores. Como resultado de presionar el botón “Simulación”, además de ver las gráficas comentadas, también se calcula el valor de la masa del conjunto y la constante de amortiguación, que aparece justo encima del esquema de la viga. Para llevar a cabo todo esto, hacemos uso de fórmulas matemáticas que nos proporcionan el valor de la masa y la constante elástica a partir de las dimensiones del dispositivo. La constante k la obtenemos directamente gracias a la expresión:

4 3

3( )[ ]6 2

EWHkL

π= [N/m] (3.1)

Debido a las dos vigas que sostienen la estructura, el valor de la constante k hay que multiplicarla por 2. Así, quedaría:

4 3

3( )[ ]3 2

EWHkL

π= [N/m] (3.2)

Para hallar la masa debemos hacer un cálculo previo del volumen de la estructura, y luego multiplicarlo por la densidad volumétrica del material con el que vayamos a construir el acelerómetro. Realmente, puede decirse que la parte más compleja o, al menos, la menos directa a la hora de calcular estos parámetros, ha sido el cálculo del volumen. Para poder hacer una estimación del volumen de la estructura nos hemos basado en las especificaciones de otros acelerómetros ya existentes y en un modelo real del ADXL311, y finalmente se ha conseguido una aproximación, no un dato exacto. El valor final del volumen queda determinado por: [( ) (4 )]V nWL WL H= + [μm3] (3.3) Y la masa nos la da la siguiente fórmula: m Vρ= [kg] (3.4) Al introducir los valores desde teclado, el programa espera datos numéricos, pues se trata de dar dimensiones (en micras) y valores de amplitud y frecuencia (voltios y Hertzios). Si en estos datos se detecta algún error, el programa para los cálculos y la simulación y muestra un mensaje de error por pantalla, invitando al usuario a escribir los datos correctamente. Como comentábamos un poco más arriba, el usuario sólo ve los resultados de todo este proceso; simplemente se limita a introducir las medidas básicas del diseño que



desea y el programa se encarga de mostrarle los resultados de una forma limpia y sencilla. No es necesario abrir el modelo en Simulink, el cual puede resultar complejo de entender en un principio, ni preocuparse por modificar los valores del modelo para adaptarlos a su diseño. Este es el funcionamiento básico de nuestra interfaz gráfica. En el siguiente apartado trataremos de explicar de forma detallada el proceso de programación de la misma, intentando que quede perfectamente claro todo lo relativo a su funcionamiento y modo de operar.

3.3. Desarrollo del programa de simulación

3.3.1. Modelo en Simulink La idea de este programa es que el usuario introduzca las dimensiones fundamentales del diseño que desee simular y el programa muestre los resultados por pantalla. Gracias al modelo que proporciona el fabricante en su página web es posible realizar esta simulación de manera cómoda y, con la programación que hemos llevado a cabo en este proyecto, conseguimos que todo tenga lugar de manera transparente al usuario. Sin embargo, el modelo de Simulink que nos facilita el fabricante en su página prácticamente no lo modificamos. En las primeras pruebas hechas con él, comprobamos que la mayoría de los parámetros no afectan a la simulación. Una vez que se tienen las entradas de ambos ejes, la cadena de bloques que controlan ganancias, filtros RC y de demodulación, ruido y demás componentes de la señal, no varía la salida de modo apreciable. Esto reduce en gran medida el trabajo en cuanto al modelo en Simulink, ya que los bloques verdaderamente importantes son los que modelan la señal de entrada. La función de transferencia para los ejes x e y van a definir la salida del acelerómetro. En esta función de transferencia el denominador viene gobernado por las constantes a y b, así que nos centramos en adecuar estas constantes a nuestro modelo. El usuario debe aportar las medidas W, L y H del acelerómetro, cuya dirección en el espacio se muestra en la siguiente figura:



Fig. 3.11: esquema del acelerómetro y las dimensiones de diseño

En nuestro programa partimos de estas medidas y obtenemos los valores de la masa y la constante de amortiguamiento de la estructura. El objetivo ahora es descubrir la relación entre la masa y la constante k y estas dos constantes de la función de transferencia. Una vez conseguido, serán modificadas por el programa de forma totalmente transparente al usuario, que sólo verá los resultados.

3.3.2. Programación de la GUI Antes de pasar a comentar todas las funciones necesarias para llevar a cabo la programación de la simulación, exponemos el diagrama de flujo del programa completo.



Introducción de datos por el usuario

Llamada a Simulink mediante el botón

‘Simulación’

¿Formato de los datos correcto?

No

Sí

- Cálculo ‘m’ y ‘k’- Matriz de simulación

- Representación gráficas entrada y salida

Llamada a la interfaz desde Command

Windows de Matlab

Esperamos datos

¿Guardar los datos?

Guarda la matriz generadora de gráficas

en ‘file1.mat’

Sí

No

Sí

A B C



¿Reset?

Cerrar interfaz

Limpiamos los recuadros

¿Salir de la aplicación?

No

No

Sí

Sí

No

A B C

Fig. 3.12: diagrama de flujo del programa de simulación Función de apertura Denominada por GUIDE como nombredelprograma_OpeningFcn, es el primer callback en todos los archivos .m de las GUI. Se ejecuta justo antes de que la interfaz sea visible por el usuario, pero después de que se hayan creado todos los componentes. Se emplea para realizar tareas que necesitan ser hechas antes de que el usuario tenga acceso a la GUI. Esta función no tiene argumentos de salida, y como argumentos de entrada tiene la estructura de los manejadores, el manejador de la figura, evendata (para su empleo en futuras versiones de Matlab) y una variable con el número de argumentos de entrada. La imagen en nuestra interfaz de la viga es un ejemplo de todo esto. Necesita llevarse a cabo antes que el usuario pueda interaccionar con la interfaz, puesto que la queremos siempre ahí como guía de las dimensiones del dispositivo. Previamente hemos dibujado la viga con los electrodos e indicado la dirección de cada una de sus dimensiones, lo único que resta por hacer es cargarla en el programa. Para esto nos servimos de las funciones imread y imshow. La primera lee la imagen del



directorio de trabajo y la almacena en una variable que nosotros hemos llamado figura, y luego de especificar dónde queremos ubicarla, imshow hace que se muestre por pantalla. En esta función también introducimos código necesario para que la interfaz aparezca centrada en la pantalla.

Cuadros de texto Los cuadros de texto están diseñados para poder escribir en ellos desde teclado.

Así, el usuario puede aportar datos que serán tenidos en cuenta por el programa, que los denomina Edit Text.

En nuestro caso, del usuario se espera que introduzca los datos principales del

diseño que desea simular. La parte izquierda superior de la interfaz contiene tres Edit Text en los que el

usuario escribirá las dimensiones del modelo, más otro para definir el número de vigas de que constará el dispositivo.

Fig. 3.13: cuadros de texto resaltados en la interfaz

Estas dimensiones las debe introducir en micras directamente, que es la medida

habitual en estos sistemas, mientras que el número de vigas es adimensional, lógicamente.



Por otra parte, también tiene que describir la función de entrada con la que pretende simular el sistema. Cada una de ellas (impulso, escalón y senoide) viene acompañada de un cuadro de texto a su derecha en el que introducir la amplitud de la señal de entrada y, en el caso de la senoide, también su frecuencia en Hz.

La programación de este tipo de funciones es sencilla en principio, aunque para

este diseño en concreto se ha querido realizar una comprobación de los datos introducidos por parte del usuario, dado que sólo se esperan números. Así, si por error o descuido se presiona alguna otra tecla, el programa lanzará un mensaje de aviso por pantalla indicando el error.

La idea inicial fue llevar a cabo esta comprobación en esta misma función,

aunque luego se vio que complicaba demasiado la programación, y finalmente se ha optado por simplificar esta función y comprobar los datos más adelante.

De esta forma, las funciones que recogen texto de teclado son: - valor_W - valor_L - valor_H - numero_vigas - amplitud_impulso - amplitud_escalon - amplitud_senoide - frecuencia_senoide

Y su código es bastante sencillo, simplemente guarda la cadena introducida por

el usuario, sin ninguna modificación, con la función get en el manejador correspondiente a cada función; por ejemplo, para amplitud_impulso, el manejador sería handles.amplitud_impulso.

Por último, guarda los cambios en la estructura de manejadores con la

instrucción guidata. La llamada a estos callbacks tiene la siguiente forma:

function valor_W_Callback(hObject, eventdata, handles)

Junto a ellos existen otras funciones que los acompañan, cuya nomenclatura, siguiendo el ejemplo de valor_W, es la siguiente:

function valor_W_CreateFcn(hObject, eventdata, handles) Son unas rutinas ejecutadas durante la creación de cada objeto y definen sus propiedades principales, tales como la apariencia, color, fondo, etc. La estructura de manejadores no se crea hasta después de haber llamado a todas las funciones de esta clase. Dentro de los cuadros de texto, hay que hacer mención aparte a los Static Text.



Así denomina el programa a aquellos cuadros de texto en los que el usuario no puede escribir nada; están ahí para mostrar resultados del programa, y no tienen ningún callback asociado. Los identificamos con la etiqueta o Tag, que sí tienen todos los objetos de la interfaz. En este programa los utilizamos para mostrar el valor de la masa m del dispositivo y su constante elástica k. Panel de entradas Con panel de entradas nos referimos al panel donde podemos elegir qué entrada queremos que llegue al acelerómetro para la simulación. Tenemos tres para elegir: entrada impulso, escalón o senoidal. La siguiente figura nos muestra la apariencia del panel:

Fig. 3.14: panel de entradas de la interfaz gráfica

Para crear este panel elegimos la figura Button Group de la paleta de componentes, y luego añadimos los botones que necesitemos. Podemos elegir entre dos tipos de botones, Radio Buttons y Toggle Buttons; nos quedamos con los primeros, que tienen el aspecto que se ve en la figura y se ajustan perfectamente a nuestra necesidad. Los botones del panel tienen la condición de que sólo uno de ellos debe estar a nivel alto y los demás a nivel bajo.



Esta función la define el mismo programa como SelectionChangeFcn. El manejador del panel queda recogido en hObject, como en cada elemento de la interfaz, y almacena qué botón ha sido seleccionado por el usuario. Para esta función hemos creado tres variables globales, llamadas impulso, escalón y senoide, una por cada tipo de entrada, para poder saber cuál es la seleccionada en la función ‘Simulación’. Las inicializamos a ‘0’ para que no haya problemas y por medio de un bucle if la función averigua cuál de los botones ha sido seleccionado; la variable global correspondiente toma el valor ‘1’. El funcionamiento del panel se basa en que, cada vez que se selecciona uno de los botones, entramos en la función SelectionChangeFcn; así, las tres variables se ponen a ‘0’ y sólo toma el valor ‘1’ aquella cuyo botón haya sido elegido por el usuario.

Luego salimos de la función, guardando antes el valor del manejador handles con la instrucción guidata.

Botón Reset El objetivo de pulsar este botón no es otro que hacer un pequeño reset de los cuadros de texto y dejarlos listos para introducir nuevos datos.

Fig. 3.15: botón de Reset en la interfaz gráfica

Realmente no es necesario este ‘limpiado’ de los cuadros de texto, puesto que en los Edit Text podemos escribir como en un procesador de textos y borrar y volver a



escribir, y en los Static Text se sobrescriben los datos, sin importar lo que hubiera antes. Pero así facilita la tarea al usuario y es una elegante opción antes de introducir nuevos valores para el diseño. Si, por ejemplo, se quiere simular con el mismo modelo (con las mismas dimensiones) pero variando la entrada, no es necesario borrar los datos de la antigua señal de entrada, el programa no la tendrá en cuenta para los nuevos cálculos. La forma de hacer todo esto es la siguiente: en primer lugar, pasamos el control de los campos a limpiar a unas nuevas variables creadas especialmente para ello. Con la función findobj identificamos los componentes de la interfaz y nos devuelve el manejador de cada uno de ellos. Veamos un ejemplo para que quede más claro: reset_W = findobj(gcbf, 'Tag', 'valor_W'); Para la función valor_W, por ejemplo, creamos otra llamada reset_W. La función findobj encuentra el componente cuya Tag es valor_W y le asigna su manejador a reset_W. A continuación procedemos a limpiar el contenido del objeto con esa etiqueta, usando la instrucción set para poner un espacio en blanco donde estaban los datos introducidos por el usuario. Por supuesto, el reset lo aplicamos a los diez cuadros de texto creados, cuyas etiquetas serían: valor_W, valor_L, valor_H, n_numero_vigas, amplitud_impulso, amplitud_escalon, amplitud_senoide, frecuencia_senoide, masa, constante_k. Botón Simular Este botón nos lleva a la función más elaborada, con diferencia, de nuestro programa. Todos los cálculos necesarios para el correcto funcionamiento de la simulación tienen lugar aquí.



Fig 3.16: botón Simular en la interfaz gráfica

Esta función recibe como argumentos de entrada los mismos que el resto (hObject, handles, evendata), pero, mientras que en las otras funciones nos limitábamos a añadir campos a la estructura, aquí vamos a ver lo importante de guardar los cambios en la estructura al final de cada callback. En simulación utilizamos los datos almacenados en los manejadores de otras funciones, lo veremos a continuación. En el apartado donde explicamos los cuadros de texto, comentábamos la intención de realizar una comprobación de los datos introducidos por el usuario desde teclado, pero vimos que no era buena idea hacerlo en aquellas funciones. La función simulación es lo primero que hace: verifica que el usuario no ha introducido letras en lugar de los números esperados. Y lo comprueba para los ocho cuadros de texto en los que el usuario puede escribir: valor_W, valor_L, valor_H, numero_vigas, amplitud_impulso, amplitud_escalon, amplitud_senoide y frecuencia_senoide. Recordemos que en los manejadores de los ocho callbacks asociados a los cuadros de texto, hemos ido almacenando la cadena de caracteres que el usuario ha escrito, sin ningún tipo de modificación. De esta forma, podemos tratar con ella sin problemas. La idea general para verificar estos datos trata de recorrer la cadena de caracteres y averiguar si estos son letras o números. En caso de que sean letras, aparecerá un mensaje por pantalla alertando al usuario de que está introduciendo unos datos incorrectos. Si todo es correcto, la simulación sigue adelante.



En primer lugar, creamos unas variables que van a contener el número de caracteres de las siete cadena de caracteres, llamadas n_valor_W, n_valor_L, n_valor_H, n_numero_vigas, n_amplitud_impulso, n_amplitud_escalon, n_amplitud_senoide, n_frecuencia_senoide, y una bandera inicializada a cero, que nos servirá para indicar si se produce un error. Para recorrer la cadena hacemos uso de un bucle for, con el índice i desde uno a la longitud de cada cadena, y la función de Matlab isletter. Al terminar el bucle for, con un nuevo bucle if comprobamos el valor de bandera, si está a ‘1’ aparece por pantalla el mensaje de error siguiente:

Fig. 3.17: mensaje de error que aparece si se introducen letras en los cuadros de texto

Es suficiente una letra en la cadena para que se contabilice el error, si hay varias igualmente bandera valdrá uno. Y si en los cuadros de texto no hay nada escrito, como puede ocurrir, por ejemplo, en los dedicados a la amplitud y frecuencia de las señales de entrada, no ocurre nada, el programa no va a señalar ningún error por ello. Si estos datos son correctos, se convierten a un formato con el que podamos trabajar. Recordemos que hasta ahora no han sufrido modificaciones, a ojos del programa sólo son caracteres. Los transformamos en formato de doble precisión (double) con la función str2double, y ya podemos tratarlos como valores numéricos. Una vez se verifican los datos de teclado, pasamos a los cálculos para realizar la simulación. Los primeros datos necesarios son la masa m y la constante elástica k. Sin ellas, la simulación no sería posible. Dada su importancia, les dedicamos un espacio en la interfaz para que el usuario conozca sus valores. Desarrollamos los cálculos necesarios para adaptar la masa y la constante k a la función de transferencia del archivo de Simulink, el cual define las constantes a y b en los bloques que nos interesan. En primer lugar declaramos la variable E, referida al módulo de Young del polisilicio, material más común para la fabricación de circuitos integrados, aunque podría ser otro como el aluminio, por ejemplo. A continuación desarrollamos la fórmula (3.2) que nos da el valor de la constante k, obtenida directamente de las dimensiones del dispositivo.



Para hallar la masa hacemos uso de las expresiones (3.3) y (3.4), con ρ representando la densidad del material, en nuestro caso polisilicio; en la función se declara la variable densidad_poly igual a 2330 kg/m3. El siguiente paso es modificar los valores de a y b del archivo Simulink para que realicen los cálculos de acuerdo con nuestros datos de diseño. Sin lugar a dudas, podemos afirmar que:

mak

= (3.5)

Bbk

= (3.6)

B es el coeficiente de fricción con el medio, del orden de 10-5. De forma que ya tenemos todos los parámetros necesarios para simular el acelerómetro deseado. A continuación establecemos todas las constantes y matrices necesarias para la simulación. Lo primero que hay que hacer es cargar el archivo de constantes y variables para inicializar el modelo de Simulink del acelerómetro. Este archivo es uno de los que proporciona Analog Devices en su página web, el ADXL311_constants.m, y nosotros respetamos los valores de todas las constantes y variables salvo de a y b, lógicamente, las cuales modificamos para que tomen el valor que nos interesa. La base de tiempos para la simulación es lo más laborioso. Definimos el tiempo de fin de simulación, el máximo tamaño del intervalo, y una serie de opciones necesarias para simular. Con la orden OPTIONS establecemos la tolerancia relativa para la simulación, el máximo tamaño del intervalo de tiempo y definimos como espacio de trabajo el actual. Así reconocerá todas las variables y constantes que carguemos justo antes de simular. La matriz de tiempos queda configurada como una matriz columna con un número de elementos igual al tiempo de parada de la simulación más uno, separados una cantidad el máximo tamaño del intervalo. En cuanto tenemos definida la base de tiempos, ya podemos pasar a simular. Primero nos servimos de un bucle if… elseif para averiguar cuál de las tres señales de entrada (impulso, escalón, senoide) vamos a utilizar. En cada caso el objetivo es construir una matriz de entrada U, que constará de cuatro columnas con el número de elementos determinado por la matriz de tiempos T. Así, la matriz U tendría la siguiente estructura: U=[T,u1t,u2t,u3t];



Donde u1t, u2t, u3t son los vectores entrada correspondientes a cada una de las tres componentes espaciales x, y, z. Para cada una de ellas se ha construido una matriz con el mismo número de elementos que T, rellenando con ceros hasta alcanzar este tamaño. En nuestro proyecto, la componente z siempre va a ser igual a cero, ya que el acelerómetro usado es biaxial y sólo es capaz de medir la aceleración en los otros dos ejes. Ahora ya tenemos todos los datos y cálculos necesarios para simular. La con la orden sim, indicándole como parámetros el nombre del archivo de Simulink, el tiempo de parada de la simulación, las opciones establecidas con la instrucción OPTIONS, y la matriz de entrada U.

[t,X,Y]=sim('ADXL311_3',xtstop,OPTIONS,U); Con esto llevamos a cabo la simulación, para poder representarla en la interfaz incluimos los comandos de dibujo de Matlab. En primer lugar indicamos al programa dónde queremos ubicar las gráficas; en este caso, tenemos dos ejes en la interfaz dispuestos para tal efecto, cuyos manejadores son handles.entrada y handles.salida, para mostrar las gráficas de la señal de entrada y de salida que simulemos. La función plot es la encargada de dibujar las gráficas. La acompañamos de una serie de instrucciones con opciones adicionales, como la rejilla de fondo en la gráfica, títulos de los ejes u orientación. Como último detalle de la función, que terminaría al dibujar las gráficas, declaramos una nueva variable global llamada matriz. En ella almacenamos la matriz resultante de la simulación para poder trabajar con ella más adelante. global matriz; matriz = [t, X, Y]; Esta matriz contiene toda la información sobre la gráfica dibujada, y almacenándola en la variable global podemos guardarla en otra función (otro callback) y recuperarla más tarde para, por ejemplo, volver a dibujarla sin tener que introducir todos los datos ni esperar a que Matlab lleve a cabo la simulación nuevamente. Función Guardar Su tarea es muy simple, almacenar la variable matriz, declarada global, en el archivo de nombre grafica_salida, con extensión .mat. La variable matriz, al ser global, hay que volver a declararla en esta función, si no el programa no almacena nada.



Fig. 3.18: botón Guardar en la interfaz gráfica

Botón ‘Salir’ Posiblemente, la función que menos problemas ha dado a la hora de programar su funcionamiento.

Fig. 3.19: botón Salir en la interfaz gráfica



Al pulsar este botón, aparece un cuadro de diálogo que pregunta al usuario si realmente desea abandonar el programa; en este se encuentra resaltada por defecto la opción de no abandonarlo.

Fig. 3.20: Cuadro de diálogo para salir de la interfaz

Si se escoge continuar en el programa, la función devuelve el control a la interfaz, cerrándose el mensaje y quedando la interfaz igual. En caso de que se pulse la opción ‘Sí’, elimina todas las variables creadas en el espacio de trabajo y limpia la ventana de comandos, además de cerrar la interfaz. Para averiguar qué botón pulsa el usuario, se emplea la función de Matlab strcmp. Esta compara dos cadenas de caracteres, si son iguales devuelve un ‘1’ lógico (trae) y en caso contrario, un ‘0’ (false). Se compara lo que el usuario elige (Sí o No) con ‘No’; mediante un bucle if se establece la comparación, si entra en él (se ha elegido ‘No’) con la sentencia return hace que salga de la función ‘Salir’. Si no entra en el bucle if, tras eliminar las variables y limpiar la pantalla se procede a salir de la interfaz con close(gcbf). La función close borra la figura que se le indique de la pantalla. En nuestro caso, le indicamos que elimine la interfaz mediante gcbf, que contiene el manejador de la misma. Función Presentación Se trata de una función creada exclusivamente para hacer más atractiva visualmente la presentación, puesto que no añade ninguna funcionalidad al programa. Consiste simplemente en una pequeña pantalla en la que dejamos constancia del título del proyecto y su autor, con una imagen de fondo relacionada con el proyecto. La función comienza limpiando variables y la ventana de comandos de Matlab. Crea una ventana para mostrar gráficos con figure y la mayor dificultad de la función reside en manejar todas las opciones que posee Matlab para tratamiento de figuras y gráficas, tales como posición de la ventana en la pantalla, localización de los rótulos, colores, imagen de fondo, etc.



En toda la interfaz sólo hemos añadido un botón, que nos permite llegar hasta la verdadera interfaz objeto de nuestro proyecto. Con este control cerramos los callback de presentación, limpiamos la pantalla y las variables del espacio de trabajo y llamamos a la interfaz que nos interesa.

3.4. Principales problemas encontrados Esta sección la dedicamos a comentar las principales dificultades que nos ha planteado el desarrollo del programa para simular el acelerómetro. El principal de los problemas ha sido el desconocimiento por parte del alumno del programa en el que se ha implementado la simulación. Esto conlleva un periodo de adaptación al software y a su funcionamiento y manejo no prevista al comienzo del proyecto. La falta de conocimientos en Simulink ha sido absoluta, aunque no ha presentado demasiados problemas para desarrollar el objetivo fundamental del proyecto. Conocer el funcionamiento de la simulación por parte de la herramienta no ha resultado complicado, sin embargo, intentar añadir nuevos bloques a los diagramas y adecuar la simulación al dominio de la frecuencia no ha resultado fácil en un principio, e incluso no se ha podido completar este objetivo. La programación de las funciones principales con el editor de Matlab sí ha resultado más complicada de lo previsto, dada las peculiaridades de Matlab respecto a otros lenguajes de programación ya empleados con anterioridad en la licenciatura. Aunque el lenguaje básico de programación es muy parecido al lenguaje C, uno de los más conocidos y cuyo aprendizaje en primer curso sentó unas bases de programación aplicables a muchos de los lenguajes existentes actualmente, Matlab presenta algunos puntos que lo diferencian y con los que el alumno ha tenido que lidiar, a veces con menos éxito del que se esperaba. A pesar de todo, el resultado final es satisfactorio, aunque ha llevado más tiempo del previsto en un principio. Una de las ventajas de Matlab es la gran variedad de funciones que incluye en su biblioteca, prácticamente hay, al menos, una función para cada propósito. Sin embargo, a veces uno de los problemas puede ser encontrar dicha función. Conocemos nuestro propósito, lo que deseamos hacer, pero no cuál es la función de Matlab que nos ayudaría en ese momento. Esto hace que, a veces, el usuario intente programar esa función y, un tiempo después, encuentre la suministrada por Matlab, ya sea por casualidad o porque ha ido acotando la búsqueda, aprendiendo cómo “piensa” Matlab.



La consecuencia de todo esto es, simplemente, alargar el tiempo de desarrollo del programa. Igualmente, la falta de información sobre el funcionamiento y, sobre todo, el desconocimiento de la existencia de GUIDE dentro de Matlab retrasó bastante su desarrollo y puesta en marcha. En un principio se empezó la programación directamente con el editor de texto de Matlab, sin tener conocimiento de la interfaz gráfica, hasta que se vio que Matlab ofrecía la posibilidad de crear un entorno gráfico mucho más elegante y cómodo para el trabajo que lo que se estaba intentando hasta el momento. A partir de aquí, lo más complicado fue entender el funcionamiento de la interfaz, como en cualquier programa que se empieza a usar por primera vez, hasta llegar a manejar con soltura los conceptos básicos de su estructura. Por lo demás, puede decirse que los principales problemas encontrados se han debido a las dificultades propias de la programación. Esto es, hallar la mejor forma de programar cierta función, intentando evitar el empleo de variables globales, aprovechando la estructura de manejadores handles que ofrece GUI, simplificando el código en la medida de lo posible, siendo claro y concreto en cada momento, etc. Y, sobre todo, el hecho de que, en cualquier trabajo que implique programación, la mayoría de los problemas suelen tener una solución simple, pero costosa de encontrar. Al igual que ocurre cuando buscamos un objeto en los bolsillos de un pantalón, siempre la solución está en el último lugar en que se mira. Como ejemplo, citamos uno de los mayores problemas que se presentaron; debido al hecho de que al utilizar GUI, el espacio de trabajo de Matlab (donde se almacenan las variables y constantes que se van creando durante la ejecución del programa) cambia desde al actual a otro. Al cargar los archivos de constantes y variables necesarios, Matlab no encontraba dichas variables; dar con la solución llevó más tiempo que otra cosa, pues con incluir dos órdenes en las opciones de simulación se solucionó el problema.


CAPÍTULO 4

VALIDACIÓN DEL MODELO

DE SIMULACIÓN

Estudio de modelos de acelerómetros Validación de la simulación


4. Validación del modelo de simulación El acelerómetro del que disponemos en el laboratorio es el ADXL311; con él, se realizó un montaje para poder medir la aceleración, construido para unas prácticas de la asignatura Sistemas Electrónicos Avanzados, y aprovechado ahora como parte de nuestro proyecto.

4.1. Montaje experimental en laboratorio El montaje en cuestión es un péndulo que consta de una guía de madera haciendo de hilo del péndulo, unida por uno de sus extremos a un soporte con un escalímetro. En el otro extremo se ha fijado la placa con el acelerómetro (la masa suspendida). A esta placa se conecta una tarjeta de adquisición de datos, para poder tomar las medidas del acelerómetro, con ayuda del software LabView 8.0. En las siguientes fotografías puede observarse todo el montaje:

Fig. 4.1: placa con acelerómetro



Fig. 4.2: Montaje péndulo con acelerómetro en laboratorio



Fig. 4.3: tarjeta adquisición de datos Fig. 4.4: montaje completo

LabView es una herramienta gráfica para pruebas, control y diseño mediante programación, muy apropiado para pruebas que incluyen adquisición, control, análisis y presentación de datos. Con esta herramienta se desarrolló un programa para representar la aceleración medida por el acelerómetro en cada uno de sus ejes. LabView permite exportar los datos tomados con la tarjeta de adquisición; estos datos corresponden a la aceleración normal y tangencial, pudiendo medirse ambas independientes la una de la otra.

4.2. Pruebas experimentales para validar el modelo Como decíamos al principio de la memoria, la idea del proyecto es comparar los dos estudios con acelerómetro, tanto en la simulación como en el sistema real. Para ello, debemos ser capaces de relacionar las dimensiones W, H y L del acelerómetro con la función de transferencia que aparece en los bloques de Simulink. En el archivo con el modelo que podemos conseguir de la página web de Analog Devices, tenemos todos los bloques definidos en función de unas constantes, y nos dan también un archivo con valores iniciales para dichas constantes. Ahora depende de nosotros conseguir adecuar estas constantes a nuestro diseño. Sin embargo, es necesario basarse en un modelo físico conocido para desarrollar la simulación, y el fabricante no nos proporciona todos los datos requeridos. En un principio se intentó seguir el modelo ADXL150 descrito en el libro Microsystem Design de Stephen D. Senturia. En este libro se somete a un detallado estudio dicho acelerómetro y se da una descripción bastante completa de las dimensiones de la estructura del acelerómetro, la masa de las vigas, número de electrodos y distancia entre ellos, y otras medidas. Conociendo todos estos datos podemos llegar a unas fórmulas muy aproximadas para el cálculo de la masa y la constante elástica y, a partir de ahí, relacionarlas con las constantes del modelo en



Simulink. Para los modelos que Analog Devices proporciona desde su página web no contamos con estos datos, no incluidos en las hojas de especificaciones. Pues bien, necesitamos conocer datos de este tipo para asegurar que nuestro modelo de simulación es correcto, ya que, aunque la estructura básica de ambos acelerómetros no es muy diferente, sería un tanto arriesgado para el modelado suponer que sus dimensiones van a coincidir.

4.2.1. Obtención de la función de transferencia del modelo real Para suplir la carencia de datos comentada y seguir adelante con el proyecto, hemos adoptado la siguiente solución. Aprovechando el montaje que tenemos en el laboratorio y el programa LabView, vamos a intentar obtener una función de transferencia que podamos asemejar a la de nuestro bloque de Simulink. Realmente intentamos llevar a cabo un proceso de ingeniería inversa, tratando de obtener los parámetros que necesitamos para nuestro diseño de un modelo real. El inconveniente principal de esta solución reside en que la simulación ya no va a diferir apenas del caso real, puesto que nos estamos basando en él para construir nuestra simulación. La idea es que, a partir de estos valores de la aceleración, construimos la función de transferencia de la señal de entrada. LabView nos da datos de la aceleración en cada punto que toma, mientras que en una gráfica viene representada en intervalos de un segundo. Una vez que la señal se estabiliza, es fácil seguir su recorrido por el tiempo. Fijándonos en la gráfica y en el archivo donde se importan los datos, conseguimos una serie de valores que nos van a servir para determinar la función de transferencia. También sabemos que el programa hecho con LabView se ha diseñado con una frecuencia de muestreo de 10 kHz. Para analizar la gráfica resultante hemos tenido que utilizar conocimientos adquiridos en cursos anteriores. Concretamente, gracias a la asignatura Teoría del Control Automático, y a los métodos para obtener la función de transferencia de un sistema a partir de su respuesta en el tiempo, intentamos obtener una aproximación de nuestro acelerómetro. Haciendo un repaso de los posibles sistemas de control en tiempo continuo, de segundo orden, tenemos las siguientes opciones: sistemas estables, críticamente estables e inestables. Lógicamente, nuestro acelerómetro va a ser un sistema estable (el críticamente estable requiere una salida perfectamente armónica), y dentro de esta categoría podría ser: sobreamortiguado, críticamente amortiguado y subamortiguado. En función de la entrada que reciba el sistema, será subamortiguado, con bruscas sobreoscilaciones, o un movimiento ondulatorio que irá disminuyendo en amplitud



debido al rozamiento con el aire. Para estos casos tratamos de averiguar los polos del sistema. El caso subamortiguado se consigue con una desaceleración brusca y repentina del sistema. Hacemos que oscile normalmente y lo frenamos de golpe. La salida que se obtiene es la siguiente:

Fig. 4.5: Salida sistema subamortiguado

Siguiendo los métodos estudiados en Teoría del Control, para hallar los polos del sistema a partir de la respuesta del sistema debemos fijarnos en detalles como la sobreoscilación del sistema y el tiempo de establecimiento. Los polos tendrán la siguiente forma:

1,2

21n ns jω δ ω δ= − ± − (4.1) Para calcular la sobreoscilación empleamos las fórmulas:

21( ) ( )

( )py t y

SO ey

δπ

δ−

−− ∞

= =∞

(4.2)

Donde y(tp) es el valor de la sobreoscilación en su punto más alto e y(∞) es el valor hacia el que tiende el sistema en régimen permanente. En cuanto al tiempo de establecimiento tenemos dos posibilidades para relacionarlo con ωn. En función del coeficiente de amortiguamiento, podemos optar por una aproximación o por otra:

si δ > 0’69, 3e

n

tδω

(4.3)

si δ < 0’69, 4e

n

t δω

(4.4)



Estos datos los obtenemos tanto para la componente normal de la aceleración, como para la componente tangencial. La función de transferencia resultante tendría la forma siguiente:

2

2 2( )2

n

n n

KH ss s

ωδω ω

=+ +

(4.5)

Aquí comienzan los problemas de este método. De momento, ya nos aparece una constante que no somos capaces de determinar. La ganancia del sistema K la calculábamos en la asignatura de Teoría de Control comparando la entrada y la salida del sistema, y aquí no podemos determinar con exactitud la entrada. De todas formas lo intentamos sin incluir esta K a ver si conseguimos unas formas de onda a la salida parecidas a lo esperado. Para probar la validez de las funciones de transferencia obtenidas de esta forma se pensó en primer lugar en sustituir el diagrama de bloques completo del ADXL311 por la nueva función obtenida. Sin embargo, tras una serie de pruebas, comprobamos que los bloques realmente importantes son los denominados X Beam H(f) e Y Beam H(f), los demás tienen una repercusión limitada sobre la salida.

Fig. 4.6: cadena de bloques para adaptar la salida de la señal

Los bloques representados en la figura 4.6 tienen la función de adaptar la señal a la salida. Hay bloques para ajuste de la sensibilidad del dispositivo, simular los efectos de la demodulación, ganancias y un filtro RC de primer orden que determina el ancho de banda. La sensibilidad del dispositivo está determinada por las especificaciones del acelerómetro y no podemos variarla a nuestro antojo, al igual que el ancho de banda, del cual depende la constante h. Por ejemplo, duplicando el ancho de banda o reduciéndolo a la mitad, el resultado no varía apreciablemente, como puede observarse en la siguiente figura:



Fig. 4.7: salida del acelerómetro variando el ancho de banda (por tanto, la constante h)

De forma parecida, variar la sensibilidad no aporta grandes diferencias a la salida, simplemente produce un leve cambio en la ganancia del sistema. Las especificaciones del data sheet del ADXL311 indican que varía entre 140 y 195 mV/g. Veamos, por ejemplo, para una sensibilidad máxima:

Fig. 4.8: respuesta acelerómetro con sensibilidad máxima de 195mV/g



Como vemos, aumenta ligeramente la ganancia. Disminuyendo la sensibilidad hasta los 140mV/g también disminuiría la amplitud de la respuesta, siendo muy suaves las variaciones dentro de este rango. Por otra parte, los efectos del filtro de demodulación podrían ser tenidos en cuenta sólo con grandes variaciones en el polo del filtro. El valor de la constante e, que es la que determina este polo, es del orden de 10-5. Sólo aumentando su valor en 2 o más órdenes de magnitud se aprecian cambios (si disminuimos varios órdenes no ocurre nada apreciable), aunque sólo en los primeros instantes de la respuesta. Por ejemplo, con e del orden de 10-3 tenemos:

Fig. 4.9: respuesta acelerómetro con e ~10-3

Tras estas pruebas concluimos que los bloques realmente importantes para el funcionamiento son las funciones de transferencia de los bloques Beam H(f), que toman directamente la señal de entrada y la transforman en tensión:



Fig. 4.10: detalle del bloque X Beam H(f), que recibe la señal captada por el sensor del eje x

Obviamente, para el eje y tenemos el mismo archivo, como puede verse en la figura 4.10. Gracias a estas conclusiones, basamos nuestro diseño en la adecuación de las constantes a y b de dicho bloque a los parámetros de diseño que vayan a definir el acelerómetro. Así, una vez tengamos una función de transferencia válida, podemos obtener valores equivalentes a las constantes a y b del modelo Simulink y preocuparnos simplemente por relacionarlas con los valores de la masa y la constante k del dispositivo, que vendrán determinadas por las dimensiones de diseño del acelerómetro, W, H y L. El método seguido para simular la nueva función de transferencia obtenida a partir de los resultados experimentales con LabView ha sido sustituir solamente el bloque resaltado en la figura 4.10 por la función nueva. No obstante, también se ha probado a sustituir el sistema entero por dicha función, para poder contrastar ambos resultados. Pero para ambas simulaciones, tanto al sustituir el sistema entero como sustituyendo un sólo bloque, los resultados no son los esperados. Tras varios intentos de obtención de una función de transferencia coherente, las salidas que ha generado el sistema no son correctas y no hemos sabido interpretar los fallos. Es por ello que no hemos desarrollado en esta memoria los cálculos realizados ni las funciones de transferencia; simplemente hemos decidido mostrar algunas de las gráficas obtenidas a la salida del sistema para que el lector pueda hacerse una idea de las respuestas conseguidas.



Esta primera gráfica fue resultado de sustituir el sistema completo por un bloque con la función de transferencia. La entrada es una senoide de frecuencia 10 Hz y amplitud también 10V. A modo orientativo, damos los valores de la constante de amortiguamiento y la frecuencia natural del sistema, δ = 0’77 y ωn = 85’56 rad/s.

Fig. 4.11: respuesta tras sustituir el sistema completo por la nueva función

Se puede observar un tiempo de subida bastante más lento, además de que la amplitud se ve reducida. Esto último puede ser solamente cuestión de ajustar la ganancia, pero por la lentitud de la señal ya concluimos que la función no es correcta. Simulando el archivo ADXL311, sustituyendo las funciones de transferencia originales por estas nuevas y con la misma senoide a la entrada, tenemos lo siguiente a la salida del sistema:



Fig. 4.12: respuesta a senoide sustituyendo bloque X Beam H(f)

En ella la amplitud parece demasiado elevada y hace que la señal quede limitada bruscamente por ambos lados. El tiempo de propagación de la señal se acerca más a lo esperado, pero seguimos sin poder concluir nada positivo de esta función Y ante una entrada escalón de amplitud 1V:

Fig. 4.13: respuesta a escalón sustituyendo bloque X Beam H(f)



Lógicamente, esto no es el resultado esperado a un escalón unitario como entrada al sistema. Parece, pues, que la función de transferencia está bastante alejada de lo que debería ser. Las causas de que esta metodología no nos sirva no quedan del todo claras, puesto que se esperaba que, aunque no coincidieran exactamente las salidas de ambos modelos, al menos tuvieran una forma parecida. Sin embargo, no es esto lo que ocurre, como se pone de manifiesto de forma muy clara en la salida ante una función escalón, por ejemplo. En este punto del proyecto se recurrió a la ayuda de profesores del Departamento de Automática de la ESI; dado que lo que se intentaba hacer era aplicación directa de los conocimientos adquiridos en Teoría del Control Automático, su opinión y consejo podían ser de utilidad. Sin embargo, no estuvieron completamente de acuerdo con la metodología seguida, debido a que no éramos capaces de determinar la entrada al sistema, ya no de forma precisa, sino ni siquiera una aproximación de dicha entrada. En su opinión, había demasiadas imprecisiones en las medidas, e incluso incoherencias en algunos puntos, tales como la velocidad de la respuesta y la constante de amortiguamiento. El tiempo de subida, por ejemplo, es muy lento en comparación al acelerómetro original que proporciona el fabricante. Si nos fijamos en las gráficas de LabView, obtenemos un tiempo de subida mucho menor al dado por el data sheet de Analog Devices:



Fig. 4.14: tiempo de subida del ADXL311

Tras esto, fueron capaces de discernir una posible solución para llegar a una solución más exacta. Esta consistía en dejar caer el acelerómetro verticalmente, de forma que la entrada aplicada podría considerarse como un escalón de 0 a 9’8 m/s2. Midiendo el instante después de soltar el dispositivo, seríamos capaces de conseguir una función de transferencia más precisa. Sin embargo, dentro del Departamento de Electrónica nos pareció buena idea para lograr nuestro propósito, pero no tanto como para deshacer todo el montaje, pues servía para las prácticas de una de las asignaturas de la especialidad. Así que pensamos otras soluciones. Lógicamente, sin ser capaces de determinar la entrada del sistema, es bastante complicado llegar a una solución clara. Si no podemos saber a qué modelo matemático corresponde un pequeño empujón al péndulo, o dejarlo caer desde la posición de 90º respecto al soporte, es prácticamente imposible conseguir una función de transferencia aproximada a la real. Ya que intentando obtener los polos del sistema no conseguimos una función de transferencia parecida a la real, tenemos que buscar otra forma de conseguirla. Matlab dispone de un paquete de herramientas denominado System Identification Toolbox que ofrece la posibilidad de hallar la función de transferencia de un sistema, pero para ello es necesario conocer entrada y salida al mismo. Así que tampoco nos resulta útil. Sí serviría para el caso propuesto por los profesores de Teoría del Control, pues tendríamos definido el escalón de entrada y, gracias a LabView, también contamos con un archivo con la salida en cada instante.



4.2.2. Comparación de la respuesta de ambos sistemas, real y simulación Dado que nos basta con saber que la simulación hecha en Simulink se asemeja a la realidad (no necesitamos una gran precisión para esta comprobación), intentamos otros métodos analíticos quizás no completamente exactos, pero igualmente válidos para nuestro objetivo.

4.2.2.1. Comparación de ambos sistemas con péndulo

Recordemos que nuestro acelerómetro de laboratorio está montado sobre un péndulo (ver figura 4.2). Pretendemos obtener la función de transferencia de un péndulo y aplicarla a nuestra simulación. Se ha diseñado, por tanto, un modelo en Simulink del péndulo físico y su respuesta la aplicamos a la entrada del modelo de acelerómetro ADXL311. Pero primero veamos algo de teoría sobre los péndulos.

La ecuación del movimiento del péndulo que describe la variación del ángulo en función del tiempo se puede obtener aplicando la primera ley de Newton y se puede expresar según:

2

2 sin 0gt lθ θ∂+ =

∂ (4.6)

Donde l es la longitud del péndulo y g es la constante de gravedad. Si se define la frecuencia ω0

2 a través de la relación:

20

gl

ω = (4.7)

La ecuación que describe el movimiento del péndulo se puede expresar según:

2

202 sin 0

tθ ω θ∂+ =

∂ (4.8)

Este sistema no es un verdadero oscilador armónico ya que para que lo fuese, el término de derecha debería ser proporcional al ángulo . Eso significa que las oscilaciones no son perfectamente sinusoidales. Pero si la amplitud de las oscilaciones es suficientemente pequeña, la oscilación será tan próxima a una sinusoide como se desee:

sin θ θ≈ 2

202 0

tθ ω θ∂+ =

∂ (4.9)

Cuya solución es una función armónica:



0 0cos( )tθ θ ω δ= + (4.10) Donde θ0 es la amplitud de las oscilaciones y δ es una constante de integración

que viene determinada por las condiciones iniciales, y el periodo de oscilación viene determinado por la expresión:

2 lTg

π= (4.11)

Esta sería la teoría básica para el péndulo simple, en el que se considera una

masa puntual, una idealidad. En el modelo real tenemos una masa, un cuerpo rígido, y estas ecuaciones varían ligeramente. Sería el llamado péndulo físico o compuesto.

El equivalente de la ley de Newton para cuerpos en rotación es:

2

2Jtθ τ∂=

∂ (4.12)

Donde J es el momento de inercia del cuerpo alrededor del eje de rotación y τ es

el momento aplicado al objeto. En este caso el momento es igual al peso del objeto multiplicado por el brazo de la palanca del peso, sinl θ :

2

2 sinJ mgltθ θ∂= −

∂ (4.13)

Con el signo menos se indica que el momento trata de dirigir el objeto hacia

posiciones en las que θ tiene signo contrario. Como en el péndulo simple, esta ecuación no es lineal, luego no corresponde a

las ecuaciones diferenciales de un oscilador armónico. Sin embargo, para oscilaciones muy pequeñas, sin θ θ≈ , y la ecuación anterior queda como:

2

2J mgltθ θ∂= −

∂ (4.14)

Que sí corresponde a un oscilador armónico cuya frecuencia angular es:

mglJ

ω = (4.15)

Por lo tanto, para pequeñas oscilaciones, el periodo de oscilación es:



2 JTmgl

π= (4.16)

Como vemos, el estudio del péndulo plano se puede abordar desde diferentes

puntos de vista y con diferentes niveles de dificultad. El movimiento del péndulo se puede entender como el movimiento de una partícula de masa m sometida a la acción de la fuerza gravitatoria estando el movimiento limitado por una varilla inextensible y sin peso. La componente de la fuerza gravitatoria perpendicular a la varilla y, por tanto, responsable del movimiento es F(θ) = -mg sen θ.

El modelo de péndulo diseñado para Simulink consiste simplemente en la

traslación de la función de transferencia del péndulo físico a los bloques de Simulink:

Fig. 4.15: modelo de péndulo en Simulink

El modelado del péndulo nos da el ángulo θ y la velocidad angular; si le añadimos un derivador, obtenemos también la aceleración angular. Multiplicada por la longitud del péndulo nos da la aceleración tangencial.

Fig. 4.16: modelo de péndulo con derivador para obtener la aceleración angular



En él podemos observar cómo se introduce un derivador justo después del

primer integrador (que nos daría la velocidad angular). Con el bloque “To File” llamado omega.mat guardamos los datos en un archivo Matlab con ese nombre para poder utilizarlo posteriormente. Igual hacemos con teta.mat, con el que salvamos el ángulo del péndulo en cada instante. La ganancia B corresponde a las fuerzas de fricción, J es el momento de inercia del péndulo, m, gra, l son la masa del objeto, la aceleración de la gravedad (9’8 m/s2) y la longitud del hilo.

Una vez que tenemos estas ecuaciones diferenciales, resolverlas a mano no resulta sencillo. Hay que recurrir a métodos numéricos, algoritmos tales como los de Euler y Runge-Kutta, el método del punto medio, o el de Heun. También existen métodos analíticos, entre ellos el de balance de armónicos es uno de los más empleados.

Simulink nos permite elegir entre varios métodos antes de hacer la simulación.

Elegimos el de Ruge-Kutta para intentar obtener una precisión aceptable. En la figura 4.17 podemos observar todos estos métodos que ofrece Simulink.

Fig. 4.17: configuración de los parámetros de la simulación

Ahora, por un lado tendremos el modelo real, representado por el acelerómetro ADXL311 montado sobre el péndulo y conectado al ordenador con LabView. Por otro,



la aceleración tangencial que obtenemos del péndulo la ponemos a la entrada del modelo en Simulink del acelerómetro. La salida de ambos sistemas (real y simulación) deben ser, al menos, parecidas. Si esto ocurre, si las salidas de ambos sistemas son coherentes, podremos estar seguros de que nuestra simulación es correcta. Analizando el montaje de laboratorio desde el punto de vista de la física, tenemos un péndulo situado a unos 52 centímetros del punto de oscilación y una masa de aproximadamente 200 gramos. En el modelo ideal de péndulo físico se considera la masa del hilo despreciable, y sólo cuenta para el cálculo la masa del objeto suspendido. En nuestro modelo real no es así, sino que contamos con un listón de madera algo alejado de lo que se considera ideal en estos casos. Así que añadimos su masa al modelo, de forma que m = 1kg. Y la longitud del ‘hilo’, unos 52cm (en este caso desde el acelerómetro hasta el punto sobre el que oscila nuestro péndulo). Para el resto de parámetros que aparecen en el modelo, tenemos que

2J ml= [kg·m2] y 2B = [N·m/(rad/s)]. Tras realizar las simulaciones correspondientes del péndulo, durante un tiempo de 30 segundos, obtenemos los siguientes resultados. A la salida del péndulo, y tras derivar apropiadamente, podemos observar el ángulo y la aceleración tangencial (obtenida de la angular), que será la entrada del acelerómetro:

Fig. 4.18: salida péndulo, indica el ángulo



Fig. 4.19: entrada al acelerómetro, aceleración tangencial

Ante esta entrada, el acelerómetro da la salida:

Fig. 4.20: salida del acelerómetro

Para comparar estas gráficas con las obtenidas experimentalmente tenemos algunos problemas; el más importante vuelve a ser la entrada al sistema. En el modelo



de péndulo en Simulink la tenemos perfectamente definida, en este caso un escalón de 0 a 1. Sin embargo, en el modelo de laboratorio seguimos sin poder determinar la entrada de manera fiable. A pesar de no saber qué tipo de entrada aplicamos al péndulo, vamos a tratar de interpretar estas gráficas de forma coherente. Hay algo en lo que sí podemos confiar, y es el hecho de que la medida de la posición (el ángulo θ) que nos da el modelo de péndulo es correcta. Lógicamente, este péndulo está sometido a una aceleración que provoca cambios en su velocidad angular; y esta será la aceleración que mida el acelerómetro. El modelo en Simulink del ADXL311 transforma la aceleración de entrada en una tensión a la salida, y realiza una simulación de cómo actuarían los bloques de demodulación y filtrado. También hemos comprobado cómo afecta la masa y la longitud del péndulo a la salida. En apariencia pueden llegar a ser bastante diferentes, aunque en realidad no lo son tanto. La diferencia radica en la imprecisión en la medida de la masa del montaje, compuesto por el listón de madera más la placa con el circuito. Hemos supuesto que el péndulo pesa alrededor de 1kg. Estimamos que unos 200g pertenecen a la masa de la placa y el circuito, pues son muy pocos componentes de escaso peso. Pero la madera que simula el hilo del péndulo debe pesar algo más de lo que imaginamos en un principio. Lejos de ser de masa despreciable, como ocurre en los casos teóricos, es muy posible que pese algo más del kilogramo estimado. Vamos a ver las representaciones gráficas de la respuesta al montaje de laboratorio y las simulaciones obtenidas con Matlab, para que todo quede más claro. En primer lugar representamos algunas de las formas de onda obtenidas con el montaje experimental del laboratorio. Las primeras gráficas corresponden al movimiento libre del péndulo; lo situamos formando 90º con el soporte metálico y soltamos dejando que oscile sin que nadie lo frene, salvo el rozamiento con el aire.



Fig. 4.21: aceleración medida al principio del movimiento

Al principio se reduce lentamente la amplitud de las oscilaciones:

Fig. 4.22: aceleración medida instantes después de iniciar el movimiento

Fig. 4.23: aceleración medida instantes después de iniciar el movimiento

En poco tiempo se reduce considerablemente la amplitud de las oscilaciones:



Fig. 4.24: aceleración con el péndulo parándose

Hasta frenar completamente:

Fig. 4.25: aceleración con el péndulo en reposo

Estas gráficas son muy ilustrativas para ver la evolución de la aceleración a que está sometido el péndulo durante su movimiento, sin embargo, no son del todo útiles para nuestro propósito de comparar el montaje real con la simulación. Esto es debido a que no conocemos analíticamente la entrada que le damos al sistema, como ya hemos comentado anteriormente. Nosotros nos limitamos a llevar el péndulo a la posición inicial (formando un ángulo recto con el soporte) y lo soltamos, pero no somos capaces de determinar qué tipo de entrada le estamos dando al péndulo. No obstante, si en pleno movimiento libre del péndulo introducimos un freno a mitad de su recorrido (simplemente colocar nuestra mano en la trayectoria), justo en el punto en que θ = 0º, de forma que el péndulo pase de velocidad máxima a cero en un instante, podría interpretarse como un escalón que se le da al sistema en un instante, aunque ya esté en movimiento. La salida a esta entrada es la siguiente:



Fig. 4.26: aceleración al provocar una parada brusca al péndulo

Y con más precisión en la medida, podemos observar:

Fig. 4.27: sobreoscilación en la aceleración al frenar el péndulo bruscamente

Como puede observarse, la medida de la componente tangencial de la aceleración no es tan precisa como la medida de la normal. Se ve mucho más afectada por ruidos y condiciones ambientales que la normal. Comparando la salida del montaje de laboratorio con la figura 4.26, ambas gráficas no parecen tener demasiadas similitudes:



Fig. 4.28: comparación figuras 4.20 y 4.26

No obstante, hay que tener en cuenta que la pantalla de LabView muestra poco recorrido de la gráfica. Y en cuanto a la salida obtenida con Simulink, suponemos que la salida tan amortiguada que se observa se debe a lo anteriormente comentado sobre la masa del montaje listón de madera más placa. Probablemente la estimación inicial de la masa del conjunto no ha sido suficiente. Veamos qué ocurre con una masa mayor, supongamos 2kg:

Fig. 4.29: entrada acelerómetro con m=2, l= 0’52



Fig. 4.30: salida acelerómetro con m=2, l=0’52

Aparentemente esta gráfica parece que tiene más sentido, bastante pareja a la obtenida experimentalmente; sin embargo, es dudoso que nuestro montaje llegue a alcanzar una masa de 2kg, y la amplitud de la respuesta tampoco se corresponde con la real. Así, no queda del todo claro el buen funcionamiento de nuestro acelerómetro. Por mucha imprecisión que haya para determinar la masa del objeto suspendido, no podemos afirmar que la salida es coherente. Hay que tener en cuenta varios factores. En primer lugar, la aceleración que obtenemos del modelo de péndulo es la aceleración tangencial. Desconocemos cualquier dato o medida acerca de la componente normal de la aceleración. El acelerómetro mide la aceleración que se produce en el eje x y en el eje y, no detecta componente normal y tangencial. De todas formas, esto no sería un problema si somos capaces de determinar al menos una de las componentes de la aceleración de forma precisa. De forma que la entrada que le estamos dando al modelo en Simulink no es correcta. Con un escalón como entrada al péndulo no solucionamos nuestro problema, la indeterminación que tenemos es la misma.

4.2.2.2. Comparación de ambos acelerómetros, sin péndulo

A partir de las conclusiones del apartado anterior, llegamos a la idea de utilizar la aceleración tangencial para comprobar la veracidad de nuestro modelo.



Las gráficas que obtenemos de LabView las hemos conseguido llevando el péndulo a la posición de 90º con respecto al soporte que lo sujeta y dejándolo oscilar libremente, bajo la acción de la fuerza gravitatoria y la fricción con el aire. Pues bien, sabemos gracias a la Física que en el punto más alto de su trayectoria, donde forma los 90º con el soporte, la velocidad se hace nula, pero la aceleración tangencial es máxima. Y en el punto en el que el objeto suspendido forma 0º con el soporte, es decir, en el punto medio de su recorrido, la velocidad es máxima, de forma que la componente tangencial es nula. Intentamos entonces introducir a la entrada del acelerómetro ADXL311 una entrada que cumpla estas condiciones, que sea máxima al inicio de su recorrido y vaya decreciendo hasta hacerse cero en la cuarta parte de su periodo (el péndulo pasa dos veces por el punto medio para completar un ciclo de su movimiento). La función matemática que buscamos puede ser una onda senoidal, de frecuencia igual a la frecuencia natural del péndulo y fase 90º. Para que pare justo en el instante que llega a cero, podemos multiplicarla por un escalón unitario de tamaño la cuarta parte del periodo de la señal. Lo primero que necesitamos es averiguar la frecuencia natural del péndulo. Esta viene dada directamente por fórmulas matemáticas y es independiente de la masa del objeto suspendido. Sólo depende de la longitud del péndulo. Recordando la expresión 4.16, en la que teníamos el periodo del péndulo:

2 JTmgl

π= (4.17)

Y sabiendo que el momento de inercia J es igual a la masa por la longitud del

hilo al cuadrado, 2J ml= , el periodo queda como 2 lTg

π= , expresión

completamente independiente de la masa del objeto. Se deduce que el tiempo de oscilación es independiente de la masa. La frecuencia natural de oscilación del péndulo es, pues:

2Tπω = 1f

T= (4.18)

2Tπω = (4.19)

Según quiera expresarse en Hz o en rad/s. En nuestro caso, en el que la longitud del péndulo es de 52cm, la frecuencia natural y el periodo toman los siguiente valores: T = 1’4473 s (4.20)



fn = 0’6909 Hz (4.21) ωn = 4’3412 rad/s (4.22) Para construir la señal de entrada utilizamos una función seno con frecuencia igual a fn y desfase de 90º, y un escalón unitario desde t = 0 hasta t = T/4, y cero el resto del tiempo de simulación. Nos faltaría definir la amplitud de entrada, pero no estamos seguros de poder hacerlo correctamente. Aplicando los conocimientos de Física, podría pensarse en un principio que el módulo de la aceleración es igual al cuadrado de la velocidad angular por el radio de la trayectoria (en este caso, la longitud del péndulo). Sin embargo, esta expresión indica el módulo de la componente normal de la aceleración. Para el módulo de la aceleración tangencial simplemente se deriva la velocidad respecto al tiempo; y este dato no lo conocemos, teniendo en cuenta que, al no ser la aceleración constante, la velocidad varía en cada punto de su trayectoria. En principio, sólo sabemos que en el instante inicial la velocidad es nula y la aceleración tangencial máxima, mientras que ocurre justo lo contrario en el punto medio de su trayectoria. Tal como está, estamos introduciendo una aceleración de valor 1g. Para realizar esta simulación nos hemos basado en el archivo original del acelerómetro, el ADXL311main_3, y lo hemos modificado de acuerdo a las necesidades de esta idea. En esta ocasión ha sido necesario alargar el tiempo de simulación, situándolo en 0.8 segundos, y hemos reducido el paso máximo de simulación, debido al tiempo que tarda Matlab en llevarla a cabo, y a que no se necesita tanta precisión. Las demás opciones de simulación se mantienen sin modificaciones. El archivo con el código utilizado se adjunta en los anexos de esta memoria, bajo el nombre de ADXL311main_3prueba. A continuación se muestran los resultados de dicha simulación, así como la señal de entrada construida a tal efecto. En primer lugar, la entrada senoidal:



Fig. 4.31: entrada al ADXL311 que simula la aceleración tangencial a que está sometido

Puede comprobarse que el instante de valor igual a la cuarta parte del periodo es el punto en el que termina la senoide, siendo este instante igual a 0’3618 segundos. La respuesta del acelerómetro a esta entrada es la siguiente:

Fig. 4.32: respuesta del ADXL311 a la entrada senoidal



Podemos comprobar cómo la salida intenta seguir a la aceleración de entrada. Se observa un pequeño retraso al comienzo de la respuesta y cómo rápidamente trata de seguir la entrada. El periodo de la salida es igual al de la entrada, lo comprobamos a continuación poniendo a la entrada del acelerómetro la misma senoide empleada aquí pero sin limitarla con un escalón y dejando que oscile libremente tal y como sería en un péndulo ideal. Con un tiempo de simulación de 5 segundos tenemos suficiente para realizar la comprobación:

Fig. 4.33: entrada al ADXL311 que simula la aceleración tangencial con tstop = 5 s



Fig. 4.34: respuesta del ADXL311 a la entrada senoidal con tstop = 5 s

En las gráficas podemos comprobar que el periodo de oscilación se cumple a la salida y vemos cómo la respuesta tarda un pequeño tiempo en ser capaz de seguir a la aceleración que está midiendo a la entrada. En la siguiente figura podemos apreciar este retraso con más detalle:

Fig. 4.35: detalle retraso en la respuesta del ADXL311



Llegados a este punto podemos decir que el acelerómetro parece que se comporta adecuadamente en simulación, pero falta compararlo con el modelo real y ver si realmente podemos asegurar su correcto funcionamiento. Para ello lo comparamos con las gráficas obtenidas en el laboratorio gracias al montaje experimental y el software LabView. A continuación se muestran algunas de las gráficas obtenidas con este método:

Fig. 4.36: respuesta del ADXL311 real al principio de la oscilación libre

Fig. 4.37: respuesta del ADXL311 real a la oscilación libre empezando a parar

Fig. 4.38: respuesta del ADXL311 real a la oscilación libre parándose



Fig. 4.39: respuesta del ADXL311 real a la oscilación libre parándose

Antes de analizar estas gráficas y compararlas con el modelo en Simulink debemos recordar que tenemos que fijarnos únicamente en la componente tangencial de la aceleración, aunque aquí hayamos puesto las dos componentes para apreciar mejor la oscilación. En ellas se muestra medio periodo de la aceleración tangencial, que oscila a una frecuencia igual a la mitad de la frecuencia de la componente normal. En esta última sí se muestra un periodo completo de la señal. Igualmente comprobamos que el periodo también se cumple a la salida del modelo real, en torno a 1’5 segundos para la aceleración tangencial. En cuanto a la forma de la onda, es una senoide aunque aparece distorsionada por el ruido. En la siguiente figura, también extraída de LabView, aunque de tamaño algo inferior, se aprecia el movimiento ondulatorio que sigue la componente tangencial.

Fig. 4.40: detalle de la aceleración tangencial

Con esta última comprobación concluimos que el modelo en Simulink diseñado cumple con lo esperado y es muy parecido a un modelo real del mismo. Sólo nos falta, para que concuerde con mayor exactitud, precisar la amplitud de la senoide de entrada y comprobar que el valor obtenido concuerda con el real.



4.3. Resumen Vamos a intentar recoger, a modo de resumen, los principales intentos de verificación del modelo y las conclusiones a las que se llegaron. En primer lugar, debemos recordar que carecíamos de datos suficientes para poder dar por válida la simulación, pues desconocíamos las dimensiones de la estructura interna del acelerómetro y, por tanto, tampoco podíamos precisar el volumen de la misma. Entonces, tanto para conseguir una estimación del volumen, necesario para poder realizar la simulación, como para poder verificarla y ver que es correcta, necesitamos utilizar el montaje del laboratorio. La primera alternativa consistió en intentar obtener la función de transferencia del sistema a partir del modelo real, para así adaptar el modelo de bloques en Simulink y asegurar su validez. Esta solución no resultó sobre todo por las incoherencias mostradas por la salida de la simulación al sustituirla por la función de transferencia obtenida experimentalmente. Las gráficas de las respectivas salidas no coincidían ni en la forma ni en sus características principales, tales como el tiempo de subida (mucho mayor), y no podíamos determinar de forma precisa la entrada al sistema. Como segunda alternativa teníamos la comparación del modelo completo de péndulo más acelerómetro con la simulación. Para ello se construyó un modelo de péndulo físico en Simulink y se simuló el conjunto entero, pero la salida tampoco era satisfactoria. Los resultados carecían de coherencia, sobre todo a causa de la entrada al sistema, que tampoco éramos capaces de determinar, al igual que en el caso anterior. Para la tercera alternativa, y definitiva, se consiguió discernir una entrada más fiable y similar a la realidad, de forma que la salida del acelerómetro pudiera medirse tanto en el modelo real como en la simulación. Para ello se trabajó con la componente tangencial de la aceleración, de la que conocíamos su comportamiento gracias a la Física, y se simuló como una onda senoidal con valor 1 en el instante inicial (formando 90º con el soporte) y 0 en el instante en que pasaba por el punto medio de su trayectoria (instante igual a la cuarta parte del periodo). Con esta solución se han conseguido a los resultados deseados, pudiéndose asegurar la validez de la simulación desarrollada.


CAPÍTULO 5

CONCLUSIONES Y

DESARROLLOS FUTUROS

Estudio de modelos de acelerómetros Conclusiones y mejoras


5. Conclusiones y desarrollos futuros

Este apartado pretende mostrar los resultados obtenidos, con los que ver las posibilidades reales del programa, y esclarecer algún punto que no haya quedado definido en capítulos anteriores, así como dejar una puerta abierta a posibles mejoras y desarrollos del programa para hacerlo más completo.

5.1. Conclusiones A lo largo de este proyecto se ha realizado un estudio de los diferentes tipos de sensores con el fin de introducir al mundo de los acelerómetros a un lector con poca idea sobre el tema. Se ha analizado características y tecnología de cada uno de ellos, así como numerosas aplicaciones. La finalidad del proyecto ha sido desarrollar un simulador que permita al usuario crear su propio acelerómetro y ver los resultados que obtendría con él. El objetivo se ha cumplido, al menos en gran parte, pero aquí dejamos constancia de algunas mejoras a las que está abierto el diseño para hacerlo más amplio y completo. En capítulos anteriores se ha explicado, con ayuda de gráficas, los motivos y causas que llevaron a la metodología seguida para completar nuestro diseño. En primer lugar se siguió la información aportada por libros de contrastados autores sobre acelerómetros y microsistemas, hasta que esa información no fue suficiente para acabar el modelado. Luego se dio a entender que seguíamos una metodología basada en una labor de ingeniería inversa para poder hallar la función de transferencia del sistema. Más tarde se comprobó que con este método no llegábamos a resultados claros, y optamos por comparar ambos modelos para corroborar nuestra simulación e intentar aproximar la función de transferencia. Ahora intentamos mostrar que esta aproximación seguida es fiable, aunque no sea completamente precisa.

5.1.1. Conclusiones acerca del cálculo del volumen de la estructura Como decíamos al principio de la memoria, este modelo de simulación debe poder servir para cualquier tipo de acelerómetro, sólo hay que darle los valores apropiados de acuerdo con su estructura interna. El ADXL311 es un acelerómetro capacitivo, y la estructura de este tipo de dispositivos es similar. Fundamentalmente varía el número de electrodos, fijos y



móviles, y sus dimensiones. Basándonos en el libro mencionado en el capítulo 4.2, intentamos hacer un estudio de su estructura para conseguir datos más o menos precisos de su volumen y dimensiones. Las medidas de la estructura están definidas, sin embargo, al realizar nosotros un cálculo “a mano” del volumen de la estructura, obtenemos un valor algo inferior al que da el libro, aunque sí del mismo orden de magnitud. Se ha pensado en introducir una constante de proporcionalidad para intentar suplir esta diferencia entre volumen de la estructura original y la aproximación calculada. Sin embargo, no sería un método para compensar el error cometido con dicha aproximación, sino que simplemente obtendríamos un volumen de forma más exacta para el tipo de acelerómetros tratados en el libro y cometeríamos un error aún mayor para otros. Finalmente decidimos dejar la aproximación sin más, aún siendo conscientes del error cometido. Así, basándonos en estos datos teóricos, en el modelo original proporcionado por Analog Devices y por los resultados del montaje experimental que tenemos en el laboratorio del departamento, creemos que la expresión (5.1) que representa el volumen genérico de un acelerómetro capacitivo es una buena aproximación, pues los resultados nos avalan. La formula final del volumen de la estructura, a partir de la cual obtenemos la masa de la misma, es: [( ) (4 )]V nWL WL H= + [μm3] (5.1) Donde n representa el número de vigas de que constará la estructura, y W, L y H son las dimensiones introducidas por el usuario. El primer término del corchete representa el área de los electrodos móviles adheridos a la estructura. El segundo término se refiere a las vigas superior e inferior, de doble anchura a los electrodos.

5.1.2. Algunas simulaciones del modelo diseñado A continuación mostramos, a modo de ejemplo, algunos resultados obtenidos como respuesta a las señales de entrada de que disponemos en el programa. Introducimos estos valores para el diseño:



Fig. 5.1: dimensiones para un acelerómetro

Ante una entrada escalón:

Fig. 5.2: detalle del tipo de entrada y su amplitud

La respuesta del diseño sería:

Fig. 5.3: respuesta del sistema a una entrada escalón

Ante una entrada senoidal de 100Hz de frecuencia:

Fig. 5.4: detalle del tipo de entrada y su amplitud y frecuencia



La salida sería la siguiente:

Fig. 5.5: respuesta del sistema a una entrada senoidal

Por último, frente a un impulso de amplitud 5:

Fig. 5.6: detalle del tipo de entrada y su amplitud

Fig. 5.7: respuesta del sistema a una entrada impulso



Puede comprobarse que ante un impulso de la amplitud que sea, el sistema siempre responde con ruido a su salida. Esto puede deberse a que con un impulso el sistema no recibe una entrada durante el tiempo suficiente para poder detectarla. Al fin y al cabo, un impulso es una fuerza aplicada durante un instante de tiempo, y la sensibilidad del sensor puede que no sea válida para tiempos tan pequeños.

5.2. Problemas encontrados en el desarrollo de la simulación Esta sección la dedicamos a comentar las principales dificultades que nos ha planteado el desarrollo del programa para simular el acelerómetro. El principal de los problemas ha sido el desconocimiento por parte del alumno del programa en el que se ha implementado la simulación. Esto conlleva un periodo de adaptación al software y a su funcionamiento y manejo no prevista al comienzo del proyecto. La falta de conocimientos en Simulink ha sido absoluta, aunque no ha presentado demasiados problemas para desarrollar el objetivo fundamental del proyecto. Conocer el funcionamiento de la simulación por parte de la herramienta no ha resultado complicado, sin embargo, intentar añadir nuevos bloques a los diagramas y adecuar la simulación al dominio de la frecuencia no ha resultado fácil en un principio, e incluso no se ha podido completar este objetivo. La programación de las funciones principales con el editor de Matlab sí ha resultado más complicada de lo previsto, dada las peculiaridades de Matlab respecto a otros lenguajes de programación ya empleados con anterioridad en la licenciatura. Aunque el lenguaje básico de programación es muy parecido al lenguaje C, uno de los más conocidos y cuyo aprendizaje en primer curso sentó unas bases de programación aplicables a muchos de los lenguajes existentes actualmente, Matlab presenta algunos puntos que lo diferencian y con los que el alumno ha tenido que lidiar, a veces con menos éxito del que se esperaba. A pesar de todo, el resultado final es satisfactorio, aunque ha llevado más tiempo del previsto en un principio. Una de las ventajas de Matlab es la gran variedad de funciones que incluye en su biblioteca, prácticamente hay, al menos, una función para cada propósito. Sin embargo, a veces uno de los problemas puede ser encontrar dicha función. Conocemos nuestro propósito, lo que deseamos hacer, pero no cuál es la función de Matlab que nos ayudaría en ese momento.



Esto hace que, a veces, el usuario intente programar esa función y, un tiempo después, encuentre la suministrada por Matlab, ya sea por casualidad o porque ha ido acotando la búsqueda, aprendiendo cómo “piensa” Matlab. La consecuencia de todo esto es, simplemente, alargar el tiempo de desarrollo del programa. Igualmente, la falta de información sobre el funcionamiento y, sobre todo, el desconocimiento de la existencia de GUIDE dentro de Matlab retrasó bastante su desarrollo y puesta en marcha. En un principio se empezó la programación directamente con el editor de texto de Matlab, sin tener conocimiento de la interfaz gráfica, hasta que se vio que Matlab ofrecía la posibilidad de crear un entorno gráfico mucho más elegante y cómodo para el trabajo que lo que se estaba intentando hasta el momento. A partir de aquí, lo más complicado fue entender el funcionamiento de la interfaz, como en cualquier programa que se empieza a usar por primera vez, hasta llegar a manejar con soltura los conceptos básicos de su estructura. Por lo demás, puede decirse que los principales problemas encontrados se han debido a las dificultades propias de la programación. Esto es, hallar la mejor forma de programar cierta función, intentando evitar el empleo de variables globales, aprovechando la estructura de manejadores handles que ofrece GUI, simplificando el código en la medida de lo posible, siendo claro y concreto en cada momento, etc. Y, sobre todo, el hecho de que, en cualquier trabajo que implique programación, la mayoría de los problemas suelen tener una solución simple, pero costosa de encontrar. Al igual que ocurre cuando buscamos un objeto en los bolsillos de un pantalón, siempre la solución está en el último lugar en que se mira. Como ejemplo, citamos uno de los mayores problemas que se presentaron; debido al hecho de que al utilizar GUI, el espacio de trabajo de Matlab (donde se almacenan las variables y constantes que se van creando durante la ejecución del programa) cambia desde al actual a otro. Al cargar los archivos de constantes y variables necesarios, Matlab no encontraba dichas variables; dar con la solución llevó más tiempo que otra cosa, pues con incluir dos órdenes en las opciones de simulación se solucionó el problema.

5.3. Desarrollos futuros y posibles mejoras Este apartado ha sido creado para intentar plasmar algunas ideas que han ido surgiendo durante el desarrollo del proyecto, con el objetivo de mejorar el programa y añadir alguna funcionalidad útil, para un mejor aprovechamiento del mismo. Una de las primeras metas del proyecto, antes de intentar cualquier tipo de interfaz y simulación del dispositivo, fue conseguir una respuesta en frecuencia del acelerómetro con Simulink.



La idea era ir familiarizándose con el manejo de Simulink a la vez que se intentaba buscar una simulación en el dominio frecuencial, bastante útil para estudios posteriores. Sin embargo, no se consiguió completar este objetivo, los resultados obtenidos no fueron satisfactorios. En principio lo achacamos a la inexperiencia en la utilización del programa, por lo que decidimos seguir adelante con la simulación en el dominio del tiempo, dejando un poco apartado esta finalidad. En cuanto al programa desarrollado, su interfaz y la simulación, proponemos algunas mejoras para hacer más cómodo su manejo y más completo el diseño. En primer lugar, habría que conseguir un método para calcular el volumen de la estructura de una forma más exacta y precisa. La falta de información sobre la estructura del acelerómetro en cuestión (el ADXL311) ha hecho el diseño más complicado de lo que parecía en un principio, aunque también ha aportado un punto de interés en cuanto a que ha habido que investigar varias formas para conseguir la función de transferencia del acelerómetro. La función de transferencia, como se ha explicado en capítulos anteriores, depende del volumen de la estructura, y en nuestro caso hemos tenido que hacer alguna aproximación sobre ella. Algunas zonas de la estructura no han podido determinarse con exactitud, por ello el diseño no es totalmente preciso. La dificultad de esta posible mejora radica en que no resulta fácil conocer dicha estructura tan detalladamente, puesto que en la bibliografía consultada sólo se ha encontrado el ADXL150 comentado con un cierto grado de profundidad (y aún así faltaban algunos datos relevantes), y desde el fabricante no han consentido proporcionarnos más información (se escribió un correo electrónico solicitando dicha información, pero no hallamos respuesta). Por otra parte, como otra mejora del programa proponemos poner límites a las dimensiones del diseño. Tal como se ha programado la interfaz, el usuario puede introducir como dimensiones W, H y L las que desee, pero en ningún momento se indica el área final de la estructura ni si esta sobrepasa unos límites dentro de lo habitual en estos casos, como podría ser, por ejemplo, un área de 500x500 μm2. El botón guardar de la interfaz también está abierto a mejoras, desde nuestro punto de vista. Tal como se ha diseñado aquí, solamente se puede almacenar una gráfica durante la ejecución de la interfaz. La mejora consistiría fundamentalmente en solucionar esta limitación, permitiendo almacenar varias gráficas y asignarles nombres para ser capaces de identificarlas posteriormente. Matlab ofrece varias funciones para ello, siendo save la empleada en este proyecto, con la que salvamos la variable deseada en un archivo .mat con el nombre deseado. Otras alternativas serían emplear la función uiputfile, la cual abre el conocido cuadro de diálogo para guardar archivos nombrándolo como deseemos,



y uigetfile, para recuperar los archivos. De todas formas no se ha comprobado su eficacia. También podría añadirse un nuevo botón a la interfaz con la función de comparar las gráficas actuales con una almacenada anteriormente. Como última mejora propuesta, podemos matizar que en este programa se ha empleado el polisilicio como material de fabricación de acelerómetros. Realmente es el material más extendido, pero hay otros. Para ello puede utilizarse un menú desplegable (llamados por GUIDE pop-up menus) en el que se ofrezcan varias opciones al usuario, polisilicio, aluminio, etc. Y en el callback correspondiente se asigne directamente el valor del módulo de Young y la densidad del material, de forma transparente al usuario. Una buena mejora sería diseñar nuevas entradas para el acelerómetro, como por ejemplo, señales que simulen aceleraciones bruscas, tanto positivas como negativas, para comprobar su eficacia ante frenazos en automóviles. Estas son las principales propuestas de mejora sobre el programa, algunas de ellas ideadas en la fase final del proyecto pero sin apenas tiempo para llevarlas a cabo de forma satisfactoria. Hay muchas más, sólo hay que dedicarle un poco de tiempo e ingenio para hacer el programa más completo y cómodo de manejo.


CAPÍTULO 6

BIBLIOGRAFÍA

Estudio de modelos de acelerómetros Bibliografía


6. Bibliografía [1] Stephen D. Senturia, “Microsystems Design”. Kluwer Academic Publishers, 2000 [2] J.A. Hidalgo y M. R. Fernández, “Física General”, Ed. Everest, 1996 [3] Manual Básico de Matlab 6.5 y 7.0 [4] Diego O. Barragán Guerrero, “Manual de interfaz gráfica de usuario en Matlab” [5] Data sheet Acelerómetro ADXL311, Analog Devices, www.analog.com


CAPÍTULO 7

ANEXOS

Estudio de modelos de acelerómetros Anexos


7. Anexos Estos apéndices pretenden complementar el proyecto con la inclusión del código para la implementación de la simulación y las pruebas realizadas, y el data sheet del ADXL311.



7.1. Anexo A: código de programa de simulación y prueba

7.1.1. Código del archivo interfaz.m Código de la función que genera la interfaz gráfica y la simulación del acelerómetro. function varargout = interfaz(varargin) % INTERFAZ M-file for interfaz.fig % INTERFAZ, by itself, creates a new INTERFAZ or raises the % existing singleton*. % % H = INTERFAZ returns the handle to a new INTERFAZ or the % handle to the existing singleton*. % % INTERFAZ('CALLBACK',hObject,eventData,handles,...) calls % the local function named CALLBACK in INTERFAZ.M with the % given input arguments. % % INTERFAZ('Property','Value',...) creates a new INTERFAZ or % raises the existing singleton*. Starting from the left, % property value pairs are applied to the GUI before % interfaz_OpeningFunction gets called. An unrecognized % property name or invalid value makes property application % stop. All inputs are passed to interfaz_OpeningFcn via. % % varargin % Last Modified by GUIDE v2.5 29-Jun-2008 17:55:38 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @interfaz_OpeningFcn, ... 'gui_OutputFcn', @interfaz_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin1) gui_State.gui_Callback = str2func(varargin1); end if nargout [varargout1:nargout] = gui_mainfcn(gui_State, varargin:); else gui_mainfcn(gui_State, varargin:); end % End initialization code - DO NOT EDIT % --- Executes just before interfaz is made visible. function interfaz_OpeningFcn(hObject, eventdata, handles, varargin) scrsz = get(0, 'ScreenSize'); pos_act=get(gcf,'Position'); xr=scrsz(3) - pos_act(3); % para centrar la interfaz en la pantalla



xp=round(xr/2); yr=scrsz(4) - pos_act(4); yp=round(yr/2); set(gcf,'Position',[xp yp pos_act(3) pos_act(4)]); figura = imread('esquema_interfaz6.bmp'); % lee la imagen axes(handles.esquema); % carga la imagen axis off; % para desactivar líneas imshow(figura); % muestra la imagen handles.output = hObject; guidata(hObject, handles); % UIWAIT makes interfaz wait for user response (see UIRESUME) % uiwait(handles.figure1); % --- Outputs from this function are returned to the command line. function varargout = interfaz_OutputFcn(hObject, eventdata, handles) varargout1 = handles.output; function valor_W_Callback(hObject, eventdata, handles) handles.valor_W = get(hObject, 'String'); % almacena el valor % escrito por el usuario guidata(hObject, handles); % guarda los cambios de % la aplicación function valor_W_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function valor_L_Callback(hObject, eventdata, handles) handles.valor_L = get(hObject, 'String'); % almacena el valor escrito por el usuario guidata(hObject, handles); % guarda los cambios de la aplicación function valor_L_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end



function valor_H_Callback(hObject, eventdata, handles) handles.valor_H = get(hObject, 'String'); % almacena el valor % escrito por el usuario guidata(hObject, handles); % guarda los cambios de la aplicación function valor_H_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function numero_vigas_Callback(hObject, eventdata, handles) handles.numero_vigas = get(hObject, 'String'); % almacena el % valor escrito por el usuario guidata(hObject, handles); % guarda los cambios de la aplicación function numero_vigas_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function limpiar_Callback(hObject, eventdata, handles) % el objetivo es resetear los cuadros de texto en los que el usuario % introduce datos manualmente; estos serían los correspondientes a las % funciones 'valor_W', 'valor_L', 'valor_H', 'amplitud_impulso', % 'amplitud_escalon', 'amplitud_senoide' y 'frecuencia_senoide' clear all; % borramos variables (no estoy seguro d q sea necesario) clc; % limpia la pantalla % otorgamos el control de los objetos que queremos resetear a otras % nuevas variables creadas para tal efecto reset_W = findobj(gcbf, 'Tag', 'valor_W'); % variables con las reset_L = findobj(gcbf, 'Tag', 'valor_L'); % propiedades de los reset_H = findobj(gcbf, 'Tag', 'valor_H'); % objetos con esas Tags reset_numero_vigas = findobj(gcbf, 'Tag', 'numero_vigas'); reset_amplitud_impulso = findobj(gcbf, 'Tag', 'amplitud_impulso'); reset_amplitud_escalon = findobj(gcbf, 'Tag', 'amplitud_escalon'); reset_amplitud_senoide = findobj(gcbf, 'Tag', 'amplitud_senoide'); reset_frecuencia_senoide = findobj(gcbf, 'Tag', 'frecuencia_senoide');



reset_masa = findobj(gcbf, 'Tag', 'masa'); reset_constante_k = findobj(gcbf, 'Tag', 'constante_k'); limpia = char(' '); % carácter espacio en blanco set(reset_W, 'String', limpia); % ponemos un espacio en set(reset_L, 'String', limpia); % blanco en lugar de la set(reset_H, 'String', limpia); % cadena anterior set(reset_numero_vigas, 'String', limpia); set(reset_amplitud_impulso, 'String', limpia); set(reset_amplitud_escalon, 'String', limpia); set(reset_amplitud_senoide, 'String', limpia); set(reset_frecuencia_senoide, 'String', limpia); set(reset_masa, 'String', limpia); set(reset_constante_k, 'String', limpia); function salir_Callback(hObject, eventdata, handles) % abrimos un cuadro de diálogo que pregunte si realmente se desea % salir del programa; en caso afirmativo, se eliminan las variables % del espacio de trabajo y se limpia la pantalla. Si no se quiere % salir aún, no ocurre nada. pregunta = questdlg('¿Desea salir del programa?','SALIR','Sí','No','No'); % la cadena 'No' se repite para quedar resaltada en el cuadro de % diálogo la función 'strcmp' compara dos cadenas y devuelve un % '1' si son iguales if strcmp(pregunta,'No') % si la respuesta es 'No', la interfaz return; % sigue abierta, salimos de esta función end clear all, clc % clear all elimina variables del workspace % clc limpia la pantalla close (gcbf) % cierra la interfaz si la respuesta fue 'Sí' function simulacion_Callback(hObject, eventdata, handles) % antes de efectuar cualquier operación, comprobamos los datos % introducidos por el usuario en los cuadros de texto % para ello recorremos las cadenas introducidas desde teclado en las % funciones 'valor_W', 'valor_L', 'valor_H', 'amplitud_impulso', % 'amplitud_escalon', 'amplitud_senoide' y 'frecuencia_senoide' % estas cadenas están almacenadas en los manejadores de dichas, % funciones y por cada una de ellas creamos una variable más, que % contiene la longitud de la cadena para poder recorrerla con el bucle % for; también se crea una bandera para determinar cuándo hay error. % Si lo hay, se muestra un mensaje en la pantalla indicándolo y % salimos de la función.



% comprobación 'valor_W' n_valor_W = length(handles.valor_W); % numero caracteres de la cadena valor_W bandera = 0; % inicializamos bandera a 0; % en caso de error, pasará a valer 1 for i=1:n_valor_W if(isletter(handles.valor_W(i))) % si hay letras, bandera = 1 bandera = 1; else % si no hay error valor_W = str2double(handles.valor_W); % convertimos a double end % para poder trabajar % con los datos end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'valor_L' n_valor_L = length(handles.valor_L); % numero caracteres de la % cadena valor_L bandera = 0; % volvemos bandera a 0; % en caso de error, pasará a valer 1 for i=1:n_valor_L if(isletter(handles.valor_L(i))) % si hay letras, bandera = 1 bandera = 1; else % si no hay error valor_L = str2double(handles.valor_L); % convertimos a end % double para poder % trabajar con los datos end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'valor_H' n_valor_H = length(handles.valor_H); % numero caracteres de la cadena % valor_H bandera = 0; % volvemos bandera a 0; % en caso de error, pasará a valer 1 for i=1:n_valor_H if(isletter(handles.valor_H(i))) % si hay letras, bandera = 1 bandera = 1; else % si no hay error valor_H = str2double(handles.valor_H); % convertimos a double end % para poder trabajar % con los datos end



% si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'numero_vigas' n_numero_vigas = length(handles.numero_vigas); % numero % caracteres de la cadena numero_vigas bandera = 0; % volvemos bandera a 0; % en caso de error, pasará a valer 1 for i=1:n_numero_vigas if(isletter(handles.numero_vigas(i))) % si hay letras, bandera = 1 bandera = 1; else % si no hay error numero_vigas = str2double(handles.numero_vigas); % convertimos a double para poder trabajar con los datos end end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'amplitud_impulso' n_amplitud_impulso = length(handles.amplitud_impulso); % número caracteres de la cadena amplitud_impulso bandera = 0; % volvemos bandera a 0; % en caso de error, pasará a valer 1 for i=1:n_amplitud_impulso if(isletter(handles.amplitud_impulso(i))) % si hay letras, % bandera = 1 bandera = 1; else % si no hay error amplitud_impulso = str2double(handles.amplitud_impulso); % convertimos a double para poder trabajar con los datos end end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'amplitud_escalon' n_amplitud_escalon = length(handles.amplitud_escalon); % numero caracteres de la cadena amplitud_escalon bandera = 0 % volvemos bandera a 0; % en caso de error, pasará a valer 1 for i=1:n_amplitud_escalon if(isletter(handles.amplitud_escalon(i))) % si hay letras, % bandera = 1 bandera = 1;



else % si no hay error amplitud_escalon = str2double(handles.amplitud_escalon); % convertimos a double para poder trabajar con los datos end end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'amplitud_senoide' n_amplitud_senoide = length(handles.amplitud_senoide); % numero caracteres de la cadena amplitud_senoide bandera = 0; % volvemos bandera a 0 % en caso de error, pasará a valer 1 for i=1:n_amplitud_senoide if(isletter(handles.amplitud_senoide(i))) % si hay letras, % bandera = 1 bandera = 1; else % si no hay error amplitud_senoide = str2double(handles.amplitud_senoide); % convertimos a double para poder trabajar con los datos end end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return; end % comprobación 'frecuencia_senoide' n_frecuencia_senoide = length(handles.frecuencia_senoide); % numero caracteres de la cadena frecuencia_senoide bandera = 0; % volvemos bandera a 0 % en caso de error, pasará a valer 1 for i=1:n_frecuencia_senoide if(isletter(handles.frecuencia_senoide(i))) % si hay letras, % bandera = 1 bandera = 1; else % si no hay error frecuencia_senoide = str2double(handles.frecuencia_senoide); % convertimos a double para poder trabajar con los datos end end % si la cadena contenía alguna letra, se muestra el mensaje de error if(bandera==1) errordlg('Ha introducido caracteres no válidos','ERROR'); return;



end % una vez comprobados todos los datos, pasamos a calcular todo lo % necesario para la simulación % en primer lugar, obtenemos el valor de la masa del conjunto y la % constante elástica del mismo % la constante elástica viene determinada directamente por las % dimensiones del dispositivo E = 169; % módulo de Young del polisilicio numerador_k = (pi^4)*E*valor_W*(valor_H^3); denominador_k = 12 * (valor_L^3); K = 2*(numerador_k / denominador_k)* 1e03; % multiplicamos por 2 % porque hay 2 vigas % para calcular la masa, necesitamos conocer el volumen % una vez conseguido el volumen, la masa es fácil de obtener % simplemente multiplicaríamos dicho volumen por la densidad del % material con el que se vaya a fabricar, polisilicio en nuestro % caso V = [(numero_vigas * valor_W * valor_L) + (2 * valor_L * valor_W * 2)] * valor_H * 1e-18; % ya tenemos el volumen; multiplicamos por la densidad del % polisilicio densidad_poly = 2330; % expresada en kg/m3 m = densidad_poly * V; set(handles.masa, 'String', m); set(handles.constante_k, 'String', K); % poner las fórmulas correctas % ahora establecemos las constantes y matrices adecuadas para % realizar la simulación; antes que nada se carga en el espacio de % trabajo el archivo de inicialización de variables del archivo de % simulink ADXL311_constants; % lee los datos iniciales, constantes y variables %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % a continuación, la escala de tiempos, para establecer una base % de tiempo: tiempo de parada de la simulación y máximo tamaño del % intervalo xtstop=0.2; % final de la simulación (segundos) ytstop=0.2; % final de la simulación (segundos) reltol=1e-7; % tolerancia relativa



maxstep=0.1e-5; % máximo paso durante la simulación (segundos) % Opciones de simulación OPTIONS = simset('RelTol',reltol,'MaxStep',maxstep, 'SrcWorkspace', 'current'); % con 'SrcWorkspace' establecido a 'current' conseguimos % que reconozca las variables y constantes de ADXL311_constants, % tomando como espacio de trabajo el actual % Establecemos la base de tiempos T=[0:maxstep:xtstop]'; % matriz columna de (xtstop/maxstep +1)elementos % bucle if...elseif para ver qué simulación hay que hacer; se % comprueba qué botón ha sido seleccionado, y se establecen los % parámetros necesarios para realizar la simulación global impulso; % es necesario volver a declarar las variables % globales global escalon; % se declararon por primera vez en la función de global senoide; % selección de botón del panel if (impulso) xinamp = amplitud_impulso; % amplitud de entrada, % recibida por teclado yinamp = 0; zinamp = 0; % establecidas a 0 long = size(T); % variable de valor la dimensión de T % las uit deben tener igual dimensión que T u1t = [xinamp zeros(1,(long(1)-1))]'; % construímos matriz con el primer elemento igual a la amplitud % deseada y el resto ceros u2t = [yinamp zeros(1,(long(1)-1))]'; u3t = zeros(size(T)); % establecida a 0 U=[T,u1t,u2t,u3t]; %matriz d entrada elseif (escalon) xinamp = amplitud_escalon; % amplitud de entrada, % recibida por teclado yinamp = amplitud_escalon; % amplitud de entrada, % recibida por teclado zinamp = 0; % establecida a 0 u1t = xinamp*ones(size(T)); % hay que conseguir que tengan % igual dimensión que la matriz T u2t = yinamp*ones(size(T)); % para ello construímos matrices % columna con el primer elemento igual



u3t = zinamp*ones(size(T)); % a la amplitud deseada y el resto 1 U = [T,u1t,u2t,u3t]; % matriz de entrada; u1t, u2t, u3t % corresponden cada una a un puerto de % entrada elseif (senoide) xinamp = amplitud_senoide; % amplitud de entrada, % recibida por teclado yinamp = amplitud_senoide; % amplitud de entrada, % recibida por teclado zinamp = 0; % establecida a 0 xinfreq = frecuencia_senoide; % frecuencia de la senoide, recibida por teclado yinfreq = frecuencia_senoide; % frecuencia de la senoide, recibida por teclado zinfreq = frecuencia_senoide; % frecuencia de la senoide, recibida por teclado u1t = xinamp*sin(2*pi*xinfreq*T); % entradas senoidales, de igual dimensión que T u2t = yinamp*sin(2*pi*yinfreq*T); % en este caso tendríamos la amplitud deseada por % una matriz de senos de tamaño T u3t = zinamp*sin(2*pi*zinfreq*T); U = [T,u1t,u2t,u3t]; % matriz de entrada end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Realizamos la simulación; se le indica el nombre del archivo a % simular el tiempo de parada de la simulación (el inicial es % t=0), las opciones especificadas anteriormente y la matriz de % entrada [t,X,Y]=sim('ADXL311_3',xtstop,OPTIONS,U); global matriz; matriz = [t, X, Y]; % almacena la matriz q va a generar la gráfica %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Se dibujan las gráficas %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% axes(handles.entrada) hold off plot(t,Y(:,1)) grid on ylabel('Acceleration (g)') xlabel('Time (seconds)') orient tall %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% axes(handles.salida)



hold off plot(t,Y(:,2)) grid on ylabel('Volts') xlabel('Time (seconds)') orient tall %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function amplitud_escalon_Callback(hObject, eventdata, handles) handles.amplitud_escalon = get(hObject, 'String'); guidata(hObject, handles); function amplitud_escalon_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function amplitud_impulso_Callback(hObject, eventdata, handles) handles.amplitud_impulso = get(hObject, 'String'); guidata(hObject, handles); function amplitud_impulso_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function amplitud_senoide_Callback(hObject, eventdata, handles) handles.amplitud_senoide = get(hObject, 'String'); guidata(hObject, handles); function amplitud_senoide_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % -------------------------------------------------------------------- function entradas_SelectionChangeFcn(hObject, eventdata, handles) global impulso; % declaramos estas variables como globales, global escalon; % necesarias para que la función 'simulación' sepa global senoide; % qué entrada ha sido seleccionada impulso=0; % es necesario inicializar estas variables a '0'; en



escalon=0; % un principio no se conoce su valor; así, cada vez senoide=0; % que seleccionamos una entrada, las variables son % puestas a '0' y sólo pasan a '1' al seleccionar un % botón %al seleccionar una entrada, ponemos a '1' la variable global %correspondiente, impulso, escalón o senoide if (hObject==handles.impulso) impulso = 1; elseif(hObject==handles.escalon) escalon = 1; elseif(hObject==handles.senoide) senoide = 1; end guidata(hObject,handles); function frecuencia_senoide_Callback(hObject, eventdata, handles) handles.frecuencia_senoide = get(hObject, 'String'); guidata(hObject, handles); function frecuencia_senoide_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function guardar_Callback(hObject, eventdata, handles) global matriz; % se carga la variable global de nuevo save('grafica_salida'); % almacena la variable en el archivo con ese nombre

7.1.2. Código archivo ADXL311_constants.m y pendulo_constantes.m Funciones que determinan constantes necesarias para desarrollar la simulación. % ADXL311_constants.m % Coefficients for 5V operation only % Model coefficients % stg = .3 % g - Self test magnitude a = 8.374e-10 % X,Y axis beam coefficient b = 5.788e-6 % X,Y axis beam coefficient sens = .174 % V/g - Sensitivity bf = 50 % Hz - 3db frequency set by % external capacitor K = 12.54*sens % - Amplifier gain



e = 2.27e-5 % - Demod filter effects h = 1/(6.28*bf) % - Output filter coefficient w = 8.250e-10 % - Z axis beam coefficient g = 2.872e-5 % - Z axis beam coefficient zx = 0 % - Z response factor Xchannel zy = 0 % - Z response factor Ychannel yx = 0 % - Y response factor Xchannel xy = 0 % - X response factor Ychannel % pendulo_constantes.m % % definición de las constantes del péndulo % l = 0.52; % longitud en metros B = 2; % coef. de fricción viscosa en N.m/(rads/s) gra = 9.8; % aceleración de la gravedad m.s^2 m = 1; % masa en kg J = m*l^2; % momento de inercia en kg.m^2 periodo = 2*pi*sqrt(J/(m*l*gra)); %periodo del péndulo

7.1.3. Código archivo presentacion.m Función presentación del programa. function presentacion %*************************************************************** % presentación: función que presenta la pantalla de presentación %*************************************************************** clear,clc,cla,close all %Creamos figura figdiag=figure('Units','Normalized',... 'Position',[0.0725 0.0725 0.57 0.57],... %Tamaño de la presentacion 'Number','off',... 'Name','Proyecto fin de carrera', ... 'Menubar','none', ... 'color',[0 0 0]); %Ubicamos ejes en figura axes('Units','Normalized',... 'Position',[0 0 1 1]); %Incluir imagen %Importamos imagen *.jpg, junto con su mapa de colores [x,map]=imread('circuit.jpg','jpg'); %Representamos imagen en figura, con su mapa de colores



image(x),colormap(map),axis off,hold on %Títulos sobre imagen %Título text(50,50,'Estudio de Modelos Matemáticos de Acelerómetros Comerciales',... 'Fontname','Arial','Fontsize',25,'Fontangle','Italic', ... 'Fontweight','Bold','color',[1 1 0]); %Nombre del programador text(50,130,'Por: Alberto Manzanares del Moral','Fontname', ... 'Comic Sans MS','Fontangle','Italic','Fontweight','Bold', ... 'Fontsize',14,'color',[1 1 1]); %Botón Continuar botok=uicontrol('Style','pushbutton', ... 'Units','normalized', ... 'Position',[.84 .03 .12 .05], ... 'String','CONTINUAR',... 'Callback','clear all; close all;clc; interfaz;');



7.1.4. Código archivo ADXL311main_3prueba.m Función para realizar las pruebas definidas en el apartado 4.2.2.3. % ADXL311main_3prueba.m % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% clear % clear all variables ADXL311_constants % reread initial data pendulo_constantes % constantes del péndulo %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% zinamp=0; % los valores para el eje z los mantenemos igual zinfreq=1/periodo; % amplitud de entrada y frecuencia % intentamos un escalón que valga 1 desde 0 hasta periodo/4, instante % en el que el seno pasa por cero, y que valga 0 desde periodo/4 hasta % xtstop (fin de la simulación) xtstop = 0.8; % fin simulación reltol=1e-7; % tolerancia relativa maxstep=0.1e-3; T=[0:maxstep:xtstop]'; % creamos un T1 xtstop1= periodo/4; T1=[0:maxstep:periodo/4]; % creamos un T2 T2=[periodo/4:maxstep:xtstop]; escalon1 = ones(size(T1)); % señal todo a uno escalon2 = zeros(size(T2)); % señal todo a cero % concatenamos los dos escalones para obtener el deseado escalon = [cat(2, escalon1, escalon2)]'; % para la senoide freq = 1/periodo; % igual a la frecuencia natural del péndulo senoide = sin(2*pi*freq*T + (pi/2)); % ahora hay que multiplicarlas y es será mi entrada entrada = escalon .* senoide; % multiplicamos elemento a elemento % Opciones para la simulación OPTIONS = simset('RelTol',reltol,'MaxStep',maxstep); % entradas al sistema



u1t = entrada; % entradas senoidales, de igual dimensión que T u2t = entrada; % en este caso tendríamos la amplitud deseada por u3t = zinamp*sin(2*pi*zinfreq*T+pi/2) % una matriz de senos de % tamaño T % Matriz de entradas. Una uit por cada puerto de entrada U=[T,u1t,u2t,u3t]; % Realizamos la simulación [t,X,Y]=sim('ADXL311_3',xtstop,OPTIONS,U); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Crea las gráficas %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% figure(1) hold off plot(t,Y(:,1)) grid on title(['ADXL311 Model - X Input Acceleration - ',date]) ylabel('Acceleration (g)') xlabel('Time (seconds)') orient tall %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% figure(2) hold off plot(t,Y(:,2)) grid on title(['ADXL311 Model - X Output Voltage - ',date]) ylabel('Volts') xlabel('Time (seconds)') orient tall %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% figure(3) hold on plot(t,Y(:,3),'r') grid on title(['ADXL311 Model - Y Input Acceleration - ',date]) ylabel('Acceleration (g)') xlabel('Time (seconds)') orient tall %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% figure(4) hold on plot(t,Y(:,4),'r') grid on title(['ADXL311 Model - Y Output Voltage - ',date]) ylabel('Volts') xlabel('Time (seconds)') orient tall



7.2. Anexo B: data sheet ADXL311

estudio de modelos matemÁticos de...

Documents