red neuronal perceptron multicapa en microchip pic ccs 18f4550

UNIVERSIDAD VERACRUZANA

FACULTAD DE INSTRUMENTACIÓN ELECTRÓNICA Y CIENCIAS ATMOSFÉRICAS

“SISTEMA DE ADQUISICIÓN DE SEÑALES DE SENSORES NO LINEALES PARA

OBTENER Y VISUALIZAR LA FUNCIÓN DE CALIBRACIÓN UTILIZANDO REDES

NEURONALES ARTIFICIALES”

T E S I S

QUE PARA EVALUAR LA EXPERIENCIA EDUCATIVA EXPERIENCIA RECEPCIONAL (MEIF), DEL P.E. DE INGENIERÍA EN INSTRUMENTACIÓN

ELECTRÓNICA

Presenta:

AGUILAR GARCÍA VÍCTOR CÉSAR

Director de Tesis: M. I. A. Leticia Cuéllar Hernández

Co-Director de Tesis:

M. en I.B. Luis Julián Varela Lara

Xalapa Ver. Mayo, 2011

ÍNDICE INTRODUCCIÓN ............................................................................................................................................... 1

CAPÍTULO I ANTECEDENTES....................................................................... 3 1.1 SENSORES ................................................................................................................................................ 3

1.1.2 características estáticas ........................................................................................................... 4 1.1.3 características dinámicas ........................................................................................................ 6

1.2 REDES NEURONALES ARTIFICIALES. ................................................................................................... 6 1.2.1 características de una red neuronal artificial ..................................................................... 8

1.3 RELACIÓN ENTRE SENSORES Y REDES NEURONALES .................................................................... 10

CAPÍTULO II ADQUISICIÓN DE SEÑAL .................................................... 11 2.1 CURVA DE CALIBRACION ...................................................................................................................... 11 2.2 SISTEMA DE ADQUISICIÓN DE SEÑAL ................................................................................................ 11 2.3 SENSOR EN UN SISTEMA DE ADQUISICIÓN ....................................................................................... 12

2.3.1 termistor ................................................................................................................................... 12 2.4 ACONDICIONAMIENTO DE SEÑAL ..................................................................................................... 14

2.4.1 acondicionamiento de señal para el termistor ................................................................ 14 2.5 CONVERSIÓN ANALÓGICA DIGITAL ................................................................................................... 15

2.5.1 convertidor analógico digital del microcontrolador ..................................................... 15 2.5.2 módulo convertidor ................................................................................................................ 16 2.5.3 programación del modulo convertidor analógico digital en C .................................. 17

2.6 PROGRAMA Y CIRCUITO DEL MICROCONTROLADOR PARA EL SISTEMA DE ADQUISICIÓN. . 18

CAPÍTULO III INTERFAZ CON UNA COMPUTADORA ..................... 21 3.1 COMUNICACIÓN MICROCONTROLADOR Y COMPUTADORA ........................................................ 21

3.1.1 puerto serie RS232 ................................................................................................................ 21 3.1.2 puerto serial UART en el microcontrolador PIC .......................................................... 23 3.1.3 max232 ..................................................................................................................................... 24

3.2 CONEXIÓN PUERTO RS232 Y MICROCONTROLADOR. .................................................................. 24 3.3 SOFTWARE PARA EL CONTROL DE LA COMUNICACIÓN. ................................................................ 26

3.3.1 el módulo UART del microcontrolador en C ................................................................. 26 3.3.2 uso de matlab para leer el puerto serial RS232. ........................................................... 27

3.4 INTERFAZ GRÁFICA DE USUARIO EN MATLAB .............................................................................. 28 3.5 DISEÑO DE INTERFAZ GRÁFICA PARA ENCONTRAR LA FUNCIÓN DE CALIBRACIÓN DEL

SENSOR NO LINEAL CON RNA. ........................................................................................................... 29 3.5.1 interfaz gráfica de usuario principal. ................................................................................ 29 3.5.2 adquisición datos del sensor a través del puerto serial para guardar la

información un archivo de texto. ................................................................................. 30

CAPÍTULO IV USO DE REDES NEURONALES ARTIFICIALES ...... 34 4.1 APLICACIÓN DE LAS REDES NEURONALES ARTIFICIALES EN LA CALIBRACIÓN DE

SENSORES NO LINEALES. .................................................................................................................. 34 4.2 ESTRUCTURA DE UN SISTEMA NEURONAL ARTIFICIAL. ............................................................... 34 4.3 MODELO ESTANDAR DE NEURONA ARTIFICIAL .............................................................................. 35 4.4 FUNCIÓN DE TRANSFERENCIA. ......................................................................................................... 36

4.4.1 función de transferencia lineal (purelin) .......................................................................... 36 4.4.3 función de transferencia sigmoidal (logsig) ................................................................... 36 4.4.4 función de transferencia tangente sigmoidal hiperbólica (tansig) ............................ 37

4.5 ARQUITECTURA DE UNA RED NEURONAL ARTIFICIAL. ................................................................ 38 4.6 FASES DE OPERACIÓN DE UNA RED NEURONAL ARTIFICIAL ........................................................ 39 4.7 PERCEPTRÓN MULTICAPA ................................................................................................................... 40 4.8 CREAR UNA RED MULTICAPA EN MATLAB ........................................................................................ 41 4.9 USO DE LA INTERFAZ GRÁFICA DE USUARIO PARA GENERAR, ENTRENAR Y EVALUAR UNA

RNA. ........................................................................................................................................................ 45

CAPÍTULO V PRUEBAS Y RESULTADOS ................................................ 50 5.1 USO DEL SISTEMA DE ADQUISICIÓN DE SEÑAL ............................................................................... 50 5.2 ELECCIÓN DE LA ARQUITECTURA DE LA RNA. ............................................................................... 52 5.3 APROXIMACIÓN DE FUNCIÓN A UNA CURVA HIPOTÉTICA ............................................................. 52 5.4 IMPLEMENTACIÓN DE LA RNA ENTRENADA EN UN MICROCONTROLADOR. .......................... 54 CONCLUSIONES ............................................................................................................................................. 60 APÉNDICE A .................................................................................................................................................... 61 REFERENCIAS BIBLIOGRÁFICAS ................................................................................................................ 72

1

INTRODUCCIÓN Para dotar un sistema electrónico de la capacidad de percibir su entorno se utilizan los sensores. Para utilizar un sensor hay que conocer las características que describen la correspondencia de la salida del sensor con la entrada. Si adquirimos datos de la salida de un sensor ante una serie de entradas, cuyo valor determinamos con un patrón de medida y se unen todos los puntos con una línea, se obtiene la llamada curva de calibración. Un sensor que se quiere calibrar, necesita de alguna técnica que nos describa el comportamiento del sensor con una función, para todos los valores de entrada y la función de los sensores con comportamiento no lineal, en ocasiones es difícil de obtener, por métodos convencionales como el de mínimos cuadrados. En esta tesis se explicará el uso de redes neuronales artificiales para obtener la función de calibración de un sensor no lineal en su rango de medida, se adquirirán datos de la salida del sensor no lineal con relación a entradas conocidas de la variable medida, como ejemplo se utilizará un termistor, ya que tiene un comportamiento no lineal, la adquisición de datos se realizará con un sistema de adquisición de señal utilizando un microcontrolador que se encargará de la conversión analógico a digital y también de enviar los datos adquiridos haciendo uso de la comunicación serial, se utilizará una computadora para guardar los datos recopilados del sensor y utilizar un programa que sirva para establecer la comunicación, estos datos serán la base para poder generar y entrenar una red neuronal artificial y obtener la función de calibración del sensor. La red neuronal artificial servirá para interpolar valores entre datos definidos por puntos en la curva de calibración del sensor, es decir, se puede aproximar la salida de una red neuronal artificial a la curva característica del sensor y precisamente es lo que se busca para poder calibrar un sensor. Para generar y probar la red neuronal artificial se utilizará un programa que permita buscar la arquitectura adecuada de la red y cuando se obtenga la red entrenada se pueda probar con valores desconocidos, es decir, para valores diferentes con los que fue entrenada la red y observar por medio de una gráfica la aproximación de la red a la curva de calibración. Se estudiará el funcionamiento de una red neuronal artificial para poder implementar en un microcontrolador la red obtenida a través de un programa de cómputo. De esta forma se podría utilizar el sensor al que se le adquirieron los datos como un sensor calibrado si se conecta al microcontrolador que contenga el código de la red neuronal artificial entrenada. En el capítulo uno se presentan los antecedentes de lo que es un sensor y la relación que tiene con las redes neuronales artificiales para fines de este proyecto. En el capítulo dos se describe como extraer información de un sensor no lineal y su acondicionamiento de señal (como ejemplo se utilizará un termistor) para acoplar la salida del sensor a la entrada de a un convertidor analógico digital. De esta forma obtener los datos que se necesitan conocer para obtener la curva de calibración del sensor.

2

En el capítulo tres se mostrará la forma de comunicar la señal del sensor con una computadora, el puerto que se ocupa y como almacenar la información en un archivo de texto, para mostrar los resultados se utilizará un programa diseñado en la interfaz gráfica de usuario de Matlab, que permite ejecutar la adquisición de datos y mostrar los resultados en gráficas. El capítulo cuatro se explicara el funcionamiento de una red neuronal artificial, específicamente perceptrón multicapa como aproximador de funciones y como generar una red utilizando Matlab y también por medio de la interfaz gráfica de usuario para hacer más fácil y entendible la forma de encontrar la red apropiada para calibrar el sensor. Durante el capítulo cinco se expondrán los resultados de las pruebas que se llevaran a cabo, desde la adquisición de datos del sensor hasta encontrar la función de calibración con las redes neuronales artificiales, también se explicará cómo implementar en un microcontrolador la red neuronal artificial entrenada.

3

ANTECEDENTES

1.1 SENSORES En la mayoría de los sistemas de instrumentación la variable de entrada es no eléctrica. Con el fin de utilizar métodos eléctricos y técnicas de medición, manipulación o control, las cantidades no eléctricas se convierten en una señal eléctrica por medio de un dispositivo que es llamado con el término de sensor. Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas, llamadas variables de instrumentación, y transformarlas en variables eléctricas. Las variables de instrumentación pueden ser por ejemplo: temperatura, intensidad lumínica, distancia, aceleración, inclinación, desplazamiento, presión, fuerza, torsión, humedad, por mencionar algunas y el sensor está siempre en contacto con la variable medida. Los sensores son los elementos de un sistema que lo conectan con su entorno físico, La función de los sensores es obtener señales eléctricas en respuesta a magnitudes de entrada no eléctricas. En un sistema de adquisición de señal el sensor es el dispositivo de entrada que recibe la cantidad por medir y envía una señal eléctrica proporcional al dispositivo acondicionador de señal. Como la finalidad de un sensor es dar una salida eléctrica que se corresponda con una determinada magnitud aplicada a su entrada, un primer grupo de características se refiere a la descripción de dicha correspondencia. Dado que en las condiciones normales de utilización la magnitud de entrada varía lentamente, se distingue entre el comportamiento del sensor frente a entradas de valor constante como características estáticas, y su comportamiento frente a entradas variables como características dinámicas.

I

4

1.1.2 Características estáticas Las características estáticas esenciales son: exactitud, precisión y sensibilidad. Otras características como linealidad, resolución, histéresis. etc., son secundarias. - Calibración. Para definir las características estáticas esenciales conviene considerar primero el proceso de calibración del sensor. Consiste en aplicar sucesivos valores de la magnitud de entrada, cuyo valor se determina con un sistema de medida de calidad superior al que se está calibrando, e ir anotando los respectivos valores de la salida. La línea que une todos los puntos obtenidos es la denominada curva de calibración. Si durante la calibración se aplica varias veces la misma magnitud de entrada, sucede que la lectura de salida no siempre es la misma. Ello es debido en último término a la aleatoriedad de los diversos factores que repercuten en el valor de la salida en presencia de una entrada específica. La dispersión de las lecturas determina la denominada fidelidad o repetibilidad del sensor. Para ajustar la curva de calibración se toma el valor medio de las lecturas. Lo más frecuente, por ser lo más práctico, es ajustar una recta a través de dichos puntos, por ejemplo con el método de los mínimos cuadrados. Pero no siempre es posible obtener una curva de calibración que sea recta, ni es necesario. Lo fundamental es que a la misma entrada le corresponda siempre la misma salida [3]. - Sensibilidad. La sensibilidad de un sensor se define como la pendiente de la curva de calibración. Si ésta es una recta, la sensibilidad es constante y se dice del sensor que es lineal. La recta no tiene por qué pasar necesariamente por el origen. Si el sensor es lineal, para determinar la entrada correspondiente a una salida observada basta restarle la salida correspondiente a entrada cero y dividir el resultado por la sensibilidad. De aquí el interés de los sensores lineales. Pero un sensor no lineal es igualmente válido con tal que sea repetible; se puede, por ejemplo, guardar en una tabla el valor de la entrada correspondiente a cada salida, o guardar los coeficientes de la curva de calibración y obtener la entrada mediante cálculo[3]. - Exactitud. La exactitud es el grado de coincidencia entre el valor real de la entrada y el valor calculado a partir de la salida obtenida y de la sensibilidad. La diferencia entre ambos valores se denomina error absoluto y el cociente entre el error absoluto y el valor real se denomina error relativo. Cuando el sensor se supone lineal, en vez de inexactitud se suele hablar de no linealidad (figura 1.1 b)). La discrepancia entre el valor real y el resultado puede ser debida simplemente a la limitada repetitividad del sensor. En este caso la repetición de la medida y el cálculo de la medida de los resultados reduce el error absoluto, pero dicha repetición no siempre es posible en la práctica. Si la discrepancia se debe a otras causas, como por ejemplo a un deterioro del sensor, entonces el valor medio de las lecturas no tiende a coincidir con el valor real y se dice que hay un error sistemático. La única forma de conocer y eventualmente corregir los errores sistemáticos es mediante calibración. [3]. -Precisión. Es la capacidad de obtener la misma salida cuando se realizan varias lecturas de la misma entrada y en las mismas condiciones.

5

- Error de cero y error de sensibilidad. Para los sensores lineales es común descomponer el error en dos términos: error de cero y error de ganancia (o de sensibilidad). El error de cero (figura 1.1 a)) es el valor de la salida del sensor en el punto en que supuestamente debía ser nula. El error de ganancia indica la discrepancia entre la sensibilidad prevista y la observada. Ambos errores varían con los factores ambientales, en particular la temperatura, y a menudo también con la tensión de alimentación y con el tiempo. Dichas variaciones se denominan derivas [3].

a) b)

Figura 1.1 a) Gráfica de error cero b) Gráfica de una respuesta no lineal. - Resolución. La resolución de un sensor es el mínimo cambio de la entrada que se puede percibir a la salida. Cuando se trata de un cambio a partir de una entrada nula se emplea a veces el término umbral. La resolución del sensor no es en general, un factor limitante en aplicaciones industriales, por cuanto siempre es posible disponer una etapa posterior con ganancia suficiente para poder percibir pequeños cambios de la entrada mediante el sistema de presentación final. El factor último que limita la resolución es el ruido (eléctrico) [3]. - Otras características. Además de las características de la relación entrada-salida, en la selección de un sensor intervienen otros factores relativos al entorno de aplicación. En primer lugar está, obviamente, el campo o margen de medida, que debe corresponderse con el margen de variación esperado para la magnitud de entrada. Si el margen de entrada del sensor es pequeño, las entradas altas pueden dañarlo de forma irreversible, si el margen de entrada del sensor es excesivo, y su margen de salida no aumenta proporcionalmente, se limita innecesariamente la resolución final. Otros factores a considerar son: límites de la tensión de alimentación, temperatura, humedad, vibraciones, presencia de sustancias corrosivas, etc. Para muchos de estos factores hay, por una parte, unos límites absolutos y, por otra, se especifica su influencia en la exactitud del sensor. En el caso de sensores con componentes activos integrados. Hay también límites en las corrientes de entrada o salida o en ambas [3]. En muchos de los casos las respuestas de los sensores no presentan una linealidad con la variable física que están observando, y aun más, en ocasiones resulta complejo intentar representar estas respuestas mediante ecuaciones matemáticas que permitan un modelo formal de los sensores.

6

En un sensor que tiene como inconveniente una respuesta no lineal, pero que tiene otras características que lo hacen apropiado para alguna aplicación en algún sistema de medida o de control, se tiene que buscar la forma de que a la misma entrada le corresponda una misma salida. Esto se pude lograr con técnicas de inteligencia Artificial específicamente con redes neuronales artificiales. Por medio de una red neuronal artificial se encuentra una función, que se pueda aproximar con un error muy bajo, a la curva de calibración del sensor.

1.1.3 Características dinámicas La presencia de elementos que almacenan energía hace que la respuesta de un sensor cuando la entrada es variable difiera de la que presenta cuando la entrada es constante. La relación matemática entre la entrada y la salida del sensor se expresa mediante una ecuación diferencial y el modelo se simplifica para que dicha ecuación sea lineal y de coeficientes constantes. En este caso es posible describir la relación entrada-salida mediante la función de transferencia, es decir, mediante el cociente entre las transformadas de Laplace de la salida y de la entrada. En los sensores ordinarios la función de transferencia consiste en una simple constante de proporcionalidad, o en una fracción cuyo denominador es un polinomio de primer o segundo orden. Se habla entonces, respectivamente, de sensores de orden cero, de primer orden, o de segundo orden. Las características dinámicas esenciales son el retardo y el error dinámico. El retardo es un término genérico para describir el intervalo de tiempo que transcurre desde que se aplica una entrada hasta que la salida alcanza su valor estacionario. El retardo del sensor es importante en aquellos sistemas de medida o control que funcionan en lazo cerrado. Dado que hay diversos criterios para definir los instantes inicial y final de la respuesta, hay también diversas definiciones para el retardo. Cuando el sensor es de primer orden y tipo paso bajo, es común tomar como retardo, o tiempo de respuesta, el tiempo que tarda la salida en alcanzar el 63 % de su valor final cuando se aplica una entrada en forma de escalón, y que coincide con la denominada constante de tiempo (t) del sistema. Otra alternativa es tomar el intervalo de tiempo que tarda la salida en pasar del 10 % al 90 % de su valor final, también frente a una entrada en escalón. Dicho intervalo se denomina tiempo de subida de la respuesta [3].

1.2 REDES NEURONALES ARTIFICIALES. Las Redes Neuronales Artificiales o simplemente RNAs, son modelos matemáticos que buscan representar, con las debidas limitaciones, algunas tareas de la neurona biológica y de las redes neuronales biológicas, tal como asociar, clasificar y agrupar información. Estas tareas son realizadas por aprendizaje de máquina, que ocurre con la presentación de una colección de muestras o patrones, que describen el universo de una aplicación. En el contexto de las RNAs, el aprendizaje máquina corresponde a la adaptación adecuada de parámetros libres llamados pesos sinápticos [1].

7

Las redes neuronales imitan la estructura hardware del sistema nervioso, con la intención de construir sistemas de procesamiento de la información paralelos, distribuidos y adaptativos, que pueden presentar un cierto comportamiento “inteligente”. Pese al extraordinario desarrollo de la electrónica y las ciencias de la computación, ni la computadora más potente puede llevar a cabo tareas tales como reconocer una mosca y atraparla al vuelo, que un sistema tan simple como el cerebro de la rana es capaz de llevar a cabo con eficiencia [5]. El cerebro y un computador convencional son muchos más diferentes de lo que suele suponerse cuando se habla de “cerebros electrónicos”. Recordemos que un computador convencional es, en esencia una máquina Vonn Neumann, construida entorno a una única CPU o procesador, que ejecuta de un modo secuencial un programa almacenado en memoria. Por el contrario, el cerebro no está compuesto por un único procesador sino por miles de millones de ellos (neuronas), aunque muy elementales, curiosamente las neuronas son más simples lentas y menos fiables que una CPU y a pesar de ello existen problemas difícilmente abordables mediante un computador convencional, que el cerebro resuelve eficazmente (reconocimiento del habla, visión de objetos inmersos en el ambiente natural, respuestas ante estímulos del entorno, por mencionar algunos). Por lo tanto, la idea que subyace en los sistemas neuronales artificiales es que, para abordar el tipo de problemas que el cerebro resuelve con eficiencia puede resultar conveniente construir sistemas que “copien” en cierto modo la estructura de las redes neuronales biológicas con el fin de alcanzar una funcionalidad similar[5]. La teoría de las Redes Neuronales Artificiales (RNA) ha brindado una alternativa a la computación clásica, para aquellos problemas, en los cuales los métodos tradicionales no han entregado resultados muy convincentes, o poco convenientes. Las aplicaciones más exitosas de las RNA son:

• Procesamiento de imágenes y de voz • Reconocimiento de patrones • Planeación • Interfaces adaptivas para sistemas Hombre/máquina • Control y optimización • Filtrado de señales • Aproximación funcional

Los sistemas de cómputo tradicionales procesan la información en forma secuencial; un computador serial consiste por lo general de un solo procesador que puede manipular instrucciones y datos que se localizan en la memoria, el procesador lee y ejecuta una a una las instrucciones en la memoria; este sistema serial es secuencial, todo sucede en una sola secuencia determinística de operaciones. Las RNA no ejecutan instrucciones, responden en paralelo a las entradas que se les presenta. El resultado no se almacena en una posición de memoria, este es el estado de la

8

red para el cual se logra equilibrio. El conocimiento de una red neuronal no se almacena en instrucciones, el poder de la red está en su topología y en los valores de las conexiones (pesos) entre neuronas.

1.2.1 Características de una Red Neuronal Artificial El modelo de una neurona artificial es una imitación del proceso de una neurona biológica, puede también asemejarse a un sumador hecho con un amplificador operacional tal como se ve en la figura 1.2

Figura 1.2 Sumador

Existen varias formas de nombrar una neurona artificial, es conocida como nodo, celda, unidad o elemento de procesamiento; En la figura 1.3 se observa la representación de una neurona artificial en forma general y su similitud con una neurona biológica.

Figura 1.3 De la neurona biológica a la neurona artificial

De la observación detallada del proceso biológico se han hallado los siguientes análogos con el sistema artificial: • Las entradas 𝑋𝑖 representan las señales que provienen de otras neuronas y que son capturadas por las dendritas. • Los pesos 𝑊𝑖 son la intensidad de la sinapsis que conecta dos neuronas; tanto 𝑋𝑖 como 𝑊𝑖 son valores reales.

9

• θ es la función umbral que la neurona debe sobrepasar para activarse; este proceso ocurre biológicamente en el cuerpo de la célula. Las señales de entrada a una neurona artificial 𝑋1, X2,…,Xn son variables continuas en lugar de pulsos discretos, como se presentan en una neurona biológica. Cada señal de entrada pasa a través de un peso, llamado peso sináptico o fortaleza de la conexión cuya función es análoga a la de la función sináptica de la neurona biológica. Los pesos pueden ser positivos (excitatorios), o negativos (inhibitorios), el nodo sumatorio acumula todas las señales de entradas multiplicadas por los pesos o ponderadas y las pasa a la salida a través de una función umbral o función de transferencia. La entrada a cada unidad de la red neuronal puede escribirse como la ecuación 1.1:

𝑛𝑒𝑡𝑖 = �𝑊𝑖𝑋𝑖

𝑛

𝑖=1

= �⃗�𝑌�⃗ 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 1.1

Una idea clara de este proceso se muestra en la figura 1.4 en donde puede observarse el recorrido de un conjunto de señales que entran a la red.

Figura 1.4 Proceso de una red neuronal Una vez que se ha calculado la activación del nodo, el valor de salida equivale a la ecuación 1.2.

𝑥𝑖 = 𝑓𝑖(𝑛𝑒𝑡𝑖) 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 1.2 Donde 𝑓𝑖 representa la función de activación para esa unidad, que corresponde a la función escogida para transformar la entrada 𝑛𝑒𝑡𝑖 en el valor de salida 𝑥𝑖 y que depende de las características específicas de cada red. Existen varios modelos de redes neuronales como lo son: el perceptrón simple, adalina y perceptrón multicapa, este último es el utilizado como aproximador de funciones y es el que se usará para encontrar una función que caracterice a un sensor no lineal. El proceso mediante el cual la red va modificando sus pesos y ganancias de tal manera que al final del proceso se tiene el comportamiento deseado se conoce como aprendizaje. Las

10

redes neuronales artificiales son capaces de aprender a partir de señales o datos provenientes del exterior, estas señales son obtenidas por los sensores en respuesta a una variable física.

1.3 RELACIÓN ENTRE SENSORES Y REDES NEURONALES De forma similar a los seres vivos, los sensores facilitan la información necesaria para que ciertas tecnologías interpreten el mundo real, los sensores proporcionan los datos necesarios que las redes neuronales necesitan para comenzar a trabajar. Son muchas las aplicaciones que tienen la RNAs con sensores, se resaltan algunas que buscan imitar nuestros sentidos, como la visión, el olfato, etc. Otra disciplina que actualmente está aprovechando las bondades de esta tecnología es la robótica. Por ejemplo un robot móvil que procesa información proveniente de una serie de sensores que conforman a su vez una red neuronal artificial que le permite esquivar obstáculos de manera autónoma e inteligente. Otra de las aplicaciones de las redes neuronales con sensores es usarlas para calibrar un sensor no lineal, que es el tema de esta tesis, se usa una red neuronal artificial multicapa como aproximador de funciones para ajustarse a la curva de calibración del sensor, para esto se necesita conocer una muestra de datos para poder entrenar la red neuronal y a partir de un conjunto de entradas proporcionar la salida deseada. Cabe aclarar que la intención de este trabajo no es verificar si las RNAs resultan más eficientes que los métodos convencionales como el de mínimos cuadrados, la finalidad es establecer la metodología a seguir para poder obtener la función de calibración de un sensor mediante el uso de una RNA, Así como también el poder implementar la red entrenada en un microcontrolador para generar un sistema embebido. Para obtener los datos necesitamos un sistema de adquisición de señal, que es el tema del próximo capítulo.

11

II

ADQUISICIÓN DE SEÑAL

2.1 CURVA DE CALIBRACIÓN Extraer datos de un sensor sirve para conocer su respuesta ante diversas entradas cuyo valor se determina con un patrón de referencia, estos datos adquiridos se pueden graficar al unir todos los puntos con una línea y formar la llamada curva de calibración o curva característica del sensor. Al momento de calibrar un sensor es necesario conocer los datos que forman la curva de calibración y para esto se puede utilizar un sistema de adquisición que sirva para obtener la información necesaria del sensor ante una serie de entradas físicas conocidas y poder encontrar la función de calibración, que puede hacerse por medio de métodos matemáticos convencionales o bien como en el caso de esta tesis por medio de una red neuronal artificial.

2.2 SISTEMA DE ADQUISICIÓN DE SEÑAL Para medir y registrar señales obtenidas a partir de la medición directa de cantidades eléctricas que pueden incluir voltajes de cd y ca, frecuencia o resistencia, y de señales que se originan a partir de sensores, como por ejemplo, galgas extensiométricas y termopares, se utiliza un sistema de adquisición de señal. Un sistema de adquisición de señales, por lo general consta de tres elementos principales: un dispositivo de entrada, un acondicionador de señal o dispositivo de procesamiento y un dispositivo de salida. El dispositivo de entrada recibe la cantidad por medir y envía una señal eléctrica proporcional al dispositivo acondicionador de señal. Aquí la señal se amplifica, se filtra o se modifica en un formato para el dispositivo de salida. Este puede ser una computadora digital para manipulación de los datos o proceso de control. El tipo de sistema depende de qué se va a medir y de qué manera se van a presentar los resultados.

12

En este trabajo se utilizará un sistema de adquisición de señal para registrar datos que se originan a partir de un sensor no lineal, los datos se obtienen de la salida del sensor y se relaciona con el valor de la variable medida en base a un patrón de referencia, con estos valores, se genera un archivo de datos que contenga las mediciones de la salidas del sensor en todo su rango de medida, estos valores son necesarios para entrenar una red neuronal artificial; los tres elementos del sistema de adquisición que se utilizan es: un sensor que recibe la variable física (por ejemplo un termistor para medir la temperatura), el circuito acondicionador del sensor, y el convertidor analógico digital, este último se basa en el uso de un microcontrolador, el diagrama a bloques se muestra en la figura 2.1.

Figura 2.1 Diagrama a bloques del sistema de adquisición de señal.

2.3 SENSOR EN UN SISTEMA DE ADQUISICIÓN El sensor es el primer elemento de un sistema de adquisición que recibe la magnitud de interés, Ésta puede ser mecánica, térmica, eléctrica, magnética, óptica o química. La cantidad de energía convertida por un sensor es pequeña, de manera que la salida hay que acondicionarla para adaptarla a las etapas siguientes. Los parámetros básicos de un sensor son: margen o campo de medida, sensibilidad, resolución y exactitud. Cuando interesa controlar una magnitud física, una vez que se tiene la información sobre el estado real y se compara con el objetivo, se toma una decisión que debe acabar en una acción sobre el proceso. El sensor a utilizar para fines de esta tesis debe tener como características la no linealidad para poder demostrar como una red neuronal artificial, permite encontrar una función que pueda describir la respuesta del sensor en todo su rango de medida, el sensor que se utilizará como ejemplo para obtener su curva de calibración, es un termistor, por ser un sensor con una respuesta no lineal.

2.3.1 Termistor El término termistor es una castellanización del inglés thermistor, formado a partir de los vocablos thermally sensitive resistor. Son resistores variables con la temperatura, pero no están basados en conductores, sino en semiconductores. Los termistores tienen un coeficiente de temperatura de resistencia negativo de valor elevado, por lo que presentan unas variaciones rápidas y extremadamente grandes para los cambios relativamente pequeños en la temperatura. Si su coeficiente de temperatura es negativo se denominan NTC (Negative Temperature Coefficient), mientras que si es positivo se denominan PTC

13

(Positive Temperature Coefficient). Los símbolos respectivos son los de la figura 2.2, donde el trazo horizontal en el extremo de la línea inclinada indica que se trata de una variación no lineal [2].

Figura 2.2 Símbolo para una resistencia con dependencia intrínseca de la temperatura y

variación no lineal, con sensibilidad positiva o negativa. Los termistores se fabrican con óxidos de níquel, manganeso, hierro, cobalto, cobre, magnesio, titanio y otros metales, y están encapsulados. La relación entre la resistencia del termistor y la temperatura viene dada por la ecuación 2.1. En la figura 2.3 pueden verse la curva características de un termistor NTC. [7]. 𝑅𝑇 = 𝑅𝑜exp {𝐵(1/𝑇 − 1/𝑇0)} 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 2.1 𝑅𝑇 = resistencia en ohmios a la temperatura absoluta T 𝑅0 = resistencia en ohmios a la temperatura absoluta de referencia 𝑇0 B= constante dentro de un intervalo moderado de temperaturas.

Figura 2.3 Curva característica de un termistor NTC.

Por su alta sensibilidad permiten obtener alta resolución en la medida de temperatura. Dada su alta resistividad, lo que les confiere una velocidad de respuesta rápida y permite emplear hilos largos para su conexión, aunque éstos vayan a estar sometidos a cambios de temperatura, porque ellos tienen mayor resistencia y coeficiente de temperatura. Permiten también una gran variedad de aplicaciones a base de autocalentamiento y todo ello a un bajo costo [2].

14

2.4 ACONDICIONAMIENTO DE SEÑAL Para aprovechar el margen dinámico de salida del convertidor analógico digital (2𝑛 valores correspondientes a un margen de tensiones de entrada M), el margen de amplitudes de la señal debe coincidir con el de entrada del convertidor (M). Para ello hay que amplificar la salida del sensor pero evitando la saturación del amplificador. Al mismo tiempo, hay que hacer compatible la salida del sensor con la entrada del convertidor analógico digital (CAD). Esta última suele ser unipolar y con impedancia de 1 a 10 k, mientras que la salida del sensor puede ser diferencial o de alta impedancia. Además, según el teorema del muestreo, el ancho de banda de la señal a convertir (incluidas las componentes no deseadas ruido. interferencias, si las hay) debe ser inferior a la mitad de la frecuencia con que se tomen las muestras en el proceso de cuantificación [3]. Los circuitos de acondicionamiento de la señal de entrada se encargan de la amplificación, filtrado y adaptación de la señal del sensor al CAD u otro tipo de etapa posterior. Deben estar protegidos frente a sobre tensiones, en particular si están separados de los sensores. Pueden realizar también funciones de procesamiento como son la linealización de sensores. La diferenciación e integración de señales, la detección de fallos, la comparación con límites y otras más complejas. Todas estas operaciones hay que hacerlas manteniendo los errores dentro de márgenes aceptables. El procesamiento analógico es más rápido pero menos flexible y más caro en componentes, que el procesamiento por software. Si los sensores necesitan una señal de alimentación externa, los circuitos de acondicionamiento de señal deben proporcionársela [3]. Dado que manejan sólo señales eléctricas sin convertirlas en otras formas físicas, los acondicionadores de señal constituyen lo que se denomina una interfaz. Otras interfaces del sistema son las necesarias para enviar la información a través de los canales o líneas de comunicación. Su función y estructura dependen tanto del medio de comunicación como del código empleado para el mensaje [3].

2.4.1 Acondicionamiento de señal para el termistor El acondicionamiento de señal para el termistor consiste en adaptar la salida del sensor a la entrada del convertidor analógico digital, el termistor que se va a acondicionar tiene un coeficiente negativo (NTC), que significa que cuando la temperatura aumenta la resistencia disminuye. Se necesita que por el termistor circule una corriente constante para que así el voltaje en las terminales del termistor este dado por la ecuación 2.2:

𝑉 = 𝐼𝑅 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 2.2 De esta manera si la corriente (I) es conocida, la única variable es la resistencia (R), que es lo que varía en el termistor cuando cambia la temperatura (variable física). En el circuito utilizado en este trabajo hay dos bloques: el bloque de alimentación del sensor y el de acondicionamiento de la caída de tensión en el. La alimentación del sensor se realiza a partir de una tensión de referencia que fuerza una corriente constante hacia el

15

sensor a través de la resistencia de polarización R2. El transistor permite obtener una corriente mayor que la que ofrece el amplificador operacional. A la salida se utiliza un seguidor para que sea la entrada al convertidor analógico digital. El diagrama se muestra en la figura 2.4.

Figura 2.4 Diagrama de acondicionamiento del termistor. Para este caso se utilizo un voltaje de referencia a través del diodo zener de 3.3v y una resistencia de polarización de 47k (R2), de esta manera se obtiene una corriente constante de 68.93 µA.

2.5 CONVERSIÓN ANALÓGICA DIGITAL La salida de los sensores es normalmente, en forma de señal analógica. En algún punto del sistema dicha señal hay que convertirla en digital, ya que los elementos de procesamiento y muchos de los de presentación requieren entradas digitales. La conversión de señales analógicas en señales digitales se realiza en dos etapas: primero se cuantifica la señal y luego se codifica. La cuantificación consiste en representar la amplitud (continua) de la señal mediante un número finito de valores distintos, en instantes determinados: si el convertidor es de n bits, hay 2𝑛 valores o estados posibles. La codificación es la representación del valor asignado a la señal mediante combinaciones de símbolos que se representan habitualmente con dos niveles de tensión (1 y 0). La cuantificación y codificación las realiza el convertidor analógico digital (CAD) [3]. En este trabajo, para realizar la conversión analógico digital se utilizará un microcontrolador Pic de clase media como se describe en el siguiente tema.

2.5.1 Convertidor Analógico Digital del microcontrolador Los microcontroladores PIC pueden incorporar un módulo de conversión de señal analógica a señal digital. Los módulos analógico digital (AD) que utiliza Microchip hacen un muestreo y retención con un condensador y después utiliza el módulo de conversión

16

(figura 2.5). El módulo de CAD es del tipo de aproximaciones sucesivas [8].

Figura 2.5 Fases de la conversión analógica/digital

El convertidor de aproximaciones sucesivas se utiliza en aplicaciones donde se necesitan altas velocidades de conversión. Se basa en realizar sucesivas comparaciones de forma ascendente o descendente hasta encontrar un valor digital que iguale la tensión entregada por el CAD y la tensión de entrada. Durante la fase de muestreo el interruptor se cierra y el condensador se carga a la tensión de entrada (el tiempo que el interruptor permanece cerrado es fundamental para la correcta carga del condensador). Una vez abierto el interruptor, el condensador mantendrá (teóricamente) la tensión de entrada mientras el modulo CAD realiza la conversión [8]. El módulo de conversión se caracteriza por parámetros como los siguientes: • Rango de entrada. • Número de bits. • Resolución. • Tensión de fondo de escala. • Tiempo de conversión. • Error de conversión. El módulo que utilizan los PIC de gama media tiene un número de bits de 10, por lo que su resolución se muestra en la ecuación 2.3:

𝑟𝑒𝑠𝑜𝑙𝑢𝑐𝑖ó𝑛 =𝑉𝐼𝑁

2𝑁 − 1 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 2.3

Siendo 𝑉𝐼𝑁 la tensión de entrada y N el número de bits del convertidor. Es decir, para la tensión máxima de entrada (5V) la resolución es de 0.0048 V. [8].

2.5.2 Módulo Convertidor El módulo CAD en la gama media posee 8 entradas analógicas. Los 16F877/874 tienen 8 canales (5 en el puerto A y 3 en el puerto E). El convertidor es de 10 bits y, tal como se ha comentado, es de aproximaciones sucesivas y permite variar la tensión de referencia. La función de transferencia del convertidor CAD es el resultado de que la primera transición ocurra cuando la tensión analógica de entrada es igual a 𝑉𝑅𝐸𝐹/1024.

17

La resolución vendrá dada por la siguiente ecuación: 1LSB=𝑉𝑅𝐸𝐹− + (𝑉𝑅𝐸𝐹+− 𝑉𝑅𝐸𝐹−)

1024 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 2.4

En el caso de que la 𝑉𝑅𝐸𝐹+= 𝑉𝐷𝐷 y 𝑉𝑅𝐸𝐹− = 𝑉𝑠𝑠 entonces la resolución es: 1LSB= 5

1024= 4.8 mV

de esta forma si la lectura es de 512 LSB, la tensión analógica leída es: 𝑉𝐼𝑁=512. 5

1024= (512)(4.8mV)= 2.4576 V

Mayor referencia [8].

2.5.3 Programación del modulo convertidor analógico digital en C Para que el microcontrolador funcione en el modulo convertidor analógico digital es necesario programarlo, para esto se necesita hacer uso de un compilador que convierte el lenguaje de alto nivel a instrucciones en código máquina. El compilador que se va a utilizar para desarrollar la aplicación que correrá en el microcontrolador PIC será el compilador en el lenguaje C de CCS. Dispone de una amplia librería de funciones predefinidas, comandos de preprocesado y además, suministra los controladores para diversos dispositivos como LCD, convertidores AD, relojes en tiempo real. EEPROM serie, etc. El CCS C es C estándar y suministra unas directivas específicas para PIC (#device, etc.); tiene un editor que permite controlar la sintaxis del programa. Las funciones que se utilizan del compilador C para manejar el convertidor AD son las siguientes: setup_adc (modo); Modo: para la configuración del módulo conversor A/D correspondientes a los bits 7:6 del registro ADCON0.

Setup_adc(modo); ADC0N0(1Fh)

ADC_OFF 00000000 00h

ADC_CLOCK_INTERNAL 11000000 C0h

ADC_CLOCK_DIV_2 00000000 00h



18

setup_adc_ports (valor); Valor: definición de las entradas analógicas correspondiente a los bits 3-0 del ADCON1 set_adc channel (canal); Canal: selección del canal analógico correspondiente a los bits 5:3 de ADCON0. Con fines didácticos, en este trabajo se escriben los códigos fuente, los cuales pueden variar de acuerdo a las características del microcontrolador. Con estas funciones podemos hacer el programa para utilizar el convertidor analógico digital del microcontrolador y mostrar los resultados en una LCD, el código es el siguiente: #include <16F877a.h> #device adc=10 #fuses HS, NOWDT #use delay(clock=20000000) #include <LCD.C> void main() { int16 q; float p; setup_adc_ports(AN0); //Canal 0 analógico setup_adc(ADC_CLOCK_INTERNAL); //Fuente de reloj RC lcd_init(); while (true) { set_adc_channel(0); //Habilitación canal0 delay_us(20); q = read_adc(); //Lectura canal0 p = 5.0 * q / 1024.0; //Conversión a tensión printf(lcd_putc, "\fADC = %4ld", q); //imprime el valor de q en LCD printf(lcd_putc, "\nVoltage = %01.2fV", p); //imprime el valor de p en LCD delay_ms(100); } }

2.6 PROGRAMA Y CIRCUITO DEL MICROCONTROLADOR PARA EL SISTEMA DE ADQUISICIÓN.

Con base a lo que se ha visto en este capítulo se puede programar y diseñar el sistema de adquisición de señal que funcionará en base a un microcontrolador Pic16f877a. Primero se programa el código para que pueda realizar la conversión analógico digital con un rango de entrada de 0 v a 5 v, este mismo valor es el que debe tener la salida del sensor a calibrar. También se incluye la comunicación serial en el código del microcontrolador para enviar el resultado de la conversión a una computadora y se agrega una LCD para ver los valores

19

de la conversión en voltaje. El programa completo es el siguiente: #include <16F877a.h> #device adc=10 #fuses HS, NOWDT #use delay(clock=20000000) #use rs232(baud=9600, xmit=pin_c6, rcv=pin_c7, bits=8, parity=N) #include <LCD.C> int16 dig; float vol; void sensor(){ set_adc_channel(0); //Habilitación canal0 delay_us(20); dig = read_adc(); //Lectura canal0 vol = 5.0 * dig / 1024.0; //Conversión a tensión } void main() { setup_adc_ports(AN0); setup_adc(ADC_CLOCK_INTERNAL); lcd_init(); while (true) { sensor (); printf(lcd_putc, "\fADC = %4ld", dig); printf(lcd_putc, "\nVoltage = %01.2fV", vol); printf("%8ld", dig); delay_ms(100); } } La comunicación serial y los componentes electrónicos necesarios para establecer la comunicación entre microcontrolador y la computadora se describen en el capítulo tres. El circuito incluye todo lo que necesita el microcontrolador para funcionar correctamente con una LCD para ver los valores convertidos por el CAD. También se agrega el circuito acondicionador del sensor (figura 2.4), que como ejemplo se utiliza el de un termistor, la salida del termistor no rebasa de 5v por que la corriente constante que circula por él es de 68.93µA y es multiplicada por su resistencia de 72K para obtener 4.96v de salida. Para que el termistor tenga una resistencia de 72k necesita que exista una temperatura de -20 y el rango de uso de este sistema es -10°C a 85 °C. Se agrega un botón de reset para poder reiniciar el microcontrolador en cualquier

20

momento, el cristal que se utiliza es es de 20MHz y el diagrama se muestra en la siguiente figura 2.6.

Figura 2.6 Diagrama del sistema de adquisición.

21

III

INTERFAZ CON UNA COMPUTADORA

3.1 COMUNICACIÓN MICROCONTROLADOR Y COMPUTADORA Una vez que se tiene el resultado de la conversión analógico digital dentro del microcontrolador se puede observar el valor de los datos por medio de una LCD, pero será necesario que estos valores sean transmitidos hacia una computadora y poder guardar la información o simplemente para observar los valores cada vez que se envíe un dato, por lo tanto se debe de establecer una comunicación entre el microcontrolador y la computadora. Se utiliza la transmisión serial para dotar al sistema de la capacidad de intercambiar información con una computadora. La transmisión en serie de información binaria consiste en enviar uno a uno y de forma sucesiva, los bits de una palabra, a través de las mismas terminales. Se utiliza el puerto RS232 de una computadora y el puerto UART del microcontrolador PIC para la transmisión serial de información.

3.1.1 Puerto serie RS232 Una de las formas más comunes de comunicar cualquier dispositivo con una computadora es a través de su puerto serie, que es compatible con el denominado estándar RS232. En una computadora puede haber varios puertos series RS232, normalmente denominados COM 1, COM 2, entre otros. [9]. El protocolo RS232 es una norma o estándar mundial que rige los parámetros de uno de los modos de comunicación serial. Por medio de este protocolo se estandarizan las velocidades de transferencia de datos, la forma de control que utiliza dicha transferencia, los niveles de

22

voltajes utilizados, el tipo de cable permitido, las distancias entre equipos, los conectores, por mencionar algunas. Los puertos serie son accesibles mediante conectores. La norma RS232 establece dos tipos de conectores llamados DB 25 (de 25 pines) y DB 9 (de 9 pines), machos y hembras como se ve en la figura 3.1, la norma RS232 se estableció para conectar una computadora con un modem, por lo que aparecen muchas terminales en los conectores DB 25 que en otro tipo de aplicaciones no se utilizan y en las que es más común utilizar el conector tipo DB-9 [9]. Cada una de las terminales del conector RS232 tiene una función especificada por la norma. Hay unas terminales por los que se transmiten y reciben datos y otros que controlan el establecimiento, flujo y cierre de la comunicación. Para comunicación con un microcontrolador es suficiente con tres líneas: • Línea de transmisión (TxD), pin 3 • Línea de recepción (RxD), pin 2 • Pin de tierra (SG), pin 5

PIN SEÑAL 1 Data Carrier Detecl (DCD) 2 Received Data (RxD) 3 Transmtted Data (TxD) 4 Data Terminal Readv (DTR) 5 Signal Ground (SG) 6 Data Set Readv ( DSR) 7 Request to Send (RTS) 8 Crear to Send (CTS) 9 Ring indicator (RI)

Figura. 3.1 Conector DB-9

En la mayoría de las computadoras actuales, sobre todo en los portátiles, están desapareciendo los puertos serie RS232. Como solución se pueden utilizar cables de conversión SERIE-USB que utilizan el Universal Serial Port (USB) que es el que se ha vuelto más común, como se muestra en la figura 3.2.

23

Figura 3.2 Cable serie-USB

3.1.2 Puerto serial UART en el microcontrolador PIC Los microcontroladores PIC poseen un puerto serie para comunicaciones denominado USART (receptor transmisor serie síncrono- asíncrono universal) o SCL (interfaz de comunicación serie) que permite la comunicación con una computadora trabajando en modo full-duplex asíncrono o con periféricos trabajando en modo half--duplex. Cuando se usa solo en modo asíncrono se le llama simplemente UART. La principal función del USART es la de transmitir o recibir datos en serie. Esta operación puede dividirse en dos categorías: síncrona o asíncrona. La transmisión síncrona utiliza una señal de reloj y una línea de datos, mientras que en la transmisión asíncrona no se envía la señal de reloj, por lo que el emisor y el receptor deben tener relojes con la misma frecuencia y fase. Cuando la distancia entre el emisor y el receptor es pequeña, se suele utilizar la transmisión síncrona, mientras que para distancias mayores se utiliza la transmisión asíncrona [8]. El USART puede transmitir o recibir datos serie. Puede transferir tramas de datos de 8 o 9 bits por transmisión y detectar errores de transmisión. También puede generar interrupciones cuando se produce una recepción de datos o cuando la transmisión ha sido completada. Básicamente, la transmisión serie consiste en enviar los datos bit a bit a través de una línea común en periodos de tiempo fijos, dando lugar a la llamada velocidad de transmisión o número de bits enviados por segundo (baudios). Tanto el emisor como el receptor poseen registros de desplazamiento para realizar la comunicación. [8]. En el modo asíncrono se emplean relojes tanto en el emisor como en el receptor. Ambos relojes deben ser de igual frecuencia y deben estar en fase o sincronizados. La frecuencia de reloj se acuerda antes de realizar la transmisión configurando la velocidad mientras que la sincronización se realiza durante la transmisión. Cada trama de datos tiene un tamaño fijo y poseen un bit inicial o de arranque (start) y un bit final o de parada (stop) que permiten realizar dicha sincronización. La transmisión es en modo full-duplex (se utilizan dos líneas,

24

una transmisora -TX- y otra receptora -RX-, transfiriendo información en ambos sentidos; se puede transmitir y recibir información de forma simultánea) [8].

Figura 3.3 Transmisión asíncrona

El modo más habitual de transmisión por el USART es el modo asíncrono, puesto que permite comunicaciones en largas distancias. Para una comunicación desde el UART del PIC, se debe conectar un mínimo número de señales, TXD y RXD así como la tierra (GND). Los niveles de tensión empleados en la norma RS232 es diferentes al empleado por el PIC. Por ello, suele ser necesaria la utilización de circuitos externos de adaptación, pues utilizan señal TTL en el módulo USART por lo que se debe utilizar un conversor de nivel RS232, como el MAX232.

3.1.3 Max232 El Max232 (figura 3.4 a) convierte los niveles RS232 (cerca de + 12 Y -12 V) a voltajes TTL (O a +5 V) Y viceversa sin requerir nada más que una fuente de +5 V. El chip contiene dos drivers TTL a RS232 y dos RS232 a TTL. Necesita cuatro condensadores externos (figura 3.4 c) de 1µf microfaradios para generar el voltaje RS232 internamente.

3.2 CONEXIÓN PUERTO RS232 Y MICROCONTROLADOR. Para establecer la comunicación se utilizan solo 3 pines del puerto serie RS232, el Pin de transmisión (TxD), Pin de recepción (RxD) y el Pin de tierra (SG). Como los niveles lógicos TTL que sales del microcontrolador no son compatibles con los niveles lógicos RS232 del puerto serial de la computadora por lo que se debe utilizar un conversor de nivel a RS232, como el max232. En figura 3.4 se muestra el integrado y su conexión. El capacitor 5 es de 10µf y los demás son de 1µf para el circuito mostrado en la figura 3.4 c). Este circuito se va a sumar al sistema de adquisición que se muestra en la figura 2.5 del capítulo dos para formar un sistema que pueda enviar datos a una computadora, el diagrama completo se muestra en la figura 3.5.

25

Figura 3.4 a) Muestra el circuito integrado, b) El nombre de cada pin, c) Conexión típica del max232.

Figura 3.5 Sistema de adquisición de señal con comunicación a una computadora.

26

3.3 SOFTWARE PARA EL CONTROL DE LA COMUNICACIÓN. Para el control de la comunicación de la computadora con el microcontrolador es necesario programar el siguiente software:

- Programa del microcontrolador con las funciones necesarias para envío de datos utilizando el puerto UART.

- Programa para que la computadora pueda leer el puerto serial RS232.

3.3.1 El módulo UART del microcontrolador en C Si se quiere usar el microcontrolador para enviar datos por el puerto serial, hay que programarlo, para esto se hace uso de algunas funciones que contiene el compilador C CCS para la configuración genérica del UART. #USE RS232 (opciones) Esta directiva permite configurar varios parámetros del UART: velocidad de transmisión, pines utilizados, etc. Se puede modificar en cualquier parte del programa pero siempre después de haber definido la directiva #USE DELAY. Esta directiva habilita el uso de funciones tales como getch (), putchar () y printf (). [8] Las opciones que lleva como parámetros son: BAUD=X Velocidad en Baudios. XMIT=pin Pin de transmisión. RCV=pin Pin de recepción. BITS =X Donde X es 5-9 (no puede usarse 5+7 con el USART Interno). PARITY=X Donde X es N, E, u O. Ejemplo: #use rs232 (baud=9600, xmit=pin_c6, rcv=pin_c7, bits=8, parity=N) Para la transmisión de datos se ocupan las siguientes funciones. putc (cdata) putchar (cdata) cdata es un carácter de 8 bits. Esta función envía un carácter mediante la patilla XMIT. La directiva #USE RS232 debe situarse siempre antes de utilizar ésta función. puts (string) string: cadena de caracteres constante o matriz de caracteres terminada con un 0. La función puts() manda los caracteres de la cadena, uno a uno, a través del bus RS-232

27

utilizando la función putc(); detrás de la cadena envía un return (13) y un retorno de carro (10). printf (fname, cstring, values ... ) string: es una cadena de caracteres (constante) o matriz de caracteres terminada con un 0. frame: las funciones a utilizar para escribir la cadena indicada; por defecto se utiliza la función put(), que permite escribir en el bus RS-232. values: valores a incluir en la cadena separados por comas; se debe indicar %nt. El formato es %nt, donde n es opcional y puede ser: 1-9 para especificar cuantos caracteres deben ser especificados; 01-09 para indicar la cantidad de ceros a la izquierda; 1.1 - 9.9 para coma flotante. t puede indicar:

C Carácter. S Cadena o carácter. U Entero sin signo. D Entero con signo. Lu Entero largo sin signo. Ld Entero largo con signo. X Entero hexadecimal (minúsculas). X Entero hexadecimal (mayúsculas). Lx Entero largo hexadecimal (minúsculas). LX Entero largo hexadecimal (mayúsculas). F Flotante con truncado. G Flotante con redondeo. E Flotante en formato exponencial. W Entero sin signo con decimales insertados. La primera

cifra indica el total, la segunda el número de decimales.

En el capítulo dos se usa un código para programar el microcontrolador en el cual se utilizan estas funciones que permiten que el microcontrolador pueda enviar datos a una computadora, así como el microcontrolador se programa, la computadora necesita también de un software para que pueda leer la información que recibe en el puerto serial RS232, el cual describimos en la siguiente sección.

3.3.2 Uso de Matlab para leer el puerto serial RS232. Una vez establecida la comunicación con el microcontrolador, solo falta un programa para que la computadora pueda recibir el valor del dato, aunque existen varios programas que pueden hacer esta tarea, se eligió Matlab por ser una herramienta que nos permitirá generar y simular una red neuronal artificial. El código en Matlab necesario para la inicializar el puerto serial es:

28

s = instrfind; if~isempty( s ) fclose( s ); delete( s ); clear s end El siguiente código permite configurar y poder abrir el puerto. SerPIC = serial('COM1'); set(SerPIC,'BaudRate',9600); set(SerPIC,'DataBits',8); set(SerPIC,'Parity','none'); set(SerPIC,'StopBits',1); set(SerPIC,'FlowControl','none'); set(SerPIC,'InputBufferSize' ,20); fopen(SerPIC); La función serial crea un objeto que contiene todos los parámetros correspondientes al puerto serial como baudios, bits de datos, bit de parada, etc. Estos parámetros son modificados con la función set. Una vez establecidos los parámetros de la comunicación, se procede a abrir el puerto con la función fopen: fopen(SerPIC); La función para leer el puerto serial es fscanf: A=fscanf(SerPIC,'%d',1) Una vez terminada la comunicación, se procede a cerrar el puerto con la siguiente línea de código: fclose(SerPIC); De esta manera podemos establecer la comunicación entre un microcontrolador Pic y una computadora utilizando Matlab.

3.4 INTERFAZ GRÁFICA DE USUARIO EN MATLAB Guide es un entorno de programación visual disponible en Matlab para realizar y ejecutar programas que necesiten de una interfaz grafica. Tiene las características básicas de todos los programas visuales como Visual Basic o Visual C++. Una vez que los controles están en posición se editan las funciones de llamada (Callback)

29

de cada uno de ellos, escribiendo el código de Matlab que se ejecutará cuando el control sea utilizado. Una aplicación GUIDE consta de dos archivos: .m y .fig. El archivo .m es el que contiene el código con las correspondencias de los botones de control de la interfaz y el archivo .fig contiene los elementos gráficos. Cada vez que se adicione un nuevo elemento en la interfaz gráfica, se genera automáticamente código en el archivo .m. A la herramienta GUIDE se accede de varias maneras, la primera de ellas es tecleando guide en la ventana de comando. >> guide Otra manera de entrar a GUIDE es través del File, opción New y por último el GUI. En el apéndice A se explican las herramientas y controles que tiene GUIDE para diseñar una interfaz grafica y como se pueden programar.

3.5 DISEÑO DE INTERFAZ GRÁFICA PARA ENCONTRAR LA FUNCIÓN DE CALIBRACIÓN DEL SENSOR NO LINEAL CON RNA.

Se diseña una interfaz gráfica de usuario en Matlab para que realice lo siguiente:

• Adquirir datos del sensor a través del puerto serial RS232 y guardar la información un archivo de texto.

• Graficar la curva de calibración y mostrar los valores usados. • Crear una red neuronal multicapa • Entrenar la red neuronal artificial • Evaluar el funcionamiento de la red para valores deferentes al entrenamiento y

mostrar los resultados en una gráfica. • Mostrar el valor de los pesos obtenidos al final del entrenamiento. • Hacer pasar por la RNA entrenada, datos leídos del puerto serial y mostrar los

resultados. Para facilitar la explicación de lo que se hace en esta interfaz, por cada punto se genera un panel en el cual se encuentran los controles necesarios para que al activarlos ejecuten las instrucciones que realizan cierta tarea.

3.5.1 Interfaz grafica de usuario principal. El diseño final de la interfaz gráfica de usuario realizado con GUIDE de Matlab se muestra en la figura 3.6. En esta interfaz se encuentran los controles necesarios para realizar las funciones antes mencionadas. En este capítulo solo se describirá el primer punto.

30

Figura 3.6 Interfaz gráfica usuario para calibrar un sensor no lineal.

Para el primer punto (adquisición de datos) requiere de varios controles para realizar su función, por eso se diseña en otra ventana, que se puede abrir desde un menú que se encuentra en la interfaz gráfica de usuario principal como se muestra en la figura 3.7 a), haciendo clic en “ADQUISICION DE DATOS” y luego en “INTERFAZ GRÁFICA”.

a) b)

Figura 3.7 a) Menú acceso a la interfaz gráfica de adquisición de datos. b) Menú de acceso al archivo de texto.

Esta nueva ventana sirve para guardar los datos en un archivo de texto. También desde el menú se puede abrir precisamente el archivo de texto que contiene los datos guardados de la adquisición, como se muestra en la figura 3.7 b), La demás funciones se podrán ejecutar a través de controles que tiene la interfaz gráfica de usuario principal y mostrar los resultados en una gráfica.

3.5.2 Adquisición datos del sensor a través del puerto serial para guardar la Información un archivo de texto.

Esta interfaz nos permite generar un archivo de texto, en el cual se guarden los datos que se obtienen del sensor a calibrar. Este archivo será utilizado posteriormente en el capítulo

31

cuatro en el uso de una red neuronal artificial. El diseño de la interfaz gráfica para adquirir y guardar datos leídos desde el puerto serie RS232 es como se muestra en la figura 3.8.

Figura 3.8 Interfaz de adquisición de datos.

En el primer panel de control se tiene un botón y un espacio para mostrar valores, como se muestra en la figura 3.9, la función que realiza, al activar el botón con el nombre de “LEER DATO” va a leer el puerto serial RS232 y mostrar los resultados en el cada vez que el microcontrolador envíe un dato.

Figura 3.9 Panel para mostrar datos que llegan al puerto serial.

En el panel llamado control se encuentran un panel con el nombre “intervalo” y otro llamado “último dato guardado” en la figura 3.10 se muestra el diseño. En el primero se encuentran dos espacios para introducir valores numéricos y el segundo solo es para mostrar el último dato guardado que se adquirió del sensor.

32

Figura 3.10 Panel llamado control para adquisición de datos.

Para guardar los datos leídos del puerto serial en un archivo de texto, se utiliza el boton con el nombre de “guarda en archivo”. La manera de utilizar la interfaz se muestra con el siguiente ejemplo: Se necesita guardar datos de un sensor de temperatura (por ejemplo el termistor) en un intervalo de -10ºC a 80 ºC cada 5 ºC. Lo que se hace en la interfaz gráfica es escribir el número -10 en valor de inicio y 5 en incremento y presionamos el botón “aceptar”, mostrara el -10 en la parte arriba, como se muestra en la siguiente figura 3.11.

Figura 3.11 Panel control

Después se presiona el botón “LEER DATO” para comenzar a leer datos del sensor, que llegan al puerto serial RS232. Para guardar los datos en un archivo de texto se presiona el botón “guarda en archivo” y se guardaran dos datos, el dato de la salida del sensor y el numero que aparece en el rectángulo blanco (es el valor de referencia), estos valores se muestran en el panel llamado “archivo generado” como se muestra en la figura 3.12.

Figura 3.12 guardar datos.

33

Para guardar los datos, es en base a las lecturas de un patrón de referencia, es decir, cuando el patrón de referencia indique que existe cierta temperatura en este caso de -10ºC entonces se presiona el botón para guardar los datos mostrados, al mismo tiempo el numero del rectángulo blanco se irá incrementando, es decir, pasar a “-5”, este es el siguiente valor que se espera que marque el patrón de referencia para que se vuelve a presionar el botón “guarda dato”, de esta forma se adquieren datos cada 5 ºC.

34

IV

USO DE REDES NEURONALES ARTIFICIALES

4.1 APLICACIÓN DE LAS REDES NEURONALES ARTIFICIALES EN LA CALIBRACION DE SENSORES NO LINEALES.

Una vez que se tienen los datos del sensor a calibrar en un archivo de texto, en este caso del termistor, se pueden graficar y con esto conocemos su curva de calibración, ahora el siguiente paso es encontrar una función de calibración por algún proceso matemático convencional o bien como es el caso de esta tesis, usar una red neuronal artificial como aproximador de funciones utilizando los datos adquiridos del sensor para poder entrenar la red. Lo que se busca es encontrar una función con una red neuronal artificial que se aproxime a la curva de calibración del sensor.

4.2 ESTRUCTURA DE UN SISTEMA NEURONAL ARTIFICIAL. Las redes neuronales artificiales imitan el sistema del hardware de un sistema nervioso, los elementos de un sistema neuronal biológico son las neuronas, que se agrupan en conjuntos compuestos por millones de ellas organizadas en capas, constituyendo un sistema con funcionalidad propia. Un conjunto de estos subsistemas da lugar a un sistema global (el sistema nervioso, en el caso biológico), en la realización de un sistema neuronal artificial puede establecerse una estructura jerárquica similar. El elemento esencial de partida será la neurona artificial, que se organiza en capas, varias capas constituirán una red neuronal; y por ultimo una red neuronal (o un conjunto de ellas ), junto con las interfaces de entrada y salida, más los módulos convencionales adicionales necesarios, constituirán el sistema global de proceso (como se puede apreciar en la figura 4.1) [5].

35

Neurona Capa RED Sistema neuronal Figura 4.1 Estructura jerárquica de un sistema de redes neuronales artificiales.

4.3 MODELO ESTANDAR DE NEURONA ARTIFICIAL Una red neuronal artificial se compone de unidades llamadas neuronas. Cada neurona recibe una serie de entradas a través de interconexiones y emite una salida. Una neurona tiene más de una entrada; en la figura 4.2 se observa una neurona con R entradas; las entradas individuales 𝑝1,𝑝2, … … ,𝑝𝑅, son multiplicadas por los pesos correspondientes 𝑊1,1,𝑊1,2, … …𝑊1,𝑅 pertenecientes a la matriz de pesos W. [10].

Figura 4.2 Neurona con múltiples entradas

La neurona tiene una ganancia b, la cual llega al mismo sumador al que llegan las entradas multiplicadas por los pesos, para formar la salida n. 𝑛 = 𝑤1,1𝑝1 + 𝑤1,2𝑝2 + … . + 𝑤1,𝑅 𝑝𝑅 + 𝑏 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 4.1

Esta expresión puede ser escrita en forma matricial 𝑛 = 𝑾𝒑 + 𝑏 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 4.2

Los subíndices de la matriz de pesos (𝑊1,2) representan los términos involucrados en la conexión, el primer subíndice representa la neurona destino y el segundo, representa la fuente de la señal que alimenta a la neurona. Por ejemplo, los índices de 𝑤1,2 indican que

36

este peso es la conexión de la segunda entrada a la primera neurona. La salida total está determinada por la función de transferencia f, la cual puede ser una función lineal o no lineal de n, y que es elegida dependiendo de las especificaciones del problema que la neurona tenga que resolver. [10].

4.4 FUNCIÓN DE TRANSFERENCIA. La función de transferencia se aplica a la salida n (figura 4.2), se utiliza para acotar la salida de la neurona y generalmente viene dada por la interpretación que queramos darle a dichas salidas, las funciones utilizadas en este trabajo se describen a continuación:

4.4.1 Función de transferencia lineal (Purelin) La salida de una función de transferencia lineal es igual a su entrada como se muestra la figura 4.3.

Figura 4.3 Función de transferencia Purelin

4.4.3 Función de transferencia sigmoidal (Logsig) Esta función toma los valores de entrada, los cuales pueden oscilar entre más y menos infinito, y restringe la salida a valores entre cero y uno. Esta función es comúnmente usada en redes multicapa, como la Backpropagation, en parte porque la función logsig es diferenciable como se ve en la figura 4.4.

Figura 4.4 Función de transferencia logsing

37

4.4.4 Función de transferencia tangente sigmoidal hiperbólica (tansig) Esta función toma los valores de entrada, los cuales pueden oscilar entre más y menos infinito, y restringe la salida a valores entre menos uno y uno (figura 4.5). Esta función es comúnmente usada en redes multicapa, como la Backpropagation.

Figura 4.5 Función de transferencia logsing

La tabla 4.1 Hace una relación de las principales funciones de transferencia empleadas en el entrenamiento de redes neuronales.

Nombre Relación Entrada /Salida Icono Función

Limitador Fuerte 𝑎 = 0 𝑛 < 0 𝑎 = 1 𝑛 ≥ 0

Hardlim

Limitador Fuerte Simétrico

𝑎 = −1 𝑛 < 0 𝑎 = +1 𝑛 ≥ 0

Hardlims

Lineal Positiva 𝑎 = 0 𝑛 < 0 𝑎 = 𝑛 𝑛 ≤ 0 Poslin

Lineal 𝑎 = 𝑛 Purelin

Lineal Saturado

𝑎 = 0 𝑛 < 0 𝑎 = 𝑛 0 ≤ 𝑛 ≥ 1 𝑎 = 1 𝑛 > 1

Satlin

Lineal Saturado Simétrico

𝑎 = −1 𝑛 < −1 𝑎 = 𝑛 − 1 ≤ 𝑛 ≤ 1

𝑎 = 1 𝑛 > 1

Satlins

Sigmoidal Logarítmico 𝑎 =

11 + 𝑒−𝑛

Logsig

Tangente Sigmoidal Hiperbólica

𝑎 =𝑒𝑛 − 𝑒−𝑛

𝑒𝑛 + 𝑒−𝑛 Tansig

38

Competitiva 𝑎 = 1 𝑛𝑒𝑢𝑟𝑜𝑛𝑎 𝑐𝑜𝑛 𝑛 𝑚𝑎𝑥 𝑎 = 0 𝑒𝑙 𝑟𝑒𝑠𝑡𝑜 𝑑𝑒 𝑛𝑒𝑢𝑟𝑜𝑛𝑎𝑠

Compet

Tabla 4.1 Funciones de Transferencia

4.5 ARQUITECTURA DE UNA RED NEURONAL ARTIFICIAL. Dentro de una red neuronal artificial, los elementos de procesamiento se encuentran agrupados por capas, una capa es una colección de neuronas; de acuerdo a la ubicación de la capa en la RNA, esta recibe diferentes nombres. Capa de entrada: sólo se encargan de recibir las señales de entrada y propagarlas a la siguiente capa. Capas ocultas: Estas capas son aquellas que no tienen contacto con el medio exterior, sus elementos pueden tener diferentes conexiones y son éstas las que determinan las diferentes topologías de la red. Capa de salida: Recibe la información de la capa oculta y transmite la respuesta al medio externo. [10]. Una red de una sola capa con un número S de neuronas, se observa en la figura 4.6 en la cual, cada una de las P entradas es conectada a cada una de las neuronas, la matriz de pesos tiene ahora S filas.

Figura 4.6 Capa de S neuronas

Ahora, si se considera una red con varias capas, o red multicapa, cada capa tendrá su propia matriz de pesos W, su propio vector de ganancias b, un vector de entradas n, y un vector de salida a. La versión completa de una red de tres capas, puede ser visualizada en la figura 4.7.

39

Figura 4.7 Red de tres capas. Para esta red se tienen R entradas, 𝑆1 neuronas en la primera capa, 𝑆2neuronas en la segunda capa, las cuales pueden ser diferentes; las salidas de las capas 1 y 2 son las entradas a las capas 2 y 3 respectivamente.[10].

4.6 FASES DE OPERACIÓN DE UNA RED NEURONAL ARTIFICIAL Clásicamente se distinguen dos fases de operación en los sistemas neuronales: la fase de aprendizaje o entrenamiento y la fase recuerdo o ejecución. El entrenamiento es de particular interés, pues una característica fundamental de las RNA es que se trata de sistemas entrenables, capaces de realizar un determinado tipo de procesamiento o cómputo aprendiéndolo a partir de un conjunto de patrones de aprendizaje o ejemplos. [5]. En el contexto de las redes neuronales se define al aprendizaje como el proceso por el que se produce el ajuste de los parámetros libres de la red a partir de un proceso de estimulación por el entorno que rodea la red. El tipo de aprendizaje se determina por la forma en la que dichos parámetros se adaptan a sus valores. En la mayoría de las ocasiones el aprendizaje consiste simplemente en determinar un conjunto de pesos sinápticos que permita a la red realizar correctamente el tipo de procesamiento deseado. Cuando se construye un sistema neuronal artificial, se parte de un cierto modelo de neurona y de una determinada arquitectura de red, estableciéndose los pesos sinápticos iniciales como nulos o aleatorios. Para que la red resulte operativa es necesario entrenarla, lo que constituye la fase aprendizaje.

40

El más convencional es el modelado de sinapsis, que consiste en modificar los pesos sinápticos siguiendo una regla de aprendizaje, se construye a partir de la optimización de una función de error, que mide la eficacia actual de la operación en red. Generalmente, una vez que el sistema ha sido entrenado, el aprendizaje “se desconecta”, por lo que los pesos y la estructura quedan fijos, estando la red neuronal ya dispuesta para procesar datos. Este modo de operación se denomina fase recuerdo o de ejecución. [5].

4.7 PERCEPTRÓN MULTICAPA Existen varios tipos de redes neuronales artificiales, dentro de este grupo de redes está el perceptrón simple, adalina y perceptrón multicapa. Este último es el modelo neuronal más empleado en las aplicaciones prácticas y es el modelo que se usa en esta tesis para calibrar un sensor no lineal.

El perceptrón simple es una red de alimentación directa, esto es la información fluye desde la capa de entrada hacia la capa de salida. Fue desarrollado por F. Rosenblatt hacia final de la década de los cincuenta basándose en la regla de aprendizaje de Hebb y de los modelos de neuronas biológicas de McCulloch y Pitts.[11]. La operacion en un perceptrón simple que consta de n neuronas de entrada y m neuronas de salida se puede expresar como la ecuación 4.1:

𝑦𝑖 = 𝑓 ��𝑤𝑖𝑗𝑥𝑗

𝑛

𝑗=1

+ 𝜃𝑖� 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 4.1

El perceptrón multicapa consta de una capa de entrada y una capa de salida y una o más capas ocultas. Dichas capas se unen de forma total hacia delante, esto es, la capa entrada se une con la primera capa oculta y esta con la siguiente y la última capa oculta se une con la capa de salida. Los valores que el perceptrón multicapa acepta son reales. [11].

Denotamos por 𝑥𝑖 a las entradas de la red, 𝑦𝑖 a las salidas de la capa oculta y 𝑧𝑘 a las de la capa final (y globales de la red); 𝑡𝑘 serán las salidas objetivo (target). Por otro lado, 𝑤𝑖𝑗 son los pesos de la capa oculta y 𝜃𝑗 sus umbrales, 𝑤′𝑘𝑗 los pesos de la capa de salida y 𝜃′𝑘 sus umbrales (ganancia). La operación de un perceptrón multicapa (MLP) con una oculta y neuronas de salida lineal (estructura que constituye un aproximador universal de funciones) se expresa como la ecuación 4.2.

𝑧𝑘 = �𝑤′𝑘𝑗𝑦𝑗 + 𝜃′𝑖𝑗

= �𝑤′𝑘𝑗𝑗

𝑓 ��𝑤𝑗𝑖𝑖

+ 𝜃𝑖� + 𝜃′𝑖 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 4.2

Esta comprobado que una red multicapa puede aproximar hasta el nivel deseado cualquier función continua en un intervalo por lo tanto son aproximadores universales de funciones [5].

41

Para su entrenamiento ocupan un algoritmo de aprendizaje denominado algoritmo de retropropagación, conocido también por su denominación en inglés, backpropagation, este algoritmo es de uso muy extendido en las aplicaciones de redes neurales. Se le identifica como parte de los procesos de aprendizaje supervisados, pues requiere que la red disponga parte de la información, usualmente en las entradas y salidas. El algoritmo es iterativo alrededor de los pesos, pues la intención es ajustarlos en cada unidad de tal manera que se reduzca el error entre la salida deseada y la real. De ahí que la variable principal sea conocida como error derivado de los pesos. Para generar y entrenar la red neuronal multicapa se utilizara Matlab, este programa nos permitirá también poder simular la red entrenada ante valores desconocidos para la red, es decir, valores distintos con los que fue entrenada. Y de esta manera probar su funcionamiento.

4.8 CREAR UNA RED MULTICAPA EN MATLAB Se utilizará Matlab para simular una red neuronal artificial (RNA) específicamente perceptrón multicapa y seleccionar la arquitectura de la red adecuada, para esto Matlab cuenta con una herramienta llamada nntool que se utiliza para generar la RNA y poder entrenar con solo proporcionar las entradas y salidas conocidas para que pueda realizar el entrenamiento, una vez entrenada, se puede simular el funcionamiento de la red para valores diferentes a los que se usaron en el entrenamiento, lo que sucede al entrenar la red, es que después de varias iteraciones, se realizan los ajusten de los pesos y ganancias que hacen que la red tenga un error muy pequeño de aproximación a la curva de calibración del sensor. Lo primero que se tiene que hacer es ingresar los datos en forma de un vector, asignados a una variable, estos datos son los adquiridos del sensor (termistor) y son los datos de entrada a la red, también se proporcionan las salidas esperadas conocidas como target. Si se grafican estos valores se observara la curva de calibración del sensor, es decir que a cada punto de entrada le corresponde un valor de salida. Como ejemplo usamos los siguientes datos: X= [329.5 247.7 188.5 144.1 111.3 86.43 67.77 53.41 42.47 33.90 27.28 22.05 17.96 14.69 12.09 10.00 8.313 6.940 5.827 4.911 4.160 3.536 3.020 2.588 2.228 1.924 1.668 1.451 1.266 1.108 0.9731 0.8572 0.7576]; Y= [-50 -45 -40 -35 -30 -25 -20 -15 -10 -5 0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 105 110]; Donde X es la resistencia y Y, los valores de las temperaturas. Si se Grafica con plot (X,Y) obtenemos la gráfica de la figura 4.7 y se observa su curva de calibración o curva característica del sensor.

42

Figura 4.8 Curva de calibración del Termistor. Una red neuronal no necesita una función de inicio a la que se tiene que aproximar la curva, es decir, no es necesaria la suposición inicial de una determinada forma funcional para el ajuste, solo se necesita los datos con los que graficamos la curva de calibración y sirven para entrenar la red. La red entrenada nos devolverá valores que le corresponde a entradas para las cuales no fue entrenada (interpolación). Después de graficar la curva de calibración del sensor se puede generar la red neuronal artificial, para esto se escribe nntool en el “Command Window” de Matlab y se presiona enter y aparece la siguiente ventana.

Aquí nos pide datos necesarios para generar la red, se utilizan los vectores X,Y que se uso

43

para graficar la curva. Solo hay que importarlas dando clic en “import" y aparece la siguiente ventana.

Se selecciona la variable y se especifica si es entrada, o salida(target) y presionar el botón “import”. Las variables van apareciendo conforme se seleccionan y se importan. Con esto ya se puede empezar a crear la red. Dando clic en “New Network” de la primera ventana, y aparece lo siguiente.

En esta ventana, para este caso se selecciona una la red multicapa, con el tipo de Feed forward backprop, se selecciona también el rango de entrada y especificar el número de capas y cuantas neuronas tendrá cada una con su función de transferencia (este proceso es a prueba y error, comenzando por una red pequeña e ir aumentando el número de neuronas hasta encontrar la arquitectura que mejor se ajusta) y presionando el botón “Create” para generar la red. Si se desea se puede cambiar el nombre en este caso se utiliza network1, como se observa en la siguiente ventana en donde aparece el nombre de la red y las variables importadas.

44

Se selecciona el botón “Train” (entrenar) y se ajusta el número de epochs (iteraciones), que en este caso es 10000. Se presiona el botón Train Network para empezar el entrenamiento y se observara lo siguiente.

Cuando acaba el entrenamiento se tienen los pesos que se obtuvieron durante el entrenamiento. Para finalizar se exporta la red a el espacio de trabajo (workspace).

45

La red aparecerá en workspace con el nombre que se le asigno. Existe una función en Matlab que sirve para simular el funcionamiento de la red, esta función es: A = sim (net, P) Donde net es el nombre de la red y P es el vector que se quiere evaluar, ejemplo: X2=0:0.05:329; %se genera un vector A=sim(network1,X2); % se evalua la RNA con los valores de X2 plot (X2,A) % se grafica el resultado. De esta forma se puede ver el funcionamiento de una red ante valores desconocidos. Con estos pasos podemos entrenar una RNA para que se ajuste a la curva característica del sensor. La versión 6.5 de Matlab no funciona sobre el sistema operativo Windows 7 y los pasos descritos son para usar la herramienta nntool en esta versión, ya que las versiones más recientes ya no incluyen esta herramienta de la misma forma, por lo que se tuvo que hacer la interfaz gráfica usuario, y utilizar de manera directa las funciones de redes neuronales. La interfaz gráfica que se diseño en el capítulo tres ya tiene incluido estas funciones para generara y entrenar una RNA multicapa y funciona en el Matlab de versiones más recientes. Su uso se explica en el siguiente tema.

4.9 USO DE LA INTERFAZ GRÁFICA DE USUARIO PARA GENERAR, ENTRENAR Y EVALUAR UNA RNA.

Para automatizar el proceso de manipular una red neuronal artificial para aproximarse a la curva de calibración del sensor, a partir de algunos datos de entrada y salida se utiliza la interfaz gráfica de usuario que se diseño en el capítulo tres.

46

Partimos de que ya se tiene un archivo de texto (generado con la interfaz gráfica en el capitulo tres) que contenga los datos adquiridos del sensor (entradas, salidas) y guardado en la misma carpeta donde está el programa principal de la interfaz gráfica. En el panel llamado “DATOS” se pueden leer los datos del archivo de texto, se presionan los botones llamados “SENSOR” y “P. REFERENCIA” para observar los datos de entrada y salida que se están utilizando, también se puede graficar los datos al hacer clic en el botón llamado “CURVA DE CALIBRACION” como se muestra en la figura 4.9.

Figura 4.9 Datos y grafica del archivo de texto leído. Luego se pasa al panel de “CREAR RNA” para poner los parámetros que necesita la capa 1 y 2 , es decir, especificar cuantas neuronas lleva en cada capa y la función de transferencia a utilizar. En este caso se eligió 10 neuronas en la capa 1 y 5 en la capa 2, todas con la función de transferencia tansig y presionamos el botón “CREAR”, cabe mencionar que la interfaz solo usa dos funciones de transferencia la “tansig y logsig” , esto nos muestra una gráfica con los puntos sin entrenamiento (figura 4.10).

47

Figura 4.10 Creación de una RNA y su grafica sin entrenamiento. Posteriormente se procede a entrenar la red desde el panel llamado “ENTRENAR RNA” solo nos pide un numero de epoch (numero de iteraciones a realizar) y se da clic en el botón “ENTRENAR”, aparece una ventana donde se muestra el entrenamiento (ver figura 4.11a ). Al finalizar se muestra en la gráfica el ajuste de los puntos en la curva de calibración como se ve en la figura 4.11 b).

a) b)

Figura 4.11 Entrenamiento y grafica de ajuste a la función.

48

Esta gráfica muestra el ajuste a los valores de entrenamiento, ahora falta evaluar la red con datos diferentes, es decir, ante valores desconocidos, para esto tenemos el panel llamado “EVALUAR RNA” de donde podemos generar un vector de datos para evaluar el funcionamiento de la red. En el ejemplo hacemos un vector desde 1 hasta 329 cada 0.001 y estamos generando 328001 valores distintos para evaluar la red en todos ellos y se presiona el botón “EVALUR RNA”, mostrara el resultado en una gráfica sobre la curva de calibración para ver su convergencia, como se muestra en la figura 4.11. Si la red está bien se exporta al workspace de Matlab para ser guardada dando clic en el botón “exportar RED”, también se puede borrar todo con el botón “BORRAR”. Para observar los pesos y ganancias (bias) se encuentra el panel llamado “PESOS” donde solo con seleccionar una opción se muestran los valores de los pesos en forma de matriz correspondiente a cada capa. Como se muestra en la figura 4.12.

Figura 4.11 Evaluación de RNA.

Figura 4.12 Pesos obtenidos.

49

El utilizar una RNA mediante una interfaz gráfica de usuario resulta más fácil, solo hay que dar clic en los botones de control y observar los resultados en una gráfica para verificar su funcionamiento, de esta manera también obtenemos la RNA que se ajuste a la curva de calibración del sensor.

50

V PRUEBAS

Y RESULTADOS

5.1 USO DEL SISTEMA DE ADQUISICIÓN DE SEÑAL Para el uso de una red neuronal artificial en la calibración de un sensor descrito en el capítulo cuatro, se utilizaron los valores de la hoja de datos del termistor, pero también se adquirieron datos del sensor a través del sistema de adquisición que se diseño en el capitulo dos. La adquisición de datos del termistor se hace con el sistema de adquisición de señal, mostrado en la figura 5.1, que nos permite obtener información del sensor, transmitirla a una computadora a través de la comunicación serial y poder almacenarla, para que por medio de la interfaz gráfica se encuentre la red adecuada y se muestren los resultados por medio de gráficas. Primero se tomaron lecturas de sensor no lineal (termistor) cada 5 °C comenzando desde la temperatura más baja que se puedo conseguir, que fue de -10 luego se incrementa la temperatura hasta 85 °C por ser el límite del termistor utilizado. La temperatura fría se obtuvo de un refrigerador y la temperatura más alta por medio de una caja de unicel donde se introduce un foco para generar calor. Se hace uso del un sensor de temperatura LM35, este se usa como referencia para determinar el valor de la variable medida y establecer la relación con los valores de salida del termistor, de tal manera que el termistor debe funcionar muy parecido a como la hace el LM35 utilizado, es decir, el sensor calibrado se debe parecer al funcionamiento del patrón de referencia. Cabe mencionar que si el patrón de referencia es de poca calidad, también lo será el sensor calibrado y si es de buena calidad la calibración será mejor.

51

Los cambios de temperatura tienen que ser lentos para que los sensores puedan dar una buena lectura, los dos sensores se colocaron juntos para que los dos reciban la misma temperatura.

Figura 5.1 Sistema de adquisición de señal.

Los datos que se obtuvieron del termistor, con el sistema de adquisición se muestran en la tabla 5.1.

ENTRADAS(ºC) SALIDAS(V) -10 2.9275 -5 2.3367 0 1.8804 5 1.5199

10 1.2380 15 1.0126 20 0.8334 25 0.6893 30 0.5730 35 0.4784 40 0.4017 45 0.3385 50 0.2867 55 0.2437 60 0.2082 65 0.1784 70 0.1536 75 0.1326 80 0.1150 85 0.1000

Tabla 5.1 Datos adquiridos del termistor con el sistema de adquisición.

52

5.2 ELECCIÓN DE LA ARQUITECTURA DE LA RNA. Lograr que una red neural artificial pueda aproximarse a una curva, depende de una buena elección de su arquitectura. En general si el problema es sencillo, bastaran pocos parámetros para su ajuste: deberá utilizarse una red pequeña. Si el programa es complejo, se necesitarán más parámetros de ajuste: se necesitará una red de mayor tamaño. Por lo tanto, deberá ajustarse el tamaño de la red a la complejidad del problema que se está tratando. Para aproximarse a la curva de calibración con una RNA multicapa, se probaron varias arquitecturas, primero se probó con una red de pocas neuronas en la capa uno y se observó que su error es muy grande para el caso de la curva del termistor, por eso se empieza con una red pequeña y si no converge se aumenta el número de neuronas en cada capa hasta encontrar la adecuada para el problema, otro parámetro es cambiar la función de transferencia de cada capa y volver a entrenar la red. Como resultado se encontró que una red con la arquitectura de 5 neuronas de entrada, 5 neuronas en la capa oculta con la función de tranferencia “tansig” y en la salida una neurona con función de transferencia Purelin, si converge a la curva de calibración del termistor con un error muy pequeño. Al graficar los datos obtenidos del sensor (ver tabla 5.1) observamos la curva de calibración del sensor. Esta curva se ajusta con una red neuronal artificial, primero se elige una arquitectura y se empieza a entrenar, en la figura 5.2 se observa como los puntos se ajustaron a la curva con una red neuronal artificial a finalizar el entrenamiento.

Figura 5.2 Aproximación de la RNA a la curva de calibración del termistor.

5.3 Aproximación de función a una curva hipotética Se realizó una prueba con una curva hipotética del comportamiento de algún sensor para ajustar su curva. Dado los datos que forman la curva como se muestra en la figura 5.3, donde se representan con pequeños círculos. x=[ 0 0.5000 1.0000 1.5000 2.0000 2.5000 3.0000 3.5000 4.0000 4.5000 5.0000 5.5000 6.0000 6.5000 7.0000 7.5000 8.0000 8.5000 9.0000 9.5000 10.0000]

53

y=[ 0 0.9794 1.8415 2.4975 2.9093 3.0985 3.1411 3.1492 3.2432 3.5225 4.0411 4.7945 5.7206 6.7151 7.6570 8.4380 8.9894 9.2985 9.4121 9.4248 9.4560]

Figura 5.3 Curva para aproximarla con RNAs

Se genero una red de 5-5-1 y se entreno a 2000 iteraciones, el resultado se muestra en la gráfica 5.4, los asteriscos muestran los puntos de ajuste para los datos de entrenamiento.

Figura 5.4 Ajuste de la curva con RNA para los datos de entrenamiento

Si evaluamos la red para valores diferentes, para ver como realiza la interpolación, obtenemos la gráfica de la figura 5.5 donde se observa como los valores diferentes a los que su usaron para el entrenamiento se ajustaron a la curva.

54

Figura 5.5 Resultado final de RNA.

5.4 IMPLEMENTACION DE LA RNA ENTRENADA EN UN MICROCONTROLADOR.

Una red entrenada se puede simular en Matlab y comprobar su funcionamiento, pero si queremos implementar la red en un microcontrolador se necesita conocer los pesos obtenidos al finalizar el entrenamiento y desarrollar una función en lenguaje C que simule la RNA entrenada al igual que lo hace Matlab con la función “sim()”. El código se hace en C porque ese es el lenguaje en que se va a programar el microcontrolador. La función recibe como parámetro un valor de entrada para ser procesado por la red, y devolverá el resultado evaluado, para hacer el código, se tiene como base el funcionamiento de la RNA descrito en el capítulo cuatro, se utiliza una arquitectura de 10 neuronas de entrada 5 en la capa oculta y una en la salida, todas con la función de transferencia tansig (tangente sigmoidal hiperbólica) excepto la ultima, que tiene una función Purelin (identidad) como se observa en la figura 5.6.

Figura 5.6 Arquitectura de la RNA utilizada

55

Si tenemos la matriz de pesos y ganancias de cada capa de la red se puede encontrar la salida de cada neurona de la capa una mediante la ecuación 5.1. 𝑎1 = 𝑓1(𝑾𝟏 ∗ 𝑝 + 𝑏1) 𝑒𝑐𝑢𝑎𝑐𝑖𝑜𝑛 5.1 El resultado de a1, es la entrada hacia la capa 2. Entonces tenemos la ecuación 5.2: 𝑎2 = 𝑓2(𝑾𝟐 ∗ 𝒂𝟏 + 𝑏2) 𝑒𝑐𝑢𝑎𝑐𝑖𝑜𝑛 5.2 El resultado de a2, es la entrada hacia la capa 3. Entonces tenemos la ecuación 5.3: 𝑎3 = (𝑾𝟑 ∗ 𝐚𝟐 + 𝑏3) 𝑒𝑐𝑢𝑎𝑐𝑖𝑜𝑛 5.3

Donde W son las matrices de pesos, p es la entrada, b son las ganancias y f son las funciones de transferencia que utilizan. La función de calibración se muestra en la ecuación 5.4: 𝑠𝑎𝑙𝑖𝑑𝑎 = (𝑊3 ∗ (𝑓2(𝑊2 ∗ (𝑓1(𝑊1 ∗ 𝑝 + 𝑏1) + 𝑏2) + 𝑏3) 𝑒𝑐𝑢𝑎𝑐𝑖𝑜𝑛 5.4

Con el entrenamiento de la red obtenemos los pesos y ganancias (W y b) que pide la ecuación, de tal manera que la ecuación 5.4 es la que se tiene que programar en el microcontrolador. Para obtener los pesos y ganancias podemos escribir en el workspace de Matlab el siguiente código. W1=net1.iw{1,1}; W2=net1.lw{2,1}; W3=net1.lw{3,2}; B1= net1.b{1}; B2= net1.b{2}; B3= net1.b{3}; También se pueden observar y copiar los pesos desde la interfaz gráfica de usuario en el panel llamado “PESOS” como se muestra en la figura 5.7.

56

Figura 5.7 Pesos en la interfaz grafica. Con estos pesos y ganancias se puede programar una función, que realice la simulación de la red entrenada pero programada en lenguaje c, lo que se debe de hacer es programar las operaciones que se realizan en la ecuación 5.4, el código de la función es: float evaluared(float z){ int i,r,c,j; float W1[10]={ //matriz de pesos w1}; float B1[10]={// matriz de pesos b1}; float A[10]; float A2[10]; float W2[5][10]={ //matriz de pesos w2}; float B2[5]={// matriz de pesos b2 }; float W3[5]={// matriz de pesos w3}; float B3= { //matriz de pesos b3}; for(i=0;i<10;i++) { total=0; total=total+(W1[i]*z)+B1[i]; A[i]=tanh(total); } for(r=0;r<5;r++) { total2=0; for(c=0;c<10;c++) { total2=total2+(W2[r][c])*A[c]; } total2=(total2+B2[r]);

57

A2[r]=tanh(total2); } total3=0; for(j=0;j<5;j++) { total3=total3+(W3[j]*A2[j]); } resultado=total3+B3; return resultado; } Esta función se probó primero en un compilador en C y después se utiliza como una función en el código del microcontrolador PIC18f450, el código del microcontrolador en es el siguiente: #include <18F4550.h> #device adc=10 #fuses HS, NOWDT #use delay(clock=20000000) #include <LCD.C> #include <math.h> int16 q; float p; void sensor(){ set_adc_channel(0); //Habilitación canal0 delay_us(20); q = read_adc(); //Lectura canal0 p = 5.0 * q / 1024.0; //Conversión a tensión } double evaluared(float z){ float resultado; float total,total2,total3; int i,r,c,j;

float W1[10]={0.084848484848485,0.084848484848485,-0.084848484848485,0.084848531939940,

0.084887945732628,-0.022725404512510,-0.148715194370628,1.822234104242093, 3.829536845420923,60.605816808595037};

float B1[10]={-28.000000000000000,-24.888888888888889,21.777777777777779,-18.666666664872306,-15.555554248039442,-1.155676457118663,-1.679606988118666,1.059215226802647,1.184455904618671,5.049550833770251};

float A[10]; float A2[10]; float W2[5][10]={-5.327431055820402,-5.362714425465943 , 4.908685259101157 ,-3.981029961152748, -4.097006938575197, 5.383088752922332, 27.987274522847017, 2.672390045197626, -

6.821958048963264, 4.133826685864658, -0.368602306561060, -1.262227008717713, 0.378867427091104 , -0.738960340576051, -1.897120748032138, 1.293964875855608, 0.607208338150842, -0.813300183932980, -0.340269649710514, 1.738617453264518,

4.622701405386316, 4.543498808529668, -3.081340950132792, 3.542731033906111 , 3.322309475554359, -5.154018179758412, -7.113930031718814, -16.222138945524474,

58

34.877833771677835 , -4.130127518668901,-2.714752961187275 , -2.199468029822385 , 3.419029881400046, -2.429087776011986 , -3.452341135366929, 4.684977219557919, 5.181433281984928, -4.866436514946287, -0.987984857651154, -1.173138875515957,

1.953145099423785, 2.191678588195891 , -1.235477471314459, 1.010628364389577, 0.899678310736375, -2.200760025409681, -1.972390775077493, 1.883937828641537, 0.527028845761892, -10.416679215405980};

float B2[5]={6.203743353488834,0.312603009101445,-

3.748755816035981,1.867959955516108,0.141205644277071}; float W3[5]={100.4566343318620, 39.2693475799980, -64.1298429036178, 65.0222535654456 , -

37.9179959748574}; float B3= 66.562452635285794; for(i=0;i<10;i++) { float total=0; total=total+(W1[i]*z)+B1[i]; if(total>14) { total=14; } if(total<(-14)) { total=-14; } A[i]=tanh(total); } for(r=0;r<5;r++) { total2=0; for(c=0;c<10;c++) { total2=total2+(W2[r][c])*A[c]; } total2=(total2+B2[r]); if(total2>14) { total2=14; } if(total2<(-14)) { total2=-14; } A2[r]=tanh(total2); } for(j=0;j<5;j++) { total3=total3+(W3[j]*A2[j]); } resultado=total3+B3; return resultado; }

59

void main() { double n; setup_adc_ports(AN0); //Canal 0 analógico setup_adc(ADC_CLOCK_INTERNAL); //Fuente de reloj RC lcd_init(); while (true) { sensor(); n=evaluared(p); printf(lcd_putc, "\fTEMP= %3.4f C\n", n); printf(lcd_putc, "VOL=%4.4f",p); delay_ms(100); } }

60

Conclusiones La finalidad de esta tesis era utilizar una red neural artificial (RNA) para encontrar la función de calibracion de un sensor, partiendo de que una red neural artificial multicapa se puede utilizar como aproximador de funciones. Lo que se aproxima con una red es la curva de calibracion de un sensor, lo cual permite establecer la relación entre la variable medida y la señal de salida del sensor mediante una función. Se utiliza una RNA aunque no es la única forma de encontrar la función, también se puede hacer con regresión por mínimos cuadrados la diferencia es que en la RNA no es necesaria la suposición de una determinada forma funcional para el ajuste, además es simple la implementación en un microcontrolador por que no implica ecuaciones muy complejas para su desarrollo. Se realizarón todas las pruebas en esta tesis sobre un termistor NTC, por ser un sensor que tiene como característica la no linealidad en su curva de calibración. Se necesitaba obtener datos del sensor, por eso se empezó con el diseño del sistema de adquisición de señal y los datos obtenidos con este sistema se utilizaron en Matlab para generar y entrenar la red obteniendo como resultado la función de calibracion del sensor. Para obtener los datos del sensor se uso el sistema de adquisición de señal, se puede decir que es de gran ayuda, pues de lo contrario se tendría que tomar lectura del sensor anotando uno a uno los datos de salida para temperaturas diferentes, este proceso es un poco difícil en el sentido de que se debe de estar cambiando el valor de la variable física que se está midiendo para poder variar la lectura del sensor. La implementación de la RNA en un microcontrolador es una de las metas más importantes que se logró, pues una RNA se puede simular en una computadora con un programa que cuente con herramientas para manejo de RNAs como Matlab, pero se requería que se pudiera llevar la función de calibración encontrada con una RNA a un microcontrolador, para lograr esto se tuvo que entender el funcionamiento de las redes neuronales artificiales y en base a eso programar el código para el microcontrolador. Al terminar este trabajo en base a las pruebas realizadas, se puedo constatar que es factible calibrar un sensor no lineal con una red neuronal artificial y que se podría hacer con cualquier otro que presente no linealidad, pues la red se puede ajustar para aproximar otra forma de curva, solo hay que modificar su arquitectura si fuera necesario. Finalmente basados en los resultados obtenidos, se puede asegurar que mediante RNA es posible encontrar la función de calibracion de un sensor. Sin embargo con la finalidad de ser evaluado en su totalidad sería necesario el empleo de otros métodos de aproximación de funciones y comparar resultados con una red neuronal artificial. Este estudio no está dentro de las metas de esta tesis y formaría parte de un trabajo de investigación a futuro.

61

APÉNDICE A INTERFAZ GRÁFICA DE USUARIO EN MATLAB

Para iniciar un proyecto, lo podemos hacer de dos maneras: • Ejecutando la siguiente instrucción en la ventana de comandos: >> guide • Haciendo un click en el ícono que muestra la figura:

Ícono GUIDE.

Se presenta el siguiente cuadro de diálogo:

Ventana de inicio de GUI.

Se presentan las siguientes opciones: a) Blank GUI (Default) La opción de interfaz gráfica de usuario en blanco (viene predeterminada), nos presenta un formulario nuevo, en el cual podemos diseñar nuestro programa. b) GUI with Uicontrols Esta opción presenta un ejemplo en el cual se calcula la masa, dada la densidad y el volumen, en alguno de los dos sistemas de unidades. Podemos ejecutar este ejemplo y obtener resultados.

62

c) GUI with Axes and Menu Esta opción es otro ejemplo el cual contiene el menú File con las opciones Open, Print y Close. En el formulario tiene un Popup menu, un push button y un objeto Axes, podemos ejecutar el programa eligiendo alguna de las seis opciones que se encuentran en el menú despegable y haciendo click en el botón de comando. d) Modal Question Dialog Con esta opción se muestra en la pantalla un cuadro de diálogo común, el cual consta de una pequeña imagen, una etiqueta y dos botones Yes y No, dependiendo del botón que se presione, el GUI retorna el texto seleccionado (la cadena de caracteres ‘Yes’ o ‘No’). Elegimos la primera opción, Blank GUI, y tenemos: Elegimos la primera opción, Blank GUI, y tenemos:

Entorno de diseño de GUI

La interfaz gráfica cuenta con las siguientes herramientas:

Alinear objetos.

Editor de menú.

Editor de orden de etiqueta.

Editor del M-file.

Propiedades de objetos.

Navegador de objetos.

Grabar y ejecutar (ctrl. + T).

Para obtener la etiqueta de cada elemento de la paleta de componentes ejecutamos: File>>Preferentes y seleccionamos Show names in component palette. Tenemos la siguiente presentación:

63

Entorno de diseño: componentes etiquetados.

La siguiente tabla muestra una descripción de los componentes:

Control Valor de estilo Descripción

Check box ‘checkbox’ Indica el estado de una opción o atributo

Editable Text ‘edit’ Caja para editar texto Pop-up menu ‘popupmenu’ Provee una lista de opciones List Box ‘listbox’ Muestra una lista deslizable Push Button ‘pushbutton’ Invoca un evento

inmediatamente Radio Button ‘radio’ Indica una opción que puede ser

seleccionada Toggle Button ‘togglebutton’ Solo dos estados, “on” o “off” Slider ‘slider’ Usado para representar un rango

de valores Static Text ‘text’ Muestra un string de texto en

una caja Panel button Agrupa botones como un grupo Button Group Permite exclusividad de

selección con los radio button Cada uno de los elementos de GUI, tiene un conjunto de opciones que podemos acceder con clic derecho.

64

Opciones del componente.

La opción Property Inspector nos permite personalizar cada elemento.

Entorno Property Inspector.

Permite ver y editar las propiedades de un objeto.

Al hacer click derecho en el elemento ubicado en el área de diseño, una de las opciones más importantes es View Callbacks, la cual, al ejecutarla, abre el archivo .m asociado a nuestro diseño y nos posiciona en la parte del programa que corresponde a la subrutina que se ejecutará cuando se realice una determinada acción sobre el elemento que estamos editando. Por ejemplo, al ejecutar View Callbacks>>Callbacks en el Push Button, nos ubicaremos en la parte del programa: function pushbutton1_Callback(hObject, eventdata, handles)

65

FUNCIONAMIENTO DE UNA APLICACIÓN GUI Una aplicación GUIDE consta de dos archivos: .m y .fig. El archivo .m es el que contiene el código con las correspondencias de los botones de control de la interfaz y el archivo .fig contiene los elementos gráficos. Cada vez que se adicione un nuevo elemento en la interfaz gráfica, se genera automáticamente código en el archivo .m. Para ejecutar una Interfaz Gráfica, si la hemos etiquetado con el nombre curso.fig, simplemente ejecutamos en la ventana de comandos >> curso. O haciendo clic derecho en el m-file y seleccionando la opción RUN. MANEJO DE DATOS ENTRE LOS ELEMENTOS DE LA APLICACIÓN Y EL ARCHIVO .M Todos los valores de las propiedades de los elementos (color, valor, posición, string…) y los valores de las variables transitorias del programa se almacenan en una estructura, los cuales son accedidos mediante un único y mismo identificador para todos éstos. Tomando el programa listado anteriormente, el identificador se asigna en: handles.output = hObject; handles, es nuestro identificador a los datos de la aplicación. Esta definición de identificador es salvada con la siguiente instrucción: guidata(hObject, handles); guidata, es la sentencia para salvar los datos de la aplicación. Aviso: guidata es la función que guarda las variables y propiedades de los elementos en la estructura de datos de la aplicación, por lo tanto, como regla general, en cada subrutina se debe escribir en la última línea lo siguiente: guidata(hObject,handles); Esta sentencia nos garantiza que cualquier cambio o asignación de propiedades o variables quede almacenado. Por ejemplo, si dentro de una subrutina una operación dio como resultado una variable x para poder utilizarla desde el programa u otra subrutina debemos salvarla de la siguiente manera: handles. x=x; guidata(hObject,handles); La primera línea crea la variable diego a la estructura de datos de la aplicación apuntada por handles y la segunda graba el valor. SENTENCIAS GET Y SET La asignación u obtención de valores de los componentes se realiza mediante las sentencias get y set. Por ejemplo si queremos que la variable utpl tenga el valor del Slider escribimos: utpl= get(handles.slider1,'Value');

66

Notar que siempre se obtienen los datos a través de los identificadores handles. Para asignar el valor a la variable utpl al statictext etiquetada como text1 escribimos: set(handles.text1,'String',utpl) [12].. Ejemplo: Insertamos los componentes uno a uno como la siguiente figura

Haciendo doble-clic en cada componente, accedemos a configurar las propiedades de cada elemento. Por ejemplo configuramos en pushbutton,:

Editar componente.

67

Podemos cambiar el nombre con el que aparecerá la función del pushbutton en el m-file, simplemente editando el campo Tag. Continuamos editando los demás componentes, hasta llegar a tener una presentación semejante a la siguiente:

Con un click derecho en cada control nos ubicamos en View Callbacks→Callback. Esto nos ubica en la parte del M-file correspondiente a cada control. El código general queda de la siguiente manera: function varargout = INTERFAZ_GRAF(varargin) gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @INTERFAZ_GRAF_OpeningFcn, ... 'gui_OutputFcn', @INTERFAZ_GRAF_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end function INTERFAZ_GRAF_OpeningFcn(hObject, eventdata, handles, varargin) handles.output = hObject; guidata(hObject, handles); function varargout = INTERFAZ_GRAF_OutputFcn(hObject, eventdata, handles) varargout{1} = handles.output; % -------------------------------------------------------------------- function A_datos_Callback(hObject, eventdata, handles) % --------------------------------------------------------------------

68

function i_grafica_Callback(hObject, eventdata, handles) TERMO function pushbutton1_Callback(hObject, eventdata, handles) op=fopen('datos.txt','rt') %Abre el archivo de datos x=fscanf(op,'%f') %guarda los datos en x fclose(op) %cierra el archivo d2=x(2:2:length(x)) %selecciona cada 2 datos set(handles.entrada,'String',d2); %muestra los valores en un List Box function entrada_Callback(hObject, eventdata, handles) function entrada_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function vector_Callback(hObject, eventdata, handles) function vector_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function pushbutton2_Callback(hObject, eventdata, handles) op=fopen('datos.txt','rt') x=fscanf(op,'%f') fclose(op) d1=x(1:2:length(x)); set(handles.target,'String',d1); function target_Callback(hObject, eventdata, handles) function target_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function pushbutton3_Callback(hObject, eventdata, handles) %a=str2num(get(handles.vector,'String')); op=fopen('datos.txt','rt') b=fscanf(op,'%f') fclose(op) t1=b(1:2:length(b)); %selecciona datos de los target r2=b(2:2:length(b)); %seleciona datos adquiridos del archivo de texto plot(r2,t1) % grafica la funcion. xlabel('entradas') ylabel('target') function uipanel1_CreateFcn(hObject, eventdata, handles) function simula_Callback(hObject, eventdata, handles) function simula_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function pushbutton5_Callback(hObject, eventdata, handles) global net1 hold on x2=str2num(get(handles.simula,'String')); y= sim(net1,x2); plot(x2,y,'r') xlabel('entradas') ylabel('target') zoom on function pushbutton6_Callback(hObject, eventdata, handles)

69

s = instrfind; if~isempty( s ) fclose( s ); delete( s ); clear s end SerPIC = serial('COM1'); set(SerPIC,'BaudRate',9600); set(SerPIC,'DataBits',8); set(SerPIC,'Parity','none'); set(SerPIC,'StopBits',1); set(SerPIC,'FlowControl','none'); set(SerPIC,'InputBufferSize' ,16); % ”n” es el número de bytes a recibir fopen(SerPIC); global net1 global A for k=1:100 A=fscanf(SerPIC,'%d',1) % 0-1024 p = (5.0 * A )/ 1024; % voltaje temperatura=sim(net1,p); set(handles.salida,'String',temperatura); pause(0.5); end fclose(SerPIC); function pushbutton7_Callback(hObject, eventdata, handles) function uipanel2_DeleteFcn(hObject, eventdata, handles) function pushbutton8_Callback(hObject, eventdata, handles) cla function radiobutton2_Callback(hObject, eventdata, handles) grid function interfaz_c_Callback(hObject, eventdata, handles) winopen('guardaa.exe') function pushbutton1_ButtonDownFcn(hObject, eventdata, handles) % -------------------------------------------------------------------- function ABRIR_Callback(hObject, eventdata, handles) % -------------------------------------------------------------------- function ARCHIVO_Callback(hObject, eventdata, handles) winopen('datos.txt') function capas_Callback(hObject, eventdata, handles) valor_pum = get(handles.capas,'value'); switch valor_pum; case 2 handles.funcion='tansig'; case 3 handles.funcion='logsig' end guidata(hObject, handles); function capas_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function pushbutton9_Callback(hObject, eventdata, handles) global net1 % la red se define como variable global. global P

70

global T global c1 global c2 op=fopen('datos.txt','rt'); b=fscanf(op,'%f'); fclose(op); p=b(2:2:length(b)); P = [p']; %transpuesta del vector op=fopen('datos.txt','rt'); b=fscanf(op,'%f'); fclose(op); t=b(1:2:length(b)); T = [t'] a=[0 330] % falta generalizar c1=str2num(get(handles.neuronas1,'String')); %mostrar resultados c2=str2num(get(handles.neuronas2,'String')); b=[c1 c2 1] net1 = newff(a,b,{handles.funcion,handles.funcion2 , 'purelin'}); %funcion para %generar %la red Y = sim(net1,P); %simulacion sin entrenar plot(P,T,P,Y,'*') xlabel('entradas') ylabel('target') zoom on guidata(hObject, handles); %sirve para que pueda ser utilisada en otros controles. % --- Executes on button press in pushbutton10. function pushbutton10_Callback(hObject, eventdata, handles) global net1 global P global T c=str2num(get(handles.iteracion,'String')); net1.trainParam.epochs = c; net.trainParam.show =100; net.trainParam.goal =1e-5; net.trainParam.lr=0.075; net.trainParam.mem_reduc =1; net.trainParam.min_grad =1e-12; net1 = train(net1,P,T); Y = sim(net1,P); plot(P,T,P,Y,'.') guidata(hObject, handles); function radiobutton3_Callback(hObject, eventdata, handles) global net1 set(handles.uitable1,'data',net1.iw{1,1}); function iteracion_Callback(hObject, eventdata, handles) function iteracion_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function neuronas1_Callback(hObject, eventdata, handles) function neuronas1_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function neuronas2_Callback(hObject, eventdata, handles)

71

function neuronas2_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function popupmenu2_Callback(hObject, eventdata, handles) valor2_pum = get(handles.capas,'value'); switch valor2_pum; case 2 handles.funcion2='tansig'; case 3 handles.funcion2='logsig'; end guidata(hObject, handles); function popupmenu2_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function mostrar_Callback(hObject, eventdata, handles) function mostrar_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in radiobutton4. function radiobutton4_Callback(hObject, eventdata, handles) global net1 set(handles.uitable1,'data',net1.lw{2,1}); function radiobutton5_Callback(hObject, eventdata, handles) global net1 set(handles.uitable1,'data',net1.lw{3,2}); function radiobutton6_Callback(hObject, eventdata, handles) global net1 set(handles.uitable1,'data',net1.b{1}); function radiobutton7_Callback(hObject, eventdata, handles) global net1 set(handles.uitable1,'data',net1.b{2}); function radiobutton8_Callback(hObject, eventdata, handles) global net1 set(handles.uitable1,'data',net1.b{3}); function pushbutton11_Callback(hObject, eventdata, handles) global net1 save net1 function pushbutton12_Callback(hObject, eventdata, handles) clear,clc,cla

72

REFERENCIAS BIBLIOGRÁFICAS [1]. Leija, L. (2009). métodos de procesamiento avanzado e inteligencia Artificial en

sistemas sensores y biosensores. México: Reverté. [2]. Pallás, R. (2003). Sensores y acondicionamiento de señal. España: marcombo. [3]. Pallás, R. (1993). Adquisición y Distribución de Señales. España: marcombo. [4]. Coughlin, R. y Sanz Molina, A. (1999). Amplificadores operacionales y circuitos

integrados lineales. México: Prentice Hall. [5]. Martín del Brío, B. y Driscoll, F. (2006). redes neuronales y sistemas borrosos.

México: Ra-Ma. [6]. Helfrick, A. y Cooper,W. (1991). Instrumentación Electrónica Moderna y Técnicas de

medición. México: Prentice Hall. [7]. Creus, A. (1998). Instrumentación Industria. Mexico: Alfaomega. [8]. García, E. (2008). I Compilador c ccs y simulador Proteus para microcontroladores

pic. Mexico: Alfaomega. [9]. Palacios,E.,Remiro,F. y J. López,L. (2004). microcontrolador PIC16f84 desarrollo de

proyectos. Mexico: Alfaomega. Páginas de internet [10]. http://ohm.utp.edu.co/neuronales [2010] [11] http://www.redes-neuronales.netfirms.com/tutorial-redes- neuronales/estructuras-de-las-redes-neuronales.htm [2011] [12] http://www.matpic.com/ [2011]

http://ohm.utp.edu.co/neuronales�

http://www.matpic.com/�

red neuronal perceptron multicapa en microchip pic ccs 18f4550

Education