UNIVERSIDAD DE LAS FUERZAS ARMADAS

ESPE EXTENSIÓN LATACUNGA

AUTOMATIZACIÓN INDUSTRIAL MECATRÓNICA

DOCENTE: PATRICIA CONSTANTE

NRC: 3007

TEMA: IMPLEMENTACIÓN DE UN PERCEPTRÓN CON EL USO

DE MATLAB Y ARDUINO.

INTEGRANTES:
Muñoz Richard
Rubio Rodrigo
Silva Carlos

2018-2019
Contenido
Objetivos:................................................................................................................................3
Objetivo General.....................................................................................................................3
Objetivos Específicos...............................................................................................................3
Introducción:...........................................................................................................................3
Materiales:..............................................................................................................................3
Marco teórico..........................................................................................................................4
Redes neuronales................................................................................................................4
Perceptrón..........................................................................................................................6
Neural Network/Data Manager en Matlab (nntool)..........................................................7
Procedimiento.........................................................................................................................8
Análisis de resultados...........................................................................................................17
Conclusiones.........................................................................................................................21
Recomendaciones.................................................................................................................21
Bibliografía............................................................................................................................21
Anexos...................................................................................................................................22
Objetivos:

Objetivo General
Implementar una compuerta NAND mediante Matlab y arduino

Objetivos Específicos
 Usar software para el entrenamiento de un perceptrón.
 Implementar el perceptrón usando arduino.

Introducción:
Se desea realizar la implementación de una compuerta NAND, usando para ellos una
Tarjeta Arduino que permita la programación de la salida de la neurona, teniendo como
entradas la lectura de dos canales analógicos en este caso dos sensores (LDR) y
presentado la respuesta en un led, como activación del perceptrón.

Materiales:
Equipos:

 Computadora con programa MATLAB.

 Tarjeta Arduino
 Protoboard
 2 sensores (LDR)
 1 Leds
 Cables
Marco teórico

Redes neuronales

Las RNA son sistemas de procesamiento de la información cuya estructura y

funcionamiento están inspirados en las redes neuronales biológicas. Consisten en un
gran número de elementos simples de procesamiento llamados nodos o neuronas que
están organizados en capas. Cada neurona está conectada con otras neuronas
mediante enlaces de comunicación, cada uno de los cuales tiene asociado un peso. Los
pesos representan la información que será usada por la red neuronal para resolver un
problema determinado. [ CITATION Mon16 \l 12298 ]

Figura 1 Modelo simplificado de neurona artificial

Así, las RNA son sistemas adaptativos que aprenden de la experiencia, esto es,
aprenden a llevar a cabo ciertas tareas mediante un entrenamiento con ejemplos
ilustrativos. Mediante este entrenamiento o aprendizaje, las RNA crean su propia
representación interna del problema, por tal motivo se dice que son autoorganizadas.
Posteriormente, pueden responder adecuadamente cuando se les presentan
situaciones a las que no habían sido expuestas anteriormente, es decir, las RNA son
capaces de generalizar de casos anteriores a casos nuevos. Esta característica es
fundamental ya que permite a la red responder correctamente no sólo ante
informaciones novedosas, sino también ante informaciones distorsionadas o
incompletas.
Las funciones de activación más comunes son las mostradas en la Figura , estas pueden
ser usadas para clasificar.

Figura 2 Funciones de activación

La arquitectura de las redes neuronales es la estructura o patrón de conexiones de la

red. Es conveniente recordar que las conexiones sinápticas son direccionales, es decir,
la información sólo se transmite en un sentido.

Figura 3 Arquitectura de RNA

En general, las neuronas suelen agruparse en unidades estructurales llamadas capas.

Dentro de una capa, las neuronas suelen ser del mismo tipo. Se pueden distinguir tres
tipos de capas:

 De entrada: reciben datos o señales procedentes del entorno.

 De salida: proporcionan la respuesta de la red a los estímulos de la entrada.
 Ocultas: no reciben ni suministran información al entorno (procesamiento
interno de la red).
Generalmente las conexiones se realizan entre neuronas de distintas capas, pero
puede haber conexiones intracapa o laterales y conexiones de realimentación que
siguen un sentido contrario al de entrada-salida.[ CITATION Ave16 \l 12298 ]

Perceptrón

El perceptrón simple fue introducido por Rosenblatt (1962) y es un modelo

unidireccional compuesto por dos capas de neuronas, una de entrada y otra de salida.
La operación en un perceptrón simple que consta de n neuronas de entrada y m
neuronas de salida se puede expresar como:

Las neuronas de entrada son discretas y la función de activación de las neuronas de la

capa de salida es de tipo escalón como en la Figura…. El perceptrón simple puede
utilizarse como clasificador, radicando su importancia histórica en su carácter de
dispositivo entrenable, ya que el algoritmo de aprendizaje del modelo introducido por
Rosenblatt (1962) permite determinar automáticamente los pesos sinápticos que
clasifican un conjunto de patrones a partir de un conjunto de ejemplos etiquetados.
[ CITATION Ped17 \l 12298 ]

El perceptrón simple presenta grandes limitaciones, ya que tan solo es capaz de

representar funciones linealmente separables. En la figura se puede observar la forma
de calcular los pesos.
 Figura 4 Región de decisión correspondiente a un perceptrón simple con dos neuronas de entrada

El algoritmo de aprendizaje del perceptr´on simple pertenece al grupo de los

algoritmos que se fundamentan en la correcci´on de errores. Los algoritmos de este
tipo ajustan los pesos de manera proporcional a la diferencia existente entre la salida
actual de la red neuronal y la salida deseada, con el objetivo de minimizar el error
actual de la red.

Neural Network/Data Manager en Matlab (nntool)

Neural Network Toolbox proporciona algoritmos, modelos preprogramados y

aplicaciones para crear, entrenar, visualizar y simular redes neuronales superficiales y
profundas. Puede realizar la clasificación, la regresión, la agrupación, la reducción de
dimensionalidad, la previsión de series de tiempo y el modelado y control de sistemas
dinámicos.[ CITATION Mat173 \l 12298 ]
 Figura 5 Entorno de desarrollo Neural Network

Procedimiento

1. Ejecutar el programa Matlab, en la ventana de comandos escriba la palabra

nntool y presione la tecla Enter. Como se observa en la Figura 6.

Figura 6 Comando nntool en la ventana de comandos de MATLAB

2. A continuación, aparece la pantalla emergente del Neural Network/Data

Manager, mostrada en la Figura 7.
 Figura 7 Entorno de desarrollo Neural Network/Data Manager

3. Diríjase al Command Windows de Matlab e ingrese las entradas y el objetivo

del perceptrón para la compuerta NAND en forma de matriz. El objetivo y las
entradas se muestran en la Tabla 1.

Tabla 1 Tabla de verdad de compuerta AND

Compuerta NAND
Entradas Objetivo
0 0 1
0 1 1
1 0 1
1 1 0
 La Figura 8 muestra el ingreso de las entradas en la matriz “entrada” y el
objetivo como el vector “objetivo”.

Figura 8 Entradas y objetivos ingresados en el Command Window

4. En la ventana de Neural Network/Data Manager, realice click en “import” para

ingresar las variables entrada y objetivo como se muestra en la Figura 9.

Figura 9 Neural Netwwork de Matlab

5. Para importar las entradas y el objetivo se selecciona “Import from MATLAB
workspace”, luego seleccionamos la variable entrada y en “Destination”
seleccionar “Input Data” para ingresarlo como los valores de entrada de la red
neuronal y realizar click en “import” como se observa en la Figura 10.

Figura 10 Ventana emergente Inport to Network/Data Manager

6. Cuando se haya importado aparcera un cuadro de dialogo como se muestra e la

Figura 11, que indica que las variables se han importado correctamente y click
en Ok, de igual manera para importar los objetivos: seleccionar la variable
“objetivo” y en “Destination” seleccionar “Target Data” para ingresar la variable
como los valores objetivos. Luego de importar las variables, click en Close.

Figura 11 Aviso cuando se ha importado la variable

7. En la ventana de Neural Network/Data Manager dar doble clic en “New..” la

pantalla emergente permite la creación de distintos tipos de redes neuronales,
para la creación del preceptrón en “Network type” seleccionar “Perceptron”,
 en “input data” seleccionar la variable “entrada”, en “Target Data” seccionar la
variable “objetivo”, como en la Figura 12 y dar clic en “Create”.

Figura 12 Configuración para la creación de RNA.

8. Cuando se haya creado aparece un cuadro de dialogo como se muestra e la

Figura 13 que indica que se creado una nueva red neuronal correctamente y
presione Ok.
 Figura 13 Aviso de creación de RNA.

9. Una vez haya creado el perceptrón en este caso con el nombre de

“netwok1”,en la ventana de Neural Network/Data Manager en la sección de
NAND dar doble click en “network1”,aparecerá una ventana emergente que
nos proporciona varias opciones para configuración de la red mostrado en la
Figura 14.

Figura 14 Cuadro de visualización de Network.

10. Diríjase a la pestaña de Train en la parte superior, esta pestaña nos permite
entrenar la red neuronal artificial, seleccionar la entrada (Input) y objetivo
(Tagets) y dar clic “Train Network” para entrenar la red, como se observa en la
Figura 15.
 Figura 15 Pestaña Train

11. A continuación, aparecerá un cuadro de dialogo como se muestra en la Figura

16 que indica datos de sobre el entrenamiento de la red neuronal, como el
número de iteraciones que fueron necesarias para enseñar a la neurona , el
tiempo necesario y click en Ok.

Figura 16 Entrenamiento de la red neuronal

12. Diríjase a la pestaña de “Simulate” en la parte superior, en esta pestaña nos
permite simular la red neuronal artificial, seleccionar la entrada(input) y dar clic
“Simulate Network” para simular la red como se muestra en la Figura 17,
aparcera un cuadro de dialogo que indica que la red se ha simulado y que los
datos han sido guardados y presione en Ok.

Figura 17 Pestaña Simulate

13. Diríjase a la pestaña de “View/Edit Weights” en la parte superior,esta pestaña

nos permite ver-editar los pesos y el bias, seleccionar “weight to layer 1 from
input 1” para ver los pesos, seleccionar “Bias to layer 1” para visualizar el valor
del bias, los cuales serán necesarios para implementar en Arduino, como en la
Figura 18 y 19.

Figura 18 Valores de pesos

 Figura 19 Valores de Bias

14. Realizar el código de programación del perceptrón en la IDE de Arduino

utilizando los pesos y el valor del bias obtenidos al entrenar la red en Matlab.

Código
double VLDR,VPOT;
double ValorLDR,ValorPOT;
double w1=-0.6,d3,w2=-0.6,b=1,salida;
int LedPin=3;

void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(3,OUTPUT);

void loop() {

VLDR=analogRead(A0);
ValorLDR=((VLDR/600)/1.71)/0.85;

VPOT=analogRead(A1);
ValorPOT=((VPOT/600)/1.71)/0.85;

d3=((ValorLDR*w1)+(ValorPOT*w2)+b);

if(d3>=0)
{
salida=1;
digitalWrite(3,HIGH);
}
else
{
salida=0;
digitalWrite(3,LOW);

Serial.print(ValorLDR);Serial.print(",");Serial.print(ValorPOT);Seri
al.print(",");Serial.println(salida);

}
15. Implementar el circuito mostrado en la Figura 20.

Figura 20 Diagrama de circuito a implementar

Análisis de resultados

Una vez implementado el perceptrón en la tarjeta de desarrollo Arduino, se variaron

las entradas (LDR) mediante una luz de celular para poder visualizar la salida mediante
el encendido y el apagado de un led, también se utilizó comunicación seriar para poder
visualizar el comportamiento de la neurona para verificar su comportamiento.
Para las pruebas realizadas el valor de las entradas al perceptrón son valores desde 0
hasta 2.15 , para que al mover los valores del potenciómetro, de izquierda a derecha,
trate de ser uniforme con respecto a los valores de entrada del perceptrón.
 Figura 21 Led encendido y apagado según las condiciones establecidas en el código

Compuerta NAND

Figura 22 Pruebas para la compuerta NAND

 Prueba 1
Los valores ingresados como entrada fueron:
Entrada uno: 0
Entrada dos: 0
Lo cual implica que la salida del sea 1 y el led este prendido
 Compuerta NAND
Entrada Objetivo
s
0 0 1

Figura 23 Prueba 1 NAND

 Prueba 2
Los valores ingresados como entrada fueron:
Entrada uno: 0
Entrada dos: 1
Lo cual implica que la salida del sea 1 y el led este prendido

Compuerta NAND
Entrada Objetivo
s
0 1 1

Figura 24 Prueba 2 NAND

 Prueba 3
Los valores ingresados como entrada fueron:
Entrada uno: 1
Entrada dos: 0
Lo cual implica que la salida del sea 1 y el led este prendido
 Compuerta NAND
Entrada Objetivo
s
1 0 1

Figura 25 Prueba 3 NAND

 Prueba 4
Los valores ingresados como entrada fueron:
Entrada uno: 1
Entrada dos: 1
Lo cual implica que la salida del sea 0 y el led este apagado

Compuerta NAND
Entrada Objetivo
s
1 1 0

Figura 26 Prueba 4 NAND

 Prueba 5 valores intermedio

Los valores ingresados como entrada 1 y la entrada 2 fueron valores que nos
fueron puestos en la entrada de la neurona cuando se la entreno por lo cual esta
trata de asimilar y dar una respuesta acorde a lo que aprendió.
 Figura 27 Prueba 5 NAND

Conclusiones
 Mediante la herramienta de redes neuronales de Matlab se obtiene los pesos y
el bias ,para le red neuronal puede funcionar de la forma que queremos la
salida implementar.
 Se requiere escalar los valores analógicos de entrada de modo que puedan ser
usados en la función de obtención de salida, mediante la programación se tiene
que escalar de forma adecuada para tener una salida coherente.
 La salida fue vizualizada mediante un LED, conectado a una salida digital que
mediante condiciones en base a los valores se ponía en HIGH si la salida es
mayor o igual a 0, caso contrario en LOW.

Recomendaciones
 En sensores LDR tener un ambiente controlado donde la luz se contante en
todas partes para tener valores analógicos fáciles de escalar

Bibliografía
Avellano. (2016). Obtenido de http://avellano.usal.es/~lalonso/RNA/index.htm
Larrañaga, P., Inza, I., & Moujahid, A. (2017). Redes Neuronales.
MathWorks. (2017). Caja de herramientas de redes neuronales.
Montaño. (2016).

Anexos

Figura 28 Preparatorio de la practica