UNIVERSIDAD AUTONÓMA DE NUEVO LEÓN

FACULTAD DE INGENIERÍA MECÁNICA Y ELÉCTRICA

AGOSTO-DICIEMBRE 2019
LABORATORIO DE PERCEPCION

PRACTICA 2

CATEDRATICO: DR. LUIS MARTIN TORRES TREVIÑO

Dia: Jueves Hora: V6 Grupo:416 Salón: 2107 Equipo: #9

Integrantes:
Matricula: Nombre:
1599382 Ortiz Rivas Adrian Alejandro
1622746 Hernández Sánchez Bryan leonardo
1666951 Cadena Madrigal Larissa
1617534 Regalado Tobías Andrea Leticia
1630782 Cardona Rojas Jared Gerardo
1460657 Núñez López Javier
1633260 Patiño Espinosa Juan Antonio
1730980 Rocha Arrambide Aldo Rodolfo
1615032 Pérez de Lara Rodríguez Sofia Catalina
 INTRODUCCION
Las redes neuronales artificiales (también conocidas como sistemas conexionistas)
son un modelo computacional vagamente inspirado en el comportamiento
observado en su homólogo biológico1. Consiste en un conjunto de unidades,
llamadas neuronas artificiales, conectadas entre sí para transmitirse señales. La
información de entrada atraviesa la red neuronal (donde se somete a diversas
operaciones) produciendo unos valores de salida.

Cada neurona está conectada con otras a través de unos enlaces. En estos enlaces
el valor de salida de la neurona anterior es multiplicado por un valor de peso. Estos
pesos en los enlaces pueden incrementar o inhibir el estado de activación de las
neuronas adyacentes. Del mismo modo, a la salida de la neurona, puede existir una
función limitadora o umbral, que modifica el valor resultado o impone un límite que
se debe sobrepasar antes de propagarse a otra neurona. Esta función se conoce
como función de activación.

Estos sistemas aprenden y se forman a sí mismos, en lugar de ser programados de

forma explícita, y sobresalen en áreas donde la detección de soluciones o
características es difícil de expresar con la programación convencional. Para
realizar este aprendizaje automático, normalmente, se intenta minimizar una función
de pérdida que evalúa la red en su total. Los valores de los pesos de las neuronas
se van actualizando buscando reducir el valor de la función de pérdida. Este proceso
se realiza mediante la propagación hacia atrás.
El objetivo de la red neuronal es resolver los problemas de la misma manera que el
cerebro humano, aunque las redes neuronales son más abstractas. Las redes
neuronales actuales suelen contener desde unos miles a unos pocos millones de
unidades neuronales
Nuevas investigaciones sobre el cerebro a menudo estimulan la creación de nuevos
patrones en las redes neuronales. Un nuevo enfoque está utilizando conexiones
que se extienden mucho más allá y capas de procesamiento de enlace en lugar de
estar siempre localizado en las neuronas adyacentes. Otra investigación está
estudiando los diferentes tipos de señal en el tiempo que los axones se propagan,
como el aprendizaje profundo, interpola una mayor complejidad que un conjunto de
variables booleanas que son simplemente encendido o apagado.
Las redes neuronales se han utilizado para resolver una amplia variedad de tareas,
como la visión por computador y el reconocimiento de voz, que son difíciles de
resolver usando la ordinaria programación basado en reglas. Históricamente, el uso
de modelos de redes neuronales marcó un cambio de dirección a finales de los años
ochenta de alto nivel, que se caracteriza por sistemas expertos con conocimiento
incorporado en si-entonces las reglas, a bajo nivel de aprendizaje automático,
caracterizado por el conocimiento incorporado en los parámetros de un modelo
cognitivo con algún sistema dinámico.
MODELO 3D
 DESAROLLO
En esta practica obtuvimos los resultados mediante Redes neuronales
de acuerdo lo aprendido en clase cada sensor será activado dándole
una inteligencia artificial utilizando el circuito de la practica 1 , se
agrega un mecanismo en 3D el cual se acoplara el servo mecanismo
asi como una jeringa de 10ml , Asi tomando la condición
MUY BUENA
BUENA
REGULAR
MALA En este estado la jeringa inyecta

En esta los datos los sacas con la tabla de valores obtenida en Excel
de cada sensor sobre capas ocultas
CIRCUITO
INTERFACE

Se observa la salida Y : junto a los datos obtenidos de cada sensor

asi determinando cada condición en este caso fue regular
APLICACIONES
Agricultura y ganadería
Sí, has leído bien. En la agricultura y ganadería también se están utilizando
aplicaciones del IoT. Sobre todo para hacer seguimiento de magnitudes como la
temperatura, humedad, luminosidad y demás factores que pueden influir en la
producción.
Todo esto facilita a los agricultores el poder predecir y cuantificar cada cosecha
antes de recogerla.
Con respecto a la ganadería, el seguimiento biométrico de los animales y su
geolocalización es un factor a tener en cuenta. En este sector, la empresa Infiswift
ofrece servicios especializados.

REFERENCIAS
https://sites.google.com/site/mayinteligenciartificial/unidad-4-redes-neuronales

https://sites.google.com/site/mayinteligenciartificial/unidad-4-redes-neuronales
CODIGO
#include <WiFi.h>
#include <Servo.h>
#include <DHT.h>

// Replace with your network credentials

const char* ssid = "iPhone de Adrian";
const char* password = "AdrianWifi";

// Set your Static IP address 172.20.10.2

IPAddress local_IP(172, 20, 10, 3); //IP iPhone Adrian
// Set your Gateway IP address
IPAddress gateway(172, 20, 10, 1);
IPAddress subnet(255, 255, 0, 0);
IPAddress primaryDNS(8, 8, 8, 8); //optional
IPAddress secondaryDNS(8, 8, 4, 4); //optional

// Set web server port number to 80

WiFiServer server(80);

// Variable to store the HTTP request

String header;

// Assign output variables to GPIO pins

const int led_1 = 13;
const int led_2 = 12;
const int led_3 = 14;
const int led_4 = 27;
const int led_5 = 26;

const int buzzer = 25;

Servo myservo;

#define DHTPIN 23
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);

float h = 0;
float t = 0;
float ilum = 0;
int puls = 0;
float cala = 0;

// Declaraciones para Red Neuronal de Perceptron INICIO

float m[10][6] = {{ -2.6085532, -0.1237776, -0.8309217, 0.5442218, -1.8252912,
0.5328704},
{1.0079067, -0.9267523, 0.9855603, -0.2034289, -1.0630823, -0.3362681},
{0.0041913, -0.3402427, -0.0111552, -0.051793, 0.3863192, -0.6419544},
{ -0.0128385, -0.4970986, -0.0052558, -0.1406123, -0.3415238, -0.5520029},
{ -1.3978701, -0.1508987, -0.9130717, -0.8212979, -1.7184572, 0.0911653},
{1.0310987, -4.8524513, -6.6310578, 0.7999263, 2.2094248, -0.9869878},
{ -0.5778352, -3.9244124, -0.7532994, -4.9391296, 1.8476172, 0.7179775},
{0.7212781, -0.5539699, 0.2539052, -0.6338306, -0.1224643, 0.0634579},
{4.2161476, 2.500868, -1.5651462, -4.641414, 2.9425681, -3.1235727},
{ -4.1737129, -0.2780502, -0.5015649, 0.2657982, -2.9906728, 0.8985783}
};

float o[10] = { -2.6711145, 1.9179803, 0.6214284, 0.4055137, -1.6916114,

5.8423785, -4.9720784, 1.1170895, -4.3989563, -4.0201738};
float N[10];
float x[6];
const float e = 2.718281;
float s = 0;
int n = 0;
int i = 0;
float y = 0;
float ynorm = 0;

void setup() {
Serial.begin(115200);
dht.begin();
// Initialize the output variables as outputs
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
pinMode(led_4, OUTPUT);
pinMode(led_5, OUTPUT);
pinMode(buzzer, OUTPUT);
myservo.attach(33);
pinMode(DHTPIN, INPUT);
// Set outputs to LOW
digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
 digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(buzzer, LOW);

// Configures static IP address IP Fija

if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
Serial.println("STA Failed to configure");
}

// Connect to Wi-Fi network with SSID and password

Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}

void loop() {
WiFiClient client = server.available(); // Listen for incoming clients
 if (client) { // If a new client connects,
Serial.println("New Client."); // print a message out in the serial port
String currentLine = ""; // make a String to hold incoming data from the
client
while (client.connected()) { // loop while the client's connected
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == '\n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what's coming, then a blank line:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();

// Lectura de los sensores

float h = dht.readHumidity();
float t = dht.readTemperature();
delay(100);

ilum = analogRead(35);
ilum = (100 * ilum) / 4096;
delay(100);
puls = analogRead(34);
puls = (130 * puls) / 4096;
if ( puls < 60)
{
puls = 60;
}
delay(100);

cala = analogRead(32);
cala = (100 * cala) / 4096;
cala = 100 - cala;
delay(100);

// Red Neuronal Perceptron

x[0] = t;
x[1] = h;
x[2] = ilum;
x[3] = cala;
x[4] = puls;
x[5] = 1;

for (n = 0; n <= 9; n++)

{
s = 0;
for (i = 0; i <= 5; i++)
{
 s = s + x[i] * m[n][i];
}
N[n] = 1 / (1 + pow(e, -s));
}

s = 0;
for (n = 0; n <= 9; n++)
{
s = s + N[n] * o[n];
}

ynorm = 1 / (1 + pow(e, -s));

y = ynorm * (10 - 0) + 0;

//Condiciones de Salud segun valor de y

if ( y >= 8 )
{
digitalWrite(13, HIGH);
delay(100);
digitalWrite(13, LOW);
}

if ( y >= 7.5 && y < 8 )

{
digitalWrite(12, HIGH);
delay(100);
 digitalWrite(12, LOW);
}

if ( y >= 5 && y < 7.5 )

{
digitalWrite(14, HIGH);
digitalWrite(25, HIGH);
delay(150);
digitalWrite(25, LOW);
digitalWrite(14, LOW);
}

if ( y >= 3 && y < 5 )

{
digitalWrite(27, HIGH);
digitalWrite(25, HIGH);
delay(100);
digitalWrite(25, LOW);
digitalWrite(27, LOW);
}

if ( y < 3 )
{
digitalWrite(26, HIGH);
digitalWrite(25, HIGH);
myservo.write(180);
delay(1000);
myservo.write(0);
 delay(1000);
digitalWrite(25, LOW);
digitalWrite(26, LOW);
}

// Display the HTML web page

client.println("<!DOCTYPE html><html>");
client.println("<head><meta name=\"viewport\" content=\"width=device-
width, initial-scale=1\">");
client.println("<meta http-equiv=\"refresh\" content=\"3\">");
client.println("<link rel=\"icon\" href=\"data:,\">");
client.println("</head>");

// Web Page Heading

client.println("<title>P2-LabPercep</title>");
client.println("<body>");

client.println("<div style='text-align:center;'>");
client.println("<h2 align='center'>Condicion de Salud</h2>");
if ( y >= 7.5 )
{
client.println("Su condicion es: ");
client.println("<br />");
client.println("EXCELENTE");
}
if ( y >= 4 && y < 7.5 )
{
client.println("Su condicion es: ");
client.println("<br />");
 client.println("REGULAR");
}
if ( y < 4 )
{
client.println("Su condicion es: ");
client.println("<br />");
client.println("M A L A");
}
client.println("<br />");
client.println("<br />");
client.println("Salida Y = ");
client.println(y);
client.println("<br />");
client.println("</div>");

client.println("<div style='text-align:center;'>");
client.println("<h2 align='center'>Sensores</h2>");
client.println("Temperatura: ");
client.println(t);
client.println("*C");
client.println("<br />");
client.println("Humedad: ");
client.println(h);
client.println("%");
client.println("<br />");
client.println("Iluminacion: ");
client.println(ilum);
client.println("%");
 client.println("<br />");
client.println("Calidad del Aire: ");
client.println(cala);
client.println("%");
client.println("<br />");
client.println("Pulso Cardiaco: ");
client.println(puls);
client.println("<br />");
client.println("</div>");

client.println("</body>");
client.println("</html>");

// The HTTP response ends with another blank line

client.println();
// Break out of the while loop
break;
} else { // if you got a newline, then clear currentLine
currentLine = "";
}
} else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = "";
// Close the connection
 client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}