Interfaz fpga - cloud computing
Ing. Alfonso Medina Duran
4lfonsomedina@gmail.com
Proyecto para la materia de Sistemas Inteligentes Distribuidos en la Maestria en ingenieria Electronica
07/06/2018
Mexicali, Baja California, México
Resumen
Actualmente la tecnología en dispositivos conectados a la red ha evolucionado significativamente, en los últimos años el uso de smartphones y el internet de las cosas ha llevado a un progresivo aumento en la cantidad de dispositivos conectados simultaneamente, esto obliga a los desarrolladores a alojar sus aplicaciones dentro de un ambiente de servidores virtuales en la red, un entorno comúnmente conocido como “la nube” los cuales deben soportar un gran número de peticiones simultáneas y una alta demanda de recursos, por suerte también nos hemos encontrado con el surgimiento nuevas tecnologías y herramientas de desarrollo que nos ayudan a satisfacer dicha demanda.
De mismo modo los modelos electrónicos presentes en cualquier dispositivo en la red han evolucionado para lograr una compatibilidad con dichas nuevas tecnologias de conectividad. Dentro de este documento se expone una poderosa tecnología de intercomunicación entre aplicaciones dentro de la nube conocida como Web Service, un entorno que nos ofrece flexibilidad, escalabilidad y estabilidad para nuestros desarrollos, las características que definen a un web service, cualidades de un fpga y el desarrollo de una interfaz fpga - cloud.
Contenido
1 Web service.
1.1. ¿Qué es un web service?
1.2. ¿Cuál es su aplicación?
1.3. Características
1.4. Estándares y protocolos
1.5. Ventajas y desventajas
2. FPGA
2.1 ¿Qué es un FPGA?
2.2 ¿Cuál es su aplicación?
2.3 Lenguajes de descripción de hardware
3 Desarrollo
3.1 Descripción de proyecto
3.2 Sintetizando en FPGA
3.3 Interfaz nodeMCU
3.4 Configurando cloud
3.5 Desarrollo de web service
4 Resultados
5 Conclusión
1 Web Service
1.1 ¿Qué es un web service?
En las bibliografías existen distintas definiciones para el concepto de web service, algunos autores lo definen como una vía de intercomunicación e interoperabilidad entre máquinas conectadas en Red, también se definen como un conjunto de protocolos y estándares para el intercambio de datos entre aplicaciones. Basicamente la funcion de un web service se lleva a cabo entre cliente y servidor donde el cliente hace una petición, el servidor la recibe, la procesa y entrega al cliente una respuesta, un ejemplo claro de webservice es google maps al cual le puedes hacer una petición a través de su API donde le envias tu direccion en formato de texto y este te contesta con las coordenadas latitud y longitud, a este proceso se le conoce como web service por lo cual se puede definir como el tráfico de mensajes entre dos máquinas.
1.2 ¿Cuál es su aplicación?
El uso de web service conlleva a la centralización de los datos, esto quiere decir que todos los datos de tu aplicación se encuentren en un solo lugar y estos pueden ser consultados desde otros dispositivos en diferentes lugares del mundo solo teniendo una conexión a internet. imagina que tienes que desarrollar una aplicación en tu ordenador para administrar tu lista de tareas del día, si piensas en desarrollar la aplicación totalmente de escritorio, para acceder a tu lista de tareas necesitas tu computador en todo momento, el problema recae al momento de querer consultar remotamente la misma lista de tareas, desde un smartphone por ejemplo, esto sería muy complicado, sin embargo con la utilización de web services puedes centralizar los datos de tu aplicación en la nube, tu desarrollo de escritorio no tendría base de datos, esta estaría alojada en la nube, esto permitirá que tu lista de tareas también pueda ser consultada a través de una aplicación móvil sin importar donde te encuentres ni el sistema operativo de este, inclusive podría ser consultada por una aplicacin web.
1.3 Características
Para que un desarrollo en la nube pueda ser considerado un web service este debe cumplir con las siguientes cualidades y características:
·
Cuenta con un protocolo de comunicación ya sea HTTP, SMTP, FTP, etc. HTTP es uno de los más utilizados ya que trabaja sobre TCP en el puerto 80, dado que por seguridad un firewall cierra distintos puertos de internet, la utilización del puerto 80 facilita la comunicación pues es el mismo puerto que utilizan los navegadores WEB.
·
·
Basado en tecnologías de intercambio de mensajes, esto quiere decir que un web service no ofrece al cliente una interfaz gráfica, o cualquier otro caso diferente al intercambio de mensajes, simplemente a cada solicitud corresponde a una respuesta.
·
·
Proporciona interfaces de comunicación establecidas, un web service presenta una funcionalidad de caja negra donde a solo se puede acceder a su contenido a través de sus interfaces bien definidas.
·
1.4 Estándares y protocolos
Como se definió anteriormente un web service establece la interfaz de comunicación por medio del protocolos HTTP, SMTP, FTP, etc. el estándar de la estructura de los mensajes puede variar, se debe de utilizar la estructura que más se ajuste al uso que se le dará, debemos tener en cuenta que todas las aplicaciones que se comuniquen con el web service deben manejar el estándar de comunicación establecido por el mismo. por ejemplo si la respuesta de tu web service es un XML, todas las aplicaciones que consumen este recurso deben estar diseñadas para escuchar y procesar una respuesta XML.
·
SOAP son usualmente utilizadas para la integración de sistema a sistema, y los equipos de operaciones de TI las prefieren debido a su estructuras de datos más precisas. solamente puede enviar mensajes con arquitectura XML.
·
·
REST son la preferencia actual de los desarrolladores móviles. las interfaces REST tienden a ser muy fáciles de implementar, y aunque son configurables, no llevan estructuras de datos complejas fuertemente tipadas como lo es el SOAP. pueden enviarse estructuras de mensaje XML, JSON,
·
·
MQTT son las preferidas para ser utilizadas en Iot, ya que los requisitos para MQTT son mínimos, está diseñado para dispositivos integrados de recursos limitados, además fue diseñado para la eficiencia de la comunicación.
·
1.5 Ventajas y desventajas
Ventajas: Intercomunica o funge como intermediario entre aplicaciones desarrolladas en distintas plataformas, en distintos lenguajes, incluso alojadas en distintos sistemas operativos. Sus protocolos y estándares de comunicación están basados en texto plano por lo cual hace más fácil el entendimiento de su funcionamiento. (como lo es XML). centraliza la información en un solo lugar por lo cual el trabajar en seguridad de la de la misma se vuelve menos complejo al estar toda en un solo lugar.
Desventajas: Debido a que los mensajes pueden interpretarse como texto plano también lo vuelve una desventaja por ejemplo al hacer una transacción bancaria esto no es recomendado. Al ser muy prácticos a distintas plataformas y protocolos sacrifica su rendimiento si lo comparamos con otros modelos de computación distribuida dedicada como lo es RMI o COBRA. ya que utilizar HTTP, el firewall podría no auditar la comunicaciones entre aplicaciones y el web service.
2 FPGA
2.1 ¿Qué es un FPGA?
Una FPGA o matriz de puertas programables (del inglés field-programmable gate array) es un dispositivo programable que contiene bloques de lógica cuya interconexión y funcionalidad puede ser configurada en el momento mediante un lenguaje de descripción especializado. La lógica programable puede reproducir desde funciones tan sencillas como las llevadas a cabo por una puerta lógica o un sistema combinacional hasta complejos sistemas en un chip.
Una jerarquía de interconexiones programables permite a los bloques lógicos de un FPGA ser interconectados según la necesidad del diseñador del sistema, algo parecido a una placa de inserción (es una placa de uso genérico reutilizable o semipermanente) programable. Estos bloques lógicos e interconexiones pueden ser programados después del proceso de manufactura por el usuario/diseñador, así que la FPGA puede desempeñar cualquier función lógica necesaria.
Una tendencia reciente ha sido combinar los bloques lógicos e interconexiones de las FPGA con microprocesadores y periféricos relacionados para formar un sistema programable en un chip. los cuales incluyen uno o más procesadores PowerPC embebidos junto con la lógica de la FPGA. El FPSLIC de Atmel es otro dispositivo similar, el cual usa un procesador AVR en combinación con la arquitectura lógica programable de Atmel. Otra alternativa es hacer uso de núcleos de procesadores implementados haciendo uso de la lógica de la FPGA.
Muchas FPGA modernos soportan la reconfiguración parcial del sistema, permitiendo que una parte del diseño sea reprogramada, mientras las demás partes siguen funcionando. Este es el principio de la idea de la computación reconfigurable, o los sistemas reconfigurables.
2.2 ¿Cuál es su aplicación?
El rango de aplicaciones de las FPGA es muy amplio, debido a la versatilidad y a la flexibilidad de estos dispositivos; siendo la principal aplicación de las FPGAs el procesamiento digital de señales (DSP), comunicaciones, procesado de datos, etc. La elección de una FPGA para aplicaciones de tratamiento de señal se debe a su alta frecuencia de trabajo, a su capacidad de procesamiento en paralelo, y a su bajo precio en comparación con los ASICs. En general, la lógica de un CPLD es insuficiente para realizar dicho procesamiento.
Cualquier circuito de aplicación específica puede ser implementado en una FPGA, siempre y cuando esta disponga de los recursos necesarios. Las aplicaciones donde más comúnmente se utilizan las FPGA incluyen a los DSP (procesamiento digital de señales), radio definido por software, sistemas aeroespaciales y de defensa, prototipos de ASIC, sistemas de imágenes para medicina, sistemas de visión para computadoras, reconocimiento de voz, bioinformática, emulación de hardware de computadora, entre otras. Cabe notar que su uso en otras áreas es cada vez mayor, sobre todo en aquellas aplicaciones que requieren un alto grado de paralelismo.
2.3 Lenguajes de descripción de hardware
En la FPGA no se realiza programación tal cual como se realiza en otros dispositivos como DSP, CPLD o microcontroladores. La FPGA tiene celdas que se configuran con una función específica ya sea como memoria (FLIP-FLOP tipo D), como multiplexor o con una función lógica tipo AND, OR, XOR. La labor del programador es describir el hardware que tendrá la FPGA. Por consiguiente, la tarea del programador es definir la función lógica que realizará cada uno de los CLB, seleccionar el modo de trabajo de cada IOB e interconectarlos.
El diseñador cuenta con la ayuda de entornos de desarrollo especializados en el diseño de sistemas a implementarse en una FPGA. Un diseño puede ser capturado ya sea como esquemático, o haciendo uso de un lenguaje de programación especial. Estos lenguajes de programación especiales son conocidos como HDL o lenguajes de descripción de hardware. Los HDL más utilizados son:
- VHDL
- Verilog
- ABEL
El diseñador cuenta con la ayuda de entornos de desarrollo especializados en el diseño de sistemas a implementarse en una FPGA. Un diseño puede ser capturado ya sea como esquemático, o haciendo uso de un lenguaje de programación especial. Estos lenguajes de programación especiales son conocidos como HDL o lenguajes de descripción de hardware. Los HDL más utilizados son:
- VHDL
- Verilog
- ABEL
En un intento de reducir la complejidad y el tiempo de desarrollo en fases de prototipado rápido, y para validar un diseño en HDL, existen varias propuestas y niveles de abstracción del diseño. Los niveles de abstracción superior son los funcionales y los niveles de abstracción inferior son los de diseño al nivel de componentes hardware básicos. Entre otras, National Instruments LabVIEW FPGA propone un acercamiento de programación gráfica de alto nivel.
3 Desarrollo
3.1 Descripción de proyecto
El proyecto consiste en diseñar y desarrollar una interfaz que nos permita interactuar de con los componentes de un FPGA desde la nube, tanto entradas como salidas deben ser configurables desde una plataforma alojada en un servidor virtual contratado con Amazon Web Service (AWS).
Para la realización del proyecto se implementaron los siguientes elementos:
Hardware
·
FPGA Altera MAX 10 10M50DAF484C6GES
·
·
nodeMCU
·
·
Sensor de temperatura digital 18B20
·
·
Motor ventilador AC 3.3v
·
Software
·
Quartus Prime 15.1 Lite Edition
·
·
Sublime text 3
·
·
Filezilla 3.28
·
·
Apache 2
·
·
Mysql
·
·
Arduino IDE
·
El proyecto se llevó a cabo en equipo DELL inspiron 15, Intel core i3, 8gd RAM, Ubuntu 18.04 LTS
3.2 Sintetizando en FPGA
Para sintetizar nuestro fpga se utilizó Quartus 15.1, el cual debido al poco soporte que tiene altera con equipos linux se opto por la instalación de una maquina virtual con windows 7.
Las instrucciones de descarga e instalación de quartus se puede encontrar en el sitio de altera :
Una vez instalados tanto los drivers del fpga max 10 y el software Quartus, podemos darnos a la tarea de sintetizar nuestro circuito.
Creación de proyecto en Quartus.
Seleccionamos New Project Wizard
Definimos el nombre del proyecto, en este proyecto utilizamos el nombre interfaz_fpga_cloud
Definimos que será un proyecto en blanco
La siguiente ventana nos pregunta si deseamos agregar librerias, solo daremos click en “Next”
Dentro de la siguiente ventana debemos seleccionar el dispositivo que nos disponemos a utilizar, buscaremos el dispositivo 10M50DAF484C6GES y presionamos “Finish”
Con estos pasos ya contamos con un nuevo proyecto en blanco.
Ahora nos dispondremos en definir la estructura de nuestro circuito que sintetizamos en nuestro fpga, para ello crearemos un nuevo documento Verilog HDL
Ahora ya podemos cargar nuestra descripción del circuito:
/*
By Ing. Alfonso Medina Duran
4lfonsomedina@gmail.com
*/
module interfaz_fpga_cloud(
output wire led1,
output wire led2,
output wire led3,
output reg O1,
output reg O2,
output reg O3,
output reg O4,
input wire I1,
input wire I2,
input wire I3,
input wire B1,
input wire B2,
input wire B3,
input wire B4);
//asignacion de entradas a leds
assign led1=I1;
assign led2=I2;
assign led3=I3;
//asignacion de botones a salidas
always @ (B1)
begin
O1=B1;
end
always @ (B2)
begin
O2=B2;
end
always @ (B3)
begin
O3=B3;
end
always @ (B4)
begin
O4=B4;
end
endmodule
Una vez capturada la descripción del circuito debemos comprobar que no contenga errores.
Si no encontramos ningún error dentro de nuestro código, el siguiente paso es asignar nuestras entradas y salidas a los puertos de nuestro fpga
En la siguiente pantalla debemos definir qué pines asignaremos a nuestras variables, para encontrar los nombres de cada pin nos apoyamos en la guia del dispositivo fpga:
Utilizamos el pmod A para las salidas de los botones y el pmod B para las entradas para encender los leds de la tarjeta MAX 10
Una vez asignados nuestras variables del código a las salidas físicas del dispositivo FPGA podemos darnos a la tarea de compilar nuestro circuito.
Esperamos algunos minutos para
3.3 Interfaz nodeMCU
El NodeMcu es un kit de desarrollo de código abierto basado en el popular chip ESP8266 (ESP-12E), que utiliza el lenguaje de programación Lua para crear un ambiente de desarrollo propicio para aplicaciones que requieran conectividad Wifi de manera rápida.
El ESP8266 es un chip altamente integrado diseñado para las necesidades de un nuevo mundo conectado. Ofrece una solución completa y autónoma de redes Wi-Fi, lo que le permite alojar la aplicación o servir como puente entre Internet y un microcontrolador.
El ESP8266 tiene potentes capacidades a bordo de procesamiento y almacenamiento que le permiten integrarse con sensores y dispositivos específicos de aplicación a través de sus GPIOs con un desarrollo mínimo y carga mínima durante el tiempo de ejecución. Su alto grado de integración en el chip permite una circuitería externa mínima, y la totalidad de la solución, incluyendo el módulo está diseñado para ocupar el área mínima en un PCB.
El ESP8266 es un chip altamente integrado diseñado para las necesidades de un nuevo mundo conectado. Ofrece una solución completa y autónoma de redes Wi-Fi, lo que le permite alojar la aplicación o servir como puente entre Internet y un microcontrolador.
El ESP8266 tiene potentes capacidades a bordo de procesamiento y almacenamiento que le permiten integrarse con sensores y dispositivos específicos de aplicación a través de sus GPIOs con un desarrollo mínimo y carga mínima durante el tiempo de ejecución. Su alto grado de integración en el chip permite una circuitería externa mínima, y la totalidad de la solución, incluyendo el módulo está diseñado para ocupar el área mínima en un PCB.
Debido a la potencia y las librerías disponibles para el IDE Arduino se optó por programar el nodeMCU mediante la descarga de algunas librerías de compatibilidad, para el proyecto este dispositivo básicamente funge como intermediario entre nuestro FPGA y un web service alojado en la nube, únicamente envía y recibe información.
Código comentado:
/*
Autor: Alfonso Medina Duran
4lfonsomedina@gmail.com
*/
///////////////librerias conexion///////////////////////
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>
#include <ArduinoJson.h>
#define USE_SERIAL Serial
ESP8266WiFiMulti WiFiMulti;
#include <Wire.h>
///////////////librerias sensor///////////////////////
#include <OneWire.h>
#include <DallasTemperature.h>
////////////variables de conexion y url/////////////////
char *ssid = "nombre_de_la_red";
char *pass = "clavede_la_red";
char *url = "http://18.191.48.211/aws_fpga/recibir_fpga.php";
/////////////Iniciando mensaje///////////
String mensaje_STR = "Conectando...";
///////////////Variables de botones y leds///////////////////////
//entradas
int i4 = 16;
int i3 = 5;
int i2 = 4;
int i1 = 0;
//salidas
//int o5 = 9;
int o4 = 2;
int o3 = 14;
int o2 = 12;
int o1 = 13;
//temperatura
#define ONE_WIRE_BUS 10
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
void setup() {
//////Iniciando serial y conexion a intenet/////////////
USE_SERIAL.begin(115200);
for(uint8_t t = 4; t > 0; t--) {
USE_SERIAL.printf("Iniciando en %d...\n", t);
USE_SERIAL.flush();
delay(1000);
}
WiFi.mode(WIFI_STA);
WiFiMulti.addAP(ssid, pass);
////////////////////Configuracion de Puertos///////////////////
//entradas
//pinMode(o5, OUTPUT);
pinMode(o4, OUTPUT);
pinMode(o3, OUTPUT);
pinMode(o2, OUTPUT);
pinMode(o1, OUTPUT);
//salidas
pinMode(i4, INPUT);
pinMode(i3, INPUT);
pinMode(i2, INPUT);
pinMode(i1, INPUT);
// libreria sensor
sensors.begin();
}
void loop() {
///////////// Lectura de temperatura ////////////////
sensors.requestTemperatures();
float temp = sensors.getTempCByIndex(0);
//float temp = 0;
///////////// nuevo url ///////////////////////
int b1 = digitalRead(i1);if(b1==1){b1=0;}else{b1=1;}
int b2 = digitalRead(i2);if(b2==1){b2=0;}else{b2=1;}
int b3 = digitalRead(i3);if(b3==1){b3=0;}else{b3=1;}
int b4 = digitalRead(i4);if(b4==1){b4=0;}else{b4=1;}
char url_v[80];
sprintf(url_v,"%s?b1=%i&b2=%i&b3=%i&b4=%i&t=%f",url,b1,b2,b3,b4,temp);
USE_SERIAL.println(url_v);
/////////////En espera de conexion esxitosa///////////
if((WiFiMulti.run() == WL_CONNECTED)) {
HTTPClient http;
http.begin(url_v);
int httpCode = http.GET();
if(httpCode > 0) {
if(httpCode == HTTP_CODE_OK) {
////////////Respuesta web service///////////
String cadenaJSON = http.getString();
////////////buffer para desencriptacion JSON///////////
DynamicJsonBuffer jsonBuffer;
StaticJsonBuffer<300> JSONBuffer;
JsonObject& parsed = JSONBuffer.parseObject(cadenaJSON);
if(parsed["L1"]=="1"){digitalWrite(o1,0);}
else{digitalWrite(o1,1);}
if(parsed["L2"]=="1"){digitalWrite(o2,0);}
else{digitalWrite(o2,1);}
if(parsed["L3"]=="1"){digitalWrite(o3,0);}
else{digitalWrite(o3,1);}
if(parsed["ENF"]=="1"){digitalWrite(o4,1);}
else{digitalWrite(o4,0);}
mensaje_STR = cadenaJSON;
}
} else {
USE_SERIAL.printf("Error: %s\n", http.errorToString(httpCode).c_str());
mensaje_STR = "Error.";
}
http.end();
//////////// Mostrar Mensaje ///////////
mostrar_mensaje();
}
delay(2000);
}
void mostrar_mensaje(){
USE_SERIAL.println(mensaje_STR);
}
3.4 Configurando cloud
Amazon Elastic Compute Cloud (Amazon EC2) proporciona capacidad de computación escalable en la nube de Amazon Web Services (AWS). El uso de Amazon EC2 elimina la necesidad de invertir inicialmente en hardware, de manera que puede desarrollar e implementar aplicaciones en menos tiempo. Puedes usar Amazon EC2 para lanzar tantos servidores virtuales como necesite, configurar la seguridad y las redes, y administrar el almacenamiento. Amazon EC2 te permite escalar hacia arriba o hacia abajo para controlar cambios en los requisitos o picos de popularidad, con lo que se reduce la necesidad de prever el tráfico.
Desde la página de amazon web service, puedes explorar la variedad de productos disponibles, para este caso práctico fue seleccionado un servidor virtual en la nube EC2.
Como primer paso debemos registrarnos en AWS para poder contar con un Dashboard donde contrataremos y administramos nuestros servidores contratados.
Solo debemos llenar algunos datos para finalmente crear una cuenta.
Una vez dentro seleccionamos launch instance.
Se mostrará una lista con los distintos servidores que pueden ser contratados, para este caso práctico se seleccionó un servidor Ubuntu Server 16.04 de 64 bits, 1 CPU, 1 GB de ram y 8GB de disco SSD , y una conexión moderada. la velocidad del internet y el CPU son virtuales y escalables por lo cual amazon no provee la velocidad de estos. Esta configuración de servidor nos permite crear un proyecto de pruebas donde no habrá un gran tráfico ni procesamiento de datos, además es uno de los servicios gratuitos que ofrece AWS, sin embargo un servidor virtual con estas características no es recomendada cuando se va a someter a producción con múltiples usuarios.
Una vez seleccionado y configurado el servidor debemos configurar el grupo de seguridad, donde nosotros debemos especificar los puertos que permanecerán abiertos. para este caso práctico solo utilizaremos los puertos 80(HTTP) y 22(SSH).
Después amazon nos pedirá que generemos una llave pem con la que podremos conectarnos vía SSH.
Con estos pasos ya tenemos un servidor configurado y listo para ser utilizado.
3.5 Desarrollo de web service
Procederemos con desarrollar un servicio web que pueda ser consumido por nuestro dispositivo, para esto debemos acceder via ssh al servidor y comenzar a gestionar los recursos del mismo, Este caso práctico se llevó a cabo desde un equipo linux por lo cual la conexión ssh se realizó mediante consola, para conectarnos debemos utilizar el comando ssh, la llave pem generada anteriormente y la dirección DNS del servidor.
$ ssh -i "4lfonsomedina.pem" ubuntu@ec2-18-191-48-211.us-east-2.compute.amazonaws.com
Una vez conectados vía ssh realizaremos un update y un upgrade a ubuntu server.
$ sudo apt -get update
$ sudo apt -get upgrade
Después procederemos con la instalación de Apache y posteriormente desarrollaremos el servicio web.
$ sudo apt -get install apache2
$ sudo apt-get install php libapache2-mod-php php-mcrypt
Con estos pasos ya tenemos corriendo un servidor HTTP en la DNS
http://18.191.48.211
Después instalamos nuestra base de datos mysql
$ sudo apt-get install mysql-server
y proseguimos con su configuración
$ mysql_secure_installation
instalamos también phpmyadmin para gestionar la base de datos de una manera mas ordenada, para lo cual se descargo la ultima version de este desde su sitio:
y se trasfirio por medio de FTP a la carpeta /var/www/htdoc
Estructura de nuestra tabla donde se almacenan los estados recibidos desde el FPGA
CREATE TABLE `estatus` (
`id` int(11) NOT NULL,
`B1` int(11) NOT NULL DEFAULT '0',
`B2` int(11) NOT NULL DEFAULT '0',
`B3` int(11) NOT NULL DEFAULT '0',
`B4` int(11) NOT NULL DEFAULT '0',
`L1` int(11) NOT NULL DEFAULT '0',
`L2` int(11) NOT NULL DEFAULT '0',
`L3` int(11) NOT NULL DEFAULT '0',
`L4` int(11) NOT NULL DEFAULT '0',
`temp` varchar(10) NOT NULL,
`max_temp` varchar(10) NOT NULL,
`ENF` int(11) NOT NULL DEFAULT '0'
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
ALTER TABLE `estatus`
ADD PRIMARY KEY (`id`);
ALTER TABLE `estatus`
MODIFY `id` int(11) NOT NULL AUTO_INCREMENT;
COMMIT;
Ahora proseguimos con el desarrollo del servicio web para lo cual tenemos que dirigirnos con el comando cp a la carpeta de /var/www/html/aws_fpga donde nos dispondremos a crear un archivo con el nombre index.php con el comando nano.
$ nano index.php
Conteniendo las siguientes lineas de codigo.
<!DOCTYPE html>
<html>
<head>
<title>fpga intefaz</title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<style type="text/css">
input[type=checkbox]{
height: 0;
width: 0;
visibility: hidden;
}
label {
cursor: pointer;
text-indent: -9999px;
width: 100px;
height: 50px;
background: grey;
display: block;
border-radius: 50px;
position: relative;
}
label:after {
content: '';
position: absolute;
top: 2px;
left: 2px;
width: 45px;
height: 45px;
background: #fff;
border-radius: 45px;
transition: 0.3s;
}
input:checked + label {
background: #bada55;
}
input:checked + label:after {
left: calc(100% - 5px);
transform: translateX(-100%);
}
label:active:after {
width: 130px;
}
th, td{
text-align: center;
}
body{
width: 100%;
background-color: #808080;
}
.container{
margin-top: 20px;
background-color: white;
border-radius: 20px;
}
h1{
text-align: center;
}
p{
text-align: center;
}
.b_on{
padding: 5px;
border-radius: 10px;
background-color: green;
color:white;
}
.b_off{
padding: 5px;
border-radius: 10px;
background-color: red;
color:white;
}
#max_temp{
}
.pu{
padding-top: 15px;
}
</style>
<script type="text/javascript">
$(document).ready(function(){
leer_datos();
$(".check").click(function(){
var leds = $("#form_leds").serialize();
$.post("recibir.php?"+leds,function(r){
leer_datos();
})
})
$("#g_max_temp").click(function(){
var max_temp = $("#max_temp").val();
$.post("max_temp.php",{max_temp:max_temp},function(r){
leer_datos();
})
})
setInterval(function(){ leer_datos(); }, 1000);
function leer_datos(){
$.post("leer.php",function(r){
var status = jQuery.parseJSON(r);
if(status.B1=='1'){$("#b1").html("<h2 class='b_on'>ON</h2>");}
else{$("#b1").html("<h2 class='b_off'>OFF</h2>");}
if(status.B2=='1'){$("#b2").html("<h2 class='b_on'>ON</h2>");}
else{$("#b2").html("<h2 class='b_off'>OFF</h2>");}
if(status.B3=='1'){$("#b3").html("<h2 class='b_on'>ON</h2>");}
else{$("#b3").html("<h2 class='b_off'>OFF</h2>");}
if(status.B4=='1'){$("#b4").html("<h2 class='b_on'>ON</h2>");}
else{$("#b4").html("<h2 class='b_off'>OFF</h2>");}
if(status.L1=='1'){$('#check_1')[0].checked = true;}
else{$('#check_1')[0].checked = false;}
if(status.L2=='1'){$('#check_2')[0].checked = true;}
else{$('#check_2')[0].checked = false;}
if(status.L3=='1'){$('#check_3')[0].checked = true;}
else{$('#check_3')[0].checked = false;}
if(status.ENF=='1'){$("#ENF").html("<h2 class='b_on'>ON</h2>");}
else{$("#ENF").html("<h2 class='b_off'>OFF</h2>");}
$("#temp").html(status.temp);
$("#temp_max").html(status.max_temp);
})
}
})
</script>
</head>
<body>
<div class="container">
<div class="col-xs-12">
<table class="table">
<thead>
<tr>
<th colspan="4"><h1>BOTONES</h1></th>
</tr>
<tr>
<th>BTN1</th>
<th>BTN2</th>
<th>BTN3</th>
<th>BTN4</th>
</tr>
</thead>
<tbody>
<tr>
<td id="b1"><h2 class="b_off">OFF</h2></td>
<td id="b2"><h2 class="b_off">OFF</h2></td>
<td id="b3"><h2 class="b_off">OFF</h2></td>
<td id="b4"><h2 class="b_off">OFF</h2></td>
</tr>
</tbody>
</table>
</div>
<br><br><br>
<div class="col-xs-12">
<form id="form_leds">
<table class="table">
<thead>
<tr>
<th colspan="3"><h1>LEDS</h1></th>
</tr>
<tr>
<th>LED1</th>
<th>LED2</th>
<th>LED3</th>
<!--
<th>LED4</th>
-->
</tr>
</thead>
<tbody>
<tr>
<td id="l1">
<input type="checkbox" class="check" id="check_1" name="l1" value="1"/>
<label for="check_1">Toggle</label>
</td>
<td id="l2">
<input type="checkbox" class="check" id="check_2" name="l2" value="1"/>
<label for="check_2">Toggle</label>
</td>
<td id="l3">
<input type="checkbox" class="check" id="check_3" name="l3" value="1"/>
<label for="check_3">Toggle</label>
</td>
<!--
<td id="l4">
<input type="checkbox" class="check" id="check_4" name="l4" value="1"/>
<label for="check_4">Toggle</label>
</td>
-->
</tr>
</tbody>
</table>
</form>
</div>
<div class="col-xs-12">
<table class="table">
<thead>
<tr>
<th colspan="3"><h1>TEMPERATURA</h1></th>
</tr>
<tr>
<th>TEMP</th>
<th>MAX_TEMP</th>
<th>ENFRIADOR</th>
</tr>
</thead>
<tbody>
<tr>
<td><h2 id="temp">0.00</h2></td>
<td>
<div class="col-xs-5"><h3 id="temp_max">0.00</h3></div></div>
<div class="col-xs-5 pu"><input type="number" class="form-control" id="max_temp"></div>
<div class="col-xs-2 pu"><a class="btn btn-success btn-sm" id="g_max_temp">
<span class="glyphicon glyphicon-floppy-open" aria-hidden="true"></span>
</a></div>
</td>
<td id="ENF"><h2 class="b_off">OFF</h2></td>
</tr>
</tbody>
</table>
</div>
</div>
<div class="col-xs-12" style="padding-top: 20px; font-weight: bold;">
<p>By Ing. Alfonso Medina Duran <br> 4lfonsomedina@gmail.com</p>
</div>
</body>
</html>
Cabe mencionar que se tuvieron que crear nodos para la recepción y consulta de datos de nuestro web service.
leer.php
<?php
$mysqli = new mysqli("localhost", "usuario_db", "clave_db", "aws_fpga");
if ($mysqli->connect_errno) {
echo "Fallo al conectar a MySQL: (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
}
$resultado = $mysqli->query("SELECT * FROM estatus");
$resultado = $resultado->fetch_assoc();
echo json_encode($resultado);
?>
max_temp.php
<?php
$mysqli = new mysqli("localhost", "usuario_db", "clave_db", "aws_fpga");
if ($mysqli->connect_errno) {
echo "Fallo al conectar a MySQL: (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
}
$temp = $_POST['max_temp'];$temp=round($temp,2);
$mysqli->query("UPDATE estatus SET max_temp='$temp'");
$resultado = $mysqli->query("SELECT * FROM estatus");
$resultado = $resultado->fetch_assoc();
echo json_encode($resultado);
?>
recibir.php
<?php
$mysqli = new mysqli("localhost", "usuario_db", "clave_db", "aws_fpga");
if ($mysqli->connect_errno) {
echo "Fallo al conectar a MySQL: (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
}
//leds
$l1=0; if(isset($_GET['l1'])){ $l1=1; }
$l2=0; if(isset($_GET['l2'])){ $l2=1; }
$l3=0; if(isset($_GET['l3'])){ $l3=1; }
$l4=0; if(isset($_GET['l4'])){ $l4=1; }
$mysqli->query("UPDATE estatus SET L1='$l1',L2='$l2',L3='$l3',L4='$l4'");
$resultado = $mysqli->query("SELECT * FROM estatus");
$resultado = $resultado->fetch_assoc();
echo json_encode($resultado);
?>
recibir_fpga.php
<?php
$mysqli = new mysqli("localhost", "usuario_db", "clave_db", "aws_fpga");
if ($mysqli->connect_errno) {
echo "Fallo al conectar a MySQL: (" . $mysqli->connect_errno . ") " . $mysqli->connect_error;
}
//botones
$b1=$_GET['b1'];
$b2=$_GET['b2'];
$b3=$_GET['b3'];
$b4=$_GET['b4'];
$t=$_GET['t'];$t=round($t,2);
$max_t = $mysqli->query("SELECT max_temp,ENF FROM estatus");
$max_t = $max_t->fetch_assoc();
$enf=$max_t['ENF'];
if($enf==0&&$t>=$max_t['max_temp']){
$enf=1;
}
if($enf==1&&$t<=($max_t['max_temp']-1)){
$enf=0;
}
$mysqli->query("UPDATE estatus SET B1='$b1',B2='$b2',B3='$b3',B4='$b4',temp='$t',ENF='$enf'");
$resultado = $mysqli->query("SELECT L1,L2,L3,L4,ENF FROM estatus");
$resultado = $resultado->fetch_assoc();
echo json_encode($resultado);
?>
una vez creado el index y los nodos de nuestro web service, podemos acceder a nuestra plataforma desde el enlace :
4 Resultados
Dentro del sitio http://18.191.48.211/aws_fpga/ tenemos nuestra plataforma funcionando, donde en la primera sección podemos ver en tiempo real que botones de nuestro fpga se encuentran presionados.
Desde la segunda sección podemos encender y apagar los leds de nuestra trajeta y podemos observar el estatus que estos tienen.
Como complemento en la tercera sección se agregó un sensor de temperatura 18B20 conectada a el nodeMCU y dentro del web service se programó una condición de que si se llega a un límite de temperatura envía una señal de encendido para nuestro ventilador y este se apaga al conseguir bajar en un grado la temperatura.
No hay comentarios.:
Publicar un comentario