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.1USO DEL SISTEMA DE ADQUISICIÓN DE SEÑAL ............................................................................... 50

5.2ELECCIÓN DE LA ARQUITECTURA DE LA RNA. ............................................................................... 52
5.3APROXIMACIÓ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
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.

1
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.

2
 I
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.

3
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.

4
- 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.

5
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].

6
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

7
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.

8
• θ 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

9
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.

10
 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.

11
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

12
(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].

13
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
14
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
15
(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.3
2𝑁 −1

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.

16
La resolución vendrá dada por la siguiente ecuación:

(𝑉𝑅𝐸𝐹+ − 𝑉𝑅𝐸𝐹− )
1LSB=𝑉𝑅𝐸𝐹− + 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 2.4
1024

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

5
1LSB= = 4.8 mV
1024

de esta forma si la lectura es de 512 LSB, la tensión analógica leída es:

5
𝑉𝐼𝑁 =512. = (512)(4.8mV)= 2.4576 V
1024

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
ADC_CLOCK_DIV_8 01000000
40h
ADC_CLOCK_DIV_32 10000000
80h

17
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

18
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

19
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.

20
 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
21
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.

22
 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,

23
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.

24
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.

25
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
26
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:

27
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)

28
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.

29
 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

30
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.

31
 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.

32
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.

33
 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].
34
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

35
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

36
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.

Relación
Nombre Icono Función
Entrada /Salida
𝑎=0 𝑛<0
Limitador Fuerte 𝑎=1 𝑛≥0 Hardlim

Limitador Fuerte 𝑎 = −1 𝑛<0

Hardlims
Simétrico 𝑎 = +1 𝑛≥0
𝑎=0 𝑛<0
Lineal Positiva Poslin
𝑎=𝑛 𝑛≤0
𝑎=𝑛
Lineal Purelin
𝑎=0 𝑛<0
𝑎=𝑛 0≤𝑛≥1
Lineal Saturado Satlin
𝑎=1 𝑛>1

𝑎 = −1 𝑛 < −1
Lineal Saturado 𝑎=𝑛 −1≤𝑛 ≤1
Satlins
Simétrico 𝑎=1 𝑛>1

Sigmoidal 1
𝑎= Logsig
Logarítmico 1 + 𝑒 −𝑛
Tangente
𝑒 𝑛 − 𝑒 −𝑛
Sigmoidal 𝑎= Tansig
Hiperbólica 𝑒 𝑛 + 𝑒 −𝑛

37
 𝑎 = 1 𝑛𝑒𝑢𝑟𝑜𝑛𝑎 𝑐𝑜𝑛 𝑛 𝑚𝑎𝑥
Competitiva 𝑎 = 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.

38
 Figura 4.7 Red de tres capas.

Para esta red se tienen R entradas, 𝑆 1 neuronas en la primera capa, 𝑆 2 neuronas 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.

39
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:

𝑦𝑖 = 𝑓 �� 𝑤𝑖𝑗 𝑥𝑗 + 𝜃𝑖 � 𝑒𝑐𝑢𝑎𝑐𝑖ó𝑛 4.1

𝑗=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].

40
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.

41
 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

42
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.

43
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).

44
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.

45
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).

46
 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.

47
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.

48
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.

49
 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.
50
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.

51
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]

52
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.

53
 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

54
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.

55
 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]);

56
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,

57
 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;
}

58
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);

}
}

59
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.

60
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.

61
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:

62
 Entorno de diseño: componentes etiquetados.

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

Valor de
Control Descripción
estilo
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.

63
 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)

64
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');

65
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.

66
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)
% --------------------------------------------------------------------

67
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)

68
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

69
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)

70
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

71
 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]

72