UNIVERSIDAD CATOLICA DE PEREIRA
INFORME FINAL
FRAMEWORK PARA LA ELABORACION DE LABORATORIOS DE
CIENCIAS BASICAS REMOTOS
PHISYLAB
ALUMNO
JUAN CARLOS MEJIA OROZCO
PROGRAMA
PROFESIONALIZACION INGENIERIA DE SISTEMAS Y
TELECOMUNICACIONES
AÑO 2012, SEGUNDO SEMESTRE
2
INFORME FINAL
FRAMEWORK PARA LA ELABORACION DE LABORATORIOS DE
CIENCIAS BASICAS REMOTOS
ALUMNO
JUAN CARLOS MEJIA OROZCO
PRESENTADO A:
COMITÉ EVALUADOR DE PROYECTOS DE GRADO
UNIVERSIDAD CATOLICA DE PEREIRA
AÑO 2012, SEGUNDO SEMESTRE
3
AGRADECIMIENTOS
Ante todo gracias a DIOS, a mi familia, a la institución a la cual pertenezco y la
cual ha permitido que pueda seguir formándome, a mis profesores, muchos de
ellos quienes ahora considero mis amigos, con quienes he compartido tanto
tiempo como con mi familia, a mi familia gracias por el sacrificio que han
hecho, son ellos quienes han soportado mi ausencia, son ellos quienes
finalmente se han sacrificado y a la vez me ha alentado para no desfallecer, no
puedo dejar pasar tampoco agradecer a las directivas de la universidad,
quienes han tratado siempre y de buena manera de facilitarme esta ardua
tarea, de nuevo gracias a Dios, es el quien nos da el aliento, nos da la vida, nos
da el ánimo para poder sobrellevar todas las situaciones que una labor como
esta exige.
4
TABLA DE CONTENIDO
1. OBJETIVOS .......................................................................................................... 9
2. INTRODUCCION ................................................................................................. 10
3. DESCRIPCION FUNCIONAL .............................................................................. 11
4. DESCRIPCION DE PHYSILAB ............................................................................ 12
4.1 Creación de un laboratorio ............................................................................ 12
4.2 Creación de un experimento ......................................................................... 14
4.3 Creación de un dispositivo ............................................................................ 14
4.4 Creación de una funcionalidad ..................................................................... 16
4.5 Creación de un comando .............................................................................. 18
4.6 Uso del laboratorio ........................................................................................ 20
4.6.1 Módulo Simulaciones: ............................................................................ 21
4.6.2 Modulo Reservas: .................................................................................. 21
4.6.3 Módulo Laboratorio: ............................................................................... 22
4.6.4 Módulo Cursos: ..................................................................................... 22
4.6.5 Módulo Ayuda: ....................................................................................... 22
4.6.6 Modulo de reservas ............................................................................... 22
4.6.7 Modulo de laboratorios remotos ............................................................ 25
5. DESCRIPCION DE LA ARQUITECTURA DE PHYSILAB .................................... 27
6. DESCRIPCION DE LOS COMPONENTES DE SOFTWARE UTILIZADOS ......... 27
6.1 NODE.JS ...................................................................................................... 27
6.1.1 Manual de instalación Node.js (Windows) ............................................. 28
6.1.2 Node ejecuta JavaScript pero no es JavaScript ..................................... 31
6.2 NPM ............................................................................................................. 32
6.3 Express ........................................................................................................ 33
6.3.1 Instalación de Express ........................................................................... 34
6.4 Jade ............................................................................................................. 36
6.4.1 Instalación de Jade ................................................................................ 38
6.5 Stylus............................................................................................................ 39
6.5.1 Instalación de stylus .............................................................................. 39
6.6 Instalación de PostgreSql ............................................................................. 40
6.6.1 Características ....................................................................................... 41
6.6.2 Manual de instalación de postgres ......................................................... 44
6.7 JSON ............................................................................................................ 48
6.8 Y como funciona NODE en Physilab?........................................................... 51
5
7. CONCLUSIONES ................................................................................................ 52
8. TRABAJO FUTURO ............................................................................................ 53
9. BIBLIOGRAFIA .................................................................................................... 54
6
INDICE DE FIGURAS
Figura 1. Creación de un laboratorio ..................................................................................... 11
Figura 2. Creación de un laboratorio ..................................................................................... 13
Figura 3. Creación de un experimento .................................................................................. 14
Figura 4. Creación de un dispositivo ..................................................................................... 14
Figura 5. Creación de una funcionalidad .............................................................................. 16
Figura 6. Esquema global de comunicación ........................................................................ 17
Figura 7. Creación de un comando ....................................................................................... 18
Figura 8. Esquema de la base de datos ............................................................................... 19
Figura 9. Comunicación básica de un laboratorio ............................................................... 20
Figura 10. Pagina principal de physilab ................................................................................ 21
Figura 11. Módulos del proyecto ............................................................................................ 21
Figura 12. Módulos del proyecto 2 ........................................................................................ 21
Figura 13. Inicio de sesión ...................................................................................................... 22
Figura 14. Nuevo usuario ........................................................................................................ 23
Figura 15. Reservas ................................................................................................................. 23
Figura 16. Calendario de reservas de laboratorio ............................................................... 24
Figura 17. Reserva de laboratorio ......................................................................................... 24
Figura 18. Interfaces de un laboratorio ................................................................................. 25
Figura 19. Resultados .............................................................................................................. 27
Figura 20. Instalación node ..................................................................................................... 28
Figura 21. Node.js setup ......................................................................................................... 29
Figura 22. descarga del setup de node ................................................................................ 29
Figura 23. Instalación setup 1 ................................................................................................ 30
Figura 24. Instalación node setup 2 ...................................................................................... 30
Figura 25. PostgresSql ............................................................................................................ 40
Figura 26. Instalación de PostgreSQL 1 ............................................................................... 44
Figura 27. Instalación de PostgreSQL 2 ............................................................................... 45
Figura 28. Instalación de PostgreSQL 3 ............................................................................... 45
Figura 29. Instalación de PostgreSQL 4 ............................................................................... 46
Figura 30. Instalación de PostgreSQL 5 ............................................................................... 47
Figura 31. JSON ....................................................................................................................... 48
Figura 32. JSON 2 .................................................................................................................... 49
Figura 33. JSON 3 .................................................................................................................... 49
Figura 34. JSON 4 .................................................................................................................... 50
Figura 35. JSON 5 .................................................................................................................... 50
7
INDICE DE TABLAS
Tabla 1. Limites de PostgreSQL ............................................................................................ 43
8
SINTESIS
SINTESIS Este trabajo de grado, ha puesto en evidencia que el trabajo en equipo si funciona, solo es poder encontrar la gente correcta y sacar lo mejor de ellas, pero como mínimo debe haber buena relación entre este grupo, así se superan más fácil los problemas, inicialmente vimos este proyecto como algo complicado, pero teníamos la confianza que con el conocimiento adquirido y la experiencia, cualquier obstáculo se podría superar, teniendo calma y trabajando en equipo. Y así se hicieron casi 4 prototipos de este proyecto y sorprendentemente todos funcionaron, hasta que quedo la plataforma de NODE, de manera definitiva, y primero prendimos led’s, hoy podemos mover un laboratorio.
ABSTRACT
This degree work has shown that teamwork does work, It is just a matter of finding the right people and make the best of them, but at least there should be a good relationship in the team. That's that way to overcome problems easier. Inicially we saw this proyect as something complicated, but we had confidence that the knowledge and experience acquired, could help us overcome any obstacle. We made nearly 4 prototypes of this project and suprisingly they all worked, we decided that NODE would be the definitive platform. First we turned on some leds and now we can control a laboratory.
Palabras claves: NODE, JSON, JQUERY, PHISYLAB, FRAMEWORK,POSTGRES,NPM, EXPRESS, JADE, STYLUS, RENATA, SERVIDOR WEB, WEB BROWSER, TARJETA DE ADQUISICION, WORDPRESS, MODDLE, JAVASCRIPT, MOTOR V8.
Keywords:
NODE, JSON, JQUERY, PHISYLAB, FRAMEWORK,POSTGRES,NPM, EXPRESS, JADE, STYLUS, RENATA, WEB SERVER, WEB BROWSER, DATA ACQUISITION, WORDPRESS, MODDLE, JAVASCRIPT, V8 MOTOR
9
1. OBJETIVOS
Explicar de una manera detallada y sencilla de que se trata el proyecto
Physilab, como se construyó, como funciona, cuál es su futuro y lo más
importante para que sirve y porque fue hecho.
10
2. INTRODUCCION
Los laboratorios remotos surgen como una necesidad manifiesta de los
estudiantes, docentes e instituciones educativas por proveer una mejor calidad
en la educación, realizar un mejor aprovechamiento de los recursos para el
aprendizaje, para lograr el objetivo de tener una educación con un mejor nivel
de calidad, teniendo como base los avances en las tecnologías de la
información; como el auge de las comunicaciones.
En el caso especifico de RENATA, y considerando aspectos tecnológicos tales
como, el incremento de los anchos de banda que mejoran considerablemente
las velocidades para la navegación en la Internet, aspectos económicos como
el bajo precio de los computadores que facilitan su adquisición, y aspectos del
orden político; como el desinterés del estado por el fomento a la investigación y
generación de conocimiento, en el cual cada vez es menor el presupuesto que
el país invierte en estos rubros.
En este orden de ideas, y considerando esta situación, nace la idea de poder
aprovechar los recursos existentes en otras instituciones para el beneficio de
las que no cuenten con los mismos, es decir; haciendo que esos recursos,
como laboratorios o centros de investigación puedan ser accesados y/o
controlados sin la necesidad de tener una presencia física en el mismo, es
decir; controlado de manera remota, así cualquier laboratorio podría compartir
con otros su infraestructura, y a su vez generar una gran red de laboratorios,
por ende; lo que se encuentra consignado en este documento consiste en la
descripción detallada y posterior explicación del proceso de la creación de una
herramienta que contribuirá en el logro de este gran sueño, basados en una
arquitectura solida y robusta.
La solución propuesta y realizada se denomino PHYSILAB, laboratorio remoto
y virtual para la enseñanza de la física, es una herramienta que combina varias
disciplinas como son electrónica, sistemas y telecomunicaciones, pedagogía
para la enseñanza, reuniendo en un solo productos estas 3 ramas de la ciencia
y como fruto de esta unión nace esta herramienta que pretende ser una base
solida y fuerte para ser mejorada y potencializada en un futuro no muy lejano,
para llevar a muchas personas la enseñanza de muchos fenómenos físicos.
11
3. DESCRIPCION FUNCIONAL
Un laboratorio puede tener varios experimentos, cada experimento para ser
accesado remotamente debe automatizar todos sus componentes, los
componentes se clasifican en sensores, actuadores y motores, en la parte de
sensores tenemos como su nombre lo indica aquellos dispositivos que nos
permiten saber cuando algo por una posición o sucedió un evento, los
actuadores son aquellos que hacen operaciones como prender, apagar,
retener, soltar y otros, los motores son aquellos que como su nombre lo indica
generan movimiento de objetos, también hace parte del experimento la tarjeta
de adquisición de datos , la cual hace la primera conexión o la conexión mas
básica y es en este punto donde se enlaza con motores, actuadores y
sensores, es la tarjeta quien se comunica a través de otros componentes con
estos elementos, a su vez entre la tarjeta de adquisición de datos y el node,
hay otro intermediario, el cual es un programa escrito en C#, y es un ejecutable
(extensión .exe) y es invocado por el servidor node y por las paginas web del
experimento cuando se quiere realizar alguna acción y este se comunica con la
tarjeta de adquisición de datos.
A continuación se presenta una breve descripción grafica del funcionamiento
de un experimento:
Figura 1. Creación de un laboratorio
12
Cada componente del experimento, se asocia con una funcionalidad, y a su vez
esta funcionalidad se asocia con unos comandos; los que a su vez se asocian
a comandos que son enviados a la tarjeta de adquisición de datos a través del
archivo ejecutable mencionado anteriormente.
4. DESCRIPCION DE PHYSILAB
Physilab, Laboratorio Remoto y virtual para la enseñanza de la Física, tiene
como uno de sus objetivos convertirse en un sistema distribuido con múltiples
nodos, donde todos y cada uno de ellos compartan con la comunidad
académica sus laboratorios, sus experimentos y de esta forma lograr construir
un gran laboratorio remoto.
Para lograr este objetivo, Physilab se construyó con una arquitectura distribuida
donde cada laboratorio siguiendo unos protocolos establecidos y una estructura
básica se pueda integrar a todo el sistema.
Physilab está construido siguiendo la estructura: laboratorio, experimento,
dispositivo, funcionalidad. La estructura de una práctica de laboratorio básica
consiste en ejecutar una funcionalidad definida, por ejemplo impulsar un objeto,
esta funcionalidad la ejecutaría un dispositivo, siguiendo con nuestro ejemplo,
este sería un solenoide que hace las funciones de un disparador, este
solenoide pertenece a un experimento en particular, (carril de aire) donde el
carril de aire pertenece al laboratorio Physilab ubicado en la Universidad
Católica de Pereira UCP.
Durante la vida útil de un experimento este presenta cambios, mejoras y
averías, lo que hace que en algunos momentos se tenga que deshabilitar o
habilitar una funcionalidad o agregar un nuevo dispositivo, etc.
Physilab permite la creación de experimentos a través de una interfaz web que
se accede a través del menú superior de la barra de menús de los
experimentos existentes, previa identificación del usuario, permite: agregar,
modificar, eliminar cada componente de un experimento.
4.1 Creación de un laboratorio
La creación de un laboratorio consiste es definir todo un espacio físico de
trabajo, en el cual pueden existir diferentes clases experimentos. Para llevar a
cabo el proceso de creación de un experimento solo es necesario ingresar los
13
El estado es utilizado para indicar la disponibilidad del
laboratorio, donde el estado activo es el único que nos indica
cuando se puede hacer uso del laboratorio y de todos los
experimentos que el contenga.
siguientes datos: código de identificación del laboratorio, nombre de la persona
que realizará el experimento, la ubicación con una descripción del laboratorio y
el estado.
En la siguiente imagen se presenta una vista de la interfaz del formulario de
ingreso al laboratorio:
Figura 2. Creación de un laboratorio
.
14
4.2 Creación de un experimento
Figura 3. Creación de un experimento
En Physilab, se denomina
experimento a cualquier
conjunto de dispositivos
intercomunicados y
controlados remotamente
que permitan mediante su
operación la comprobación
de uno o varios fenómenos
de la física y que tenga
mecanismos para obtener
datos para su posterior
análisis.
Para la creación de un experimento solo es necesario suministrar un código, un
nombre, un estado y seleccionar a que laboratorio pertenece el experimento.
4.3 Creación de un dispositivo
Figura 4. Creación de un dispositivo
En Physilab un dispositivo es un
instrumento o aparato, el cual es
controlado remotamente con el
objetivo de suministrar al
experimento de una o varias
funcionalidades.
Por ejemplo la fuente de aire, es
un dispositivo que permite
generar una corriente de aire
continua para que los carros
leviten sobre la corriente de aire,
este dispositivo, tiene las
funcionalidades de prender y
apagar.
15
Para la creación de un dispositivo solo es necesario suministrar el nombre, el
laboratorio al cual pertenece, el experimento donde el dispositivo presta su
funcionalidad.
Los limites inferior y superior son dos valores numéricos que permiten describir
el rango de funcionalidad del dispositivo, por ejemplo, en la creación de los
motores que permiten desplazar los sensores en el experimento carril de aire
del laboratorio de la UCP, estos tienen un rango donde permiten desplazarse,
fuera de estos rangos podrían presentarse colisiones con otros dispositivos.
Posición nos permite calibrar la posición actual del dispositivo en su rango de
operación y dependiendo de su ubicación física.
Agregar una imagen nos permite seleccionar una nueva imagen para identificar
el dispositivo en la interfaz de experimentación.
Tipo es un valor que nos permite indicar en que submenú de la interfaz de
experimentación se mostrara el icono que permite interactuar con el dispositivo.
Y por último características es un campo de texto donde ingresamos
información de descripción del dispositivo y que es visualizada en la interfaz de
experimentación a manera de ayuda.
16
4.4 Creación de una funcionalidad
Figura 5. Creación de una funcionalidad
Las funcionalidades son la
descripción de una tarea que
puede ejecutar un dispositivo en
particular, por ejemplo, el
elevador, dispositivo que permite
cambiar el Angulo de inclinación
del carril de aire del laboratorio
de la Universidad Católica de
Pereira UCP, es un dispositivo
que tiene dos funcionalidades,
subir n grados el carril y bajar n
grados el carril.
Para la creación de una funcionalidad se debe seleccionar el laboratorio,
experimento y dispositivo, suministrar un nombre a la funcionalidad, nombre
relacionado con su función, un estado, que indica si esta funcionalidad estará
disponible para los usuarios que utilicen el laboratorio y seleccionar si esta
funcionalidad recibe parámetros o no, por ejemplo, al utilizar la funcionalidad de
subir el elevador debemos indicarle cuantos grados queremos subir, indicando
si en esta opción, le permitimos al sistema capturar un valor al momento de
utilizar esta funcionalidad en la interfaz de experimentación.
Al finalizar el proceso de creación de las funcionalidades sigue el proceso de
definición de cada funcionalidad, este es un proceso donde indicamos
exactamente paso a paso como la funcionalidad hace lo que debe hacer.
Por ejemplo, con el experimento carril de aire del laboratorio de la Universidad
Católica de Pereira queremos utilizar la funcionalidad de subir el elevador en 5
grados, para que nuestro experimento reaccione como esperamos que lo haga,
debemos comunicarnos a través de la tarjeta de adquisición por un canal y una
línea específica y enviarle un comando, indicando que se debe activar un
tiempo determinado y un sentido especifico, si esto se hace en la secuencia
correcta y la duración establecida el efecto que veremos en el experimento
será la elevación de los 5 grados en el carril.
17
La tarjeta de adquisición es un aparato que nos permite la comunicación en
ambas vías, entrada/salida con los dispositivos de los experimentos que son
controlados remotamente, todo esto en conjunto con una serie de micro-
controladores y demás elementos que hacen parte del sistema de control.
Para la comunicación entre un usuario remoto conectado a través de Renata
con el dispositivo lo hacemos a través de varios sistemas y por diferentes
canales.
Inicialmente el usuario activa una función que tiene disponible en la interfaz web
de experimentación, que es comunicada a través de Renata, al servidor Node
que a su vez interpreta la función activando una aplicación local, que es en
ultimas la que le envía uno o varios comandos al sistema de control que indican
que se debe hacer y quien lo debe hacer
Figura 6. Esquema global de comunicación
18
4.5 Creación de un comando
Figura 7. Creación de un comando
Un nombre, identificar a cual
funcionalidad corresponde
seleccionando el laboratorio, el
experimento, el dispositivo y la
funcionalidad, seleccionar el tipo
de comando, si es un motor, un
actuador, o un sensor,
seleccionar el programa local
que se comunica con la tarjeta
de adquisición, indicar el
dispositivo, puerto y línea, esto
depende de la conexión física
donde el dispositivo se une con
la tarjeta de adquisición e indicar
el comando.
Por ultimo se indica el estado y el
efecto.
19
El Comando es el código con el cual
el servidor Node invocara la
funcionalidad y el programa local lo
interpretara y lo ejecutar
El efecto indica si el comando
desplaza un elemento generando
un aumento o una disminución en
el estado del dispositivo y es usado
para asegurar que el dispositivo
permanezca en los límites
establecidos
Figura 8. Esquema de la base de datos
En la creación de un comando se pueden incluir varios subcomandos, por
ejemplo, para ejecutar la tarea de subir el carril de aire en 5 grados, se le debe
indicar al sistema de control, cual motor activar, por cuanto tiempo lo debe
hacer y en qué sentido debe girar, esto implica la creación de tres comando
para una funcionalidad, la de subir el elevador en 5 grados.
20
Figura 9. Comunicación básica de un laboratorio
En el siguiente diagrama
podemos ver la
interacción entre los
módulos que permiten la
comunicación entre el
usuario ubicado
remotamente y un
dispositivo físico ubicado
en uno de los dos
laboratorios que tenemos
en esta primera fase del
proyecto, y permite su
control remoto.
4.6 Uso del laboratorio
Physilab al ser un laboratorio remoto, suministra un mecanismo que permite a
los usuarios conectados a Renata acceder a él, previo un registro y una
reserva.
El objetivo de los laboratorios remotos es que sirvan como un instrumento
donde los docentes del área de la física de las universidades conectadas a
Renata y que no cuenten con un laboratorio en sus instalaciones lo pueden
usar, de manera independiente o como parte de un programa virtual que
ayudara a complementar sus clases presenciales.
La dirección web Physilab es: physilab.ucp.edu.co, al acceder a esta web
ingresamos al proyecto Physilab.
21
Figura 10. Pagina principal de physilab
Aquí podemos ingresar a cada uno de los módulos del proyecto: simulaciones,
reservas, laboratorios, cursos, ayuda
Figura 11. Módulos del proyecto
Figura 12. Módulos del proyecto 2
4.6.1 Módulo Simulaciones: Este módulo contiene laboratorios simulados
que les permiten a los usuarios practicar los
conocimientos adquiridos. Lo que se busca con
el laboratorio virtual es facilitar un entorno virtual
en donde el usuario pueda practicar cuantas
veces necesite sin tener problemas de
concurrencia de usuarios y facilitar un entorno
que no presente problemas de seguridad o de
configuración.
4.6.2 Modulo Reservas: modulo que permite la gestión de los
laboratorios remotos, gestiona los tiempos y los
usuarios que accederán a los laboratorios
remotos, permitiendo que los usuarios de
Physilab se programen según sus necesidades y su disponibilidad de tiempo.
22
4.6.3 Módulo Laboratorio: este módulo es el que le permite a los usuarios el acceso a la interacción
remota con el laboratorio físico, es uno de los componentes más importante ya
que este cumple el objetivo principal del proyecto que es la interacción con el
laboratorio desde un lugar distante, para la implementación de este módulo
será necesario un sistema de reservaciones el cual gestiona el acceso a los
usuarios para la utilización de los experimentos físicos, puesto que, cada
experimento físico solo puede ser utilizado por un estudiante simultáneamente.
4.6.4 Módulo Cursos: Este módulo permite la creación de cursos, los cuales tomarán los alumnos de
las diferentes universidades. La idea de este módulo es la de darle las
herramientas a los profesores para que diseñen sus propios cursos, tomando
información gestionada por el módulo de contenidos o generando nueva
información, de esta forma podrán decidir cuándo y cómo dictarán sus materias
y cuando integrarán a los laboratorios virtuales y remotos según su
metodología de enseñanza.
Este módulo estará basado en un LMS llamado Moodle, el cual es un sistema
gratuito y de código abierto que nos facilita la inclusión de los cursos virtuales.
4.6.5 Módulo Ayuda: Este módulo contiene información de ayuda y soporte para los distintos
usuarios de la plataforma, así como brindar mecanismos de comunicación
donde los usuarios podrán estar en contactos con los administradores del sitio.
Para esto se utilizará un CMS llamado Wordpress.
Para la implementación de cada uno de estos módulos se hizo uso de
herramientas de libre distribución, el cual nos permiten tanto implementarlas
como modificarlas para adaptarlas a nuestras necesidades.
4.6.6 Modulo de reservas Figura 13. Inicio de sesión
El sistema Physilab permite el acceso a
todos y cada uno de los módulos a los
usuarios del proyecto, previo una
inscripción a la plataforma.
Para acceder al sistema de reservas, se
hace por el menú principal, enlace
reservas, este es el único mecanismo con
23
que los usuarios pueden acceder y operar los laboratorios remotos, las
reservas se pueden realizar en cualquier horario y en cualquier fecha, con una
duración máxima de 1 hora por sesión.
Al ingresar al módulo de reservas, debemos identificarnos frente al sistema, o
registrarnos si aún no somos usuarios.
El proceso de registro solicita datos básicos del usuario, con el fin de
identificarlo frente al sistema o recuperar sus datos en caso de olvido o extravío
de sus credenciales. La información solicitada en el proceso es: un nombre de
usuario, una contraseña, una dirección de correo, su nombre y apellido.
Figura 14. Nuevo usuario
Una vez que ya hemos ingresado al sistema de reservas, podemos visualizar
nuestra cuenta, mis reservas pasadas y futuras, las disponibilidades de los
laboratorios y mi información personal, también podemos generar una nueva
reserva.
Figura 15. Reservas
24
Para crear una nueva reserva, basta con dar clic en el panel izquierdo enlace
reservas, allí desplegara un calendario donde se muestran todos los
laboratorios disponible con sus respectivos horario, también se puede ver la
disponibilidad de cada experimento y cuales usuario tienen reservas.
Figura 16. Calendario de reservas de laboratorio
Figura 17. Reserva de laboratorio
Para establecer la nueva reserva,
seleccionamos la hora en que
deseamos utilizar el laboratorio y en la
ventana que se despliega,
ingresamos los datos de: hora inicio,
hora fin, una descripción, la
periodicidad de la reserva, y si
queremos un recordatorio.
25
4.6.7 Modulo de laboratorios remotos
Para acceder al módulo de laboratorios remotos, se hace a través del enlace
situado en el menú principal, pero para acceder a un laboratorio especifico solo
es posible previa reservación.
Figura 18. Interfaces de un laboratorio
Una vez ingresado al laboratorio podemos empezar a experimentar, la ventana
de experimentación está conformada por cinco secciones:
Un menú superior de comandos que nos permiten ejecutar la experiencia.
Una barra lateral de dispositivos, los cuales tiene funciones definidas.
Un área de trabajo, donde configuramos nuestro experimento.
Un área de visualización, donde podemos acceder a las cámaras que tengamos disponibles en nuestro experimento.
Un área de ayuda, donde vemos la información del dispositivo que tengamos seleccionado.
Utilizar Physilab es similar a utilizar un laboratorio real, debemos preparar
nuestra práctica, alistar los instrumentos, ajustar posiciones, ejecutar el
experimento, capturar datos y analizarlos.
26
Para ejecutar una función, basta
con arrastrar al área de trabajo el
dispositivo, seleccionar la
funcionalidad y parametrizar según
el caso, y finalizar con los botones
compilar y ejecutar.
El botón compilar, sirve para validar
que las instrucciones seleccionadas
se puedan ejecutar y no violen
ningún mecanismo de seguridad
En Physilab es igual, se debe seleccionar en la barra lateral de dispositivos
cuales van a ser utilizados, el orden de ejecución y los parámetros para ser
configurados.
Por ejemplo: queremos utilizar el experimento carril de aire, ubicado en el
laboratorio de la Universidad Católica de Pereira, luego de haber reservado e
ingresado según la agenda, nos disponemos a realizar nuestra práctica.
En nuestra práctica queremos comprobar la velocidad inicial de un objeto que
es impulsado, para esto los pasos que debemos hacer es:
Verificamos la inclinación del carril, si no es cero, la moveremos arriba o abajo según corresponda.
Ubicamos los sensores en las posiciones que queramos, siempre y cuando nos permitan realizar los cálculos necesarios.
Ubicamos las cámaras de tal forma que tengamos una buena visión del experimento
Prendemos la fuente de aire
Esperamos unos segundos para asegurarnos que la presión es estable.
Soltamos el carro, ejecutando el solenoide que hace las veces de disparador.
Por ultimo esperamos unos segundos para asegurarnos que los sensores tomaron los datos
Y por último apagamos la fuente
Al finalizar todos los pasos recopilamos los datos y hacemos los cálculos, y
necesarios para identificar el valor de la velocidad inicial,
Figura 15: resultados
27
Figura 19. Resultados
5. DESCRIPCION DE LA ARQUITECTURA DE PHYSILAB
Physilab se compone un servidor central el cual contiene una base de datos con la información de cada laboratorio y el manejo de los usuarios, cada laboratorio debe estar creado en esta base de datos, a su vez el laboratorio trae una dirección ip fija de la institución en donde se encuentra físicamente dicho laboratorio, una institución puede tener varios laboratorios, referenciados con una misma dirección ip. En el laboratorio debe existir y referenciando dicha ip un servidor web ejecutándose en un determinado puerto, puede haber varios servidores web ejecutándose en diferentes puertos, y los cuales tiene las interfaces tanto para el usuario como para la tarjeta de adquisición de datos de cada experimento, y a su vez hay una base de datos en cada laboratorio con la información de cada componente y que función o funciones realiza.
6. DESCRIPCION DE LOS COMPONENTES DE SOFTWARE
UTILIZADOS
6.1 NODE.JS
Es un intérprete de JavaScript del lado del servidor, implementando un modelo
innovador de cómo debe funcionar un servidor. Su objetivo principal es permitir
a un programador hacer aplicaciones altamente escalables y que manejen
miles de conexiones simultáneas en una misma maquina física. Añade además
muy buenas herramientas para manejar eventos y cabe anotar que es un
servidor Asíncrono. Soporta protocolos TCP, DNS , UDP, HTTP, sockets .
Como funciona?
28
Node ejecuta el motor V8 JavaScript en el lado del servidor, estamos
acostumbrados a que el JavaScript solo se ejecuta del lado del cliente, Google
con este programa lo lleva al lado del servidor, ya no tenemos que tener java
en el servidor, Perl, Python u otros lenguajes, todo queda sobre el mismo
lenguaje JavaScript. Para aclarar Google implementa el motor V8 en su
navegador Chrome. Como se mencionó anteriormente es Asíncrono, una
petición hecha al servidor no detiene las otras, las peticiones que se van
atendiendo se van entregando a quien la solicito, o sea que si tenemos un
procesos que debe hacer varias peticiones debemos tener mucho cuidado, es
posible que la ultima petición termine antes que la primera, aquí radica uno
delos grandes cambios en este servidor, y a los cuales el programador
convencional no esta acostumbrado a enfrentar, ahí hay un cambio de
mentalidad y la solución inicial cuando eso nos ocurra es que se aniden las
peticiones y solo seguimos si la anterior termino.
6.1.1 Manual de instalación Node.js (Windows)
Descargar el instalador desde la página oficial: Instalador de Node.js en Windows. http://nodejs.org/
Figura 20. Instalación node
Una vez descargado el instalador, simplemente ejecutarlo y presionar siguiente según indique el instalador.
29
Figura 21. Node.js setup
Figura 22. descarga del setup de node
Aceptamos los términos de la licencia y luego esperamos que concluya el proceso de instalación.
30
Figura 23. Instalación setup 1
Figura 24. Instalación node setup 2
Una vez instalado en la carpeta donde se instaló c:\archivos de programa/node.js ejecutamos desde una consola cmd de Windows
set path=%PATH%;%CD% set path “%PATH%”
Esto para ejecutar Node desde cualquier parte del sistema operativo y listo, el
proceso de instalación ya está terminado
31
También usaremos algunas bibliotecas de terceros para compilar esta
aplicación, así que querrá instalar NPM, que es el gestor de paquetes de Node.
NPM le permite especificar dependencias con versión de su proyecto, que
después pueden ser descargadas e incluidas en su ruta de compilación.
6.1.2 Node ejecuta JavaScript pero no es JavaScript
El Node es un programa para ejecutar JavaScript, pero no es JavaScript en sí
mismo. De hecho, el Node es un programa realizado en lenguaje de
programación C.
Node fue construido en C gracias a que este tiene soporte para manejo de
redes, sockets y tratamiento de objetos pesados, características que JavaScript
no posee, además C es muy estable y sirve de base para interpretar JavaScript
de una manera muy eficiente y es más accesible para la mayoría de los
programadores.
Node ha sido diseñado para ayudar a los desarrolladores a construir programas
de red escalables, Node es un entorno de programación del lado del servidor
que virtualmente ha reinventado JavaScript para toda una nueva generación de
desarrolladores. Para muchos desarrolladores de Java, lo más importante de
Node es su nuevo enfoque para la concurrencia de software. Aunque la
plataforma de Java continúa evolucionando en su enfoque para la concurrencia
(con mejoras bastante anticipadas en Java 7 y Java 8), el hecho es que Node
satisface una necesidad y lo hace en la forma más ligera que muchos
desarrolladores de Java han adoptado recientemente. Como los scripts del lado
del cliente con JavaScript, los scripts del lado del servidor en el entorno de
Node son tan buenos debido a que simplemente funcionan, y están trabajando
en un área donde muchos desarrolladores de Java son actualmente
desafiados.
fuentes
http://www.ibm.com/developerworks/ssa/opensource/library/os-
nodejs/index.html, http://es.wikipedia.org/wiki/Nodejs, documentos de entrega
proyecto Physilab.
32
6.2 NPM
NPM es un gestor de paquetes para Node. Se puede utilizar para instalar y
publicar programas de Node. Maneja las dependencias, actualizaciones,
versiones entre otras cosas.
Desde la versión 0.6.3 NPM viene integrado en el proceso de instalación de
node.js, así que no se tiene que instalar por separado.
NPM como gestor de paquetes permite instalar Express, Jade, Stylus,
Nodemon. Para la instalación de cada uno de ellos ejecutamos la consola cmd
en modo administrador.
33
6.3 Express
Es un framework desarrollado para Node, con el objetivo de permitir crear
aplicaciones en un tiempo mas corto y bien estructurados, lo que hace es
entregarnos un servidor básico ya funcionando y apto para empezar a montarle
los servicios que deseamos ofrecer.
34
6.3.1 Instalación de Express
Asumimos que ya tenemos Node, ejecutamos los siguientes pasos:
1. Se ejecuta la consola de comandos o la shell de Linux
2. Se procede a ubicar el directorio de proyectos.
3. Posteriormente, desde el directorio de proyectos se debe ingresar el
siguiente comando:
npm install –g express
Este comando instala Express de manera global para todo el Node, o sea que
si deseo crear otro proyecto ya no necesito ejecutarlo de nuevo.
4. La instrucción: express myapp, crea un nuevo directorio y en su interior
aparecen las siguientes sentencias:
Create: myapp
Create: myapp/package.json
Create:myapp/app.js (archivo que lanza el servidor Node, de la siguiente
manera node app.js)
Create: myapp/public
Create: myapp/public/javascripts
Create: myapp/public/images
Create: myapp/public/stylesheets
Create: myapp/public/stylesheets/style.styl
Create: myapp/routes
Create: myapp/routes/index.js
Create: myapp/views
Create: myapp/views/layout.jade
Create: myapp/views/index.jade
myapp se debe cambiar por el nombre que el usuario elija para la aplicación.
35
App.js es el nombre principal del proyecto y en su interior ya esta configurado
para funcionar el servidor.
Public: directorio raíz o por defecto donde queda ubicado al ser lanzado el
servidor, se usa normalmente para poner ahí los JavaScript de las paginas,
imágenes, CSS y otros.
Routes: es el sitio para establecer donde busco archivos y ejecutar un
enrutamiento básico.
Views: en este directorio se ponen las paginas web HTML, ya no con la
extensión HTML, sino con extensión .jade, el Jade es un elemento importante
en Node y se describirá mas adelante.
Si se quiere tester o realizado, se puede hacer lo siguiente:
Node myapp.js, y de inmediato lanzar la aplicación, normalmente se monta por
defecto en el puerto 3000, y se puede testear de la siguiente manera, en el
navegador puede digitar localhost:3000 y aparecerá un mensaje de Express.
En este instante tenemos ya un servidor web listo para ser usado, y en menos
de 5 minutos.
Luego de este paso, se debe entrar en myapp, y ejecutar el comando
npm install
Para terminar de instalar más paquetes por defecto.
Si el servidor necesita Jade se puede digitar npm install jade, y asi con cada
paquete que se requiera e incluso con los paquetes de terceros, dentro de los
paquetes básicos que se deben instalar esta la siguiente lista y su descripción:
Npm install connect , para manejar sesiones
Npm install stylus, paquete para escribir CSS de una manera mas fácil, luego
este paquete lo traduce a .css.
Npm install jade, paquete para hacer que digitar etiquetas HTML sea también
muy sencillo, luego lo traduce a HTML.
Npm install pg, paquete para conectarse a la base de datos Postgresql.
Npm install emailjs, paquete para enviar correos electrónicos.
Y existen muchos paquetes más.
36
6.4 Jade
Es un paquete o plugin diseñado para Node, el cual permite que hagamos
HTML de una manera fácil y sencilla, sin tener la complejidad de HTML y el
abrir y cerrar etiquetas, este paquete nos hace olvidarnos de ese tipo de cosas.
Un ejemplo podría ser así:
header
link(rel='stylesheet', href='smoothness/demo_table_jui.css')
link(rel='stylesheet', href='css/jquery-ui-1.8.15.custom.css')
link(rel='stylesheet', href='smoothness/TableTools_JUI.css')
link(rel='stylesheet', href='/stylesheets/pantallas.css')
script(type='text/javascript',src='/javascripts/nomina_cargos.js')
script(type='text/javascript',src='/javascripts/nomina_cargos_1.js');
h2(class='tit') Cargos de la empresa
#div1
#div2
#div3
#div4
#div6
table(id='listdatos' , class='display')
thead
tr
th Id
th Codigo
th Nombre
th Accion
tbody
A groso modo, crea 6 elementos div, carga unos JavaScript y le asigna a una
etiqueta h2, la clase “tit” (class=”tit”), para ser modificado por CSS, de este se
puede apreciar la facilidad del código generado en Jade, en el cual, la
37
identación es fundamental para la construcción de la vista, normalmente la
identación de las líneas es de 2 espacios, cuando un elemento va dentro de
otro, esto es lo que da un poco mas de dificultad, pero el programador podría
pensar que complicado digitar el código de jade para paginas ya existentes,
para eso también hay solución el sitio http://html2jade.aaron-powell.com/, se
puede poner el código HTML y él le devuelve el código en jade, así no hay
razones para obviar jade. Y como dato adicional uno puede comprar una
plantilla que soporte JQuery y puede ser traducida e implementada en Node
con esta herramienta.
38
6.4.1 Instalación de Jade
Se procede a ingresar en el directorio del proyecto y se ejecuta el siguiente
comando :
Npm install jade
Y posteriormente, ya puede ser usado.
39
6.5 Stylus
Otro gran paquete para Node, podemos escribir CSS sin tener tanto énfasis
en la sintaxis, podemos manejar variables inclusive, el genera un archivo .styl,
y ahí esta contenido nuestro código, el cual luego es procesado y genera el
correspondiente archivo .css.
6.5.1 Instalación de stylus
Se debe ingresar en el directorio del proyecto, y ejecutar el comando:
npm install stylus.
40
6.6 Instalación de PostgreSql
PostgreSQL es un sistema de gestión de bases de datos objeto-relacional,
distribuido bajo licencia BSD y con su código fuente disponible libremente.
Figura 25. PostgresSql
PostgreSQL utiliza un
modelo cliente/servidor
y usa multiprocesos en
vez de multihilos para
garantizar la estabilidad
del sistema. Un fallo en
uno de los procesos no
afectará el resto y el
sistema continuará
funcionando.
Aplicación cliente: Esta es la aplicación cliente que utiliza PostgreSQL como administrador de bases de datos. La conexión puede ocurrir vía TCP/IP o sockets locales.
Demonio postmaster: Este es el proceso principal de PostgreSQL. Es el encargado de escuchar por un puerto/socket por conexiones entrantes de clientes, también es el encargado de crear los procesos hijos que se encargaran de autentificar estas peticiones, gestionar las consultas y mandar los resultados a las aplicaciones clientes.
41
Ficheros de configuración: Los 3 ficheros principales de configuración utilizados por PostgreSQL, postgresql.conf, pg_hba.conf y pg_ident.conf.
Procesos hijos Postgres: Procesos hijos que se encargan de autentificar a los clientes, de gestionar las consultas y mandar los resultados a las aplicaciones clientes.
PostgreSQL share buffer cache: Memoria compartida usada por PostgreSQL para almacenar datos en caché.
Write-Ahead Log (WAL): Componente del sistema encargado de asegurar la integridad de los datos (recuperación de tipo REDO).
Kernel disk buffer cache: Caché de disco del sistema operativo.
Disco: Disco físico donde se almacenan los datos y toda la información necesaria para que PostgreSQL funcione
6.6.1 Características
La última serie de producción es la 9.1. Sus características técnicas la hacen
una de las bases de datos más potentes y robustas del mercado.
Su desarrollo comenzó hace más de 16 años, y durante este tiempo,
estabilidad, potencia, robustez, facilidad de administración e implementación de
estándares han sido las características que más se han tenido en cuenta
durante su desarrollo. PostgreSQL funciona muy bien con grandes cantidades
de datos y una alta concurrencia de usuarios accediendo a la vez al sistema.
Características generales
Es una base de datos 100% ACID.
Integridad referencial.
Tablespaces.
Nested transactions (savepoints).
Replicación asincrónica/sincrónica / Streaming replication - Hot Standby.
Two-phase commit.
PITR - point in time recovery.
Copias de seguridad en caliente (Online/hot backups).
42
Unicode.
Juegos de caracteres internacionales.
Regionalización por columna.
Multi-Version Concurrency Control (MVCC).
Múltiples métodos de autentificación
Acceso encriptado vía SSL.
Actualización in-situ integrada (pg_upgrade).
SE-postgres.
Completa documentación.
Licencia BSD.
Disponible para Linux y UNIX en todas sus variantes (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64) y Windows 32/64bit.
Características de Programación / Desarrollo
Funciones/procedimientos almacenados (stored procedures) en numerosos lenguajes de programación, entre otros PL/pgSQL (similar al PL/SQL de Oracle), PL/Perl, PL/Python y PL/Tcl.
Bloques anónimos de código de procedimientos (sentencias DO).
Numerosos tipos de datos y posibilidad de definir nuevos tipos. Además de los tipos estándares en cualquier base de datos, tiene disponible, entre otros, tipos geométricos, de direcciones de red, de cadenas binarias, UUID, XML, matrices, etc.
Soporta el almacenamiento de objetos binarios grandes (gráficos, videos, sonido,...).
APIs para programar en C/C++, Java, .Net, Perl, Python, Ruby, Tcl, ODBC, PHP, Lisp, Scheme, Qt y muchos otros.
43
SQL
SQL92,SQL99,SQL2003,SQL2008
Llaves primarias (primary keys) y foráneas (foreign keys)
Check, Unique y Not null constraints
Restricciones de unicidad postergables (deferrable constraints)
Columnas auto-incrementales.
Índices compuestos, únicos, parciales y funcionales en cualquiera de los métodos de almacenamiento disponibles, B-tree, R-tree, hash ó GiST.
Sub-selects.
Consultas recursivas.
Funciones 'Windows'.
Joins.
Vistas (views).
Disparadores (triggers) comunes, por columna, condicionales.
Reglas (Rules).
Herencia de tablas (Inheritance).
Eventos LISTEN/NOTIFY.
Algunos de los límites de PostgreSQL son:
Tabla 1. Limites de PostgreSQL
Límite Valor
Máximo tamaño base de dato Ilimitado (Depende de tu sistema de almacenamiento)
Máximo tamaño de tabla 32 TB
Máximo tamaño de fila 1.6 TB
Máximo tamaño de campo 1 GB
Máximo número de filas por tabla
Ilimitado
Máximo número de columnas por tabla
250 - 1600 (dependiendo del tipo)
Máximo número de índices por tabla
Ilimitado
44
6.6.2 Manual de instalación de postgres
Este manual le enseñará la forma más sencilla de instalar PostgreSQL para
Windows en su computadora desde descargarlo de la página hasta instalar
todos sus componentes.
4 debemos obtener la versión más reciente, la podemos descargar de la dirección http://www.enterprisedb.com/products/pgdownload.do#windows Después haga clic en guardar en el recuadro de descarga si desea guardar el instalador y elija el lugar donde desee guardar o solo haga clic en ejecutar para comenzar la descarga sin guardar.
Figura 26. Instalación de PostgreSQL 1
5 Si hizo clic en guardar, vaya a la carpeta donde fue guardado y dé clic en el ícono para iniciar el proceso de instalación, si hizo clic en ejecutar esto no será necesario y usted puede comenzar con el proceso directamente.
6 Cuando aparezca la ventana Setup-PostgreSQL dé clic en siguiente (Next).
7 Elija la carpeta donde desea que se instale el programa y dé clic en siguiente.
45
Figura 27. Instalación de PostgreSQL 2
8 Después aparece una ventana similar pero ésta es para elegir la carpeta donde quiere guardar la información generada. Sigua los pasos del cuadro anterior y dé clic en siguiente.
9 Inserte una contraseña para su cuenta de postgres. La primer contraseña se agrega en el primer recuadro en blanco y en el segundo la repite. Después da clic en siguiente.
10 El siguiente recuadro es para seleccionar el puerto para el servidor. Elija el puerto que desee utilizar (puede dejar el que el programa le indica) y dé clic en siguiente.
Figura 28. Instalación de PostgreSQL 3
46
11 En el siguiente recuadro le pide que elija la ubicación para el clúster. Seleccione su país de residencia en la lista (aparece el idioma primero y después el país separado por una coma) y dé clic en siguiente.
12 Dé clic en siguiente una vez más para comenzar la instalación.
Figura 29. Instalación de PostgreSQL 4
13 Después de que se termine el proceso de instalación, dé clic en finalizar (finish).
14 A continuación comienza la instalación de software adicional. Seleccione la opción PostgreSQL x.x on port 5432 de la lista que aparece abajo y después dé clic en siguiente.
15 Después seleccione las aplicaciones que desea instalar de la lista que se le muestra. Aquí les muestro algunas de las aplicaciones básicas que puede instalar. Después de clic en siguiente.
47
Figura 30. Instalación de PostgreSQL 5
16 En el siguiente cuadro elija el espejo del cual se bajará el programa. Aquí hay un ejemplo de cuál espejo usar. Después dé clic en siguiente.
17 En el siguiente cuadro verifique que los programas que ha elegido se
encuentran en la lista y después dé clic en siguiente.
48
6.7 JSON
JSON (JavaScript Object Notation) es un formato ligero de intercambio de
datos. Es fácil de leer y escribir para los seres humanos y es fácil para las
máquinas de procesar y generar. Se basa en un subconjunto del lenguaje de
programación JavaScript, estándar ECMA-262 3ra Edición - Diciembre 1999.
JSON es un formato de texto que es completamente independiente del
lenguaje, pero utiliza las convenciones que son familiares para los
programadores de la familia de lenguajes C, incluyendo C, C++, C#, Java,
JavaScript, Perl, Python, y muchos otros. Estas propiedades hacen JSON un
ideal de intercambio de datos del lenguaje.
JSON se basa en dos estructuras:
Una colección de parejas nombre/valor. En varios idiomas, esto se realiza como un objeto, registro, estructura, diccionario, tabla hash, lista con llave, o una matriz asociativa.
Una lista ordenada de valores. En la mayoría de los idiomas, esto se realiza como una matriz, un vector, una lista o secuencia.
Estas son estructuras de universales datos. Prácticamente todos los lenguajes
de programación modernos apoyarlos en una forma u otra. Tiene sentido que
un formato de datos que es intercambiable con los lenguajes de programación
también se basan en estas estructuras.
En JSON, adquieren estas formas:
Un objeto: es un conjunto desordenado de pares nombre/valor. Un objeto
comienza con { (llave izquierda) y termina con } (llave derecha) . Cada nombre
es seguido por: (dos puntos) y los pares de nombre/valor están separados por,
(coma).
Figura 31. JSON
49
Un conjunto: es una colección ordenada de valores. Un conjunto comienza
con [ (corchete izquierdo) y termina con ] (corchete derecho). Los valores
están separados por, (coma).
Figura 32. JSON 2
Un valor: puede ser una cadena entre comillas dobles, o un número, o un
verdadero o falso, o nulo, o un objeto o una matriz. Estas estructuras se
pueden anidar.
Figura 33. JSON 3
Una cadena: es una secuencia de cero o más caracteres Unicode, entre
comillas dobles, con escapes de barra invertida. Un carácter es representado
como una cadena de un único carácter. Una cadena es muy parecida a una
cadena en C o Java.
50
Figura 34. JSON 4
Un número: es muy parecido a un número de C o Java, salvo que el octal y
hexadecimales no se utilizan.
Figura 35. JSON 5
Cabe agregar que prácticamente todo el transporte este servidor y cliente se
hace con este formato, aunque uno puede decirle al servidor como debe
responder, aunque recordemos que al devolver JSON al cliente, yo puedo usar
el siguiente comando: variable = JSON.parseJSON(datos_json) y
automáticamente se crea la variable, si es un array ya queda listo para ser
accesado, esta sentencia remplaza al método “eval” y es una manera muy
segura y avalada como una buena práctica de programación.
51
6.8 Y como funciona NODE en Physilab?
Después de instalar varias herramientas, experimentar una y otra vez con Java
Servlets, Apache , Apache Tomcat, Ruby on Rails, e invertir mucho tiempo
integrando estas herramientas, llegamos a un servidor que esta revolucionando
el mundo de los sistemas, NODE, pasamos de tener 3 o 4 herramientas
instaladas e intercomunicadas a una sola herramienta interactuando con la
tarjeta de adquisición de datos , una sola herramienta que hacia lo que antes
realizábamos con 3 herramientas, esto es parte de lo que se ha vivido en
Physilab, una verdadera evolución. Como se describió antes el punto de
llegada es el sistema de reservas, y ya en ese punto si se ha hecho la reserva,
esta pagina de reservas lo lleva al laboratorio y experimento seleccionado, vale
la pena aclarar que dicho experimento debe tener asociada una dirección IP
pública, con esta dirección IP, busca el Node instalado en esa institución y
simplemente carga el contenido de ese sitio, de esta manera logramos unificar
criterios y estandarizar un solo modelo para todos los laboratorios, además la
aplicación base de los laboratorios, cada laboratorio posee su propia base de
datos que obedece al modelo heredado de la universidad católica, y que es una
base de datos en la cual se pueden crear las piezas físicas de cada
experimento y a su vez que es lo que debe hacer y así poco a poco se
estructura un laboratorio virtual. Dentro de esta definición se tienen motores,
sensores y actuadores, con este modelo cada dispositivo del laboratorio debe
ser clasificado dentro de una de estas 3 categorías, luego se deben relacionar
los comandos que hacen que cada componente ejecute sus funciones, y hacer
interface con la tarjeta de adquisición de datos.
En Node no solo se interactúa con la tarjeta de adquisición de datos, sino que
también podemos publicar paginas, manejar JQuery, es un servidor web
parecido a los tradicionales.
52
7. CONCLUSIONES
1. El trabajo en equipo si funciona, es difícil de lograr armar un buen equipo, pero es posible y physilab lo demuestra, es vital construir un buen equipo de trabajo.
2. Todo comenzó prendiendo un LED y hoy manejamos un carril de aire de manera remota
3. Podemos ver en physilab el conocimiento de varias disciplinas llevado a la práctica y funcionando.
4. La universidad necesita más proyectos reales, donde se pueda corroborrar que el conocimiento se puede plasmar y dar frutos en un tiempo razonable y con pocos recursos.
5. Los grandes proyectos comienzan con el primer paso.
53
8. TRABAJO FUTURO
Como se menciono anteriormente, se han sembrado las bases para desarrollar
una plataforma robusta, resistente y distribuida, los siguiente pasos son el uso
intensivo por parte de los estudiantes, foguear esta aplicación, hacer ajustes,
mejorar las interfaces, en el tema de interfaces ya se tienen algunas muestras
para mejorarlo, se ha rayado la posibilidad de crear un pseudo-lenguaje para la
elaboración de los experimentos, también en la parte de los dispositivos la idea
es hacer pequeños programas que controlen cada dispositivo, o que cada
dispositivo nos informe de su estado sin que lo haga el microprocesador
central, que bueno sería que cada componente llevara inmerso su propio
software, obviamente se requiere el apoyo de la universidad o de terceros para
seguir el desarrollo de physilab.
54
9. BIBLIOGRAFIA
http://www.ibm.com/developerworks/ssa/opensource/library/os-
nodejs/index.html, http://es.wikipedia.org/wiki/Nodejs, documentos de entrega
proyecto Physilab.
