UBIDOTS

La plataforma virtual de ubidots, nos pareció muy buena, ya que tiene una muy buena interacción con el usuario, ya que no es como los tradicionales sitios web para guardar datos, los cuales toca programar linea a linea con código, crea una excelente interfaz, y muy útil en aplicaciones que requieren prioridad y atención constante, como lo son aplicaciones medicas.

¿COMO FUNCIONA?

Nuestro prototipo funciona utilizando un arduino ethernet. el cual, recibe señales por medio de sus entradas análogas, nuestro programa de arduino recibe las señales de los sensores de temperatura y de la fotocelda para saber sus valores cada segundo, y por medio de nuestro programa los envía a través de Internet a la plataforma de ubidots. 
En nuestro programa tenemos programadas las alertas para cuando la temperatura es mayor o menor y lo mismo con la luminosidad, para que se realicen diferentes eventos. Cuando la temperatura en la incubadora es mayor o igual a 29°C automáticamente se encienden los ventiladores para intentar llevarla a su estado normal, lo mismo ocurre con el bebe, cuando la temperatura es mayor o igual a 27°C se enciende la alarma y lo mismo con los ventiladores par intentarlo controlar. Cuando la fotocelda recibe poca luz, se encienden los leds dependiendo de la intensidad de la luz en ese momento, entre menos luz halla, mas luz emiten los leds, utilizando las salidas análogas del arduino.
En el momento que el arduino recibe esos datos, también en el ubidots se encienden las alarmas, enviando un mensaje de texto al celular de la persona encargada de bebe, informándole el problema, para que lo revise y se logre llegar a una solución inmediata al problema.

ADAPTACIÓN FINAL DE LA INCUBADORA

En los días 2 y 3 se terminó de adaptar la incubadora; se agregaron los ventiladores que controlar la temperatura de la incubadora y del bebé; también se terminó de realizar las conexiones entre los sensores y el Arduino Ethernet. el resultado se muestra a continuación.

Cableado de los leds ubicados en la tapa de la incubadora

Ventiladores que sirven para regular la temperatura de la incubadora

Montaje final

Etapa de potencia-sistema de ventilación.

Etapa de potencia-sistema de ventilación.

Para la etapa de potencia de los ventiladores se hizo uso de un puente H, controlado con las salidas del net-duino, y alimentados a 12V dc, para aprovechar la máxima capacidad de estos motores.

El diagrama de conexión se muestra a continuación.

Gràfica tomada de: http://lawebdeingenieria.jimdo.com/home/montajes/

La foto del circuito implementado se muestra a continuación:

Interfaz grafica de usuario

INTERFAZ GRAFICA DE USUARIO CON DE0-NANO

Para la interfez gráfica de usuario se hizo uso de una fpga de0-nano conectada a una pantalla TFT de 4", se utilizo un sistema embebido con micro-controlador(librerias de la pantalla) y ADC(para adquirir datos de los sensores) y se hizo la simulación en la pantalla de una señal  de electro-cardiograma mediante una simulaciòn elaborada con el sistema NIOS II, el RTL del sistema se muestra a continuaciòn:

En el diagrama se puede observar los diferentes bloques que se incorporaron en el sistema, se utilizò un PLL para controlar la maquina de estados que controla el adc, divisores de frecuencia y atrapadores de flanco para controlar las intrucciones del mismo, el sistema micro-procesado NIOS II se encarga de controlar la TFT, y mediante el software eclipse se programaron los gràficos de la TFT.

Adicionalmente se utilizò el Nios II flash programmer para hacer el sistema no volatil, por lo que no hay necesidad de programar el sistema cada vez que se quiera utilizar porque ya programado en la memoria EPCS de la de0-nano.

El resultado final es el mostrado a continuación:

Si desea puede consultar  detalladamente còmo programar y utilizar la pantalla dando click aca.

AVANCES DÍA 1

SELECCIÓN DE HERRAMIENTAS

Para la realización de este proyecto, se cuenta con una tarjeta Arrduino Ethernet, FPGA De0 nano, sensores de temperatura (lm 35), fotoceldas para medir la luminosidad y los materiales para simular una incubadora.

Tarjeta Arduino Ethernet

FPGA DE0 NANO

Materiales para representar el prototipo de incubadora

Se escogió la Tarjeta Arduino Etehernet ya que nos permite una rápida conexión a Internet, además que, como cualquier tarjeta de Arduino; la podemos programar para medir las variables que se quieren monitorear y controlar en este proyecto. 

La FPGA DE0 nano se seleccionó para poder visualizar los datos que se están tomando mediante los sensores, de esta forma el médico o la persona que esté supervisando la incubadora, podrá corroborar que todo el sistema esté funcionando correctamente, además gracias a la configuración que se planea hacer con la tarjeta Arduino Ethernet, los datos medidos estarán almacenados en el sistema de UBIDOTS para que cualquier persona interesada en conocer el estado en que se encuentra el bebé, pueda hacerse una idea observando los datos que hay en la red; de esta forma se garantiza la seguridad y cuidado de salud del bebé.

Los materiales con los que se hará el prototipo de incubadora son: una caja plástica que se observa en la imagen; leds que representan las fuentes de luz que tienen las incubadoras reales.

Las fotoceldas se emplearán para poder medir la intensidad de luz a la cual está expuesto el bebé; en la industria clínica se emplea un parche que está sobre el bebé y es el que mide la luminosidad. 

Se escogió el dispositivo lm35 para medir la temperatura dentro de la incubadora y del bebé; este dispositivo está diseñado para este tipo de aplicaciones y es sencillo de adaptar al sistema de monitoreo.

TRABAJO CON ARDUINO

Configuración de la tarjeta Arduino Ethernet

Una primera configuración que se hiso con la tarjeta Arduino Ethernet fue basa en uno de los ejemplos que el programador de Arduino proporciona, el Ethernet "WebServer", cuyo código se muestra a continuación:

/*

  Web Server

 A simple web server that shows the value of the analog input pins.

 using an Arduino Wiznet Ethernet shield.

 Circuit:

 * Ethernet shield attached to pins 10, 11, 12, 13

 * Analog inputs attached to pins A0 through A5 (optional)

 created 18 Dec 2009

 by David A. Mellis

 modified 9 Apr 2012

 by Tom Igoe

 */

#include <SPI.h>

#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.

// The IP address will be dependent on your local network:

byte mac[] = {

  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress ip(192,168,1,177);

// Initialize the Ethernet server library

// with the IP address and port you want to use

// (port 80 is default for HTTP):

EthernetServer server(80);

void setup() {

 // Open serial communications and wait for port to open:

  Serial.begin(9600);

   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

  // start the Ethernet connection and the server:

  Ethernet.begin(mac, ip);

  server.begin();

  Serial.print("server is at ");

  Serial.println(Ethernet.localIP());

}

void loop() {

  // listen for incoming clients

  EthernetClient client = server.available();

  if (client) {

    Serial.println("new client");

    // an http request ends with a blank line

    boolean currentLineIsBlank = true;

    while (client.connected()) {

      if (client.available()) {

        char c = client.read();

        Serial.write(c);

        // if you've gotten to the end of the line (received a newline

        // character) and the line is blank, the http request has ended,

        // so you can send a reply

        if (c == '\n' && currentLineIsBlank) {

          // send a standard http response header

          client.println("HTTP/1.1 200 OK");

          client.println("Content-Type: text/html");

          client.println("Connection: close");  // the connection will be closed after completion of the response

 client.println("Refresh: 5");  // refresh the page automatically every 5 sec

          client.println();

          client.println("<!DOCTYPE HTML>");

          client.println("<html>");

          // output the value of each analog input pin

          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {

            int sensorReading = analogRead(analogChannel);

            client.print("analog input ");

            client.print(analogChannel);

            client.print(" is ");

            client.print(sensorReading);

            client.println("<br />");      

          }

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

          break;

        }

        if (c == '\n') {

          // you're starting a new line

          currentLineIsBlank = true;

        }

        else if (c != '\r') {

          // you've gotten a character on the current line

          currentLineIsBlank = false;

        }

      }

    }

    // give the web browser time to receive the data

    delay(1);

    // close the connection:

    client.stop();

    Serial.println("client disonnected");

  }

}

El montaje realizado para medir temperatura y luminosidad se observa en la figura 5.

Montaje para medir temperatura y luminosidad. A la izquierda el sensor LM35, a la derecha la fotocelda.

Después de modificar el código base se obtuvo el siguiente resultado:

Primeros resultados en la toma de datos.

Como se observa en la figura 6 el programa modificado funciona correctamente; se establece comunicación con Internet y en la dirección IP asignada al Arduino Ethernet, se pueden ver los datos que miden los sensores. Aunque estos primeros resultados fueron buenos, no es lo que se buscaba, ya que nosotros estabamos trabajando como un servidor y se necesitaba que fuesemos clientes, ya que el servidor sería la plataforma UBIDOTS; así que se cambió el código.

Por fortuna, en los ejemplos de Arduino existe uno en el que se muestra como configurar la tarjeta Arduino Ethernet como cliente además de poder enviar datos al sitio web con el que se establecerá comunicación para el envío de datos; el programa base fue el ejemplo Ethernet "PachubeClient". 

Durante la tarde del día 1 y la mañana del día 2, se trabajó en el código y en cómo manejar la plataforma UBIDOTS para el monitoreo de las variables medidas. 

Resultados Obtenidos:

* Código:

#include <SPI.h>

#include <Ethernet.h>

//direccion arduino ethernet

byte mac[] = { 

  0x90, 0xA2, 0xDA, 0x0E, 0x10, 0x57};

//dirección ip a la que se conectará el arduino en caso de no establecer comunicación con ubidots

IPAddress ip(10,152,174,34);

//inicializacion

EthernetClient client;

//direccion del servidor al cual se conectará

char server[] = "things.ubidots.com";   // name address for pachube API

//configuracion

unsigned long lastConnectionTime = 10;          // last time you connected to the server, in milliseconds

boolean lastConnected = false;                 // state of the connection last time through the main loop

const unsigned long postingInterval = 0; //delay between updates to ubidots.com

//programa

void setup() {

 // Open serial communications and wait for port to open:

  Serial.begin(9600);

   while (!Serial) {

    ; // wait for serial port to connect. Needed for Leonardo only

  }

 // start the Ethernet connection:

  if (Ethernet.begin(mac) == 0) {

    Serial.println("Failed to configure Ethernet using DHCP");

    // DHCP failed, so use a fixed IP address:

    Ethernet.begin(mac, ip);

  }

}

void loop() {

  // read the analog sensor:

  int sensor1 = analogRead(A0);   

  int sensor2 = analogRead(A1);

  int sensor3 = analogRead(A2);

  if (client.available()) {

    char c = client.read();

    Serial.print(c);

  }

//no hay conexion

  if (!client.connected() && lastConnected) {

    Serial.println();

    Serial.println("disconnecting.");

    client.stop();

  }

  // if you're not connected, and ten seconds have passed since your last connection, then connect again and send data:

  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {

    sendData(sensor1,sensor2,sensor3);

    delay(100);

  }

  // store the state of the connection for next time through the loop:

  lastConnected = client.connected();

}

//funcion 1 de sensado de las variables.

void sendData(int thisData,int thisData1,int thisData2) {

  // if there's a successful connection:

  if (client.connect(server, 80)) {

    Serial.println("connecting...");

       

//TEMPERATURA

      int temperatura=analogRead(A0);

    //calculo del valor real de temperatura

      temperatura=temperatura*0.48828125;

// LUZ    

      int luz=analogRead(A1);

    //    valor real milivolts

      luz=488-luz;

      luz=luz*0.3;

//TEMPERATURA BEBE

      int tempbebe=analogRead(A2);

      tempbebe=tempbebe*0.48828125;

//SE LLAMA LA FUNCIÓN QUE CONTROLA LAS ALARMAS

      alarma(temperatura,luz,tempbebe);

//CONFIGURACION PARA ENVIAR LOS DATOS MEDIDOS A UBIDOTS    

    String a="[{\"variable\": \"53fb51c37625422ca173b2b3\",\"value\":" +String(temperatura)+"},{\"variable\": \"53fb52137625422c626e2c39\",\"value\":"+String(luz)+"},{\"variable\": \"53fca41c7625424cc6c9b0e2\",\"value\":" +String(tempbebe)+"}]";

    int len=a.length(); 

    client.println("POST /api/v1.6/collections/values HTTP/1.1");

    client.println("Content-Type: application/json");

    client.println("X-Auth-Token: O6L7ngMzkBoZgTLZ0PfANqJAxPhTKIz51bcKkxKN7SVnhlnB3GvvorPjnYkz");

    client.println("Host: things.ubidots.com");

    client.println("Content-Length: "+String(len)); 

    client.println();

    client.println(a);

    client.println("Refresh: 10");

     client.println();

  } 

  delay(1);

}

//FUNCION ALARMAS

void alarma(int tempi, int luminosidad, int tempb)

{

  //control de temperatura

  int ventilador1= 7;//pin de salida digital para el ventilador 1

  int  ventilador2= 8;//pin de salida digital para el ventilador 2

  pinMode(ventilador1, OUTPUT);      

  pinMode(ventilador2, OUTPUT); 

  int alto= HIGH;

  int bajo=LOW;

  if (tempi>=38){

              digitalWrite(ventilador1, alto);

        } else

        {

          digitalWrite(ventilador1, bajo);

        }

  if (tempb>=36){

              digitalWrite(ventilador2, alto);

        } else

        {

          digitalWrite(ventilador2, bajo);

        }

  //control de luminosidad

   int luces1 = 3;

   int luces2 = 5;

   int luces3 = 6;

   int luces4 = 9;

   int valor;

   int  altopw=255;

   if(luminosidad>=120){

              valor =0;

              analogWrite(luces1,valor);

              analogWrite(luces2,valor);

              analogWrite(luces3,valor);

              analogWrite(luces4,valor); 

     }else{

     if(luminosidad>=100){

              valor =50;

              analogWrite(luces1,valor);

              analogWrite(luces2,valor);

              analogWrite(luces3,valor);

              analogWrite(luces4,valor); 

     }else{

        if(luminosidad>=80){

              valor =100;

              analogWrite(luces1,valor);

              analogWrite(luces2,valor);

              analogWrite(luces3,valor);

              analogWrite(luces4,valor); 

     }else{

      if(luminosidad>=60){

              valor =250;

              analogWrite(luces1,valor);

              analogWrite(luces2,valor);

              analogWrite(luces3,valor);

              analogWrite(luces4,valor); 

     }

     else{

            analogWrite(luces1,altopw);

            analogWrite(luces2,altopw);

            analogWrite(luces3,altopw);

            analogWrite(luces4,altopw);

       }

     }

    }

   }

}  

 *Visualización de los datos en la plataforma Ubidots

Datos medidos visualizados en la plataforma UBIDOTS

TRABAJO CON FPGA DE0-NANO

En una primera configuración de la FPGA para la visualización de datos, se obtuvo el siguiente resultado:

Figura 8. Resultado de la primera configuración de la FPGA para visualización de datos.

Durante el día 2 se estuvo adaptando la FPGA para poder visualizar correctamente los valores medidos. El la figura 8 solo se observa una interfaz gráfica que no aporta información acerca de las variables que se quieren medir.

ADAPTACIÓN DEL PROTOTIPO DE INCUBADORA

Lo primero que se realizó como adaptación de la caja de plástico para que simulara una incubadora, fue agregar luces en la tapa de la caja como se observa en la figura 9, se realizó una configuración especial de leds, ya que eran demasiados si se conectaban todos en paralelo necesitarían mucha corriente para funcionar bien y la tarjeta Arduino no sería capaz de generar tanta corriente, así que se hicieron 4 circuitos diferentes y se emplearon las 4 salidas análogas que tiene el Arduino Ethernet para alimentar estos circuitos y además realizar el control de luminosidad cundo fuese necesario.

adaptación de la tapa de la incubadora.

DIAGRAMA DE BLOQUES

Objetivos del proyecto

OBJETIVO GENERAL

•Desarrollar un prototipo de incubadora neo-natal que permita el monitoreo del entorno en el que se encuentra el neo-nato.

OBJETIVOS ESPECÍFICOS

•Monitorear y controlar  variables como: temperatura del neo-nato y del medio, luminosidad dentro de la incubadora y ritmo cardíaco.

•Enviar la información obtenida al sistema UBIDOTS para conocer el estado del neo-nato en cualquier instante.