facultad de ciencias físicas y matemáticas escuela profesional ...

UNIVERSIDAD NACIONAL

“PEDRO RUIZ GALLO”

FACULTAD DE CIENCIAS FÍSICAS Y

MATEMÁTICAS

ESCUELA PROFESIONAL DE INGENIERÍA EN

COMPUTACIÓN E INFORMÁTICA

“DISEÑO DE UN SISTEMA INMÓTICO UTILIZANDO LA

PLATAFORMA ARDUINO PARA EL LABORATORIO DE

COMPUTACIÓN E INFORMÁTICA DE LA FACULTAD DE CIENCIAS

FÍSICAS Y MATEMÁTICAS DE LA U.N.P.R.G., LAMBAYEQUE - 2017”

TESIS

Presentada Por:

Vasquez Chamay Yoreli Meilin

Primo Paico Diana Medalit

Para optar por el título profesional de:

Ingeniero en Computación e Informática

Lambayeque-Perú

2019

i

UNIVERSIDAD NACIONAL

“PEDRO RUIZ GALLO”

FACULTAD DE CIENCIAS FÍSICAS Y

MATEMÁTICAS

ESCUELA PROFESIONAL DE INGENIERÍA EN

COMPUTACIÓN E INFORMÁTICA

“DISEÑO DE UN SISTEMA INMÓTICO UTILIZANDO LA

PLATAFORMA ARDUINO PARA EL LABORATORIO DE

COMPUTACIÓN E INFORMÁTICA DE LA FACULTAD DE

CIENCIAS FÍSICAS Y MATEMÁTICAS DE LA U.N.P.R.G.,

LAMBAYEQUE 2017”

TESIS

Presentada Por:

Vasquez Chamay Yoreli Meilin

Primo Paico Diana Medalit

Para optar por el título profesional de:

Ingeniero en Computación e Informática

Lambayeque-Perú

2019

vi

DEDICATORIA

A mis queridos padres Luisa Pilar y Santiago por

su incondicional apoyo, por apostar en mi futuro

y por toda la confianza depositada y por estar a

mi lado y ayudarme a superar todas las

adversidades.

A mi hermano Kevin por compartir junto a mí

muchos momentos que atesoro y por ser la razón

por la que me esfuerzo día a día.

A mis familiares y amigos quienes siempre

estuvieron a mi lado apoyándome y motivándome

en cada momento y compartiendo conmigo este

proceso de aprendizaje.

A todos y cada uno de los docentes quienes nos

brindaron sus conocimientos y experiencias

adquiridas, y sobre todo por sus grandes consejos.

A todos ustedes gracias por todo.

Yoreli Vasquez

Dedico mi tesis con mucho amor y cariño a Dios,

por haberme dado salud para lograr mis objetivos,

por su infinita bondad y amor.

A mis padres Martha y Alejandro, por su apoyo

en todo momento, por sus consejos, sus valores,

que me han permitido ser una persona de bien,

pero más que nada, por su amor.

A mis hermanas Laura y Sonia, por ser el ejemplo

de hermanas mayores, de las cuales he aprendido

mucho, por estar siempre presentes,

acompañándome para poderme realizar.

Diana Primo.

vii

AGRADECIMIENTOS

En primera instancia agradecemos a Dios por el regalo de la vida, por las bendiciones

recibidas y por guiar e iluminar nuestros caminos para alcanzar nuestras metas.

También expresamos nuestro sincero y profundo agradecimiento Al ingeniero Martin

Manuel Leiva Castillo por aceptar ser nuestro asesor y brindarnos su apoyo, capacidad,

experiencia y conocimientos durante el desarrollo de nuestro proyecto, por la paciencia y

por guiar nuestro trabajo a través de sus correcciones y pautas.

A los integrantes del jurado: Dr. Armando José Moreno Heredia, Mg. Roger Ernesto Alarcón

García y Dra. Giuliana Fiorella Lecca Orrego, quienes fueron nuestros docentes durante

nuestra formación como profesionales, porque gracias a sus sugerencias hemos podido

mejorar este proyecto de investigación.

A todas aquellas personas que colaboraron de manera directa e indirecta a que se haga

posible la culminación de este proyecto.

viii

RESUMEN

En las últimas décadas, los avances tecnológicos han ido creciendo cada día más, y los

lugares donde vivimos, trabajamos, o estudiamos no han sido exentos de estos cambios; los

mismos que vienen teniendo un impacto muy significativo en cuanto a confort y seguridad,

automatizando cada una de sus funciones, llevando de esta forma un uso adecuado de estos.

Debido al escenario actual en el que se encuentra los laboratorios de la Escuela Profesional

de Computación e Informática y a la importancia de brindar un servicio de calidad, donde

alumnos y docentes cuenten con ambientes cómodos y seguros, así como para los bienes

existentes, es necesario contar con tecnología que nos permitan mejorar la calidad de

servicio. Por tal motivo, se optó por proponer un sistema inmótico, el mismo que tiene como

finalidad mejorar la seguridad, iluminación y confort en los ambientes del Laboratorio.

El estudio se inició con el análisis de los requerimientos los cuales nos permitieron

desarrollar la estructura del sistema, así como los eventos de actuación para cada escena

(encendido y apagado de alarmas, focos y aires).

Para la implementación se utilizó la tecnología Arduino, y una aplicación web a través del

cual se tendrá el control de los sensores de forma remota.

Palabras Clave: Domótica e Inmótica, Tecnología Arduino, Normativa de Domótica e

Inmótica

ix

ABSTRACT

In recent decades, technological advances have been growing, and the places where we live,

work, or study have not been exempt from these changes; the same ones that been having a

very significant impact in terms of comfort and safety, automating each of their functions,

thus carrying out an appropriate use of these.

Due to the current scenario in which the laboratories of Escuela Profesional de Computación

e Informática are located and the importance of providing a quality service, where students

and teachers have comfortable and safe environments, it is necessary to have technology that

allows us to improve the quality of service for users. For this reason, the study and design of

an immotic system was chosen, the same that aims to improve safety, lighting and comfort

in the laboratory's environments.

The study began with the analysis of the requirements by the users which allowed us to

develop the structure of the system, as well as the action events for each scene (turn on and

turn off of alarms, spotlights and air conditioners).

For the implementation, Arduino technology (open source electronic platform) will be used,

as well as a web page through which the sensors will be controlled remotely.

Keywords: Domotic and Inmotic, Arduino Technology, Domotics and Inmotics Regulations.

x

INDICE GENERAL

INTRODUCCIÓN ................................................................................................................. 1

1. CAPITULO I: DISEÑO TEÓRICO .............................................................................. 4

1.1 DATOS GENERALES DE LA ORGANIZACIÓN ................................................................ 4

1.1.1 Descripción de la Organización ......................................................................... 4

1.1.2 Misión, Visión y Objetivos de la Organización ................................................ 5

1.1.3 Estructura Orgánica ........................................................................................... 6

1.2 PROBLEMÁTICA DE LA INVESTIGACIÓN ....................................................................... 8

1.2.1 Planteamiento del Problema .............................................................................. 8

1.2.2 Formulación del Problema................................................................................. 9

1.2.3 Justificación e Importancia de la investigación ................................................. 9

1.3 OBJETIVOS DE LA INVESTIGACIÓN ............................................................................ 11

1.3.1 Objetivo General.............................................................................................. 11

1.3.2 Objetivos Específicos ...................................................................................... 11

1.3.3 Limitaciones de la Investigación ..................................................................... 11

1.4 MARCO METODOLÓGICO .......................................................................................... 12

1.4.1 Tipo de Investigación ...................................................................................... 12

1.4.2 Hipótesis .......................................................................................................... 12

1.4.3 Operacionalización de Variables ..................................................................... 12

1.5 MARCO TEÓRICO ...................................................................................................... 15

1.5.1 Antecedentes .................................................................................................... 15

1.6 BASE TEÓRICA ......................................................................................................... 19

1.6.1 Domótica e Inmótica ....................................................................................... 19

1.6.2 Arquitecturas ................................................................................................... 21

1.6.3 Dispositivos para la automatización ................................................................ 24

1.6.4 Tecnologías de control y automatización ........................................................ 25

1.6.5 Tecnologías de control de datos ...................................................................... 29

1.6.6 Normativas ...................................................................................................... 32

1.6.7 Organismos de normalización ......................................................................... 33

1.6.8 Arduino ............................................................................................................ 34

1.7 SELECCIÓN DE LA METODOLOGÍA PARA EL DESARROLLO DEL PROYECTO ................ 66

1.7.1 Metodología en Cascada .................................................................................. 66

1.8 CONSIDERACIONES DEL DISEÑO DOMÓTICO EN LA VIDA REAL .................................. 68

xi

1.8.1 Normas y Certificaciones Técnicas ................................................................. 70

1.9 CONCEPTOS Y DEFINICIONES .................................................................................... 75

2. CAPITULO II: MÉTODOS Y MATERIALES .......................................................... 79

2.1 PLANTEAMIENTO DEL PROYECTO.............................................................................. 79

2.1.1 Identificación del escenario del proyecto ........................................................ 79

2.2 IDENTIFICACIÓN DE LOS USUARIOS Y ÁREAS INTERVINIENTES .................................. 79

2.2.1 Áreas intervinientes ......................................................................................... 79

2.2.2 Usuarios ........................................................................................................... 80

2.3 ANÁLISIS DE FACTIBILIDAD ...................................................................................... 81

2.3.1 Factibilidad operativa ...................................................................................... 81

2.3.2 Factibilidad técnica .......................................................................................... 81

2.3.3 Factibilidad económica .................................................................................... 81

2.4 DEFINICIÓN DE REQUERIMIENTOS DE NEGOCIO ......................................................... 82

2.4.1 Requerimientos funcionales ............................................................................ 82

2.4.2 Requerimientos no funcionales ....................................................................... 83

2.5 DISEÑO DE LA ARQUITECTURA TÉCNICA ................................................................... 83

2.6 DISEÑO Y DESARROLLO DE PRESTACIÓN DE DATOS .................................................. 85

2.6.1 Materiales utilizados para el circuito ............................................................... 85

3. CAPITULO III: RESULTADOS Y DISCUSIÓN ...................................................... 88

3.1 IDENTIFICACIÓN DE SITUACIÓN ACTUAL ................................................................... 88

3.2 DEFINICIÓN DE ESCENARIOS ..................................................................................... 88

3.3 CREACIÓN DEL CIRCUITO ......................................................................................... 91

3.4 PROGRAMACIÓN DEL ARDUINO ................................................................................ 97

3.5 DISEÑO DEL SISTEMA ............................................................................................... 99

3.5.1 Diagramas de caso de uso ................................................................................ 99

3.5.2 Diseño de Base de Datos ............................................................................... 102

3.5.3 Diseño Físico ................................................................................................. 107

3.5.4 Interfaz web ................................................................................................... 113

3.6 CONSTRUCCIÓN DE MAQUETA ................................................................................ 119

3.7 VERIFICACIÓN DE SENSORES .................................................................................. 120

3.8 PRUEBAS MÍNIMAS PARA EL PROYECTO .................................................................. 122

3.9 RESULTADO DE PRUEBAS DE SIMULACIÓN .............................................................. 170

xii

3.10 ANÁLISIS DE COSTOS .............................................................................................. 172

3.10.1 Costos de implementación ......................................................................... 172

3.11 ANÁLISIS DE RENTABILIDAD DEL PROYECTO.......................................................... 173

3.11.1 Umbral de Rentabilidad ............................................................................. 173

3.11.2 Proyección de ahorros ............................................................................... 174

3.11.3 Periodo de tiempo estimado para la rentabilidad....................................... 176

3.12 BENEFICIOS............................................................................................................. 177

3.12.1 Beneficios Tangibles ................................................................................. 177

3.12.2 Beneficios intangibles ............................................................................... 178

4. CAPITULO IV: CONCLUSIONES .......................................................................... 180

5. CAPITULO V: RECOMENDACIONES .................................................................. 183

6. BIBLIOGRAFIA ....................................................................................................... 184

ANEXOS ........................................................................................................................... 187

Índice de Tablas

Tabla 1: Variable Independiente.......................................................................................... 13

Tabla 2: Variable Dependiente ............................................................................................ 14

Tabla 3: Tecnologías de Control y Automatización ............................................................ 25

Tabla 4: Tecnologías de Control de Datos .......................................................................... 29

Tabla 5: Especificaciones Técnicas Arduino Mega ............................................................ 37

Tabla 6: Especificaciones Técnicas Arduino Nano ............................................................. 41

Tabla 7: Definición de escenario de actuación .................................................................... 90

Tabla 8: Descripción de entidades y atributos ................................................................... 103

Tabla 9: Descripción de entidades y atributos ................................................................... 103

Tabla 10: Descripción de entidades y atributos ................................................................. 104






xiii

Tabla 16: Descripción de tablas y campos ........................................................................ 109








Tabla 24: Resultado de pruebas de simulación ................................................................. 170

Tabla 25: Costos de implementación ................................................................................ 173

Tabla 26: Resumen de Costos ........................................................................................... 173

Tabla 27: Análisis de Rentabilidad .................................................................................... 173

Tabla 28: Análisis de Rentabilidad .................................................................................... 175

Tabla 29: Depreciación de Equipos de Laboratorio .......................................................... 175

Tabla 30: Flujo de Caja ..................................................................................................... 176

Tabla 31: Costos de Mantenimiento .................................................................................. 177

Índice de Figuras

Figura 1: Esquema organizaciones de la facultad de Ciencias Físicas y Matemáticas ......... 7

Figura 2: Modelo de casa domótica ..................................................................................... 20

Figura 3: Esquema de Arquitectura de Sistema Domótica Centralizada ............................. 22

Figura 4: Esquema de Arquitectura de Sistema Domótica Descentralizada ....................... 22

Figura 5: Esquema de Arquitectura de Sistema Domótica Distribuida ............................... 23

Figura 6: Dispositivos de Sistemas Domóticos ................................................................... 25

Figura 7: Arduino Mega ...................................................................................................... 35

Figura 8: Arduino Nano ....................................................................................................... 44

Figura 9: Orientación de los pines y elementos en el Arduino Uno .................................... 46

Figura 10: Modelo de Protocolo I2C ................................................................................... 49

Figura 11: Modelo de Protocolo SPI ................................................................................... 50

Figura 12: Lista de Bibliotecas Arduino.............................................................................. 58

Figura 13: IDE Arduino ....................................................................................................... 63

Figura 14: Componentes principales del sketch de Arduino ............................................... 64

Figura 15: Fases del modelo Cascada.................................................................................. 68

xiv

Figura 16: Representación de bombilla conectada al Arduino ............................................ 70

Figura 17: Laboratorio FACFYM ....................................................................................... 80

Figura 18: Laboratorio FACFYM ....................................................................................... 80

Figura 19: Diseño Arquitectónico ....................................................................................... 84

Figura 20: Diseño Arquitectónico (1er proceso) ................................................................. 84

Figura 21: Diseño Arquitectónico (2do proceso) ................................................................ 85

Figura 22: Esquemático de la placa shield del arduino mega. ............................................. 91

Figura 23: Esquemático de la placa shield del arduino mega. ............................................. 92

Figura 24: Entradas digitales del arduino mega .................................................................. 92

Figura 25: Etapa de iluminación .......................................................................................... 93

Figura 26: Alimentación de la casa inmotica ...................................................................... 93

Figura 27: Shield Arduino Mega ......................................................................................... 94

Figura 28: Arduino nano ..................................................................................................... 95

Figura 29: LCD 16x2 caracteres .......................................................................................... 95

Figura 30: Teclado ............................................................................................................... 96

Figura 31: Periferia del Arduino Nano ................................................................................ 96

Figura 32: Administrador de dispositivos ........................................................................... 97

Figura 33: Conexión de placa arduino con el computador .................................................. 98

Figura 34: Selección de placa en IDE Arduino ................................................................... 98

Figura 35: Selección de puerto en IDE Arduino ................................................................. 99

Figura 36: Diagrama de caso de uso Sistema Inmótico..................................................... 100

Figura 37: Diagrama de caso de uso Administrar Sistema ................................................ 100

Figura 38: Diagrama de caso de uso Controlar Luces y Aires .......................................... 101

Figura 39: Diagrama de caso de uso Gestionar Alarmas................................................... 101

Figura 40: Diseño lógico de la Base de Datos ................................................................... 102

Figura 41: Diseño físico de la Base de Datos .................................................................... 108

Figura 42: Pantalla de acceso al sistema ........................................................................... 114

Figura 43: Pantalla de inicio al sistema ............................................................................. 114

Figura 44: Pantalla de luces ............................................................................................... 115

Figura 45: Pantalla de Aires Acondicionados ................................................................... 115

Figura 46: Pantalla de Alarmas ......................................................................................... 116

Figura 47: Pantalla de Reporte de Alarmas ....................................................................... 116

Figura 48: Pantalla de Reporte Acciones por Alarma ....................................................... 117

Figura 49: Pantalla de Configuraciones............................................................................. 117

xv

Figura 50: Pantalla de Usuarios ......................................................................................... 118

Figura 51: Pantalla de Inicio para Docentes ...................................................................... 118

Figura 52: Pantalla de Restricción para Docentes ............................................................. 119

Figura 53: Segundo Piso Edificio FACFYM .................................................................... 119

Figura 54: Maqueta del Segundo Piso Edificio FACFYM ............................................... 120

Figura 55: Verificación de mediciones con monitor serial ............................................... 121

1

INTRODUCCIÓN

En la actualidad se viene hablando de Inmótica para referirse a la automatización de

edificios terciarios o de servicios (hoteles, oficinas, hospitales, plantas industriales,

universidades…)”, (Hugo Martín Domínguez y Fernando Sáez Vacas. (2006). Domótica:

Un enfoque sociotécnico, Madrid - España) es por tanto "aquella que integra un conjunto de

automatismos en materia de electricidad, electrónica, robótica, informática y

telecomunicaciones, con el objetivo de asegurar al usuario un aumento del confort, la

seguridad, el ahorro energético, las facilidades de comunicación y las posibilidades de

entretenimiento".

La presente investigación se realiza debido a la falta de ambientes que van de acuerdo

al avance de la tecnología, y que permitan brindar un servicio de calidad para todos los que

hacen uso de los ambientes donde se imparten cursos con los que cuenta la malla curricular.

Por tal motivo nuestro principal objetivo es diseñar e implementar un sistema

inmótico, mediante el uso de la plataforma Arduino, que nos permita mejorar la calidad de

servicio a un bajo costo, para ello, es necesario identificar los efectos de actuación, definir

la infraestructura de intercambio de información, así como el desarrollo de una aplicación

web para tener el control de forma remota de los dispositivos que se desean controlar, para

la implementación de la misma será a través de un prototipo el cual nos permita representar

los ambientes de los laboratorios a pequeña escala.

En dicho contexto se optó por el uso de la metodología en cascada, la misma que nos

permitirá tener bien definidos los puntos de revisión antes de avanzar a una siguiente etapa

del proyecto; la investigación se realizó a través de una entrevista con el jefe de laboratorio,

la cual sirvió para definir los requerimientos del sistema, posteriormente se definieron los

escenarios de actuación, así como la tecnología que se emplearía para el diseño de circuitos

y las herramienta de programación para el desarrollo de la aplicación que me permita

controlar remotamente los dispositivos.

En el capítulo I se abordan las cuestiones teóricas que sustentan el planteamiento de

la investigación, el problema, los objetivos, la justificación y el marco teórico el cual incluye

los antecedentes generales sobre la Domótica e Inmótica, sus características principales,

arquitecturas, aplicaciones y su potencial frente al ahorro energético. También se hace una

descripción de las placas y del software Arduino, principal tecnología empleada para el

desarrollo del proyecto, posteriormente se nombra algunas normas de gestión de energía.

2

En el capítulo II se identifica el escenario del proyecto, las áreas intervinientes y los

usuarios, se realiza el análisis de factibilidad, así como la definición de los requerimientos

de negocio, por ultimo encontramos el diseño de la arquitectura técnica y los materiales a

utilizar en el circuito.

En el capítulo III se ofrece la discusión e interpretación de los resultados, se puede

apreciar los esquemas de los circuitos creados para la implementación de los sensores y

actuadores asociados al proyecto, así como las directivas para el desarrollo del código fuente.

En el capítulo IV y V se presentan las conclusiones y recomendaciones de esta tesis

respectivamente.

3

CAPITULO I

DISEÑO TEÓRICO

4

1. CAPITULO I: DISEÑO TEÓRICO

1.1 Datos Generales de la Organización

1.1.1 Descripción de la Organización

La Facultad de Ciencias Físicas y Matemáticas es una de las 14 facultades con

las que cuenta la Universidad Nacional Pedro Ruiz Gallo, fue creada por

resolución N° 568-81-R del 25 de mayo de 1981.

Inicialmente contaba con las especialidades de Física, Matemática y Estadística,

otorgando a sus egresados el grado de Bachiller en las especiales antes

mencionadas y los títulos de Licenciado en Física, Licenciado en Matemática y

Licenciado en Estadística.

La escuela profesional de Computación e Informática se creó con resolución N°

444-92-R de fecha 27 de abril de 1992, adscribiéndola a la facultad de Ciencias

Físicas y Matemáticas, mientras que la escuela de Ingeniería Electrónica se creó

con resolución N° 007-98-AU-R.

Está formada por:

Consejo de Facultad

Los departamentos académicos de Matemática, Física, Estadística,

Ingeniería en Computación e Informática e Ingeniería Electrónica.

Centro de Investigación.

Unidad de Responsabilidad Social.

La oficina de Procesos Académicos.

La oficina de administración.

Las escuelas profesionales de Matemática, Física, Estadística, Ingeniería

en Computación e Informática e Ingeniería Electrónica.

Unidades de Producción.

5

1.1.2 Misión, Visión y Objetivos de la Organización

La definición de la misión y visión y objetivos de la organización fueron tomados

del Documento Plan Estratégico de la Facultad de Ciencias Físicas y

Matemáticas.

Misión

Somos una facultad líder en la formación humanística, científica y tecnológica

en el norte del país.

(Vásquez & Ortiz, s.f., pág. 25)

Visión

Formamos licenciados en Física, Matemática y Estadística; ingenieros

electrónicos e ingenieros en computación e informática, altamente competitivos

en ciencia y tecnología para el desarrollo sostenible y sustentable.


Objetivos Estratégicos

Según el Plan Estratégico de la Facultad de Ciencias Físicas y Matemáticas sus

objetivos estratégicos son:

Desarrollar un modelo de educación universitaria basado en

competencias permitiendo la innovación de los métodos de enseñanza-

aprendizaje, la investigación como eje integrador en el plan de estudios,

la proyección social y la extensión universitaria como eje de la inserción

en la sociedad.

Realizar investigación científica y tecnológica para los sectores de la

producción y servicios.

Incentivar proyectos de proyección social y de extensión universitaria en

el ámbito local y regional.

Gestionar estrategias de cooperación nacional e internacional que

permitan a nuestros docentes desarrollar proyectos compartidos.

(Vásquez & Ortiz, s.f., págs. 26,27,28)

6

1.1.3 Estructura Orgánica

La Facultad de Ciencias Físicas y Matemáticas es la unidad de formación

académica y de gestión, donde cultiva y enseña Estadística, Matemática, Física,

Ingeniería en Computación e Informática e Ingeniería Electrónica.

Está integrado por profesores y alumnos agrupados en cuatro departamentos

académicos: de Estadística, de Física, de Matemática, de Ingeniería en

Computación e Informática. La facultad a diferencia del departamento

académico, cuenta con organismos asesores: consejo de facultad, escuelas

profesionales, comisiones de currículo, institutos de investigación, conformados

por los propios profesores para fines de administración de lo académico.

El departamento es la unidad fundamental de la academia (conjunto de

intelectuales que crean conocimiento) y son los docentes adscritos los

responsables de la gestión de los syllabus de las disciplinas que imparten.

Tal como se observa en la figura 1 orgánicamente consta de:

a) Consejo de Facultad, constituido por el decano (máxima autoridad de la línea

de la facultad), quien lo preside 5 profesores principales, 3 docentes

asociados, 2 maestros auxiliares, 1 graduado y 6 estudiantes.

b) Los departamentos académicos de Matemática, Física, Estadística, Ingeniería

en Computación e Informática.

c) Centro de Investigación, integrado por el jefe del centro y todos los docentes

adscritos a él.

d) Unidad de responsabilidad social, compuesto por el jefe del centro y todos

los docentes adscritos a él.

e) La oficina de procesos académicos.

f) La oficina de administración.

g) Las escuelas profesionales de Matemática, Física, Estadística, Ingeniería en

Computación e Informática e Ingeniería Electrónica.

h) Unidades de Producción: Centro de idiomas FACFyM


7

Figura 1: Esquema organizaciones de la facultad de Ciencias Físicas y Matemáticas

Fuente: Plan Estratégico de la Facultad de Ciencias Físicas y Matemáticas.

8

1.2 Problemática de la investigación

1.2.1 Planteamiento del Problema

En los últimos años hemos sido testigos del avance de la tecnología y las

comunicaciones, los hogares y edificios no han sido la excepción; es por ello que

la domótica e inmótica vienen siendo una alternativa para volver nuestros

edificios “inteligentes”.

La Escuela Profesional de Ingeniería en Computación e Informática podría

beneficiarse con estos avances; que se aplicarían de manera específica en los

cinco laboratorios que brindan servicios principalmente a los cursos de pre-grado

de dicha escuela profesional, así como el dictado de cursos libres que se

organizan en sus ambientes, ya que en dichos laboratorios hemos observado que

presentan deficiencias en cuanto al control de aparatos eléctricos y electrónicos,

en los que debería intervenir algún dispositivo que los ayude a tener un mejor y/o

adecuado control de las funciones que realiza.

Los sectores que hemos podido identificar y que se tomarán para este caso de

estudio serán los siguientes:

Seguridad y protección : En cuanto al tema de seguridad es una de las principales

preocupaciones que se presenta, ya que los laboratorios cuentan con bienes de

alto valor económico; el mismo que en ocasiones ha sido víctima de robos; por

tal razón consideramos que es indispensable que éstos cuenten con un sistema de

video vigilancia inteligente dentro de las instalaciones y fuera del mismo,

permitiendo de esta manera mantener a buen recaudo el patrimonio, dicho

sistema podrá enviar mensajes de alerta a los usuarios, así como tener la

capacidad de activar las diferentes alarmas con las que cuente.

Otra de las preocupaciones en cuanto al tema de seguridad es el de incendios, que

podría traer grandes pérdidas y daños materiales, es por ello que se plantea el uso

de alarmas técnicas (incendio, humo), que permitan detectar a tiempo un siniestro

y alertar al personal correspondiente al área.

Iluminación: Se ha podido reconocer que en los ambientes donde se desarrollan

las labores académicas (laboratorios) en muchas ocasiones no se cuenta con una

9

adecuada iluminación que permita un ambiente de trabajo adecuado, por lo que

se necesita de un sistema de luminaria automatizado que opere de acuerdo a

diferentes escenarios que se planteen, así como el encendido y apagado de luces

a través de un sistema web, permitiendo de este modo mejorar la calidad de

servicio y contribuir con el cuidado del medio ambiente, al mismo tiempo que

reducimos costes.

Confort: Para garantizar un buen ambiente laboral y de estudios es necesario

contar con un clima adecuado, los laboratorios por el simple hecho de contar con

un gran número de computadoras crea un ambiente de calor extremo en época de

verano, por ello es necesario contar con un sistema de aire acondicionado

automatizado, y para que funcione es necesario contar con un sistema de sensores

que mide las condiciones, calidad y temperatura dentro del inmueble y poder

regularla a través del encendido o apagado del aire acondicionado a la vez que

pueda funcionar a través de otros escenarios; a través de la automatización de la

calefacción se ahorraría un gran porcentaje de costos por ahorro de energía.

Para efectos de nuestra investigación solo se considerarán lo concerniente a

seguridad e iluminación y confort; para ello planteamos la solución a través de la

implementación de un prototipo con una aplicación hecha a medida para el

control de los dispositivos desde internet de acuerdo a los requerimientos,

haciendo uso de la plataforma Arduino y software de bajo coste, permitiendo que

el usuario controle y automatice tareas.

1.2.2 Formulación del Problema

¿El diseño y la implementación de un sistema inmótico mediante el uso de la

plataforma Arduino permitirán mejorar la seguridad, iluminación y confort en los

ambientes del Laboratorio de Computación e Informática de la Facultad de

Ciencias Físicas y Matemáticas?

1.2.3 Justificación e Importancia de la investigación

10

Si bien es cierto en los últimos años la domótica e inmótica han tenido mayor

presencia en nuestras vidas, una serie de tecnologías se han venido desarrollando

a lo largo de este tiempo, con la finalidad de contribuir a mejorar nuestra calidad

de vida.

En este proyecto se realizarán estudios de los diferentes sistemas de

automatización; como lo son: sistemas de iluminación, sistemas de seguridad

(sistema de intrusión, sistema de detección en caso de incendio), los mismos que

servirán de referente para nuevas investigaciones en la región; contribuyendo de

este modo en la difusión de estas nuevas tecnologías y en el uso de las mismas.

El avance de la electrónica ha logrado que se desarrollen un sinnúmero de placas

para cada necesidad o requerimiento, es así que la Plataforma Arduino nos

presenta su micro controlador a un bajo precio y muy sencillo de utilizar que nos

permitirán desarrollar cualquier diseño de control.

La implementación de estas soluciones puede llegar a ser muy cara o muy

económica, dependiendo de tres factores, quien va a realizar la implementación,

las dimensiones de los ambientes y el tipo de tecnología que se utilizará; sin

embargo, es posible que una implementación domótica/inmótica resulte

totalmente económica, si tenemos que adaptar los equipos y sistemas con los que

ya se cuenta dependiendo de nuestras necesidades y gustos. El ahorro que se

genera con sistemas automatizados se ve en el consumo de energía eléctrica, dado

que tenemos diferentes opciones para gestionar los dispositivos de manera

automática y remota.

La domótica ha cambiado la forma en cómo se realizan las tareas del hogar o

como se controlan los diferentes aparatos que se encuentran en un edificio,

ofreciendo no solo seguridad y confort a los seres humanos, en especial de

aquellos que presentan algún tipo de discapacidad; sino también contribuyendo

con el medio ambiente, ya que nos permite optimizar el uso de energía eléctrica.

Por lo expuesto la domótica se presenta como una alternativa a nuestra nueva

forma de vida, integrando diferentes tipos de tecnológicas con la única finalidad

de generar soluciones integradas y a la vez estar a la vanguardia tecnológica.

11

1.3 Objetivos de la Investigación

1.3.1 Objetivo General

Diseñar e implementar un sistema inmótico mediante el uso de la plataforma

Arduino, para mejorar la seguridad, iluminación y confort en los ambientes del

Laboratorio de Computación e Informática de la Facultad de Ciencias Físicas y

Matemáticas.

1.3.2 Objetivos Específicos

Identificar los problemas o deficiencias que presenta el Laboratorio de

Computación e Informática de la Facultad de Ciencias Físicas y Matemáticas.

Identificar los eventos de actuación para cada tipo de escena de acuerdo a las

actividades que se realizan en cada laboratorio.

Diseñar el esquema de intercambio de información para los ambientes de los

laboratorios.

Realizar investigación y programación de las placas Arduino que nos

permitirá automatizar los dispositivos electrónicos y eléctricos, así como

también para servicios SMS, a través de la tarjeta GSM/GPRS, la misma que

enviará las alertas respectivas a los teléfonos móviles de los encargados del

laboratorio.

Diseñar y desarrollar la interfaz gráfica con la que se controlará los sensores

y actuadores que se encuentran distribuidos en los diferentes laboratorios.

Construir una maqueta a pequeña escala que representaran los ambientes de

los laboratorios para la implementación de la automatización.

Verificar el funcionamiento de los sensores de intromisión, así como la

activación de alarmas respectivas.

Realizar las pruebas y correcciones respectivas del sistema inmótico para el

laboratorio.

1.3.3 Limitaciones de la Investigación

El presente proyecto cuenta con limitaciones que a continuación se detallan.

A pesar de que este sistema ha sido pensado para ser utilizado por un amplio

número de personas con distintos tipos de discapacidades, en algunos casos

12

extremos, como es el caso de personas ciegas, este sistema no podría ajustarse

a sus necesidades particulares, debido principalmente a que no podrían

interactuar con el sistema.

Puesto que el sistema propuesto se enmarca dentro de una investigación, es

que no se incluyen pruebas formales del sistema, ya que el resultado sólo es

un software y circuito "Prototipo", y sólo se realizarán pruebas funcionales.

Esto se debe principalmente a que el sistema no pasará por la etapa de

implantación puesto que esto puede retrasar toda la investigación en general.

Se necesita conocimientos previos de los lenguajes que se ocuparán en el

desarrollo del sistema Inmótico tales como PHP, ARDUINO y MYSQL.

Se necesita conocimientos de electrónica para poder ensamblar dicho

proyecto.

1.4 Marco Metodológico

1.4.1 Tipo de Investigación

Tecnológica - Formal

1.4.2 Hipótesis

Si se diseña e implementa un sistema inmótico mediante el uso de la plataforma

Arduino, entonces permitirá mejorar la seguridad, iluminación y confort en los

ambientes del Laboratorio de Computación e Informática de la Facultad de

Ciencias Físicas y Matemáticas.

1.4.3 Operacionalización de Variables

13

1.4.3.1 Variable Independiente

VARIABLE

INDEPENDIENTE DEFINICION

DIMENSIONES INDICADOR

Sistema Inmótico

Sistema informático en el cual mediante el uso

de Arduino y PHP nos permitirá automatizar y

controlar los diferentes ambientes del

laboratorio, éste consta de una red de

comunicación que permite interconectar los

diferentes equipos para obtener información

del ambiente y basado en ello, ejecutar una

serie de acciones sobre el entorno. Este sistema

tendrá conexión con el exterior a través de

internet, para el control y monitoreo de forma

remota de los laboratorios de Computación e

Informática.

Accesibilidad Económica

Tiempo

Cantidad de dinero que se

invierte en la implementación

del proyecto.

Tiempo de demora del

desarrollo de la aplicación

web.

Tiempo de desarrollo del

código Arduino.

Tiempo de elaboración placas

adicionales y cableado del

prototipo

Tabla 1: Variable Independiente

Fuente: Elaboración propia

14

1.4.3.2 Variable Dependiente

VARIABLE DEPENDIENTE DESCRIPCION DIMENSIONES INDICADOR

Mejorar la seguridad, iluminación

y confort

Se busca la mejora de la

iluminación, seguridad y confort

de los laboratorios de Ingeniería

en Computación Informática para

aumentar la calidad de servicio a

través del encendido y apagado de

luces, aires y el reporte de alarmas

de acuerdo a los escenarios

activados.

SEGURIDAD

Tiempo promedio de lectura

de números telefónicos para

envío de SMS.

Tiempo promedio para

activar una alarma.

ILUMINACIÓN


encender y apagar focos.

CONFORT


encender y apagar aires

acondicionados.

Tabla 2: Variable Dependiente


15

1.5 Marco Teórico

1.5.1 Antecedentes

1.5.1.1 Antecedentes en el contexto Internacional

Lledó, E. (2012): Diseño de un sistema de control domótico basado en la

plataforma Arduino. Valencia – España

Conclusiones:

El proyecto se basaba en construir un sistema domótico con una placa

Arduino y un servidor que trabajase sobre Linux, he decidido

desviarme un poco y he cambiado el servidor por otra placa Arduino.

Con esto he conseguido ver que, aunque se puede hacer, reduce las

posibilidades de ampliación del sistema.

Se ha podido demostrar que es posible instalar un sistema domótico

apoyándonos en la plataforma Arduino, con un coste muy inferior al

que se utiliza en las viviendas de lujo, a cambio de dedicarle un poco

de tiempo.

A la hora de programar los distintos elementos ayuda mucho realizar

de antemano un esquema con las funciones que necesitamos y no

alterarlo ya que un proyecto cada vez va haciéndose más grande y

tener que cambiar una cosa que a priori parece insignificante puede

dar mucho trabajo adicional.

Balderon, D. y Congacha, M. (2014): “Estudio y diseño de un sistema

domótico aplicado en el edificio de laboratorios para la facultad de mecánica.

Riobamba - Ecuador”.

Conclusiones:

Se ha demostrado que el proyecto domótico del edificio de laboratorios

de la Facultad de Mecánica beneficiará a sus usuarios, por el hecho de

realizar tareas con mayor facilidad y el control de dispositivos a distancia

16

brinda un escenario adecuado incluso a personas con algún tipo de

discapacidad.

Se realizó un análisis de las condiciones del diseño de la edificación a ser

intervenida, la cual resultó apta para incorporar un sistema domótico X-

10, integrando los sistemas de iluminación. Persianas y circuito cerrado

de cámaras en una solución centralizada, permitiendo al usuario

monitorizar y controlar los sistemas desde una misma aplicación, cuya

interfaz es de fácil manejo.

Se ha estudiado y diseñado el presente proyecto que ofrecerá una gran

flexibilidad para poder expandir el sistema con aplicaciones futuras, pues

la facilidad que presenta el trabajar con el cableado eléctrico permite

integrar dispositivos a la red sin la necesidad de efectuar trabajos

adicionales que afecten a la estética del inmueble.

1.5.1.2 Antecedentes en el contexto Nacional

Rodríguez, W. (2012): “Sistema de control domótico utilizando una central

IP PBX basado en software libre. Lima - Perú”.

Conclusiones:

El uso del controlador ENC28J60 en el módulo de comunicaciones

permitió al Controlador de Equipos la comunicación vía Internet o

LAN. Permitiendo así eliminar cualquier limitante de distancia con el

Servidor Domótico. Además, gracias a la arquitectura planteada, a la

independencia entre el Módulo de Control y Comunicaciones en el

Controlador de Equipos, y al estándar SPI que soporta el controlador

ENC28j60 el sistema planteado es heterogéneo y escalable.

La implementación del Gestor de eventos mediante lenguaje de

programación PHP basado en sockets y el mapeo de puertos en los

router, permitió la comunicación por Internet o LAN entre el Servidor

Domótico y los Controladores de Equipos.

La implementación de la base de datos Modelo de área en MySQL

permitió no solo integrar las tablas con el SID, sino también con el

servidor WEB.

17

DÍAZ, A. (2010): “Diseño de un sistema automatizado de seguridad contra

intrusión en un edificio de departamentos utilizando el estándar de

tecnología inalámbrica Zigbee. Lima - Perú”.

Conclusiones:

El sistema de seguridad diseñado en la presente tesis asegura el

cumplimiento de las características esenciales de: bajo costo , bajo

consumo de energía, estética: es libre de cables y su tamaño es

reducido, transportabilidad: es un sistema inalámbrico que se

desinstala con sencillez y puede llevarse en caso de mudanza, bajo

mantenimiento: al no tener cableado no se requieren reajustes y se

elimina el riesgo de corte de cables por delincuentes, sencillez de

uso para el cliente: el sistema tiene un control remoto de solo 2

botones, seguridad: cuenta con el respaldo de la tecnología IEEE

802.15.4 y ZigBee para las transmisiones y retransmisiones con

CSMA-CA.

El sistema de seguridad contiene elementos esenciales como: el

módulo coordinador, diferentes módulos de monitoreo: sensor de

rotura de vidrio, contactos magnéticos y el módulo control remoto.

Opcionalmente el sistema de seguridad también acepta la

integración de un módulo de aviso para alertar en la zona común piso

del departamento.

1.5.1.3 Antecedentes en el contexto Local

Carrillo, M. y Vite, C., 2016: “Aplicación de una red neuronal para el control

domótico de encendido de luces en una vivienda de la urbanización Santa

Ángela – Chiclayo 2015. Lambayeque - Perú”.

Conclusiones:

18

La red neuronal utilizada es de tipo RNA con tres capas: capa de

entrada, capa oculta y capa de salida. El circuito electrónico

encargado de controlar el fluido eléctrico en la maqueta está

compuesto por focos LED, resistencias, diodos, ácido férrico, fuente

de poder, cables y una placa Arduino UNO que es la encargada de

transmitir los datos del programa MATLAB para que generen

instrucciones de encendido o pagado de luces dentro de la maqueta.

Los dispositivos electrónicos han sido soldados con ácido férrico y

unidos a la placa Arduino UNO, la cual mediante un cable USB se

conecta con un computador que va a conectar el programa MATLAB,

mediante el puerto COM5, posteriormente se declaran los pines de

salida de la placa Arduino para el encendido y apagado de luces.

Chasquero, M. y Guerrero, L. (2015): “Mejoramiento de la eficiencia

eléctrica en el Jockey Club de Chiclayo con aplicación de domótica.

Pimentel - Perú”.

Conclusiones:

La realización de una auditoría eléctrica tiene como objetivo obtener

el máximo rendimiento de la energía consumida y de las instalaciones

necesarias para su generación, transporte, distribución y utilización;

garantizando un funcionamiento sin interferencias de todos los

receptores conectados a la red eléctrica.

Para lograr optimizar un sistema eléctrico se requiere conocer como

están repartidos los consumos a lo largo del tiempo, cuales son las

cargas con factor de potencia más desfavorable y cuál es la causa en

definitiva del bajo rendimiento de la instalación. Todo ello requiere

fundamentalmente de instrumentación adecuada para la medida,

registro y tratamiento de datos.

El beneficio esperado post propuestas de mejora será 541.6 soles por

mes; y un ahorro de emisiones de 836.48 kg CO2 por mes.

19

1.6 Base Teórica

1.6.1 Domótica e Inmótica

Vivimos en la era de la tecnología y la modernidad donde las comunicaciones se

han vuelto cada vez más importantes e indispensables en nuestras vidas tan

agitadas. Es este ritmo de vida el que ha provocado que dispongamos de menos

tiempo para realizar las labores del hogar el que ha provocado que surja la

necesidad de automatizar dichas labores; es así como nace la domótica e inmótica

El termino domótica proviene del latín domus (casa, domicilio) y tica de la

palabra griega “automática”; aunque hay autores quienes dice que deriva de

informática, como define el Diccionario de la RAE, o incluso de robótica.

Lorente S. (2004) a través de un análisis realizado a dicha palabra propone que

deriva del acrónimo Domo-TIC-A; donde “Domo” viene siendo casa o vivienda,

"TIC" por Tecnologías de la Información y las Comunicaciones y finalmente "A"

denotará automatización; pero esto está fuera del marco etimológico.

Huidobro J.M. y Millán R. (2004) dicen que los orígenes de la Domótica se

remontan a los años setenta, cuando en Estados Unidos de Norte América

aparecieron los primeros dispositivos de automatización de edificios basados en

la muy reconocida tecnología X-10. Ya para los años noventa con la aparición de

las computadoras personales y el cableado estructurado aparecen también las

aplicaciones de control y seguridad.

20

Según CEDOM, la domótica es “el conjunto de tecnologías aplicadas al control y la

automatización inteligente de la vivienda, que permite una gestión eficiente del uso

de la energía, que aporta seguridad y confort, además de comunicación entre el

usuario y el sistema”, tal como se muestra en la figura 2.

Mientras que la inmótica según la asociación española de domótica e inmótica define

la inmótica como: “El conjunto de tecnologías aplicadas al control y la

automatización inteligente de edificios no destinados a vivienda, como hoteles,

centros comerciales, escuelas, universidades, hospitales y todos los edificios

terciarios, permitiendo una gestión eficiente del uso de la energía, además de aportar

seguridad, confort, y comunicación entre el usuario y el sistema.”

Tanto la domótica e inmótica se aplican en los siguientes campos:

Climatización y consumo energético

Programación del encendido y apagado de todo tipo de aparatos (aire

acondicionado, toldos, luces, calderas, etc.) según las condiciones

ambientales y otros eventos

Adaptación a los planes de tarifas reducidas (tarifa nocturna)

Contadores eléctricos que informan el consumo de energía.

Entretenimiento y confort

Conexión a internet desde cualquier punto

Juegos en red

Visión de canales de tv en cualquier habitación

Fuente: http://www.cdigitalit.com/que-es-domotica/

Figura 2: Modelo de casa domótica

21

Control de los dispositivos eléctricos y electrónicos del hogar desde

un PC por internet o desde un teléfono.

Seguridad

Configuración de procedimientos de avisos en caso de intrusión o

avería (alarmas técnicas).

Instalación de cámaras y micrófonos para tener un sistema de

seguridad y control de acceso a la vivienda.

Servicios comunitarios

Control de la iluminación en zonas comunes.

Alarmas de seguridad y alarmas técnicas.

1.6.2 Arquitecturas

Según la Dirección General de Industria, Energía y Minas de la Comunidad de

Madrid y Fundación de la Energía de Comunidad de Madrid, en el documento

denominado “La Domótica como solución del futuro” considera las siguientes

arquitecturas:

Arquitectura Centralizada – Los sistemas centralizados se caracterizan por

tener un único nodo que recibe toda la información de las entradas, que la

procesa y envía a las salidas las órdenes de acción correspondiente. Están

unidas a un nodo central que dispone las funciones de control y mando.

(López Jimeno, Hidobro, Novel, & Calafat, 2007).

En la figura 3, se puede observar que a un único controlador se conectan

actuadores, sensores e interfaces.

22

Fuente: https://sltecnologia.wikispaces.com/Domotica

Arquitectura Descentralizada – En un sistema descentralizado, todos los

elementos de red actúan de forma independiente unos de otros. Comparten la

misma línea de comunicación y cada uno de ellos dispone de funciones de

control y mando tal como se observa en la figura 4. Es necesario en estos

entornos, un protocolo de comunicaciones, para que todos los elementos

produzcan una acción coordinada. (López Jimeno, Hidobro, Novel, &

Calafat, 2007).


Figura 3: Esquema de Arquitectura de Sistema Domótica Centralizada

Figura 4: Esquema de Arquitectura de Sistema Domótica Descentralizada

https://sltecnologia.wikispaces.com/Domotica

23

Arquitectura Distribuida – Los sistemas distribuidos combinan las

topologías centralizada y descentralizada. La inteligencia del sistema está

localizada en cada uno de los nodos de control y cada nodo tiene acceso físico

directo a una serie limitada de elementos en la red. Es necesario al igual que

en el caso de los sistemas descentralizados, un protocolo de comunicaciones

para que todos los módulos produzcan una acción coordinada, tal como lo

muestra la figura 5 (López Jimeno, Hidobro, Novel, & Calafat, 2007)


Algunos autores consideran una clasificación adicional

Arquitectura Híbrida / Mixta – En este tipo de sistema se combinan las

arquitecturas de los sistemas centralizadas, descentralizadas y distribuidas.

En éstos, se combinan las arquitecturas de los anteriormente mencionados.

Puede contar con un controlador central, como en el caso de la Arquitectura

Centralizada, o varios controladores descentralizados; asimismo, los

diferentes módulos que lo componen (actuadores, interfaces, sensores)

pueden operar como controladores, como en el caso de la Arquitectura

Distribuida. En este caso, los diferentes dispositivos pueden recoger,

gestionar y transmitir la información recibida al resto de los que componen el

sistema y que se encuentran distribuidos por la vivienda, sin que ésta tenga

que pasar, necesariamente, por un controlador principal. (HogarTec, 2012)

Figura 5: Esquema de Arquitectura de Sistema Domótica Distribuida

24

1.6.3 Dispositivos para la automatización

Los elementos que se deben de utilizar para el control y automatización de

cualquier edificio básicamente son los siguientes:

Controlador, es el dispositivo que interconecta los distintos dispositivos

destinados a la automatización del edificio, haciendo de interfaz común de

todos hacia las redes externas. Permite el control local o remoto de los

dispositivos.

El sistema, es el dispositivo responsable de llevar el control de los

dispositivos que se encargan de la automatización, de acuerdo a los

parámetros de actuación.

Canal de comunicación; es aquel que se encarga de comunicar a los

diferentes elementos que componen el sistema y que hacen posible la

comunicación y transmisión de datos e información. Los diversos sistemas

domóticos ofrecidos actualmente te permiten establecer la comunicación de

los diversos elementos a través de un cableado exclusivo para el sistema, sin

embargo, también se puede hacer uso de la red Ethernet, WIFI o utilizando la

red eléctrica de la vivienda o edificio.

Los sensores, dispositivos encargados de recoger la información de los

diferentes parámetros (temperatura, presencia, fugas etc.) y enviarla a la

pasarela para que ejecute las tareas programadas.

Los actuadores, son dispositivos utilizados para modificar los estados de

equipos e instalaciones (alarmas, control de calefacción, ventilación,

luminosidad, etc.). (López Jimeno, Hidobro, Novel, & Calafat, 2007).

En la figura 6 se pueden observar ejemplos de cada uno de estos elementos

que podrían formar parte de un sistema de automatización

25

Fuente https://www.ecured.cu/Dom%C3%B3tica

1.6.4 Tecnologías de control y automatización

Fuente: Junestrand et al (2005), ProHome (2003a)

Recogemos en la tabla 4 el grupo de tecnologías más conocidas que permiten el

intercambio de paquetes de datos de pequeño tamaño y baja latencia, propias de las

redes de control y automatización. Se trata de tecnologías que han nacido y madurado

Figura 6: Dispositivos de Sistemas Domóticos

Tabla 3: Tecnologías de Control y Automatización

26

en los últimos años con origen en las necesidades de control y automatización, de

quieres a continuación se hará una breve descripción. (Domínguez & Sáez Vacas,

2006)

Konnex (KNX)

La KNX Association es creadora y propietaria de «la tecnología KNX:

el ESTÁNDAR mundial para el control de viviendas y edificios» y también

propietaria a nivel mundial del logotipo de la marca KNX. Los miembros son

fabricantes que desarrollan dispositivos para múltiples aplicaciones para el control

de viviendas y edificios basado en KNX, como por ejemplo control de la iluminación,

control de persianas y toldos, calefacción, ventilación, aire acondicionado, gestión

energética, medición, supervisión, monitorización, sistemas de alarmas/intrusos,

electrodomésticos, sistemas de audio y video y muchas otras más.

KNX es el único estándar mundial para el control de la vivienda y del edificio con:

Una única herramienta de puesta en marcha (ETS) independiente de cualquier

fabricante.

Una completa gama de medios de transmisión (TP, PL, RF e IP).

Una completa gama de modos de configuración (modos System y Easy).

KNX está aprobado como:

Estándar Europeo (CENELEC EN 50090 y CEN EN 13321-1).

Estándar Internacional (ISO/IEC 14543-3).

Estándar Chino (GB/T 20965).

Estándar Norteamericano (ANSI/ASHRAE 135).

LonWorks

Echelon desarrolló la Tecnología LonWorks (hardware y software) y la presenta

hacia 1990.

Entre el Software desarrollado tenemos:

Herramienta de Integración LonMaker

Analizadores de Red.

27

Y tecnología Hardware como:

Chip Neuron Transceivers

Módulos Routers

Adaptadores LonTalk

Módulos LonPoint – Nodos

Es una tecnología para la gestión técnica y el control de las instalaciones. Presenta

un control distribuido y descentralizado, permitiendo distribuir la inteligencia entre

sensores y actuadores. Fabricantes de sistemas de control pueden acortar el tiempo

de desarrollo de producto, y los integradores la implantación.

Los dispositivos en una red de LonWorks se comunican a través de un protocolo

específico para redes de control creado por la compañía Echelon. El protocolo ha

sido ratificado como un estándar oficial por un gran número de normas nacionales e

internacionales, incluyendo ANSI, IEEE, CEN y EN. En enero de 2009, el protocolo,

que es la base de la plataforma LonWorks, fue ratificado como un estándar mundial

de control de edificios. Formalmente conocido ahora como ISO/IEC 14908-1.

X10

La tecnología X10, basada en corrientes portadoras, fue desarrollada entre 1976 y

1978 por los ingenieros de Pico Electronics Ltd, en Glenrothes, Scontland. X10

surgió de una familia de chips denominada los proyectos X (o series X). Esta empresa

comenzó a desarrollar este proyecto con la idea de obtener un circuito que pudiera

ser insertado en un sistema mayor y controlado remotamente. En colaboración con

BSR, una empresa dedicada a los sistemas de audio, comenzaron a construir los

dispositivos X10.

Existe una amplia gama de equipos que implementan el protocolo X10, desde

interruptores para iluminación a completos paneles de control, emisores y receptores

de radiofrecuencias, sensores de movimiento e incluso cámaras. La instalación de

casi todos esos dispositivos se reduce a enchufarlos a una toma de corriente

convencional de la casa, y para el caso de los dispositivos inalámbricos, su colocación

se reduce a fijarlos a una superficie.

28

X10 es el "lenguaje" de comunicación que utilizan los productos compatibles X10

para hablarse entre ellos, aprovechando para ello la instalación eléctrica existente de

220V de su casa, y evitando tener que instalar cables.

Los productos de automatización del hogar X10 están diseñados para que puedan ser

instalados fácilmente por cualquier persona sin necesidad de conocimientos

especiales. Cada aparato tiene una dirección a la que responde o envía, existiendo un

total de 256 direcciones. Todos los productos X10 son compatibles entre sí por lo

que se pueden combinar para formar el sistema más adecuado a sus preferencias.

ZigBee

ZigBee es un estándar de comunicaciones inalámbricas diseñado por la ZigBee

Alliance. Es un conjunto estandarizado de soluciones que pueden ser implementadas

por cualquier fabricante. ZigBee está basado en el estándar IEEE 802.15.4 de redes

inalámbricas de área personal (Wireless personal área Newark, WPAN) y tiene como

objetivo las aplicaciones que requieren comunicaciones seguras con baja tasa de

envío de datos y maximización de la vida útil de sus baterías. ZigBee es un sistema

ideal para redes domóticas, específicamente diseñado para reemplazar la

proliferación de sensores/actuadores individuales. ZigBee fue creado para cubrir la

necesidad del mercado de un sistema a bajo coste, un estándar para redes Wireless

de pequeños paquetes de información, de bajo consumo eléctrico, seguro y fiable.

Si hablamos de los tipos de dispositivos, nos encontramos con tres categorías de

nodos:

El primero y más importante ya que ha de existir obligatoriamente en una red.

El Coordinador ZigBee es el nodo más completo y se encarga de controlar

toda la red y los caminos para su comunicación.

Por debajo tenemos el Router ZigBee que interconecta los nodos para poder

ejecutar código del usuario, es decir, ofrece un nivel de aplicación dentro de

la torre de protocolos.

Por último, el Dispositivo final ZigBee sólo recibe información y se comunica

únicamente con el nodo padre. La ventaja de este dispositivo es que puede

29

permanecer dormido y ‘despertarse’ en ciertos momentos para alargar la

duración de batería.

1.6.5 Tecnologías de control de datos

Originarias en su mayoría de los entornos empresariales, las tecnologías de redes

de datos se han introducido en los hogares a un ritmo vertiginoso. Si bien el

predominio de las soluciones cableadas tipo Ethernet sigue siendo claro, han

aparecido numerosas alternativas inalámbricas como WiFi o que aprovechan las

infraestructuras ya existentes en la vivienda como HomePlug, que hace uso del

cableado eléctrico, o HomePNA, que aprovecha la red y tomas telefónicas.

(Domínguez & Sáez Vacas, 2006)

Fuente: Junestrand et al (2005), ProHome (2003a)

Ethernet

La primera LAN (Red de área local) del mundo fue la versión original de

Ethernet. El primer estándar de Ethernet fue publicado por un consorcio formado

por Digital Equipment Corporation, Intel y Xerox (DIX). El estándar para

Ethernet es el 802.3. El IEEE quería asegurar que sus estándares fueran

compatibles con los del modelo OSI de la Organización Internacional para la

Estandarización (ISO). Ethernet opera a través de dos capas del modelo OSI. El

modelo ofrece una referencia sobre con qué puede relacionarse Ethernet, pero en

realidad se implementa sólo en la mitad inferior de la capa de Enlace de datos,

Tabla 4: Tecnologías de Control de Datos

30

que se conoce como subcapa Control de acceso al medio (Media Access Control,

MAC), y la capa física.

Las primeras versiones de Ethernet utilizaban cable coaxial para conectar

computadoras en una topología de bus. La capacidad de migrar la

implementación original de Ethernet a las implementaciones de Ethernet actuales

y futuras se basa en la estructura de la trama de Capa 2, que prácticamente no ha

cambiado.

Los medios físicos originales de cable coaxial grueso y fino se reemplazaron por

categorías iniciales de cables UTP. En comparación con los cables coaxiales, los

cables UTP eran más fáciles de utilizar, más livianos y menos costosos. La

topología física también se cambió por una topología en estrella utilizando hubs,

quienes concentran las conexiones.

HomePlug

HomePlug es una alianza de varias empresas que trabajan en el desarrollo de una

tecnología que permita implementar redes de área local usando la instalación

eléctrica de baja tensión de las viviendas, oficinas o industrias, evitando así la

instalación de nuevos cables. Con velocidades que, en su primera versión llega a

los 14 Mbps tal como se menciona en la tabla resumen 5. El usuario podrá

conectarse a Internet desde cualquier zona de la vivienda en donde disponga de

una toma eléctrica estándar, consiguiendo así la movilidad y flexibilidad que

necesitan la mayoría de los usuarios en sus aplicaciones cotidianas.

HomePNA

Históricamente, el HomePNA y la tecnología inalámbrica 802.11 han seguido los

mismos pasos. Ambas nacieron con el objetivo de ofrecer 2-3 Mbps de ancho de

banda (HomePNA 1.0 y 802.11) y fallaron al intentar captar la atención del

mercado. Posteriormente, fueron mejoradas para alcanzar los 10 Mbps

(HomePNA 2.0 y 802.11b (WiFi)) cifra similar a la que los usuarios están

acostumbrados con el Ethernet cableado. El objetivo es construir una red de área

local sin nuevos cables ni obras que permitan unir ordenadores, impresoras y

31

otros recursos como hubs específicos, routers ADSL o pasarelas residenciales. Al

igual que las tecnologías de bucle de acceso xDSL, la HomePNA usa el ancho de

banda libre de los cables telefónicos de la vivienda para inyectar su señal

modulada por encima de los 2 MHz. Al igual que xDSL, el HomePNA usa

modulación FDM (Frequency Division Multiplexing) formadas por multitud de

portadoras ocupando un gran ancho de banda. HomePNA es una iniciativa

desarrollada para el mercado norteamericano, donde la mayoría de las viviendas

tienen una toma telefónica en cada habitación.

IEEE 802.11 WiFi

Una red Wi-Fi es una red de comunicaciones de datos y, por lo tanto, permite

conectar servidores, PC, impresoras, etc., con la particularidad de alcanzarlo sin

necesidad de cableado. El acrónimo Wi-Fi se utiliza para identificar los productos

que incorporan cualquier tecnología sin hilos de los estándares IEEE 802.11, que

permiten la creación de redes de área local sin hilos conocidas como WLAN, y

que son plenamente compatibles con los de cualquier otro fabricante que utilice

estos estándares.

Las características generales de funcionamiento de una red Wi-Fi son las mismas

que las de una red con cableado. La particularidad es que el Wi-Fi utiliza el aire

como medio de transmisión. Los componentes básicos de una red Wi-Fi son:

• El punto de acceso (AP): es la unión entre las redes con cableado y la red WiFi,

o entre diversas zonas cubiertas por redes Wi-Fi, que actúa entonces como

repetidor de la señal entre estas zonas (celdas).

• Unas o más antenas conectadas al punto de acceso.

• Un terminal Wi-Fi. Éste puede tener forma de dispositivo externo Wi-Fi, que se

instala en el PC del usuario, o bien puede encontrarse ya integrado, como sucede

habitualmente con los ordenadores portátiles.

La mayoría de los dispositivos inalámbricos comerciales (teléfonos móviles,

televisión, radio, etc.) usan frecuencias de radio adjudicadas mediante una

licencia. Las grandes organizaciones pagan elevados cánones por el derecho de

utilizar esas frecuencias. WiFi utiliza porciones del espectro que no requieren

licencia, tales como:

32

Las bandas ISM (Industrial, Scientific and Medical) permiten el uso de

las porciones 2.4-2.5 GHz, 5.8 GHz, y muchas otras frecuencias (no

utilizadas en WiFi).

Las bandas UNII (Unlicensed National Information Infrastructure)

permiten el uso sin licencia de otras porciones del espectro de 5

GHz.HomeRF

HomeRF

HomeRF es la tecnología que compite directamente con los productos de la IEEE

802.11b y Bluetooth en la banda de 2.4 GHz. La velocidad máxima de HomeRF

es 10 Mbps, ideal para las aplicaciones caseras, aunque se manejan otras

velocidades de 5, 1.6 y 0.8 Mbps. Según el grupo de trabajo, HomeRF ofrece más

seguridad, los dispositivos consumen menos potencia que los productos de las

tecnologías contrincantes, además de permitir aplicaciones para telefonía y video.

1.6.6 Normativas

La guía 2:1996 de ISO define las normas como documentos elaborados por

consenso y aprobados por un organismo reconocido que ofrecen, para uso común

reglas, directrices o características para actividades o los resultados de éstas, con

el fin de lograr un óptimo nivel de orden en un contexto determinado.

La certificación de instalaciones domóticas se basa en la especificación de

AENOR EA0026: 2006 Instalaciones de sistemas domóticos en viviendas.

Prescripciones generales de instalación y evaluación.

La especificación técnica EA0026, confeccionada por el Comité de

Normalización AENOR 202/SC205 fue aprobada en septiembre de 2013 a nivel

europeo y se convierte en documento de referencia para la norma europea UNE-

EN 50491-6-1 "Sistemas Electrónicos para Viviendas y Edificios", que se

encuentra en fase de elaboración.

La EA0026 permite certificar instalaciones domóticas de acuerdo a una

clasificación de tres niveles que se han definido basándose en el principio de

alcanzar un nivel considerado "básico" Nivel 1, "intermedio" o Nivel 2, y el que

se corresponde con "excelente" o Nivel 3.

33

Se considera que un sistema es domótico si alcanza el Nivel 1.

1.6.7 Organismos de normalización

CENELEC: Comité Europeo de Normalización Electrotécnica y es

responsable de la normalización en el campo de la ingeniería

electrotécnica. La misión de CENELEC preparar estándares de carácter

voluntario, que ayudan a facilitar el comercio entre los países, crear nuevos

mercados, reducir los costos de cumplimiento y apoyar el desarrollo de un

mercado único europeo.

CEN el Comité Europeo de Normalización (CEN) es un catalizador de

negocios en Europa, la eliminación de las barreras comerciales para los

agentes europeos, como la industria, la administración pública, los

proveedores de servicios, los consumidores y otras partes interesadas. Su

misión es fomentar la economía europea en el comercio mundial, el bienestar

de los ciudadanos europeos y el medio ambiente. A través de sus servicios

CEN proporciona una plataforma para el desarrollo de las normas europeas y

otras especificaciones.

ETSI: Eurpean Telecommunications Standards Instiitute (ETSI) creada en

1988 produce normas de aplicación mundial para Tecnologías de

Información y Comunicación (TIC), incluyendo telefonía fija, móvil, radio y

convergentes, tecnologías aeronáuticas, de difusión y de Internet y es

reconocido oficialmente por la Unión Europea como una organización de

estándares europeos. ETSI es una asociación independiente sin fines de lucro

que tiene más 800 organizaciones miembros, procedentes de 67 países de los

5 continentes.

ITU es el organismo especializado de las Naciones Unidas encargado de

regular las tecnologías de la información y la comunicación – TIC. Desarrolla

las normas técnicas que garanticen las redes y tecnologías de interconexión a

34

la perfección, y se esfuerzan por mejorar el acceso a las TIC a comunidades

en todo el mundo.

La UIT se ha comprometido a conectar todas las personas del mundo -

dondequiera que vivan y sean cuales sean sus medios.

IEC Fundada en 1906, la IEC (Comisión Electrotécnica Internacional) es la

organización líder en el mundo para la preparación y publicación de normas

internacionales para todas las tecnologías eléctricas, electrónicas y

relacionadas. Estos son conocidos colectivamente como "electrotecnia". IEC

proporciona una plataforma para empresas, industrias y gobiernos para

reunirse, discutir y desarrollar las Normas Internacionales que requieren.

Todas las normas internacionales de la IEC representan las necesidades de

las partes interesadas de cada nación que participan en el trabajo de IEC.

1.6.8 Arduino

Arduino es una plataforma electrónica de código abierto basado en hardware y

software fácil de usar.

Arduino nació en el año 2005 en el Instituto de Diseño Interactivo de Ivrea

(Italia), centro académico donde los estudiantes se dedicaban a experimentar con

la interacción entre humanos y diferentes dispositivos (muchos de ellos basados

en microcontroladores) para conseguir generar espacios únicos, especialmente

artísticos. Arduino apareció por la necesidad de contar con un dispositivo para

utilizar en las aulas que fuera de bajo coste, que funcionase bajo cualquier sistema

operativo y que contase con documentación adaptada a gente que quisiera

empezar de cero.

El principal responsable de la idea y diseño de Arduino, y la cabeza visible del

proyecto es el llamado “Arduino Team”, formado por Massimo Banzi (profesor

en aquella época del Instituto Ivrea), David Cuartielles (profesor de la Escuela de

Artes y Comunicación de la Universidad de Mälmo, Suecia), David Mellis (por

aquel entonces estudiante en Ivrea y actualmente miembro del grupo de

investigación High-Low Tech del MIT Media Lab), Tom Igoe (profesor de la

Escuela de Arte Tisch de Nueva York), y Gianluca Martino (responsable de

35

empresa fabricante de los prototipos de las placas, cuya web oficial es:

http://www.smartprojects.it).

1.6.8.1 Hardware Arduino

Es una placa hardware libre que incorpora un microcontrolador

reprogramable y una serie de pines-hembra (los cuales están unidos

internamente a las patillas de E/S del microcontrolador) que permiten

conectar allí de forma muy sencilla y cómoda diferentes sensores y

actuadores.

No obstante, cuando hablamos de “placa Arduino”, deberíamos especificar el

modelo concreto, ya que existen varias placas Arduino oficiales, cada una con

diferentes características (como el tamaño físico, el número de pines-hembra

ofrecidos, el modelo de microcontrolador incorporado –y como consecuencia,

entre otras cosas, la cantidad de memoria utilizable–, etc.). Conviene conocer

estas características para identificar qué placa Arduino es la que nos

convendrá más en cada proyecto. (Arduino.cc, Arduino, 2019).

1.6.8.2 Arduino Mega

El Mega 2560 es una placa electrónica basada en el Atmega2560; dicha placa

tiene 54 pines digitales de entrada / salida (de los cuales 15 se pueden utilizar

como salidas PWM), 16 entradas analógicas, 4 UARTs (puertos serie de

hardware), un oscilador de 16MHz, una conexión USB, un conector de

alimentación, una cabecera ICSP, y un botón de reinicio; y es compatible de

con la mayoría de Shields Arduino. (Arduino.cc, 2019)

Figura 7: Arduino Mega

36

Fuente: https://arduino.cl/arduino-mega-2560/

ESPECIFICACIONES TÉCNICAS

En la tabla 6 se hace un listado de las características que se deben tener en cuenta al

momento de implementar un proyecto utilizando la placa Arduino que se muestra en

la figura 7.

Microcontrolador ATmega2560

Tensión de trabajo 5V

Tensión de entrada (recomendada) 7-12V

Tensión de entrada (límite) 6-20V

Pines Digitales I/O 54 (de los cuales 15 proporcionan salida PWM)

Pines de entradas Analógicas 16

DC Corriente por Pin I/O 20 mA

DC Corriente por Pin 3.3V 50 mA

Memoria Flash 256 KB de los cuales 8 KB se usan por el

bootloader

SRAM 8 KB

EEPROM 4 KB

Velocidad del reloj 16 MHz

Largo 101.52 mm

Ancho 53.3 mm

http://www.atmel.com/Images/Atmel-2549-8-bit-AVR-Microcontroller-ATmega640-1280-1281-2560-2561_datasheet.pdf

37

Peso 37 g

Tabla 5: Especificaciones Técnicas Arduino Mega

Fuente: https://store.arduino.cc/usa/arduino- mega-2560-rev3

Alimentación eléctrica

El Arduino Mega puede ser alimentado a través de la conexión USB o con una fuente

de alimentación externa.

La alimentación externa (no USB) puede venir de un adaptador de CA a CC o de una

batería.

La tarjeta puede funcionar con un suministro externo de 6 a 20 voltios. Si se alimenta

con menos de 7 V, sin embargo, el pin de 5V puede suministrar menos de cinco

voltios y la placa se puede volver inestable. Si se utiliza más de 12 V, el regulador

de voltaje se puede sobrecalentar y dañar la placa. El rango recomendado es de 7 a

12 voltios.

Los pines de alimentación son los siguientes:

VIN: A través de este pin es posible proporcionar alimentación a la placa

cuando se utiliza una fuente de alimentación externa.

5V: Podemos obtener un voltaje de 5V y una corriente de 40mA desde este

pin; que se obtiene desde el conector de alimentación de CC (7 a 12 V); sin

embargo, este suministro de energía no pasa por el regulador y en caso de

sobrecarga de tensión podría dañar la placa.

3.3V: Podemos obtener un voltaje de 3.3V y una corriente de 50mA desde

este pin.

GND: El ground (0V) de la placa.

IOREF. Este pin en la placa proporciona la referencia de tensión con la que

opera el microcontrolador. Un escudo bien configurado puede leer la tensión

del pin IOREF y seleccionar la fuente de alimentación adecuada o habilitar

traductores de tensión en las salidas para trabajar con el 5 V o 3.3 V.

(Arduino.cc, 2019)

Memoria

38

El Atmega2560 tiene 256 KB de memoria flash para almacenar el código (de la que

se utilizan 8 KB para el cargador de arranque), 8 KB de SRAM y 4 KB de EEPROM

(que puede ser leída y escrita con la biblioteca EEPROM).

(Arduino.cc, 2019)

Entrada y Salida

Cada uno de los 54 pines digitales del Mega se puede utilizar como una entrada o

como una salida, utilizando las funciones pinMode(), digitalWrite() y digitalRead().

Cada pin puede proporcionar o recibir 20 mA como condición de funcionamiento

recomendada y tiene una resistencia de pull-up (desconectada por defecto) de 20-50

k ohmios. Un máximo de 40 mA es el valor que no debe superarse para evitar daños

permanentes en el microcontrolador.

Además, algunos pines tienen funciones especializadas:

Serial: 0 (RX) y 1 (TX); Serial 1: 19 (RX) y 18 (TX); Serial 2: 17 (RX) y 16

(TX); Serial 3: 15 (RX) y 14 (TX). Usado para recibir (RX) y transmitir (TX)

TTL datos por serial. Los Pines 0 y 1 también están conectados a los pines

correspondientes ATmega8U2 USB-to-TTL Serial chip.

Interrupciones Externas: 2 (interruptor 0), 3 (interruptor 1), 18 (interruptor 5), 19

(interruptor 4), 20 (interruptor 3), y 21 (interruptor 2). Estos pines se pueden

configurar para activar una interrupción en un valor bajo, un flanco ascendente o

descendente, o un cambio en el valor.

PWM: 0 a 13. Proporciona 8-bit PWM de salida con la función analogWrite().

SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). Estos pines soportan la

comunicación SPI usando la librería SPI. Los Pines SPI también se dividen en el

encabezado de ICSP, que es físicamente compatible con Uno, Duemilanove y

Diecimila.

39

LED: 13. Hay un LED incorporado conectado al pin digital 13. Cuando este pin

está a nivel HIGH (Alto), el led se encuentra encendido, sin embargo; cuando el

pin está a nivel LOW (Bajo), éste está apagado.

I2C: 20 (SDA) y 21 (SCL). Soporta la comunicación I2C (TWI) utilizando la

librería Wire. Tenga en cuenta que estos pines no están en la misma ubicación

que los pines I2C en Duemilanove o Diecimila

El Mega 2560 tiene 16 entradas analógicas, cada una de las cuales proporcionan 10

bits de resolución (es decir, 1024 valores diferentes).

Hay un par de pines en la placa:

AREF. Tensión de referencia para las entradas analógicas. Se utiliza

con analogReference().

Reset. Llevar esta línea a nivel LOW para reiniciar el microcontrolador.

(Arduino.cc, 2019)

ATmega2560-Arduino Pin Mapping

Las ubicaciones de los pines las podemos observar en el anexo 1 y el detalle de cada

uno de ellos en la tabla del anexo 2.

Comunicación

La placa Mega 2560 tiene permite la comunicación con un ordenador, otra placa, u

otros microcontroladores a través de una serie de puertos que vienen incorporados en

esta.

La conexión USB con la PC es necesaria para programar la placa y no solo para

encenderla.

El software de Arduino (IDE) incluye un monitor serial que permite que los datos de

texto simples puedan ser enviados hacia y desde la placa. Los LEDs RX y TX de la

placa parpadean indicando que se están transmitiendo datos a través de él.

La biblioteca SoftwareSerial permite la comunicación serie en cualquiera de los pines

digitales del Mega 2560.

40

El Mega 2560 también es compatible con la comunicación TWI y SPI. El software

de Arduino (IDE) incluye una biblioteca Wire para simplificar el uso del bus

TWI. Para la comunicación SPI, utilice la biblioteca SPI.

(Arduino.cc, 2019)

Programación

La placa Mega 2560 se puede programar con el software de Arduino (IDE) y vienen

pre programadas con un cargador de arranque (bootloader) que le permite cargar un

nuevo código en ella sin el uso de un programador de hardware externo. Se comunica

utilizando el protocolo original STK500.

También puede pasar por alto el gestor de arranque y programar el microcontrolador

a través del conector ICSP (In Chip Serial Programmer).

(Arduino.cc, 2019)

1.6.8.3 Arduino Nano

El Arduino Nano es una placa pequeña, completa y fácil de utilizar basado en

el ATmega328P (Arduino Nano 3.x). Tiene más o menos la misma

funcionalidad del Arduino Duemilanove, pero en un paquete diferente (figura

8).

A continuación, en la tabla 7 se detallan las características técnicas que se

deben tener en cuenta al momento de implementar un proyecto.

Microcontroller ATmega328

Architecture AVR

Operating Voltage 5 V

Flash Memory 32 KB of which 2 KB used by bootloader

SRAM 2 KB

Clock Speed 16 MHz

Analog IN Pins 8

41

EEPROM 1 KB

DC Current per I/O Pins 40 mA (I/O Pins)

Input Voltage 7-12 V

Digital I/O Pins 22 (6 of which are PWM)

PWM Output 6

Power Consumption 19 mA

PCB Size 18 x 45 mm

Weight 7 g

Product Code A000005

Tabla 6: Especificaciones Técnicas Arduino Nano

Fuente: https://store.arduino.cc/usa/arduino-nano

Alimentación

El Arduino Nano se puede alimentar a través de la conexión USB Mini-B,

una fuente de alimentación externa no regulada de 6-20 V (pin 30) o una

fuente de alimentación externa regulada de 5 V (pin 27). La fuente de poder

se selecciona automáticamente a la fuente de voltaje más alto.

(Arduino.cc, 2019)

Memoria

El ATmega328 tiene 32 KB (con 2 KB utilizados para el cargador de

arranque). El ATmega328 tiene 2 KB de SRAM y 1 KB de EEPROM.

(Arduino.cc, 2019)

Entradas y salidas.

42

Cada uno de los 14 pines digitales del Nano se puede usar como entrada o

salida, usando las funciones pinMode (), digitalWrite () y digitalRead (). Esto

funciona a 5 voltios. Cada pin puede proporcionar o recibir un máximo de 40

mA y tiene una resistencia de pull-up interna (desconectada por defecto) de

20-50 KOhms. Además, algunos pines tienen funciones especializadas:

Serie: 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y transmitir (TX)

datos serie TTL. Estos pines se conectan a los pines correspondientes

del chip serial FTDI USB a TTL.

Interrupciones externas: 2 y 3. Estos pines se pueden configurar para

activar una interrupción en un valor bajo, un flanco ascendente o

descendente, o un cambio en el valor utilzando la función

attachInterrupt().

PWM: 3, 5, 6, 9, 10 y 11. Proporciona una salida PWM de 8 bits con

la función analogWrite ().

SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines son

compatibles con la comunicación SPI, que, aunque proporcionada por

el hardware subyacente, no se incluye actualmente en el lenguaje

Arduino.

LED: 13. Hay un LED incorporado conectado al pin digital 13.

Cuando el pin tiene un valor ALTO, el LED está encendido, cuando

el pin está BAJO, está apagado.

El Arduino Nano tiene 8 entradas analógicas, cada una de las cuales

proporciona 10 bits de resolución (es decir, 1024 valores diferentes). Por

defecto, miden desde tierra hasta 5 voltios, aunque es posible cambiar el

extremo superior de su rango utilizando la función analogReference(). Los

pines analógicos 6 y 7 no pueden usarse como pines digitales. Además,

algunos pines tienen funcionalidad especializada:

I2C: A4 (SDA) y A5 (SCL). Admite la comunicación I2C (TWI)

utilizando la librería Wire.

Hay un par de otros pines en la placa los cuales son:

43

AREF. Tensión de referencia para las entradas analógicas. Utilizado

con analogReference().

Reiniciar. Normalmente se usa para agregar un botón de reinicio a las Shields

cuando se bloquea el de la placa.

(Arduino.cc, 2019)

Comunicación

El Arduino Nano tiene una serie de instalaciones para comunicarse con una

computadora, otro Arduino u otros microcontroladores. El ATmega328

proporciona comunicación serial UART TTL (5V), que está disponible en los

pines digitales 0 (RX) y 1 (TX). Un FTDI FT232RL en la placa canaliza esta

comunicación serie a través de USB y los controladores FTDI (incluido con

el software Arduino) proporcionan un puerto de comunicaciones virtual para

el software en la computadora. El software Arduino incluye un monitor en

serie que permite enviar datos textuales simples hacia y desde la placa

Arduino. Los LED de RX y TX en la placa parpadearán cuando los datos se

transmitan a través del chip FTDI y la conexión USB a la computadora (pero

no para la comunicación en serie en los pines 0 y 1). La librería SoftwareSerial

permite la comunicación en serie en cualquiera de los pines digitales del

Nano. El ATmega328 también admite la comunicación I2C (TWI) y SPI. El

software Arduino incluye una biblioteca Wire para simplificar el uso del bus

I2C.

(Arduino.cc, 2019)

Programación

El Arduino Nano se puede programar con el software Arduino. Únicamente

se debe seleccionar "Arduino Duemilanove o Nano w / ATmega328" en el

menú Herramientas> Placa (de acuerdo con el microcontrolador en su placa).

44

El ATmega328 en el Arduino Nano viene precargado con un cargador de

arranque que le permite cargar un nuevo código sin el uso de un programador

de hardware externo. Se comunica utilizando el protocolo original STK500.

También puede omitir el gestor de arranque y programar el microcontrolador

a través del encabezado de ICSP (Programación en Serie en Circuito) usando

Arduino ISP o similar.

(Arduino.cc, 2019)

Fuente: https://arduino.cl/arduino-nano/

1.6.8.4 Otras placas oficiales de Arduino

Entre una de las placas más conocidas se encuentra la mundialmente famosa

Arduino Uno.

Arduino UNO

Arduino / Genuino Uno es una placa electrónica basada en el ATmega328P.

Cuenta con 14 pines digitales de entrada / salida (de los cuales 6 se podrán

utilizar como salidas PWM), 6 entradas analógicas, un cristal de cuarzo de 16

MHz, una conexión USB, un conector de alimentación, una cabecera ICSP y

Figura 8: Arduino Nano

45

un botón de reinicio. Contiene todo lo necesario para soportar el

microcontrolador; basta con conectarlo a un ordenador con un cable USB o

la corriente con un adaptador de CA a CC o una batería para empezar. Fue

elegido para marcar el lanzamiento de Arduino Software (IDE) 1.0.

Desde que apareció en 2010 ha sufrido tres revisiones, por lo que el modelo

actual se suele llamar UNO Rev3 o simplemente UNO R3.

El modelo del microcontrolador UNO

El microcontrolador que lleva la placa Arduino UNO es el modelo

ATmega328P de la marca Atmel. La “P” del final significa que este chip

incorpora la tecnología “Picopower” (propietaria de Atmel), la cual permite

un consumo eléctrico sensiblemente menor comparándolo con el modelo

equivalente sin “Picopower”. De todas formas, aunque el ATmega328P

pueda trabajar a un voltaje menor y consumir menos corriente que el

Atmega328 (especialmente en los modos de hibernación), ambos modelos

son funcionalmente idénticos.

Tiene una arquitectura de tipo AVR, más concretamente, el ATmega328P

pertenece a la subfamilia de microcontroladores “megaAVR”. Si se desea

saber más sobre la arquitectura AVR y los modelos y características consultar

la web de la propia empresa fabricante:

http://www.atmel.com/products/microcontrollers/avr/default.aspx). Y más

en concreto, si se desea consultar la especificación técnica del ATmega328P

ver aquí:

http://www.atmel.com/dyn/resources/prod_documents/doc8161.pdf.

Todas las patillas (también llamadas “pines”) de entrada/salida del

microcontrolador sirven para comunicar el microcontrolador con el mundo

exterior, es cierto que cada pin suele tener una determinada función

específica. Como cada modelo de microcontrolador tiene un número y

ubicación de pines diferente, en este caso podemos ver la disposición de pines

del ATmega328P en la figura 9.

http://www.atmel.com/dyn/resources/prod_documents/doc8161.pdf

46

Fuente: https://aprendiendoarduino.wordpress.com/tag/esquemas-electricos/

Observando la imagen se puede saber qué pin es el que recibe la alimentación

eléctrica (señalado como “VCC”), qué dos pines están conectados a tierra (los

señalados como “GND”), qué pines son los de E/S (señalados como PBx, PCx

o PDx) y la existencia de otros pines más específicos como el AVCC (donde

se recibe la alimentación suplementaria para el convertidor analógico-digital

interno del chip) o el AREF (donde se recibe la referencia analógica para

dicho convertidor –esto lo estudiaremos más adelante–). También se puede

observar que junto el nombre de los pines de E/S se indica entre paréntesis

las funciones especializadas que cada uno de ellos tiene en particular (además

de su función genérica de entrada/salida).

Las memorias del microcontrolador

Figura 9: Orientación de los pines y elementos en el Arduino Uno

47

Memoria Flash: memoria persistente donde se almacena permanentemente

el programa que ejecuta el microcontrolador (hasta una nueva reescritura si

se da el caso). En el caso del ATmega328P tiene una capacidad de 32KB. En

los microcontroladores que vienen incluidos en la placa Arduino no podemos

usar toda la capacidad de la memoria Flash porque existen 512 bytes (el

llamado “bootloader block”) ocupados ya por un código pre programado de

fábrica (el llamado “bootloader” o “gestor de arranque”), el cual nos permite

usar la placa Arduino de una forma sencilla y cómoda sin tener que conocer

las interioridades electrónicas más avanzadas del microcontrolador.

Memoria SRAM: memoria volátil donde se alojan los datos que en ese

instante el programa (grabado separadamente en la memoria Flash,

recordemos) necesita crear o manipular para su correcto funcionamiento.

Estos datos suelen tener un contenido variable a lo largo del tiempo de

ejecución del programa y cada uno es de un tipo concreto (es decir, un dato

puede contener un valor numérico entero, otro un número decimal, otro un

valor de tipo carácter… también pueden ser cadenas de texto fijas u otros

tipos de datos más especiales). Independientemente del tipo de dato, su valor

siempre será eliminado cuando se deje de alimentar eléctricamente al

microcontrolador. En el caso del ATmega328P esta memoria tiene una

capacidad de 2KB.

Si necesitáramos ampliar la cantidad de memoria SRAM disponible, siempre

podríamos adquirir memorias SRAM independientes y conectarlas al

microcontrolador utilizando algún protocolo de comunicación como SPI o

I2C.

Memoria EEPROM: memoria persistente donde se almacenan datos que se

desea que permanezcan grabados una vez apagado el microcontrolador para

poderlos usar posteriormente en siguientes reinicios. En el caso del

ATmega328P esta memoria tiene una capacidad de 1 KB, por lo que se puede

entender como una tabla de 1024 posiciones de un byte cada una.

48

Si necesitáramos ampliar la cantidad de memoria EEPROM disponible,

siempre podemos adquirir memorias EEPROM independientes y conectarlas

al microcontrolador utilizando algún protocolo de comunicación (SPI o I2C).

O bien, alternativamente, adquirir tarjetas de memoria de tipo SD (“Secure

Digital”) y comunicarlas mediante un circuito específico al microcontrolador.

Los registros del microcontrolador

Los registros son espacios de memoria existentes dentro de la propia CPU de

un microcontrolador. Son muy importantes porque tienen varias funciones

imprescindibles: sirven para albergar los datos (cargados previamente desde

la memoria SRAM o EEPROM) necesarios para la ejecución de las

instrucciones previstas próximamente (y así tenerlos perfectamente

disponibles en el momento adecuado); sirven también para almacenar

temporalmente los resultados de las instrucciones recientemente ejecutadas

(por si se necesitan en algún instante posterior) y sirven además para alojar

las propias instrucciones que en ese mismo momento estén ejecutándose.

Los protocolos de comunicación I2C/TWI y SPI

Cuando se desea transmitir un conjunto de datos desde un componente

electrónico a otro, se puede hacer de múltiples formas. Una de ellas es

estableciendo una comunicación “serie”; en este tipo de comunicación la

información es transmitida bit a bit (uno tras otro) por un único canal,

enviando por tanto un solo bit en cada momento. Otra manera de transferir

datos es mediante la llamada comunicación “paralela”, en la cual se envían

varios bits simultáneamente, cada uno por un canal separado y sincronizado

con el resto.

I2C (Inter-Integrated Circuit, también conocido con el nombre de TWI –de

“TWo-wIre”, literalmente “dos cables” en inglés–): es un sistema muy

utilizado para comunicar circuitos integrados entre sí. Su principal

característica es que utiliza dos líneas para transmitir la información: una

(llamada línea “SDA”) sirve para transferir los datos (los 0s y los 1s) y otra

49

(llamada línea “SCL”) sirve para enviar la señal de reloj (Véase figura 10).

En realidad, también se necesitarían dos líneas más: la de alimentación y la

de tierra común, pero estas ya se presuponen existentes en el circuito.

Por “señal de reloj” se entiende una señal binaria de una frecuencia periódica

muy precisa que sirve para coordinar y sincronizar los elementos integrantes

de una comunicación (es decir, los emisores y receptores) de forma que todos

sepan cuándo empieza, cuánto dura y cuándo acaba la transferencia de

información. En hojas técnicas y diagramas a la señal de reloj en general se

le suele describir como CLK (del inglés “clock”).

Cada dispositivo conectado al bus I²C tiene una dirección única que lo

identifica respecto el resto de dispositivos, y puede estar configurado como

“maestro” o como “esclavo”. Un dispositivo maestro es el que inicia la

transmisión de datos y además genera la señal de reloj, pero no es necesario

que el maestro sea siempre el mismo dispositivo: esta característica se la

pueden ir intercambiando ordenadamente los dispositivos que tengan esa

capacidad.

Para funcionar correctamente tanto la línea “SDA” como la “SCL” necesitan

estar conectadas mediante una resistencia “pull-up” a la fuente de

alimentación común, la cual puede proveer un voltaje generalmente de 5 V o

3,3 V. La velocidad de transferencia de datos es de 100 Kbits por segundo en

el modo estándar (aunque también se permiten velocidades de hasta 3,4

Mbit/s). No obstante, al haber una única línea de datos, la transmisión de

información es “half duplex”

SPI (Serial Peripheral Interface): al igual que el sistema I²C, el sistema de

comunicación SPI es un estándar que permite controlar (a cortas distancias)

Figura 10: Modelo de Protocolo I2C

50

casi cualquier dispositivo electrónico digital que acepte un flujo de bits serie

sincronizado (es decir, regulado por un reloj). Igualmente, un dispositivo

conectado al bus SPI puede ser “maestro” o “esclavo”, donde el primero es el

que inicia la transmisión de datos y además genera la señal de reloj (aunque,

como con I²C, con SPI tampoco es necesario que el maestro sea siempre el

mismo dispositivo) y el segundo se limita a responder.

La mayor diferencia entre el protocolo SPI y el I²C es que el primero requiere

de cuatro líneas (“cables”) en vez de dos (figura 11). Una línea (llamada

normalmente “SCK”) envía a todos los dispositivos la señal de reloj generada

por el maestro actual; otra (llamada normalmente “SS”) es la utilizada por ese

maestro para elegir en cada momento con qué dispositivo esclavo se quiere

comunicar de entre los varios que puedan estar conectados (ya que solo puede

transferir datos con un solo esclavo a la vez); otra (llamada normalmente

“MOSI”) es la línea utilizada para enviar los datos –0s y 1s– desde el maestro

hacia el esclavo elegido; y la otra (llamada normalmente “MISO”) es la

utilizada para enviar los datos en sentido contrario: la respuesta de ese esclavo

al maestro. Es fácil ver que, al haber dos líneas para los datos la transmisión

de información es “full duplex”.

RS-232

Figura 11: Modelo de Protocolo SPI

51

Es un protocolo desarrollado para la comunicación serial de dispositivos

sencillos, ampliamente utilizado debido a la facilidad de comunicación y las

ventajas en coste que representa la comunicación serial. Hace uso de

conectores de tipo DB-25, sin embargo, es común observar dispositivos con

conectores de tipo DB9, de 9 pines debido a su menor costo.

(Ramirez Suarez, 2013)

Es muy importante porque muchos dispositivos de comunicación inalámbrica

usan la comunicación serie para hablar con Arduino como los módulos

bluetooth y los módulos Xbee.

Todas las placas Arduino tienen al menos un puerto serie disponible en los

pines digitales 0 (RX) y 1 (TX) compartido con el USB. Por lo tanto no es

posible usar estos pines como entradas/salidas digitales.

Todas las placas Arduino tienen al menos un puerto serie disponible en los

pines digitales 0 (RX) y 1 (TX) compartido con el USB. Por lo tanto no es

posible usar estos pines como entradas/salidas digitales.

(Comunicación Serie Arduino, 2016)

Gestor De Arranque

En las placas Arduino viene pregrabado de fábrica un pequeño programa

llamado “bootloader” o “gestor de arranque”, que resulta imprescindible para

un cómodo y fácil manejo de la placa en cuestión. Este software (también

llamado “firmware”, porque es un tipo de software que raramente se

modifica) ocupa, en la placa Arduino UNO, 512 bytes de espacio en un

apartado especial de la memoria Flash, el llamado “bootloader block”, pero

en otros modelos de placas Arduino puede ocupar más (por ejemplo, en el

modelo Leonardo ocupa 4 Kilobytes).

La función de este firmware es gestionar de forma automática el proceso de

grabación en la memoria Flash del programa que queremos que el

microcontrolador ejecute. Lógicamente, el bootloader realizará esta

grabación más allá del “bootloader block” para no sobrescribirse a sí mismo.

52

En la placa Arduino UNO, el bootloader siempre se ejecuta durante el primer

segundo de cada reinicio. Durante esos instantes, el gestor de arranque se

espera a recibir una serie de instrucciones concretas de parte del entorno de

desarrollo para interpretarlas y realizar la correspondiente carga de un posible

programa. Si esas instrucciones no llegan pasado ese tiempo, el bootloader

termina su ejecución e igualmente se empieza a procesar lo que haya en ese

momento en la memoria Flash.

El bootloader que tiene pregrabado el ATmega328P del Arduino UNO,

basado en un firmware libre llamado Optiboot

(http://code.google.com/p/optiboot), el cual logra una velocidad de grabación

de 115 kilobits de programa a cargar por segundo gracias al uso de

instrucciones propias derivadas del “estándar” STK500.

La alimentación

El voltaje de funcionamiento de la placa Arduino (incluyendo el

microcontrolador y el resto de componentes) es de 5 V. Podemos obtener esta

alimentación eléctrica de varias maneras:

Conectando la placa Arduino a una fuente externa, tal como un adaptador

AC/DC o una pila. Para el primer caso, la placa dispone de un zócalo donde

se puede enchufar una clavija de 2,1 milímetros de tipo “jack”. Para el

segundo, los cables salientes de los bornes de la pila se pueden conectar a los

pines-hembra marcados como “Vin” y “Gnd” (positivo y negativo

respectivamente) en la zona de la placa marcada con la etiqueta “POWER”.

Conectando la placa Arduino a nuestro computador mediante un cable

USB.

Para ello, la placa dispone de un conector USB hembra de tipo B. La

alimentación recibida de esta manera está regulada permanentemente a los 5

V de trabajo y ofrece un máximo de hasta 500 mA de corriente (por lo tanto,

la potencia consumida por la placa es en ese caso de unos 2,5 W). Si en algún

momento por el conector USB pasa más intensidad de la deseable, la placa

Arduino está protegida mediante un poli fusible reseteable que

53

automáticamente rompe la conexión hasta que las condiciones eléctricas

vuelven a la normalidad.

El voltaje de salida ofrecido ha de ser de 9 a 12 V DC. En realidad, el

circuito regulador que lleva incorporado la placa Arduino es capaz de manejar

voltajes de salida (de entrada para la placa) de hasta 20 V, así que en teoría se

podrían utilizar adaptadores AC/DC que generen una salida de 20 V DC.

La intensidad de corriente ofrecida ha de ser de 250 mA (o más). Si

conectamos a nuestra placa Arduino muchos componentes o unos pocos pero

consumidores de mucha energía (como por ejemplo una matriz de LEDs, una

tarjeta SD o un motor) el adaptador debería suministrar al menos 500 mA o

incluso 1 A.

Las entradas y salidas digitales

La placa Arduino dispone de 14 pines-hembra de entradas o salidas (según lo

que convenga) digitales, numeradas desde la 0 hasta la 13. Es aquí donde

conectaremos nuestros sensores para que la placa pueda recibir datos del

entorno, y también donde conectaremos los actuadores para que la placa

pueda enviarles las órdenes pertinentes, además de poder conectar cualquier

otro componente que necesite comunicarse con la placa de alguna manera. A

veces a estos pines-hembra digitales de “propósito general” se les llama pines

GPIO (de “General Purpose Input/Output”).

Todos estos pines-hembra digitales funcionan a 5 V, pueden proveer o recibir

un máximo de 40 mA y disponen de una resistencia “pull-up” interna de entre

20 KΩ y 50 KΩ que inicialmente está desconectada (salvo que nosotros

indiquemos lo contrario mediante programación software).

Hay que tener en cuenta, no obstante, que, aunque cada pin individual pueda

proporcionar hasta 40 mA como máximo, en realidad, internamente la placa

agrupa los pines digitales de tal forma que tan solo pueden aportar 100 mA a

la vez el conjunto de los pines nº 0, 1, 2, 3 y 4, y 100 mA más el resto de pines

54

(del 5 al 13). Esto quiere decir que como mucho podríamos tener 10 pines

ofreciendo 20 mA a la vez.

Las entradas analógicas

La placa Arduino dispone de 6 entradas analógicas (en forma de pines hembra

etiquetados como “A0”, “A1”... hasta “A5”) que pueden recibir voltajes

dentro de un rango de valores continuos de entre 0 y 5 V. No obstante, la

electrónica de la placa tan solo puede trabajar con valores digitales, por lo que

es necesaria una conversión previa del valor analógico recibido a un valor

digital lo más aproximado posible. Esta se realiza mediante un circuito

conversor analógico/digital incorporado en la propia placa.

Arduino LEONARDO

El Arduino Leonardo es una placa electrónica basada en el ATmega32u4

(ficha técnica). Cuenta con 20 pines digitales de entrada / salida (de los cuales

7 se pueden utilizar como salidas PWM y 12 entradas como analógicos), un

oscilador de cristal de 16 MHz, una conexión micro USB, un conector de

alimentación, una cabecera ICSP, y un botón de reinicio. Simplemente debe

conectarlo a un ordenador con un cable USB o la corriente con un adaptador

de CA a CC o una batería para empezar.

El Leonardo difiere de todas las placas anteriores en que el ATmega32u4

tiene la comunicación incorporada del USB, eliminando la necesidad de un

procesador secundario.

Arduino/Genuino 101

Se trata de una placa que se conoce como Arduino 101 en América y Genuino

101 fuera de Estados Unidos. Genuino 101 sigue la misma filosofía de las

placas oficiales de Arduino, pero llama la atención su módulo Intel Curie, El

módulo contiene dos núcleos minúsculos, un núcleo x86 (Quark) y un núcleo

55

de arquitectura ARC de 32 bits, ambos con una frecuencia de 32MHz (una

oportunidad única de programar en una plataforma x86, alejándose de los

ATMega y los ARM), 80KB de SRAM (24KB disponible para sketches), 384

KB de memoria flash, DSP, Bluetooth, sensores acelerómetros y giroscopio,

etc. Por el resto de características, como conexiones y tamaño, es igual a

Arduino UNO y compatibles con sus shields.

Arduino YUN

El Arduino Yun es una placa electrónica basada en el ATmega32u4 y el

Atheros AR9331. El procesador Atheros compatible con una distribución

Linux basada en OpenWrt llamado Linino OS. El tablero incorporada soporte

Ethernet y WiFi, un puerto USB-A, ranura para tarjeta micro-SD, 20 pines de

entrada / salida digital (7 de ellos se puede utilizar como salidas PWM y 12

como entradas analógicas), un cristal de 16 MHz oscilador, una conexión

micro USB, una cabecera ICSP y 3 botones de reinicio.

Arduino ETHERNET

La Arduino Ethernet es una placa electrónica basada en el ATmega328 (ficha

técnica). Cuenta con 14 pines digitales de entrada / salida, 6 entradas

analógicas, un 16 MHz oscilador de cristal, un conector RJ45, un conector de

alimentación, una cabecera ICSP, y un botón de reinicio.

Los pines 10, 11, 12 y 13 están reservados para la interfaz con el módulo

Ethernet y no debe ser utilizado de otra manera. Esto reduce el número de

pines disponibles a 9, con 4 disponibles como salidas PWM.

1.6.8.5 Shields Oficiales Arduino

Las Shields son boards que nos permite extender las capacidades de las placas

Arduino. Algunas de ellas son:

Xbee: El Shield Xbee permite a una placa Arduino comunicarse de forma

inalámbrica mediante Zigbee. Se basa en el módulo Xbee de

56

MaxStream. El módulo se puede comunicar hasta 100 pies en interiores o

al aire libre de 300 pies (con la línea de visión). Actualmente es obsoleto.

Arduino Ethernet Shield: Este shield está pensado para los que le

quieren añadir a la placa Arduino UNO la capacidad de conectarse a una

red cableada TCP/IP. Aporta la misma funcionalidad que la placa Arduino

Ethernet, pero en forma de shield complementario acoplado a la placa

Arduino UNO.

Arduino Wireless SD Shield: Este shield está pensado para permitir a

una placa Arduino UNO poderse comunicar inalámbricamente mediante

el uso de un módulo XBee (adquirido aparte) o similar. Esto permite

establecer un enlace con otro dispositivo XBee a una distancia de hasta

unos 100 metros en interior y de hasta unos 300 metros en exterior con

línea de visión directa.

Arduino WiFi Shield: Pensado para los que le quieren añadir a la placa

Arduino UNO la capacidad de conectarse inalámbricamente a una red

TCP/IP. Incorpora el chip HDG104 del fabricante H&D Wireless, el cual

incluye una antena integrada y permite conectarse a redes Wi-Fi de tipo

802.11b y de tipo 802.11g. También incorpora el chip ATmega 32UC3,

un microcontrolador de 32 bits que en este shield viene pre programado

de fábrica para proporcionar una pila IP completa (TCP y UDP).

Arduino Motor Shield: Incorpora el chip L298P del fabricante

STMicroelectronics; la “P” final simplemente indica el tipo de

encapsulado que tiene, ya que para el mismo chip L298 existen otras

formas y tamaños, identificados con otras letras). Este chip está diseñado

para controlar componentes que contienen inductores –“bobinas”– en su

estructura interna, tales como relés, solenoides, motores de corriente

continua –DC– o motores paso a paso – “steppers” –, entre otros.

(Arduino.cc, Arduino, 2019)

1.6.8.6 Software Arduino

57

El código abierto Arduino Software (IDE) hace que sea fácil de escribir

código y subirlos a su tablero. Se ejecuta en Windows, Mac OS X y Linux. El

entorno está escrito en Java y basado en Processing.

Este software se puede utilizar con cualquier placa Arduino.

En la versión de escritorio el entorno de desarrollo integrado Arduino -

Arduino o software (IDE) - contiene un editor de texto para escribir código,

un área de mensajes, una consola de texto, una barra de herramientas con

botones para las funciones comunes y una serie de menús. Se conecta al

hardware Arduino y Genuino para cargar programas y comunicarse con ellos.

Si tiene una conexión a Internet fiable, puede utilizar el IDE en línea (Arduino

Web Editor). Le permitirá guardar sus bocetos en la nube, tenerlos

disponibles desde cualquier dispositivo y realizar copias de seguridad.

Siempre tendrá la versión más actualizada del IDE sin necesidad de instalar

actualizaciones o bibliotecas generadas por la comunidad.

Librerías

Las librerías proporcionan funcionalidad adicional para su uso en sketch, por

ejemplo, trabajar con el hardware o manipular los datos. Para utilizar una

librería en un sketch, selecciónelo de la pestaña Programación > Incluir

Librería > Gestionar Librería (tal como se muestra figura 12). Esto insertará

una o más “#include” (declaraciones en la parte superior del boceto) y

compile la librería con su proyecto. Debido a que las librerías se cargan en la

placa con su proyecto, se aumentan la cantidad de espacio que ocupa. Si un

sketch ya no necesita una librería, sólo tiene que borrar sus #include de la

parte superior de su código.

58

Fuente:

https://www.arduino.cc/en/Guide/Libraries

Algunas librerías se incluyen con el software de Arduino. Otros pueden ser

descargados desde una variedad de fuentes a través del gestor de

librerías. Desde la versión 1.0.5 del IDE, usted puede importar una librería de

un archivo Zip y utilizarlo en un sketch abierto.

Condiciones de uso

EL software de Arduino se le proporciona "tal cual" y no se ofrece ninguna

edición EXPRESS o implícita en cuanto a su funcionalidad, operabilidad o

uso, sin limitación de comerciabilidad, o para un propósito particular.

Arduino.cc queda exento de cualquier responsabilidad por daños directos,

indirecto, de la pérdida de ingresos, pérdida de ganancias, pérdidas resultantes

de interrupción de negocio o pérdida de datos.

(Arduino.cc, Arduino, 2019)

IDEs Alternativos

CodeBlocks (http://www.codeblocks.org): es un IDE libre y

multiplataforma para el desarrollo de aplicaciones escritas en lenguaje

Figura 12: Lista de Bibliotecas Arduino

https://www.arduino.cc/en/Guide/Libraries

59

C y C++. No obstante, se pueden escribir programas directamente en

lenguaje Arduino (y también cargarlos en la placa) mediante una

versión modificada de este software, la llamada “CodeBlocks Arduino

Edition”, descargable desde la dirección

http://www.arduinodev.com/codeblocks.

Gnoduino (http://gnome.eu.org): IDE libre que intenta imitar en

aspecto y funcionalidad al oficial, pero que evita su dependencia de

Java, ya que está escrito en otro lenguaje, Python. Esto hace que sea

especialmente ligero y rápido. No obstante, solo funciona en Linux, y

más específicamente dentro el escritorio GNOME debido a sus

dependencias.

Codebender (http://www.codebender.cc): este IDE en realidad es una

aplicación web, por lo que funciona enteramente de forma “online”

dentro del navegador, sin necesidad de instalar nada. Incluye un

completo editor de textos, un compilador y un cargador de sketches,

todo sin salir del navegador. Además, previo registro gratuito, permite

almacenar “en la nube” el conjunto de códigos realizados. Este

proyecto es libre, por lo que uno puede descargar e instalar el software

necesario para montar una plataforma Codebender propia.

Visualmicro (http://visualmicro.codeplex.com): en realidad se trata

de un complemento (“plug-in”) para usar el lenguaje Arduino dentro

del entorno de programación Visual Studio

(http://www.microsoft.com/visualstudio), de Microsoft.

Desgraciadamente, no funciona en la versión Express de este entorno

(la gratuita), por lo que se ha de comprar alguna edición superior,

como por ejemplo la Professional.

1.6.8.7 Instalación del IDE Arduino

Ubuntu

La manera más fácil de instalar el IDE de Arduino en Ubuntu es mediante

el uso de su “Centro de Software” (o cualquier otro gestor de paquetes

equivalente, tal como Synaptic o apt-get/aptitude). El paquete que

60

necesitamos se llama “Arduino” y estará disponible si tenemos activado

el repositorio “universe”. Si queremos usar el terminal de comandos para

instalar el IDE de Arduino, podríamos escribir: sudo apt-get -y install

Arduino.

Es interesante notar que Ubuntu divide el entorno de programación

Arduino en dos paquetes diferentes: el llamado “arduino”, que incluye los

ficheros que conforman la interfaz gráfica del IDE y el llamado “arduino-

core”, que incluye las herramientas fundamentales de compilación,

programación y grabación de sketches.

Cualquier sistema Linux

Para instalar el IDE de Arduino en una distribución cualquiera de Linux,

debemos ir a http://arduino.cc/en/Main/Software, la página de descargas

oficial de Arduino. Allí, bajo el apartado “Downloads”, aparecen dos

enlaces diferentes para descargar la versión del IDE Arduino para Linux.

Ambos enlaces apuntan a un archivo comprimido en formato “tgz”

alojado en el almacén de software oficial de Arduino ubicado en

http://code.google.com/p/arduino), pero un enlace corresponde a la

versión del IDE de 32 bits y el otro a la de 64 bits; descargarnos entonces

el paquete “tgz” correspondiente.

Cuando entremos dentro de la carpeta descomprimida que obtengamos,

no encontraremos ningún instalador ni nada parecido (solo una estructura

de archivos y subcarpetas que no deberemos modificar para nada) porque

de hecho, nuestro IDE ya está listo para ser usado desde este mismo

momento: tan solo deberemos clicar sobre el archivo ejecutable (en

realidad, un Shell script con permisos de ejecución) llamado “Arduino”

y, después de confirmar la opción “Ejecutar” que aparecerá en el cuadro

emergente, veremos el IDE finalmente ante nosotros.

Las dependencias

Desgraciadamente, es posible que al intentar ejecutar el IDE tal como se

describe en este apartado, obtengamos diferentes errores debidos a no

tener previamente instalados en el sistema los paquetes necesarios para

61

poder ejecutar el script “Arduino” sin problemas (es decir, por no tener

instaladas las “dependencias” del IDE Arduino).

PAQUETE UBUNTU: openjdk-7-jre

PAQUETE FEDORA: java-1.7.0-openjdk

PAQUETE UBUNTU: librxtx-java

PAQUETE FEDORA: rxtx

PAQUETE UBUNTU: gcc-avr

PAQUETE FEDORA: avr-gcc y avr-gcc-c++

PAQUETE UBUNTU: avr-libc

PAQUETE FEDORA: avr-libc

PAQUETE UBUNTU: avrdude

PAQUETE FEDORA: avrdude

Los permisos de usuario

Además de instalar todas esas dependencias, aún debemos asegurarnos de

que nuestro usuario del sistema tenga los permisos necesarios para que, al

utilizar el IDE, este pueda comunicarse a través del cable USB con la

placa. Si no hacemos esto, solamente ejecutando el IDE como usuario

“root” podremos cargar programas en el microcontrolador, lo cual no es

muy recomendable. En Ubuntu simplemente tendremos que tener la

precaución de añadir nuestro usuario al grupo de usuarios predefinido

“dialout”, abriendo un intérprete de comandos y ejecutando: sudo

usermod -a -G dialout nombredelusuario

Windows

Para instalar el IDE de Arduino en Windows 8, deberemos ir a su página

oficial de descargas: http://arduino.cc/en/Main/Software. Allí aparecerá,

bajo el apartado “Downloads”, un enlace para descargar la versión del

IDE para Windows, que no es más que un archivo comprimido en formato

Zip. Descomprimimos la carpeta y deberemos clicar sobre el archivo

ejecutable “arduino.exe” y aparecerá ante nosotros.

Sin embargo, para poder utilizar nuestra placa Arduino en la versión 8 de

Windows se necesita de ciertos drivers para poder establecer la

62

comunicación con la placa; así que debemos suponiendo que nuestra placa

es el modelo Arduino UNO, los pasos a realizar son:

1. Conectar la placa Arduino UNO mediante USB a nuestro computador.

2. Acceder al “Administrador de dispositivos” de nuestro Windows 8.

Para ello, debemos ubicarnos dentro del cuadro "Escritorio", y una vez

allí, situar el cursor del ratón en la esquina superior derecha de la pantalla.

Aparecerá un menú lateral de iconos; allí debemos seleccionar el icono

"Configuración", y seguidamente, en el panel lateral recién surgido,

debemos elegir la opción "Panel de control". Se abrirá una ventana en la

que se muestran diferentes categorías; la que nos interesa es “Sistema y

seguridad”. Clicando sobre ella podemos visualizar finalmente el enlace

que nos lleva al "Administrador de dispositivos".

3. En la lista que nos muestra el "Administrador de dispositivos", debemos

ver un “dispositivo desconocido”. Lo seleccionamos, clicamos con el

botón derecho y elegimos la opción “Actualizar software de controlador”.

4. Elegimos “Buscar software de controlador en el equipo” y navegamos

hasta la carpeta que contiene los ficheros “.inf”, los cuales incluyen la

información necesaria para que Windows pueda finalmente instalar el

driver correcto (hay un fichero “.inf” por cada modelo de placa Arduino).

La carpeta donde están estos ficheros se llama “Drivers” y está situada

dentro de la carpeta descomprimida que contiene los ficheros del IDE.

Ojo, no confundir con la subcarpeta “FTDI USB Drivers”.

5. Hemos de hacer caso omiso de la advertencia por parte de Windows de

la inexistencia de firma digital en los drivers de Arduino. Tras este paso,

el proceso de instalación debería concluir sin mayor problema. Para

comprobar que todo ha salido bien, deberíamos observar en la lista

mostrada por el “Administrador de dispositivos” un nuevo dispositivo

dentro de la categoría “Puertos (COM y LPT)” llamado “Arduino UNO

(COMxx)”, donde “xx” será un número (normalmente será el 3 o el 4,

pero puede ser otro).

Este número será importante recordarlo posteriormente para poder utilizar

nuestra placa correctamente.

63

IDE Arduino

El IDE Arduino facilita escribir código y cargarlo a las placas, la interfaz

de desarrollo contiene una barra de menú, seguido de una barra que

contiene los botones de acceso rápido, los mimos que se indican en la

figura 13, un área de edición y el área de compilación que se encuentra en

la parte inferior, en la cual se muestran los resultados de la verificación

y/o compilación.

Verificar

Cargar

programa

Nuevo

Abrir

archivo

Guardar

archivo

creado

Abrir

Monitor

Serial

Menú

rápido

Figura 13: IDE Arduino

64


1.6.8.8 Introducción del sketch al Arduino

Los componentes principales de un sketch de Arduino son:

Variables, son un espacio en memoria donde se almacenan datos y

estos datos pueden variar.

Funciones, son un trozo de código que puede ser usado/llamado desde

cualquier parte del sketch. A la función se le puede llamar

directamente o pasarle unos parámetros, en función de cómo esté

definida.

Setup() y loop(), son dos funciones especiales que es obligatorio

declarar en cualquier sketch.

Comentarios, fundamentales para documentar el proyecto

En la figura 14 podemos ver el orden en el que deberían definirse dichos

componentes.

Funcion Loop()

Funcion Setup()

Variable

Librerias

Figura 14: Componentes principales del sketch de Arduino

65


1.6.8.9 Ventajas de usar la Tecnología Arduino

Asequible - placas Arduino son relativamente baratos en comparación

con otras plataformas de micro controladores. La versión menos cara del

módulo Arduino puede ser ensamblado a mano, e incluso los módulos

premontados Arduino cuestan menos de $ 50

Multiplataforma - El software de Arduino (IDE) se ejecuta en Windows,

Macintosh OS X, y Linux. La mayoría de los sistemas de

microcontrolador se limitan a Windows.

Simple, entorno de programación clara - El software de Arduino (IDE)

es fácil de usar para los principiantes, pero lo suficientemente flexible

para los usuarios avanzados que lo aprovechan también. Para los

profesores, se basa convenientemente en el entorno de programación

Processing, para los estudiantes que aprenden a programar en ese entorno

estarán familiarizados con cómo funciona el IDE de Arduino.

El código abierto y el software extensible - El software de Arduino se

publica como herramientas de código abierto, disponible para la extensión

por los programadores experimentados. El idioma se puede ampliar a

través de bibliotecas de C ++, y la gente que quiere entender los detalles

técnicos pueden dar el salto de Arduino para el lenguaje de programación

C AVR en la que se basa. Del mismo modo, puede agregar código AVR-

C directamente en sus programas de Arduino, si así lo desea.

El código abierto y hardware ampliable - Los planes de las placas

Arduino se publican bajo una licencia de Creative Commons, por lo que

los diseñadores de circuitos experimentados pueden hacer su propia

versión del módulo, ampliándolo y mejorándolo. Incluso los usuarios con

poca experiencia pueden construir la versión de tablero del módulo con el

fin de entender cómo funciona y ahorrar dinero.

Arduino tiene una gran comunidad: muchas personas lo utilizan,

enriquecen la documentación y comparten continuamente sus ideas.

66

Las placas Arduino son reutilizables y versátiles: reutilizables porque

se puede aprovechar la misma placa para varios proyectos (ya que es muy

fácil de desconectarla, reconectarla y reprogramarla), y versátiles porque

las placas Arduino proveen varios tipos diferentes de entradas y salidas

de datos

1.7 Selección de la Metodología para el desarrollo del proyecto

1.7.1 Metodología en Cascada

El modelo de cascada original se desarrolló entre las décadas de los años 60 y 70

y se define como una secuencia de actividades, donde la estrategia principal es

seguir el progreso del desarrollo del proyecto hacia puntos de revisión bien

definidos (en inglés, milestones o checkpoints) mediante entregas programadas

con fechas precisas (en inglés, schedule). No se muestra una etapa explícita de

documentación dado que ésta se lleva a cabo en el transcurso de todo el

desarrollo. El modelo original planteaba que cada actividad debía completarse

antes de poder continuar con la siguiente actividad. Sin embargo, en una revisión

posterior se extendió el modelo, permitiendo regresar a actividades anteriores.

Algunas de las creencias del modelo de cascada son que las metas se logran mejor

cuando se tienen puntos de revisión bien preestablecidos y documentados

(dividiendo el desarrollo del software en actividades secuenciales bien definidas),

los documentos técnicos son comprensibles para usuarios y administradores no

técnicos, cada detalle de los requisitos se conoce de antemano antes de desarrollar

el proyecto (dichos detalles son estables durante el desarrollo) y las pruebas y

evaluaciones se realizan de manera eficiente al final del desarrollo.

El modelo en Cascada cuenta con las siguientes fases (figura 15), las cuales serán

adaptadas de acuerdo a nuestro proyecto.

Ingeniería y análisis del sistema. En esta primera fase se desarrollará

una investigación e identificación sobre las necesidades y problemas

hallados en los ambientes del laboratorio, el tipo de arquitectura; las

placas, sus características, especificaciones de uso y modo de

comunicación que manejan, se investigará sobre las aplicaciones

67

inmóticas, sus características, costos y especificaciones de equipos ya

existentes, además se investigaran los estándares y protocolos que rigen

este tipo de proyectos, y para finalizar se hará un estudio de los

dispositivos a controlar desde la aplicación inmótica como lo son

elementos de iluminación, alarmas, etc.

Análisis de los requisitos. Se analizan los requerimientos de los usuarios

finales para determinar qué objetivos deben cubrirse. De esta fase surge

una memoria llamada SRD (Documento de Especificación de

Requisitos), que contiene las especificaciones funcionales del sistema,

características del edificio, consideraciones sobre los modos de operación

y las interfaces de usuario, aspectos constructivos de la edificación,

implicaciones con el resto de instalaciones, limitaciones económicas, etc.

Diseño. Teniendo ya los requerimientos de funcionamiento de los

posibles elementos, se iniciará el diseño de todas las partes que

conforman el proyecto. Se descompone y organiza el sistema en

elementos que puedan elaborarse por separado. Como resultado surge un

documento en el cual deberán describirse lo siguiente:

Las aplicaciones implementadas en el sistema (por ejemplo,

detección de intrusión, automatización de la iluminación, etc.).

Elementos que intervienen en la instalación inmótica (pasarelas

residenciales, entre otros).

La ubicación de cada uno de los dispositivos inmóticos, así como

las posibles redes de cable.

Diseño de la aplicación web que nos permitirá controlar

remotamente los dispositivos electrónicos.

Identificación de la documentación que se entregara al usuario.

Construcción. Se implementa el diseño del proyecto que se hizo en la

anterior actividad. Esto es, la realización de los circuitos de control,

establecer la comunicación necesaria para el funcionamiento del

proyecto, el desarrollo de los programas haciendo uso de prototipos, así

como pruebas y ensayos para corregir errores, la configuración de las

cámaras IP y la puesta en marcha del web server, entre otros.

68

Pruebas. Cuando se tengan todas las partes que conforman el proyecto

ya hecho se pasa a unir todas estas y se hacen las pruebas pertinentes para

comprobar que se haya cumplido los objetivos propuestos desde un

principio, verificar continuamente la calidad del proyecto, es decir si el

comportamiento de los dispositivos es de acuerdo a lo especificado.

Mantenimiento. Es una de las fases finales del proyecto. En el desarrollo

surgen cambios, para corregir errores o bien para introducir mejoras.

Fuente:http://www.ptolomeo.unam.mx:8080/xmlui/bitstream/handle/132.248.52.10

0/175/A5%20Cap%C3%ADtulo%202.pdf?sequence=5

1.8 Consideraciones del diseño domótico en la vida real

Actualmente la domótica es una de las ramas de la tecnología que más importancia

está tomando en nuestras vidas y que se viene desarrollando a pasos agigantados, es

así que podemos ver que cada vez más está presente en nuestras vidas.

Figura 15: Fases del modelo Cascada

http://www.ptolomeo.unam.mx:8080/xmlui/bitstream/handle/132.248.52.100/175/A5%20Cap%C3%ADtulo%202.pdf?sequence=5

http://www.ptolomeo.unam.mx:8080/xmlui/bitstream/handle/132.248.52.100/175/A5%20Cap%C3%ADtulo%202.pdf?sequence=5

69

A la fecha han podemos observar que se han podido superar una serie de

impedimentos tales como la dependencia de a las conexiones cableadas o la baja

capacidad de procesamiento de los elementos técnicos y ahora podemos instalar

múltiples elementos y controlarlos desde un móvil de manera remota, pudiendo

simular situaciones en un determinado horario entre otras cosas.

En la actualidad las instalaciones en las viviendas y edificios permiten la

conectividad de diferentes dispositivos que nos permitan su control y automatización

y permiten la comodidad.

En el presente proyecto se detallarán los materiales que se utilizarán para poder

implementarlo en la vida real.

Materiales:

Focos

Cámara IP

Aire acondicionado

Canaletas

Cable Ethernet Cat. 5e o 6a

Servidor web

Conexión

Para la implementación de la automatización en los ambientes del laboratorio, se ha

creado un código en Arduino que permita ejecutar múltiples de funciones de control

desde un computador o teléfono móvil tan solo con tener acceso a internet por medio

de la aplicación web, en el cual con solo presionando un botón podemos apagar o

encender un loco o el aire acondicionado o del mismo modo activar o desactivar una

alarma entre otras cosas; así también a través de un panel conectado directamente al

Arduino se puede controlar exclusivamente las alarmas.

En el programa se encuentra definido quienes serán los pines de entrada (que servirán

para los sensores) quienes enviaran la información del medio ambiente para que esta

a su vez sea enviada a la base de datos a través de método GET y posteriormente se

ejecuten las acciones correspondientes definidas por el usuario o ejecutadas por el

70

Arduino mismo a través de los pines de salida enviando pulsos (donde se encuentran

conectados los actuadores)

Los cables estarán adheridos a la pared mediante canaletas para su mejor conexión;

sin embargo, también se podría optar por una conexión WiFi cambiando el módulo

Ethernet Shield por un módulo WiFi.

Para cargar los programas a los Arduinos correspondientes se deberán conectar a

través del puerto USB mediante un cable USB el cual nos dará el acceso total al

Arduino.

En este caso para poder controlar elementos que están conectados a grandes voltajes,

como por ejemplo una bombilla de nuestra casa, se deberá de modificar el código

puesto que necesitamos de un componente que por un lado se conecte a la red

eléctrica y por otro lado se pueda conectar a nuestra placa de Arduino y que esta

controle esa conexión (véase la forma de conexión de la figura 16). Para ello

disponemos de los relés, unos interruptores eléctricos que conmutan una red de alto

voltaje (por ejemplo 220V) a través de un voltaje de control mucho inferior (5V de

la Arduino UNO o 3.3V de la Arduino MKR1000).

Figura 16: Representación de bombilla conectada al Arduino

Fuente: https://programarfacil.com/blog/arduino-blog/rele-y-arduino-mkr1000/

1.8.1 Normas y Certificaciones Técnicas

Hablar de normas de seguridad en nuestro país existe es también hablar de

AENOR

AENOR

https://programarfacil.com/blog/arduino-blog/rele-y-arduino-mkr1000/

71

Ofrece a las organizaciones certificados que les ayuden a responder con éxito a

sus nuevos retos como sostenibilidad, I+D+i, seguridad, tecnologías de la

información etc.

La Norma UNE-ISO/IEC 20000-1 promueve la adopción de un enfoque de

procesos integrados para una provisión eficaz de servicios gestionados de TI, que

satisfaga los requisitos del negocio y de los clientes a través de la mejora continua

mediante el modelo PDCA.

Con la implantación de la Norma UNE-ISO/IEC 20000-1 se logra que los

servicios TI estén orientados al negocio, es decir, el objetivo básico y

fundamental del área de explotación/ producción es dar un servicio con la

máxima calidad bien a la propia organización, o bien a sus clientes externos.

El Código de Buenas Prácticas es la segunda parte de la Norma UNE-ISO/IEC

20000-2 y representa el conjunto de mejores prácticas adoptadas y aceptadas por

la industria en esta materia.

Beneficios para su empresa:

Alinear los servicios de TI a las necesidades de negocio.

Proporcionar una adecuada gestión de la calidad del servicio

de TI ofrecido.

Maximizar la calidad y eficiencia del servicio de TI.

Reducir los riesgos asociados a los servicios de TI.

Reducir costes y generar negocio.

Aumentar la satisfacción del cliente.

Visión clara de la capacidad de los departamentos de TI.

Minimizar el tiempo del ciclo de incidentes y cambios, y mejorar

resultados en base a métricas.

Toma de decisiones en base a indicadores de negocio y TI.

http://www.aenor.es/aenor/normas/normas/fichanorma.asp?tipo=N&codigo=N0048609



72

Aportar un valor añadido de confianza, mejorando su imagen de cara a

otras empresas convirtiéndose en un factor de distinción frente a la

competencia.

(AENOR Peru, 2019)

NORMA DE GESTION DE ENERGIA

La Certificación de Sistemas de Gestión Energética, según la Norma UNE

216301, se dirige especialmente a aquellas organizaciones,

independientemente de su sector de actividad o su tamaño, que quieren

demostrar que han implantado un sistema de gestión energética, hacen un

mayor uso de energías renovables o excedentes, y/o han sistematizado sus

procesos energéticos, buscando la coherencia de éstos con la política

energética de la organización.

Amparado por la Norma UNE 216301 "Sistemas de gestión energética.

Requisitos" se trata de un sistema paralelo a otros modelos de gestión (ISO

14001, ISO 9001...) para la mejora continua en el empleo de la energía, su

consumo eficiente, la disminución de los consumos de energía y los costes

financieros asociados, la reducción de las emisiones de gases de efecto

invernadero, la adecuada utilización de los recursos naturales, así como el

fomento de las energías alternativas y las renovables.

El SGE se basa en el ciclo de mejora continua PDCA (Plan - Do - Check -

Act), siendo compatible con otras medidas de ahorro y eficiencia energética.

Del mismo modo, esta nueva norma se ha diseñado de manera similar a otras

normas como ISO 14001 o ISO 9001, por lo que resulta una herramienta

complementaria, compatible e integrable con estos otros sistemas de gestión.

(AENOR PERU, s.f.)

Norma Técnica Peruana “NTP-ISO/IEC 12207:2016- Ingeniería de

Software y Sistemas. Procesos del ciclo de vida del software. 3ª Edición”

73

Esta norma establece un marco de trabajo común para los procesos del ciclo

de vida del software, con terminología bien definida, que puede servir de

referencia para la industria del software. Contiene procesos, actividades y

tareas que son aplicables durante la adquisición de un producto o servicio de

software y durante el suministro, desarrollo, operación, mantenimiento y de

los productos software. El software incluye la parte software del “firmware”.

Esta norma se aplica a la adquisición de productos y servicios de sistemas y

software, al suministro, desarrollo, operación, mantenimiento y disposición

de los productos software y de la parte software de un sistema, ya sea que se

ejecute interna o externamente a una organización. Se incluye aquellos

aspectos de la definición del sistema, necesarios para proporcionar el contexto

para los productos y servicios software. Esta norma también proporciona un

proceso que se puede emplear para definir, controlar y mejorar los procesos

del ciclo de vida del software. Los procesos, actividades y tareas de esta

norma - sea solo o en conjunto con la ISO/IEC 15288 2 - también se puede

aplicar durante la adquisición de un sistema que contiene software.

(Insituto Nacional de la Calidad, 2016)

Manejo de los Residuos de Aparatos Eléctricos y Electrónicos en el Perú

– RAEE PERÚ

El Reglamento RAEE establece los derechos y obligaciones para la adecuada

gestión y manejo de los residuos de aparatos eléctricos y electrónicos (RAEE)

a través de las diferentes etapas de manejo, generación, recolección,

transporte, almacenamiento, tratamiento, reaprovechamiento y disposición

final, involucrando a los diferentes actores en el manejo responsable con la

finalidad de mejorar las condiciones de vida, mitigar el impacto en el

ambiente y en la salud de las personas. El Reglamento también señala a las

autoridades conforme a sus competencias. Entró en vigencia a partir del

Decreto Supremo N° 001-2012-MINAM el 28 de junio del año 2012.

(Ministerio del Ambiente, 2014)

74

Organismos Internacionales de Normalización de Telecomunicaciones

TIA (Telecommunications Industry Association), fundada en 1985

después del rompimiento del monopolio de AT&T. Desarrolla normas

de cableado industrial voluntario para muchos productos de las

telecomunicaciones y tiene más de 70 normas preestablecidas.

ANSI (American National Standards Institute), es una

organización sin ánimo de lucro que supervisa el desarrollo de

estándares para productos, servicios, procesos y sistemas en los

Estados Unidos. ANSI es miembro de la Organización Internacional

para la Estandarización (ISO) y de la Comisión Electrotécnica

Internacional (International Electrotechnical Commission, IEC).

EIA (Electronic Industries Alliance), es una organización formada

por la asociación de las compañías electrónicas y de alta tecnología de

los Estados Unidos, cuya misión es promover el desarrollo de mercado

y la competitividad de la industria de alta tecnología de los Estados

Unidos con esfuerzos locales e internacionales de la política.

ISO (International Standards Organization), es una organización

no gubernamental creada en 1947 a nivel mundial, de cuerpos de

normas nacionales, con más de 140 países.

IEEE (Instituto de Ingenieros Eléctricos y de Electrónica),

principalmente responsable por las especificaciones de redes de área

local como 802.3 Ethernet, 802.5 TokenRing, ATM y las normas de

GigabitEthernet.

Normas sobre cableado estructurado

ANSI/TIA/EIA-568-B: Cableado de Telecomunicaciones en

Edificios Comerciales sobre cómo instalar el Cableado: TIA/EIA 568-

B1 Requerimientos generales; TIA/EIA 568-B2: Componentes de

cableado mediante par trenzado balanceado; TIA/EIA 568-B3

Componentes de cableado, Fibra óptica.

75

ANSI/TIA/EIA-569-A: Normas de Recorridos y Espacios de

Telecomunicaciones en Edificios Comerciales sobre cómo enrutar el

cableado.

ANSI/TIA/EIA-570-A: Normas de Infraestructura Residencial de

Telecomunicaciones.

ANSI/TIA/EIA-606-A: Normas de Administración de Infraestructura

de Telecomunicaciones en Edificios Comerciales.

ANSI/TIA/EIA-607: Requerimientos para instalaciones de sistemas

de puesta a tierra de Telecomunicaciones en Edificios Comerciales.

ANSI/TIA/EIA-758: Norma Cliente-Propietario de cableado de

Planta Externa de Telecomunicaciones.

(Unitel – Soluciones e infraestructuras Tecnológicas, 2019)

Normas técnicas sobre instalaciones eléctricas

NTP IEC 60364-1:2011 (revisada el 2016) Instalaciones eléctricas de

baja tensión. Parte 1: Principios fundamentales, determinación de las

características generales, definiciones

NTP 370.303 2003 INSTALACIONES ELECTRICAS EN

EDIFICIOS. Protección para garantizar la seguridad. Protección

contra los choques eléctricos.

NTP 370.306 2003 INSTALACIONES ELECTRICAS EN

EDIFICIOS. Protección para garantizar la seguridad. Protección

contra las sobre intensidades.

NTP 370.302 2001 (revisada el 2016) INSTALACIONES

ELÉCTRICAS EN EDIFICIOS. Selección e instalación de equipos

eléctricos. Canalizaciones

1.9 Conceptos y Definiciones

AC: Corriente Alterna

ARM: ARM es una arquitectura RISC de 32 bits y recientemente con la llegada de

su versión V8-A también de 64 Bits desarrollada por ARM Holdings.

76

ATmega328P: El Atmega328 AVR 8-bit es un Circuito integrado de alto

rendimiento que está basado un microcontrolador RISC.

CC: Corriente Continua

Corporación Echelon Propietaria de la tecnología LonWorks, y por tanto de la

tecnología del Neuron Chip necesario para todo aparato LonWorks.

Intel: Intel Corporation es el mayor fabricante de circuitos integrados del mundo,

según su cifra de negocio anual.

ISP: Programación en el sistema (ISP por las siglas del inglés: In-system

programming), también conocido como Programación serial en circuito (ICSP por

las siglas del inglés: In-Circuit Serial Programming), es la habilidad de

algunos dispositivos lógicos programables, microcontroladores y otros circuitos

electrónicos, de ser programados mientras están instalados en un sistema completo,

en lugar de requerir que el chip sea programado antes de ser instalado dentro del

sistema.

LON (Local Operating Network) Red diseñada para obtener interoperabilidad

mediante un protocolo abierto.

LonMaker Herramienta de instalación y el mantenimiento de la red, donde puede

haber aparatos de distintos fabricantes.

LonTalk El protocolo (lenguaje). Diseñado para la utilización con redes de control.

Un estándar abierto.

LonWorks La tecnología. Una familia de productos hardware y software. Soporta el

desarrollo y utilización de redes de control.

PWM: La modulación por ancho de pulsos (también conocida como PWM, siglas en

inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en

la que se modifica el ciclo de trabajo de una señal periódica.

RISC: en arquitectura computacional RISC (del Inglés Reduced Instruction Set

Computer, en español Computador con Conjunto de Instrucciones Reducidas) es un

tipo de diseño de CPU generalmente utilizado en microprocesadores o

microcontroladores.

SRM: SRAM son las siglas de la voz inglesa Static Random Access Memory, que

significa memoria estática de acceso aleatorio (o RAM estática), para denominar a

77

un tipo de tecnología de memoria RAM basada en semiconductores, capaz de

mantener los datos, mientras siga alimentada

WPAN: Personal Area Network (PAN), Red de Área Personal, es una red de

computadoras para la comunicación entre distintos dispositivos (computadoras,

puntos de acceso a internet, teléfonos celulares, PDA, dispositivos de audio,

impresoras) cercanos al punto de acceso.

Xerox: Xerox Corporation es el proveedor más grande del mundo de fotocopiadoras

de tóner y sus accesorios.

CAPITULO II

MÉTODOS Y MATERIALES

79

2. CAPITULO II: MÉTODOS Y MATERIALES

2.1 Planteamiento del proyecto

2.1.1 Identificación del escenario del proyecto

Este proyecto tiene como finalidad ofrecer una herramienta que mejore la calidad

del servicio brindado por la Facultad de Ciencias Físicas y Matemáticas a los

cientos de estudiantes y docentes que acuden a diario a las instalaciones de los

laboratorios para recibir e impartir conocimientos respectivamente.

Se desarrolla teniendo en cuenta como escenario lo antes ya mencionado y los

requerimientos que la misma presenta, permitiéndoles facilidades en el control

de los diversos ambientes y aparatos con los que cuenta, pudiendo realizar el

encendido y apagado de luces y aires acondicionados que se encuentran en cada

laboratorio a través de una aplicación web que me permitirá además monitorear

los espacios.

Entre las ventajas que presenta este proyecto es que permite que el edificio se

controle desde cualquier lugar donde se encuentren, sólo teniendo acceso al

mismo a través de la aplicación.

Resaltamos que las pruebas funcionales se realizaran en una maqueta, la misma

que es una copia fiel de la ubicación y compartimientos de los laboratorios que

se pueden apreciar en las figuras 17 y 18.

2.2 Identificación de los usuarios y áreas intervinientes

2.2.1 Áreas intervinientes

Laboratorio 1: Largo – 8.63 m / Ancho - 6m

Laboratorio 2: Largo – 8.63 m / Ancho – 7.90 m




Jefatura: Largo – 5.61m / Ancho – 4.70m

80

Pasillos 1: Largo – 10 m / Ancho – 3.85 m

Pasillos 2: Largo – 9.20 m / Ancho – 1.64 m

Fuente: Elaboración Propia


2.2.2 Usuarios

Las acciones de control de encendido y apagado de luces ventiladores y

sistema de seguridad, así como el apagado de alarmas podrán ser

ejecutadas por los usuarios que estén debidamente registrados en la base

de datos y que cuenten con un usuario y contraseña para que puedan

acceder a la aplicación.

Este sistema de control está pensado para cualquier tipo de usuarios que

no tenga como discapacidad la ausencia de visión. Sin embargo eso no

Figura 17: Laboratorio FACFYM

Figura 18: Laboratorio FACFYM

81

impedirá que los demás usuarios puedan hacer uso de las funcionalidades

habituales del edificio.

2.3 Análisis de factibilidad

2.3.1 Factibilidad operativa

El lugar donde se llevarán a cabo las investigaciones y para cual está

pensado el desarrollo del prototipo, cuenta con la infraestructura

adecuada y el personal que nos ayude a realizar las pruebas. Se dispone

del tiempo adecuado para realizar las investigaciones.

2.3.2 Factibilidad técnica

Técnicamente el desarrollo del proyecto es factible, ya que en la

actualidad las placas Arduino cuentan con el soporte necesario y la

arquitectura para soportar incluso grandes proyecto, así como el respaldo

de una comunidad que día a día implementa nuevas actualizaciones y las

comparte con el mundo entero y el costo de estas no es demasiado

elevado, además el desarrollo de la aplicación se realizara en PHP, el

mismo que permite la comunicación entre el Arduino y la base de datos

cuya implementación se realiza en MYSQL, una herramienta muy

potente.

Existe suficiente información que nos permitan sacar adelante nuestra

investigación, la misma que es obtenida a través de internet o libros, lo

cual nos permitirá desarrollar el proyecto de manera confiable

2.3.3 Factibilidad económica

El desarrollo de la investigación se encuentra dentro de los márgenes de

un proyecto económico; esto debido a que los materiales que se usan para

su elaboración ya se encuentran siendo distribuidos en el mercado

peruano a un costo muy accesible.

82

2.4 Definición de requerimientos de negocio

Análisis de requerimiento

El análisis de requerimientos de la fase uno de la metodología en cascada, es muy

importante para el desarrollo del prototipo del sistema Inmótico; puesto que es en

esta fase es donde se establece la idea, la visión del sistema y los requerimientos.

La idea se basa en desarrollar un prototipo de un sistema Inmótico; controlar las

variables del prototipo "iluminación", “confort” y “seguridad”, mediante órdenes

dadas por la aplicación web para el control remoto de la misma.

Visión: crear un prototipo de bajo costo y flexible, utilizando la tecnología Arduino

y PHP.

2.4.1 Requerimientos funcionales

Proporcionar datos como entrada al Arduino a través de la

aplicación web y este a su vez que se le indique cuál es la salida

(respuesta) esperada.

Permitir al usuario ingresar a la aplicación web y ver lo que está

ocurriendo en tiempo real o guardar archivos .jpg para poder

realizar posteriormente el reconocimiento de algún individuo en

caso de robo.

Permitir al usuario dar órdenes a través de botoneras para control

del encendido de Luces, ser procesadas en la placa Arduino y esta

posteriormente las enviara a la aplicación web para actualizar el

estado de los botones.

Permitir al usuario ingresar a través de la aplicación web y activar

o desactivar las diferentes alarmas de seguridad, así como detener

el sonido producido por una alarma y este se verá reflejado en la

pantalla led que se encuentra instalada en el prototipo. Del mismo

modo a través de un teclado instalado en la maqueta se podrá

ingresar con un usuario y contraseña para activar o desactivar una

alarma y esta se procesara en el Arduino y se enviara a la

aplicación web para la actualización del estado de los botones

correspondientes.

83

Encender luces, aires acondicionados, activar alarmas, registrar

mediciones y acciones.

Cada usuario deberá tener una clave y una contraseña para poder

tener acceso al sistema; es decir, deberá estar registrado

previamente.

Cada usuario deberá tener un nivel de acceso, lo cual le permitirá

tener ciertos privilegios o no.

Mostrar los datos de las alarmas y acciones registradas en base a

los acontecimientos ocurridos en alguno de los ambientes a través

de la aplicación web.

2.4.2 Requerimientos no funcionales

La aplicación debe ser fácil de manipular, para que cualquier

persona que no presente discapacidad visual e incluso para

aquellas que no tengan conocimientos sobre informática, puedan

hacer uso de la misma.

El software debe responder dentro de un lapso de 40 segundos a

las peticiones del usuario.

La aplicación se construirá en PHP la cual se comunicará con las

placas Arduino y a su vez tendrá acceso a una base de datos donde

se registrarán las mediciones y acciones.

La interfaz debe funcionar accediendo a la aplicación web a través

de internet. Mientras que el software Arduino debe de ser instalado

en un equipo de cómputo (ya sea PC o laptop) en caso de que se

quisiera monitorear directamente.

2.5 Diseño de la arquitectura técnica

Esta es una fase donde se planifica las actividades necesarias, especificando las

características y el diseño de la arquitectura del sistema.

Diseño arquitectónico

84

En la figura 19 se puede observar la interacción que hay entre los diferentes

elementos que conforman el sistema de automatización


En el primer proceso tal como se ve en la figura 20 el usuario interactúa con el

controlador a través de la aplicación web.

Figura 20: Diseño Arquitectónico (1er proceso)


Figura 19: Diseño Arquitectónico

85

El segundo proceso tal como se ve en la figura 18 el Arduino recoge información de

los sensores para que posteriormente sean registrados.


2.6 Diseño y desarrollo de prestación de datos

Arduino es donde se desarrollan las funciones del sistema Inmótico y quien tiene

el control de la automatización del edificio.

2.6.1 Materiales utilizados para el circuito

5 Sensores De Humo

1 Shield Geeetech Gsm/Gprs

1 Shield Ethernet

10 Leds

4 Cooler

1 Camara Ip

1 Ldr

5 Dht 22 (Humedad Y Temperatura)

1 Buzzer Modulo

Figura 21: Diseño Arquitectónico (2do proceso)

86

1 Pir

1 Sensor Magnetico De Puerta Mc _38

1 Modulo Laser + 1x Modulo Receptor

4 Sensores De Flama

1 Teclado Matricial 4 X4 Alfanumerico

1 Lcd 16 X 2

1 Pcb

Cables Y Conectores Variados

1 Arduino Nano

2 Arduino Mega

1 Fuente De Pc

1 Cargador 12v 1A

Componentes Pasivos

87

CAPITULO III

RESULTADOS Y DISCUSIÓN

88

3. CAPITULO III: RESULTADOS Y DISCUSIÓN

3.1 Identificación de situación actual

Para identificar la problemática que presentaba el laboratorio de Ingeniería en

Computación e Informática, se realizó una entrevista con el jefe de laboratorio donde

se identificaron cuáles eran las carencias respecto a la seguridad, monitoreo y control

de los ambientes las mismas que se mencionan en capítulo I, índice 1.2.1.

3.2 Definición de Escenarios

En la tabla 7 se detallan los escenarios de actuación por cada sector

89

TIPO ALARMA ESCENA ACCIÓN

Segu

rid

ad

Alarma de robo

interna

Detección de movimiento o cambia de estado el sensor

magnético mientas la alarma está activada.

Detección de movimiento cuando el nivel de luminosidad es

oscuro se encienden las luces del ambiente.

Registro de alarma, activación

de sonido y envío de mensajes

de texto.

Encendido de luz de

emergencia.

Alarma de robo

externa

Detección de interrupción de señal de sensor láser

Alarma de fuego

Detección de la medición menor al parámetro configurado en la

programación del arduino

Alarma de humo

Detección de la medición mayor al parámetro configurado en la

programación del arduino

90

Video vigilancia

Transmisión de imágenes en tiempo real

Detección de intrusión

Envío de correo electrónico,

sonido de alarma y registro de

capturas de la intrusión.

Iluminación

Encendido y apagado de focos a través de la aplicación Web o

interrupción manual.

Actualización de estados

provenientes de pulsadores y

botones.

Confort

Encendido y apagado de equipos de aire acondicionado vía Web.

Activación automática a través de la aplicación Web según el

nivel establecido en la ventana de configuración.

Encendido de led de advertencia de niveles altos de

temperatura.

Registrar mediciones de los

sensores

Tabla 7: Definición de escenario de actuación


91

3.3 Creación del Circuito

Para el diseño del esquema de intercambio de información entre los diferentes

dispositivos que compone el sistema inmótico, se eligió la arquitectura centralizada,

para la que además se tuvo que diseñar placas adicionales como las que se muestran

a continuación.

Fuente: Elaboración propia.

En la figura 22 se encuentra el esquemático de las conexiones de los sensores, iluminación

y comunicaciones principales del edificio inmótico.

Figura 22: Esquemático de la placa shield del arduino mega.

92


En la figura 23 se representa la interconexión de los sensores analógicos de la casa inmótica.


En la figura 24 se representa la interconexión de los sensores digitales de la casa inmótica

Figura 23: Esquemático de la placa shield del arduino mega.

Figura 24: Entradas digitales del arduino mega

93


En la figura 25 se representa la etapa de potencia controladoras de los LEDs que conforman el equipo luminario del laboratorio

inmótico.


En la figura 26 se representa los dos tipos de fuentes de voltaje que alimentan a la maqueta inmótica

Figura 25: Etapa de iluminación

Figura 26: Alimentación de la casa inmotica

94


En la figura 27 se representa los pines de entradas y salidas generales de un Arduino Mega

Figura 27: Shield Arduino Mega

95


En la figura 28 se representa los pines de entradas, salidas y comunicaciones del Arduino

nano.


En la figura 29 representa el display LCD de 16x2 caracteres y se representa su interconexión

con el Arduino Nano.

Figura 28: Arduino nano

Figura 29: LCD 16x2 caracteres

96

Figura 30: Teclado


En la figura 30 se representa la conexión de un teclado matricial 4x4 con el Arduino nano.

Figura 31: Periferia del Arduino Nano


En la figura 31 se representa la conexión del Arduino Nano con los siguientes elementos:

Un switch magnético para la seguridad de la puerta, un indicador luminoso led RGB, una

interfaz de comunicación RS 232 y la conexión de la fuente de voltaje.

97

3.4 Programación del Arduino

Para empezar con la programación debemos:

Conectar placa Arduino a través de cable USB al ordenador

Verificación del COM conectado

1. Conectar el Arduino de tipo B macho a la entrada del Arduino

y del otro extremo conectar a un puerto USB de la laptop o

PC.

2. Ingresar al administrador de dispositivos haciendo clic en

Equipo > Administrar y Administrador de dispositivos y

verificar que aparezca conectado el puerto del Arduino tal

como se muestra en la figura 32.

3.4.1 Conexión con el Sketch

a. Introducir sketch a la placa Arduino

b. Introducir sketch a Arduino

3.4.2 Simulación

3.4.3 Interfaces de presentación

6.1.1. Conexión con el sketch


Con el IDE Arduino para Arduino Hardware, nos va a permitir programar y

grabar la programación en la placa y a la vez permite la comunicación y el

paso de datos a través del monitor serial a través de un cable USB. El paquete

le permite realizar tareas tales como:

Adquirir datos de los sensores analógicos y digitales conectados a

la placa Arduino.

Figura 32: Administrador de dispositivos

98

Controlar otros los actuadores a través de las salidas digitales.

Controlar DC, servo, y motores paso a paso.

Transmisión de datos a través de Ethernet, entre otras.

Para empezar a trabajar con el ID Arduino en primer lugar se debe de conectar

la placa Arduino al computador tal como se observa en la figura 33 y verificar

que se encuentre parpadeando el led de encendido.


Luego de abrir el IDE se debe de ir a la pestaña Herramientas y en la opción

Placa se debe de elegir el tipo de placa que vayamos a usar del listado que

muestra la figura 34.


Luego de elegir el tipo de placa se debe seleccionar el número de puerto que

previamente hemos verificado en el Administrador de Dispositivos que esté

conectado. Para ellos se debe de ir al Menú Herramientas > Puerto >

Seleccionar Puerto (ver figura 35).

Lista de Placas

arduino ->

Seleccionar el

Seleccionar el

Figura 33: Conexión de placa arduino con el computador

Figura 34: Selección de placa en IDE Arduino

99


Una vez realizadas las configuraciones necesarias se procede con la

programación del sketch para los Arduinos empleados, para más detalle vea

el Anexo 3.

3.5 Diseño del Sistema

3.5.1 Diagramas de caso de uso

Sistema Inmótico

Nuestro Sistema Inmótico (figura 36) cuenta con los siguientes casos de uso:

administrar sistema, controlar luces y aires, gestionar alarmas y visualizar

transmisión, los actores del sistema son Usuario y Arduino.

Figura 35: Selección de puerto en IDE Arduino

100


Administrar Sistema

En este caso de uso (figura 37) se registra, modifica e inhabilita al usuario y

también se generan los reportes para los usuarios como para las alarmas.


Controlar Luces y Aires

Figura 36: Diagrama de caso de uso Sistema Inmótico

Figura 37: Diagrama de caso de uso Administrar Sistema

101

En este caso de uso (figura 38) se encienden y apagan las luces y aires

acondicionados


Gestionar Alarmas

En este caso de uso (figura 39) se activan y desactivan alarmas, así como se

generan y apagan alarmas.


Figura 38: Diagrama de caso de uso Controlar Luces y Aires

Figura 39: Diagrama de caso de uso Gestionar Alarmas

102

3.5.2 Diseño de Base de Datos

3.5.2.1 Diseño lógico

Nuestro diseño lógico cuenta con las siguientes entidades: ambiente, dispositivo, sensor, medición, alarma, acción, usuario, tal como

se muestra en la figura 40.

Figura 40: Diseño lógico de la Base de Datos


103

3.5.2.2 Diccionario de datos

Descripción de entidades y atributos

A continuación haremos una descripción de las entidades (tabla 8) y de los

atributos para cada entidad: ambiente (tabla 9), dispositivo (tabla 10), sensor

(tabla 11), medición (tabla 12), alarma (tabla 13), acción (tabla 14), usuario

(tabla 15).

Fuente: elaboración propia

Entidad: AMBIENTE

Nombre Dominio Obligatorio Descripción PK

código

ambiente

NUMBER SI Código del ambiente. SI

nombre

ambiente

STRING SI Nombre del ambiente. No


Tabla 8: Descripción de entidades y atributos

Entidades

Nombre Descripción

AMBIENTE Almacena los datos de los ambientes del laboratorio.

DISPOSITIVO Almacena datos de luces y alarmas.

SENSOR Almacena los datos de los sensores.

MEDICIÓN Almacena datos de las mediciones de sensores.

ALARMA Almacena los datos de las alarmas.

ACCIÓN Almacena datos de las acciones respecto a las alarmas

USUARIO Almacena los datos de los usuarios para el inicio de sesión.


104

Entidad: DISPOSITIVO


código dispositivo NUMBER Si Código del

dispositivo.

Si

nombre dispositivo STRING Si Nombre del

dispositivo.

No

estado dispositivo

NUMBER Si Estado del

dispositivo

(encendido o

apagado)

No

código ambiente NUMBER Si Código del

ambiente

No


Entidad: SESOR


código sensor NUMBER Si Código del sensor. Si

nombre sensor STRING

Si Nombre del sensor. No

tipo sensor STRING

Si Tipo del sensor:

Iluminación, Seguridad,

Confort.

No

estado sensor STRING

Si Estado del sensor :

Activo, Inactivo

No

Código

ambiente

NUMBER Si Código del ambiente. No




105

Entidad: MEDICIÓN


código medición NUMBER Si Código secuencial

de medición.

Si

fecha medición DATETIME

Si Fecha de la

medición.

No

hora medición DATETIME

Si Hora de la medición. No

valor medición NUMBER Si Valor de la medición No

código sensor NUMBER Si Código del sensor No


Entidad: ALARMA


código alarma NUMBER Si Código de

alarma.

Si

fecha alarma DATETIME

Si Fecha de la

alarma.

No

hora alarma DATETIME

Si Hora de la

alarma.

No

tipo alarma

STRING Si Tipo de alarma:

Robo Interno,

Robo Externo,

Fuego, Humo

No

código sensor NUMBER Si Código del

sensor

No




106

Entidad: ACCIÓN


código acción NUMBER Si Código secuencial

de acción.

Si

fecha acción DATETIME

Si Fecha de la acción. No

hora acción DATETIME

Si Hora de la acción.

acción STRING Si Acciones:

Activado,

Desactivado,

Encendido, OFF

No

código usuario NUMBER Si Código de usuario No

código sensor NUMBER Si Código de sensor No

código alarma NUMBER No Código de alarma No


Entidad: USUARIO


código usuario NUMBER Si Código de usuario Si

nombre usuario STRING Si Nombre del usuario. No

apellido paterno STRING Si Apellido paterno del

usuario

No

apellido materno STRING Si Apellido materno del

usuario

No

DNI usuario STRING Si DNI del usuario. No

sexo usuario NUMBER Si Sexo del usuario:

Femenino(0)

Masculino(1)

No

celular STRING Si Celular del usuario. No


107

Entidad: USUARIO


correo STRING Si Correo del usuario No

dirección STRING Si Dirección del usuario No

login usuario STRING Si Nombre de usuario para

el inicio de sesión.

No

contraseña

usuario

STRING Si Contraseña de usuario

para el inicio de sesión.

No

estado usuario STRING Si Estado de usuario:

Vigente, No vigente

No

cambio

contraseña

NUMBER Si Indica si su próxima

sesión en el sistema

debe de cambiar

contraseña,

(0) no cambiar

contraseña, (1) cambiar

contraseña.

No

cargo usuario STRING Si Cargo de usuario:

Jefe, Soporte, Docente

No


3.5.3 Diseño Físico

Nuestro diseño físico cuenta con las siguientes entidades: ambiente, dispositivo, sensor,

medición, alarma, acción, usuario, tal como se muestra en la figura 41.


108

Fuente: Elaboración propiaFigura 41: Diseño físico de la Base de Datos

109

3.5.3.1 Diccionario de Datos

Descripción de tablas y campos

A continuación, haremos una descripción de las tablas (tabla 16) y de los

campos para cada tabla: ambiente (tabla 17), dispositivo (tabla 18), sensor

(tabla 19), medición (tabla 20), alarma (tabla 21), acción (tabla 22), usuario

(tabla 23).



Tabla 16: Descripción de tablas y campos

Tablas

Nombre Descripción

AMBIENTE Almacena los datos de los ambientes del laboratorio.

DISPOSITIVO Almacena datos de luces y alarmas.

SENSOR Almacena los datos de los sensores.

MEDICIÓN Almacena datos de las mediciones de sensores.

ALARMA Almacena los datos de las alarmas.

ACCIÓN Almacena datos de las acciones respecto a las alarmas

USUARIO Almacena los datos de los usuarios para el inicio de sesión.


Tabla: AMBIENTE

Nombre Tipo de dato Nulo Descripción PK FK Clave

foránea

codigo_amb INT NOT

NULL

Código secuencial del

ambiente.

Si No -

nombre_amb VARCHAR(30) NOT

NULL

Nombre del ambiente. No No -

110

Tabla: DISPOSITIVO

Nombre Tipo de dato Nulo Descripción PK FK Clave foránea

codigo_dis INT NOT

NULL

Código secuencial del

dispositivo.

Si No -

nombre_dis VARCHAR(30) NOT

NULL

Nombre del

dispositivo.

No No -

codigo_amb INT NOT

NULL

Código del ambiente No Si FK_SENSOR

_AMBIENTE

estado_dis BOOLEAN NOT

NULL

Estado del dispositivo:

Apagado 0

Encendido 1

No No -




Tabla: SESOR

Nombre Tipo de dato Nulo Descripción Default PK FK Clave foránea

codigo_sen INT NOT

NULL

Código secuencial

de sensor.

- Si No -

nombre_sen VARCHAR(30)

NOT

NULL

Nombre del sensor. - No No -

tipo_sen ENUM(‘I’,’S’,’C’) NOT

NULL

Tipo del sensor:

Iluminacion ’I’

Seguridad ’S’

Confort ’C’

- No No -

estado_sen ENUM(‘A’,’I’) NOT

NULL

Estado del sensor :

Activo ’A’

Inactivo’I’

‘A’ No No -

código_amb INT NOT Código de - No Si FK_SENSOR_A


Tabla: MEDICIÓN


codigo_med INT NOT

NULL

Código secuencial

de medición.

Si No -

fechahor_med TIMESTAMP

NOT

NULL

Fecha y hora de la

medición.

No No -

valor_med INT NOT

NULL

Valor de la medición No No -

codigo_sen INT NOT

NULL

Código del sensor No Si FK_MEDICION

_SENSOR


111


Tabla:ALARMA


codigo_ala INT NOT

NULL

Código secuencial

de alarma.

Si No -

fechahor_ala TIMESTAMP

NOT

NULL

Fecha y hora de la

alarma.

No No -

codigo_sen INT NOT

NULL

Código del sensor No Si FK_ALARMA_S

ENSOR

tipo_ala ENUM(‘I’,’E’,’F

’,’H’)

NOT

NULL

Tipo de alarma:

Robo Interno ’I’

Robo Extreno’E’

Fuego ’F’

Humo ’H’

No No -


Tabla:ACCION


codigo_acc INT NOT

NULL

Código secuencial

de acción.

Si No -

fechahor_acc TIMESTAMP

NOT

NULL

Fecha y hora de la

acción.

No No -

accion_acc ENUM(‘A’,’D’,’

E’,’O’)

NOT

NULL

Acciones:

Activado ’A’

Desactivado ’D’

Encendido ’E’

No No -

NULL ambiente. MBIENTE

valormax_sen INT NULL Valor máximo del

sensor.

- No No -


112

Tabla:ACCION


OFF ’O’

codigo_usu INT NULL Código de usuario No Si FK_ACCION_US

UARIO

codigo_sen INT NOT

NULL

Código de sensor No Si FK_ACCION_SE

NSOR

codigo_ala INT NULL Código de alarma No Si FK_ACCION_AL

ARMA


Tabla: USUARIO

Nombre Tipo de dato Nulo Descripción Default PK FK Clave

foránea

codigo_usu INT NOT

NULL

Código secuencial de

usuario

- Si No -

nombre_usu VARCHAR(

50)

NOT

NULL

Nombre del usuario. - No No -

apellidopat_usu VARCHAR(

30)

NOT

NULL

Apellido paterno del

usuario

- No No -

apellidomat_usu VARCHAR(

30)

NOT

NULL

Apellido materno del

usuario

- No No -

dni_usu CHAR(8) NOT

NULL

DNI del usuario. - No No -

sexo_usu BOOLEAN NOT

NULL

Sexo del usuario:

Femenino 0

Masculino 1

- No No -

celular_usu CHAR(9) NOT

NULL

Celular del usuario. - No No -

correo_usu VARCHAR( NOT Correo del usuario - No No -


113

Tabla: USUARIO

Nombre Tipo de dato Nulo Descripción Default PK FK Clave

foránea

45) NULL

direccion_usu VARCHAR(

80)

NOT

NULL

Dirección del usuario - No No -

usuario_usu VARCHAR(

20)

NOT

NULL

Nombre de usuario para

el inicio de sesión.

- No No -

contraseña_usu VARCHAR(

6)

NOT

NULL

Contraseña de usuario

para el inicio de sesión.

- No No -

estado_usu ENUM(‘V’,’

N’

NOT

NULL

Estado de usuario

Vigente ’V’

No vigente’N’

‘V’ No No -

cambiarcon_usu BIT NOT

NULL

Indica si su próxima

sesión en el sistema debe

de cambiar contraseña

0 no cambiar password

1 cambiar password

1 No No -

cargo_usu ENUM(‘J’,’

S’,’D’)

NOT

NULL

Cargo de usuario

Jefe ’J’

Soporte’S’

Docente’D’

- No No -


3.5.4 Interfaz web

Pantalla de Acceso al sistema

La aplicación muestra una pantalla de inicio donde debe ingresarse un usuario

y su contraseña tal como se muestra en la figura 42.


114


Pantalla de inicio para jefe de laboratorio y personal administrativo

Una vez ingresado el usuario y contraseña correctos, la pantalla que se mostrará para

el jefe de laboratorio y el personal administrativo será como se muestra en la figura

43.

Figura 43: Pantalla de inicio al sistema


Figura 42: Pantalla de acceso al sistema

115

Pantalla de Luces

Una de las opciones que cuenta la aplicación es el encendido y apagado de luces, a

continuación se muestra la pantalla del menú Luces, figura 44.

Figura 44: Pantalla de luces


Pantalla de Aires Acondicionados

Otra opción con la que cuenta la aplicación es el encendido y apagado de aires

acondicionados, a continuación se muestra la pantalla del menú Aire Acondicionado,

figura 45.

Figura 45: Pantalla de Aires Acondicionados


116

Pantalla de Alarmas

La opción Alarmas de la aplicación nos permite activar y desactivar las alarmas, a

continuación se muestra la pantalla del menú Alarmas, figura 46.

Figura 46: Pantalla de Alarmas


Pantalla de Reporte de Alarmas

La opción Reportes de la aplicación contiene los reportes de alarmas y reportes de

acciones por alarmas, a continuación se muestra la pantalla del menú Reporte de

Alarmas, figura 47 y la pantalla de Reporte de Acciones por alarma, figura 48.

Figura 47: Pantalla de Reporte de Alarmas

117


Pantalla de Reporte de Acciones por Alarma

Figura 48: Pantalla de Reporte Acciones por Alarma


Pantalla de Configuraciones

La opción Configuraciones de la aplicación nos permite modificar la temperatura

máxima para que los aires acondicionados se enciendan, a continuación se muestra

la pantalla del menú Configuraciones, figura 49.

Figura 49: Pantalla de Configuraciones

118


Pantalla de Usuarios

La opción Usuarios de la aplicación nos permite buscar, registrar, modificar e

inhabilitar usuarios, la imagen muestra la pantalla del menú Usuarios, figura 50.

Figura 50: Pantalla de Usuarios


Pantalla de inicio para docentes

Una vez ingresado el usuario y contraseña correctos, la pantalla que se mostrará para

docentes será como se muestra en la figura 51.

Fuente: Elaboración propia Figura 51: Pantalla de Inicio para Docentes

119

Pantalla de restricción a docentes sin acceso a alarmas y reportes

Para los docentes están restringidas las opciones de Alarmas y Reportes, para ello se

le mostrará el siguiente mensaje, figura 52

Figura 52: Pantalla de Restricción para Docentes


3.6 Construcción de Maqueta

Para la construcción de la maqueta se tomaron medidas de los ambientes que

conforman el laboratorio para posteriormente graficarlas en el programa AutoCAD,

tal como se aprecia en la figura 53.

Fuente: Elaboración Propia Figura 53: Segundo Piso Edificio FACFYM

120

Los materiales principales utilizados para replicar el diseño a pequeña escala son

(figura 54):

MDF

Cartón doble corrugado

Mica gruesa

Palitos de cedro

Figura 54: Maqueta del Segundo Piso Edificio FACFYM


3.7 Verificación de Sensores

Para comprobar el adecuado funcionamiento de los sensores de intrusión y de mas,

se utiliza el monitor serial del IDE Arduino, tal como se observa en la figura 55, en

la cual se lista las diferentes mediciones de los sensores y las respuestas a cada acción

ejecutada por el Arduino.

121

Figura 55: Verificación de mediciones con monitor serial


122

3.8 Pruebas mínimas para el proyecto

FORMATO DE EJECUCIÓN Y RESULTADO DE PRUEBA INTERNA FUNCIONAL

1. Código de

Prueba: 01

2. Nombre de Prueba

Ingreso de usuario y clave

3. Fecha de inicio de la prueba: 08/01/2019

4. Versión de la solución: 01

5. Datos de entrada del caso de prueba:

session_start();

require_once '../bd/conexion.php';

require_once '../clases/clsUsuario.php';

$usu = new Usuarios();

$nomusu = $_POST['usuario'];

$pasusu = $_POST['clave'];

if (empty($nomusu))

{ $errors[] = "Ingresar Usuario"; }

else if (empty($pasusu))

{ $errors[] = "Ingresar Password"; }

else if ( !empty($nomusu) && !empty($pasusu) )

{

$usu->setUsuario(addslashes($nomusu));

123

$usu->setContrasenia(addslashes($pasusu));

$lstusu = $usu->Login();

if ($lstusu[0]['tipo'] == 'T')

{

//CREA LA SESSION

$_SESSION['codigo_usu'] = $lstusu[0]['codigo_usu'];

$_SESSION['estado_usu'] = $lstusu[0]['estado_usu'];

$_SESSION['apellidopat_usu'] = $lstusu[0]['apellidopat_usu'];

$_SESSION['apellidomat_usu'] = $lstusu[0]['apellidomat_usu'];

$_SESSION['nombre_usu'] = $lstusu[0]['nombre_usu'];

$_SESSION['cargo_usu'] = $lstusu[0]['cargo_usu'];

$_SESSION['cambiarcon_usu'] = $lstusu[0]['cambiarcon_usu'];

}

if ($lstusu[0]['tipo'] == 'T') {

echo $lstusu[0]['mensaje'].'-'.$lstusu[0]['tipo'].'-

'.$lstusu[0]['cambiarcon_usu'];

} else {

echo $lstusu[0]['mensaje'].'-'.$lstusu[0]['tipo'];

}

124

}

6. Procedimientos realizado en la ejecución de la prueba:

Se le ingresa la clave Vasquez2018

7. Fecha y hora de Terminación:

08/01/2019

8. Resultado Real de la Prueba:

Ingreso correctamente

9. De acuerdo con los criterios de aceptación del caso de prueba, el resultado fue:

Exitoso: _X__ No Exitoso: _______ No ejecutada: _________

125

10. Comentarios: Para los usuarios jefe de soporte y jefe de laboratorio sus claves deben de contener solo números.

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 08/01/2019


1. Código de

Prueba: 02

2. Nombre de Prueba

Registro de un nuevo

Usuario




function registrar(){

var formData = new FormData(document.getElementById("frmDatos"));

$.ajax({

url: "InsertaUsu.php",

type: "POST",

dataType: "HTML",

data: formData,

126

cache: false,

contentType: false,

processData: false

}).done(function(data){

var arrSMS = data.split('/');

if(arrSMS[0]=="T") {

var pregunta = confirm('¿Desea agregar otro usuario?');

if(pregunta)

{ window.location='RegUsuarios.php'; }

else

{ window.location='Usuarios.php'; }

}

else

{

alert(arrSMS[1]);

}

});

}

// InsertaUsu.php

if(isset($_SESSION['codigo_usu']))

{

$dni=$_POST['txtdni'];

$correo=$_POST['txtemail'];

127

$apellidoPat=ltrim(rtrim($_POST['txtapellidoPat']));

$apellidoMat=ltrim(rtrim($_POST['txtapellidoMat']));

$nombre=ltrim(rtrim($_POST['txtnombre']));

$sexo=$_POST['cboSexo'];

$direccion=$_POST['txtdireccion'];

$celular=$_POST['txtcelular'];

$usuario=$_POST['txtusuario'];

$password=$_POST['txtpassword'];

$cargo=$_POST['cboCargo'];

$usu->setDNI($dni);

$usu->setCorreo($correo);

$usu->setApellidoPaterno($apellidoPat);

$usu->setApellidoMaterno($apellidoMat);

$usu->setNombres($nombre);

$usu->setDireccion($direccion);

$usu->setCelular($celular);

$usu->setUsuario($usuario);

$usu->setContrasenia($password);

if ($sexo=="Femenino")

{ $sexo=0; }

else

{ $sexo=1; }

$usu->setSexo($sexo);

if ($cargo=="Jefe de Laboratorio")

{ $cargo='J'; }

128

else

{

if ($cargo=="Soporte")

{ $cargo='S'; }

else

{ $cargo='D'; }

}

$usu->setCargo($cargo);

$lstusu = $usu->RegistrarUsuario();

if(count($lstusu)>0)

{ echo $lstusu[0]['tipo'].'/'.$lstusu[0]['mensaje']; }

else

{ echo "error/error"; }

}else{

header('location:../index.php');

}

129


Se ingresa los datos de un nuevo usuario que no haya sido previamente registrando

7. Fecha de Terminación:

08/01/2019


Registro exitoso.



10. Comentarios: Al dar clic en el botón Guardar si los datos son correctos estos se guardarán en la Base de Datos y

automáticamente aparecerá un mensaje por si deseamos seguir registrando otro usuario.

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 08/01/2019

130


1. Código de

Prueba: 03

2. Nombre de Prueba

Buscar Usuario




if(isset($_SESSION['codigo_usu']) && isset($_POST['txtApeNombres'])){




$usu->setApellidoPaterno($_POST['txtApeNombres']);

$lstusu = $usu->BuscarUsuario();

echo "<div class='table-responsive'>";

echo "<table class='table my-5 ' id='Tabla' >

<thead>

<tr>

<th>DNI</th>

<th>Apellidos y Nombres</th>

<th></th>

<th></th>

</tr>

131

</thead>";

echo " <tbody>";

if(count($lstusu)>0){

for($i=0; $i<count($lstusu); $i++){

echo "<tr>";

echo " <td scope='row' style='display: none;'> ".$lstusu[$i]['dni_usu']."</td>";

echo " <td scope='row'> ".$lstusu[$i]['dni_usu']."</td>";

echo " <td>".$lstusu[$i]['apellidoPat_usu']." ".$lstusu[$i]['apellidoMat_usu'] ."

".$lstusu[$i]['nombre_usu'] ."</td>";

echo " <td>";

echo " <form action='ModificarUsu.php' method='POST'>";

echo " <input type='text' name='codigo' id='codigo'

value='".$lstusu[$i]['codigo_usu'] ."' style='display: none;'>";

echo " <input type='submit' class='btn btn-primary' style='background-color:

#6ECAAC; border-color: #6ECAAC;' value='Modificar'>";

echo " </form>";

echo " </td>";

echo " <td><input class='btn btn-danger Inhabilitar' type='button' name='btnInhabilitar'

value='Inhabilitar' onclick='Inhabilitar(".$lstusu[$i]['codigo_usu'] .")';></td>";

echo "</tr>";

}

}

else{

echo "<tr>";

132

echo " <td><font color='red'> No existen usuarios con los datos

digitados</font></td>";

echo "</tr>";

}

echo"</tbody>";

echo"</table>";

echo "</div>";


Se le ingresa el apellido VENTURA


09/01/2019


133

Búsqueda exitosa.



10. Comentarios: Si se no se conoce el nombre de la persona que se desea buscar solo se debe de dar clic sobre el botón

BUSCAR y se listará todos los registros.

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 09/01/2019


1. Código de

Prueba: 04

2. Nombre de Prueba

Actualización Datos de

Usuario




function modificar(){

134

var formData = new FormData(document.getElementById("frmDatos"));

$.ajax({

url: "ModUsuario.php",

type: "POST",

dataType: "HTML",

data: formData,

cache: false,

contentType: false,

processData: false

}).done(function(data){

if($.trim(data)=="exito")

{ window.location='Usuarios.php'; }

Else { alert(data); }

});

}

//ARCHIVO ModUsuario.php

if(isset($_SESSION['codigo_usu']))

{

$codigo=$_POST['codigo'];

$dni=$_POST['txtdni'];

$correo=$_POST['txtemail'];

$apellidoPat=ltrim(rtrim($_POST['txtapellidoPat'])); //addslashes

$apellidoMat=ltrim(rtrim($_POST['txtapellidoMat']));

$nombre=ltrim(rtrim($_POST['txtnombre']));

135

$sexo=$_POST['cboSexo'];

$direccion=$_POST['txtdireccion'];

$celular=$_POST['txtcelular'];

$cargo=$_POST['cboCargo'];

if ($sexo=="Femenino"){ $sexo=0; }

else{ $sexo=1; }

if ($cargo=="Jefe de Laboratorio") { $cargo='J'; }

else

{

if ($cargo=="Soporte") { $cargo='S';}

Else { $cargo='D'; }

}

$usu->setCodigo($codigo);

$usu->setApellidoPaterno($apellidoPat);

$usu->setApellidoMaterno($apellidoMat);

$usu->setNombres($nombre);

$usu->setDNI($dni);

$usu->setCorreo($correo);

$usu->setSexo($sexo);

$usu->setDireccion($direccion);

$usu->setCelular($celular);

$usu->setCargo($cargo);

$lstuser = $usu->ModificarUsuario();

136

echo "exito";


Se le agrega el segundo nombre (Meilin)


13/01/2019


Actualización Correcta



137

10. Comentarios: Para actualizar los datos se valida los campos DNI, Teléfono, Correo, Nombres y Apellidos.

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 13/01/2019


1. Código de

Prueba: 05

2. Nombre de Prueba

Inhabilitar usuario




function Inhabilitar(codigo)

{ //alert(codigo);

var pregunta = confirm('¿Desea Inhabilitarlo?');

if (pregunta)

{

// si pone aceptar registramos

$.post('Inhabilitar.php',

{ txtcodigo:codigo },function(data){ location.reload(); });

138

}

else // si pone cancelar

return false;

}

if(isset($_SESSION['codigo_usu'])){


$usu->setCodigo($_POST['txtcodigo']);

$lstusu = $usu->InhabilitarUsuario();

}else{

header('../location:index.php');

}

139


Se inhabilita al usuario LEIVA CASTILLO


13/01/2019


Inhabilitación Correcta



10. Comentarios: Una vez inhabilitado el usuario no se mostrará en la lista de usuarios.

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 13/01/2019

140


1. Código de

Prueba: 06

2. Nombre de Prueba

Cambiar Contraseña





$Cargo=$_SESSION['cargo_usu'];

if(isset($_SESSION['codigo_usu']) && isset($_POST['claveant']) &&

isset($_POST['clavenw1']) && isset($_POST['clavenw'])){

$clvant = $_POST['claveant'];

$clvnw = $_POST['clavenw'];

$clvnw1 = $_POST['clavenw1'];

$codusu=$_SESSION['codigo_usu'];

if($clvnw1==$clvnw){

if (strlen($clvnw)>5) {

if ($clvant!=$clvnw) {




$usu->setCodigo($codusu);

$usu->setContrasenia($clvant);

$usu->setCambiarContrasenia($clvnw);

141

$lstusu = $usu->CambiarContrasenia();

if($lstusu[0]['tipo'] == 'F'){

$Mensaje= $lstusu[0]['mensaje'];

echo "<br><center><font color='red' focus();>".$Mensaje."</font></center>";

}else{

if($Cargo=='J'){

echo"<script type='text/javascript'>

alert('La contraseña ha sido actualizada');

var signo='$';

window.location='xmlUsuario.php?state=' +signo + $clvnw +signo + '&number=1';

</script>";

}

if($Cargo=='S'){

echo"<script type='text/javascript'>


var signo='$';

window.location='xmlUsuario.php?state=' +signo + $clvnw +signo + '&number=3';

</script>";

}else{

echo "<script type='text/javascript'>


window.location='../principal.php';

</script>";

142

}

}

}else

echo"<br><center><font color='red' focus();>"."La nueva clave debe ser diferente a la

antigua"."</font></center>";

}else{

echo "<br><center><font color='red' focus();>"."La nueva clave debe tener por lo menos seis

caracteres"."</font></center>";

}

}else{

echo "<br><center><font color='red' focus();>"."La nueva clave no

coinicide"."</font></center>";


143

Se cambia la clave anterior 654321 por Leiva1


14/01/2019


Inhabilitación Correcta



10. Comentarios:

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 14/01/2019


144

1. Código de

Prueba: 07

2. Nombre de Prueba

Listado de

Alarmas/Acciones




if(mysqli_num_rows($consulta2)>0){

$i=1;

while($fila = mysqli_fetch_array($consulta2))

{

echo "<tr>";

$cont=$i++;

echo "<th scope='row'>".$cont. "</th>";

if($fila[1] == 'E'){

echo "<td>Robo Externo</td>";

}

else{

if($fila[1] == 'I'){

echo "<td>Robo Interno</td>";

}

else{

if($fila[1] == 'F'){

echo "<td>Fuego</td>";

}

145

else{

echo "<td>Humo</td>";

}

}

}

echo "<td>".$fila[2]."</td>";



echo "</tr>";

}

}

echo"</tbody>";

echo"</table>

146


En el tipo de alarma se selecciona alarma de robo interno y en fecha inicial 01/03/2019 y fecha final 20/07/2019


22/01/2019


Listado correctamente



10. Comentarios: Para el caso del reporte de acciones se procede de la misma forma y con la misma lógica.

Ejecución del

caso de Prueba

Nombre: Diana Primo

Fecha: 22/01/2019


147

1. Código de

Prueba: 08

2. Nombre de Prueba

Encendido y Apagado de

Luces




session_start();


require_once '../clases/clsEstado.php';

$est = new Estados();

if (isset($_SESSION['codigo_usu']) )

{

//DATOS DE ILUMINACION

$codigo = $_GET['codigo'];

$valor = $_GET['valor'];

$accion = $_GET['accion'];

//DATOS DE SENSOR

//$numSensor = $_GET[];

$accionSensor = $_GET['acc_Sensor'];

$arr = array();

if($accion == 0) //LEER ESTADOS

148

{

$lstEst = $est->ObtenerValor_Estado();

if(count($lstEst)>0)

{

for($j=0;$j<(count($lstEst));$j++)

{

if($lstEst[$j]['codigo_est']>=1 && $lstEst[$j]['codigo_est']<=9)

{

$cod = $lstEst[$j]['codigo_est'];

$est = $lstEst[$j]['valor_est'];

$txt_est = $lstEst[$j]['estado'];

$color = $lstEst[$j]['color'];

$btnHTML = $lstEst[$j]['boton'];

//VALORES PARA EL XML

if($cod == 1) { $btnXML = 0; }

if($cod == 2) { $btnXML = 1; }

if($cod == 3) { $btnXML = 2; }

if($cod == 4) { $btnXML = 3; }

if($cod == 5) { $btnXML = 4; }

if($cod == 6) { $btnXML = 5; }

if($cod == 7) { $btnXML = 6; }

if($cod == 8) { $btnXML = 7; }

if($cod == 9) { $btnXML = 8; }

149

if($est == 1) { $estXML = 'ON'; } else { $estXML = 'OFF'; }

$arr[] = array('codigo' => $cod,

'botonHTML' => $btnHTML,

'estado' => $est,

'lblestado' => $txt_est,

'color' => $color,

'botonXML' => $btnXML,

'estadoXML' => $estXML);

//CAMBIA VALORES EN XML

$devicenumber = $btnXML; //BOTON 1

$xml = simplexml_load_file("test.xml") or die("Error:Cannot create

object");

if($estXML == "ON")

$xml->device[(int)$devicenumber]->state = "ON";

else

$xml->device[(int)$devicenumber]->state = "OFF";

$xml->asXML("test.xml");

}

}

//$arr[] = array('codigo' => $cod, 'nombre' => 'Maria');

$valLuces = json_encode($arr);

}

150

}

else //ACTUALIZAR ESTADOS

{

$est->setCodigo($codigo);

$est->setValor($valor);

$lstEst = $est->CambiarValor_Estado();

if(count($lstEst)>0)

{

for($j=0;$j<(count($lstEst));$j++)

{

if($lstEst[$j]['codigo_est']>=1 && $lstEst[$j]['codigo_est']<=9)

{

$cod = $lstEst[$j]['codigo_est'];

$est = $lstEst[$j]['valor_est'];

$txt_est = $lstEst[$j]['estado'];

$color = $lstEst[$j]['color'];

$btnHTML = $lstEst[$j]['boton'];

//VALORES PARA EL XML

if($cod == 1) { $btnXML = 0; }

if($cod == 2) { $btnXML = 1; }

if($cod == 3) { $btnXML = 2; }

if($cod == 4) { $btnXML = 3; }

if($cod == 5) { $btnXML = 4; }

if($cod == 6) { $btnXML = 5; }

151

if($cod == 7) { $btnXML = 6; }

if($cod == 8) { $btnXML = 7; }

if($cod == 9) { $btnXML = 8; }

if($est == 1) { $estXML = 'ON'; } else { $estXML = 'OFF'; }

$arr[] = array('codigo' => $cod,

'botonHTML' => $btnHTML,

'estado' => $est,

'lblestado' => $txt_est,

'color' => $color,

'botonXML' => $btnXML,

'estadoXML' => $estXML);

}

}

$valLuces = json_encode($arr);

}

//CAMBIA VALORES EN XML

$updatestate = $_GET["state"];

$devicenumber = $_GET["number"];

$xml = simplexml_load_file("test.xml") or die("Error:Cannot create object");

if($updatestate == "ON")

$xml->device[(int)$devicenumber]->state = "ON";

else

$xml->device[(int)$devicenumber]->state = "OFF";

$xml->asXML("test.xml");

152

}

echo $valLuces;

}


Se encienden los botones las luces de los laboratorios 1 4 y 5

Se apagan los botones de las luces de los laboratorios 1, 4 y 5


04/02/2019


Encendido correctamente

153

Apagado Correctamente.



10. Comentarios: Al hacer clic sobre los botones, se envía el código del botón y el número del botón para que sea

actualizada la tabla estados y el archivo XML respectivamente se actualiza automáticamente, para posteriormente ser

leído por el Arduino. Si se da clic sobre el botón apagar todos se envían todos los códigos para ser actualizados.

Ejecución del

caso de Prueba

Nombre: Yoreli Vasquez

Fecha: 04/02/2019


1. Código de

Prueba: 9

2. Nombre de Prueba

Activación de aire

acondicionado en

Automático


154



function ActivarDesactivar(){

var c=document.getElementById("b10")

var x=c.textContent;

button7.style.backgroundColor="#616A6B";

if(x=="Desactivar Automaticamente"){

button7.innerText="Activar Automaticamente";

window.location="xmlupdateA.php?state=OFF&number=6";

}

else if(x=="Activar Automaticamente"){

button7.innerText="Desactivar Automaticamente";

window.location="xmlupdateA.php?state=ON&number=6";

}

}

//LECTURA DE LOS VALORES MAX DE ACUERDO AL CODIGO DEL SENSOR

if (isset($_SESSION['codigo_usu']) ) {

$miconexion = new Conexion();

$conexion = $miconexion->conectar();

$query1 = "call pa_leerSensor(1)";

$consulta1= mysqli_query($conexion, $query1);

$fila1 = mysqli_fetch_array($consulta1);

155

mysqli_close($conexion);

}


Se dio Clic sobre el botón Activar Automáticamente.


04/02/2019


Encendido correctamente

Apagado Correctamente.


156


10. Comentarios: Cuando se activa la función activar automáticamente se leen los valores máximos guardados en la

tabla sensor para ser comparados con las mediciones que realiza el Arduino y si una de ellas es mayor o igual al valor

máximo registrado este se enciende.

Ejecución del

caso de Prueba


Fecha: 09/02/2019


1. Código de

Prueba: 10

2. Nombre de Prueba

Actualización de valores

máximos




// MOSTRAR EL VALOR MAXIMO EN LOS TEXBOX

<?php

157

require_once '../clases/clsSensor.php';


$sen = new Sensores();

$sen->setCodigoSen(1);

$lstsen = $sen->LeerValor();

if(count($lstsen)>0)

{

for($i=0; $i<count($lstsen); $i++)

{

?>

<input type="text" class="form-control txtValor2" id="txtValor2"

name="txtValor[]"

onKeyPress="return SoloNum(this,event);"

value="<?=$lstsen[$i]['valormax_sen']?>">

<?php

}}

//INSERTA EL VALOR MAXIMO

<?php

require("../bd/conexion.php");

session_start();


require_once '../clases/clsSensor.php';

158


$sen = new Sensores();

$valor=$_POST['txtValor'];

$codSensor = '9, 1, 6, 7, 8';

$cadena = explode(',', $codSensor);

for ($x = 0; $x < count($valor); $x++)

{

$sen->setValormaxSen($valor[$x]);

$sen->setCodigoSen($cadena[$x]);

$lst = $sen->InsertaValorMax();

}

echo $lst[0]['tipo'];

}else{

header('location:../index.php');

}

159


Se le ingresa el 24 en temperatura máxima de laboratorio 1


09/02/2019


Actualizado correctamente



160

10. Comentarios: El Valor máximo ingresado en la ventana de configuración nos permitirá establecer un límite antes

de activarse el/los aires acondicionados.

Ejecución del

caso de Prueba


Fecha: 09/02/2019


1. Código de

Prueba: 11

2. Nombre de Prueba

Activar / Desactivar

Alarmas




function ActDes_AlaInt(idBoton)

{

codigoBoton = idBoton;

var estado = document.getElementById("btn_" + idBoton).innerText;

accion = 1;

if(estado =="Desactivar" || estado =="Apagar Buzzer")

161

{

if (estado =="Desactivar")

{ var pregunta = confirm('¿Está seguro de desactivar alarma?'); }

else

{ var pregunta = true; }

if (pregunta)

{

if(estado == "Desactivar" || estado == "Apagar Buzzer")

// { document.getElementById('btn_15').style.display = 'inline';

}

//POR CAMBIAR >> COMO OCULTAR UN BOTON EN JAVASCRIPT

//VALOR QUE SE PASARÁ A LA BD(TABLA ESTADO) - 0.APAGADO 1.ENCENDIDO

valor_est = 0;

//VALOR QUE SE PASARÁ A LA BD(TABLA ACCION) - A.ACTIVO D.DESACTIVADO

accion_acc = 'D'

//VALORES QUE SE PASARÁ AL XML

estadoXML = 'OFF';

numeroXML = 0;

CambiarEstado_AlaInt();

}

else

{


valor_est = 1 ;

162


accion_acc = 'A'


estadoXML = 'ON';

numeroXML = 0;

}

}

else if(estado == "Activar")

{


valor_est = 1;


accion_acc = 'A'


estadoXML = 'ON';

numeroXML = 0;

CambiarEstado_AlaInt();

}

163

accion = 0;

}


Se activa las alarmas de Robo Interno y la alarma de Humo y posteriormente se desactiva la alarma de Robo Interno.


15/02/2019


Activado y Desactivado correctamente



164

10. Comentarios:

Ejecución del

caso de Prueba


Fecha: 15/02/2019


1. Código de

Prueba: 12

2. Nombre de Prueba

Registrar Acción




function CambiarEstado_AlaInt()

{

var codigo_est = 0;

if (accion == 0) //SI LA PAGINA ESTA LEYENDO

{ codigo_est = ""; }

else // SI SE HIZO CLIC PARA ACTIVAR/DESACTIVAR

{

codigo_est = codigoBoton;

165

//PARA ENVIAR LOS SENSORES A GUARDAR EN LA TABLA ACCION

if(codigo_est == 10)

{ codigo_sen = "3,5"; }

else if(codigo_est == 11)

{ codigo_sen = "14"; }


{ codigo_sen = "2,10,11,12"; }


{ codigo_sen = "13"; }


{ codigo_sen = ""; } //2,3,5,10,11,12,13,14

}

//ARCHIVO ActEstadosPrueba.php REGISTRA ACCION

$arrCodSensor = explode(",", $codigoSensor);

for ($i=0; $i < count($arrCodSensor) ; $i++)

{

$acc->setAccion($accionSensor);

$acc->setCodigoUsuario($_SESSION['codigo_usu']);

$acc->setCodigoSensor( $arrCodSensor[$i]);

$lstAcc = $acc->RegistrarAccion();

166

}


Se activa las alarmas de Robo Interno


15/02/2019


Registro correcto



167

10. Comentarios: Dependiendo de la alarma que se active o desactive se Registran las acciones para los sensores

correspondientes.

Ejecución del

caso de Prueba


Fecha: 15/02/2019


1. Código de

Prueba: 13

2. Nombre de Prueba

Registrar Mediciones




$med = new Mediciones();

$est = new Estados();

$alar = new Alarmas();

$acc = new Acciones();

$val1 = $_GET['valor1']; // temperatura

$val2 = $_GET['valor2'];// fuego

$val3 = $_GET['valor3'];//movimeinto

168

...

$med->setCodigoSen(1);

$med->setValorMed($val1);

$med->RegistrarMedicion();








Se envía los datos desde el Arduino hasta el archivo salvardatos.


30/01/2019

169


Registro Correcto



10. Comentarios:

Ejecución del

caso de Prueba


Fecha: 30/01/2019

170

3.9 Resultado de pruebas de simulación

Tabla 24: Resultado de pruebas de simulación

N° Indicador Descripción Objetivo MEDICION

1

SEGURIDAD

Tiempo promedio de lectura de

números telefónicos para envío

de SMS

Determinar el tiempo en leer

los números telefónicos

Reducir el tiempo de lectura de

números telefónicos 40 segundos

2 Tiempo promedio para activar

una alarma.

Determinar el tiempo en

realizar una acción en el

laboratorio

Reducir el tiempo promedio en


laboratorio

16 segundos

3 ILUMINACION Tiempo promedio para

encender y apagar focos.



laboratorio



laboratorio

10 segundos

4 CONFORT


encender y apagar aires

acondicionados



laboratorio



laboratorio

12 segundos

171


172

3.10 Análisis de Costos

3.10.1 Costos de implementación

Cantidad Descripción Precio

Unitario (S/.)

Precio

TOTAL

(S/.)

27 Tubo de luz fluorescente S/ 13.00 S/ 351.00

6 Sensor de temperatura S/ 11.00 S/ 66.00

6 Relé Relay Estado Solido 4 Canales Ssr

G3mb-202p Arduino S/ 17.00 S/ 102.00

6 Aire acondicionado S/ 1,500.00 S/ 9,000.00

3 Cable Mellizo 2x12 Marca Ulix, Rollo 100

Metros S/ 35.25 S/ 105.75

7 Mc 38 Sensor Magnético De Puerta S/ 8.00 S/ 56.00

7 Arduino Mega 2560 R3 S/ 50.00 S/ 350.00

1 Shield Ethernet W5100 Arduino Cnc Pic S/ 50.00 S/ 50.00

7 Sensor De Fuego Para Arduino S/ 4.00 S/ 28.00

6 Sensor Pir Detector De Movimiento S/ 3.00 S/ 18.00

1 Diodo Laser Rojo 5mw 650nm S/ 26.13 S/ 26.13

1 Fotodiodo Bpw34 S/ 7.86 S/ 7.86

1 Soporte Ajustable Para Diodo Laser S/ 38.70 S/ 38.70

3 Cinta LED WS2812B: 10 LEDs x 16cm S/ 12.00 S/ 36.00

1 Teclado matricial de botones plásticos S/ 10.00 S/ 10.00

1 Display LCD Gráfico 128x64 S/ 19.00 S/ 19.00

7 Fuente de alimentación DC para Arduino

9VDC/1A S/ 21.00 S/ 147.00

5 Sensor de Gas MQ2 S/ 10.00 S/ 50.00

32 Fuente para proyectos 3W - 5V/0.6A S/ 20.00 S/ 640.00

1 Módulo Wireless Gsm Sim900 Quad Band

Shield Arduino S/ 189.99 S/ 189.99

27 Placa lectora de interruptores de luminaria S/ 10.00 S/ 270.00

1 Kit 8 Cámaras Ip S/ 2,600.00 S/ 2,600.00

1 Mano de obra de instalación S/ 3,000.00 S/ 3,000.00

1 Televisor LG LED 43" FHD Smart TV S/ 1,200.00 S/ 1,200.00

1 Rollo de cable de Red Cat6 S/ 410.00 S/ 410.00

10 Conectores Rj45 Cat6 Marca Amp S/ 0.50 S/ 5.00

173

1 Programa informático S/ 1,000.00 S/ 1,000.00

1 Servicio de Hosting (Mensual) S/ 70.00 S/ 70.00

TOTAL 19,846.43

Tabla 25: Costos de implementación


PRESUPUESTO GLOBAL DE LA PROPUESTA POR

FUENTES DE FINANCIACION (En miles de S./)

RUBROS TOTAL

Materiales de Equipamiento S/ 15,776.43

Servicios S/ 1,070.00

Mano de Obra S/ 3,000.00

TOTAL S/19,846.43

Tabla 26: Resumen de Costos


3.11 Análisis de Rentabilidad del Proyecto

Para un proyecto de estas características se debe realizar una inversión media que no

supera los S/19,846.43 soles. El 75% de la inversión está compuesto por

equipamiento electrónico e informático y el 15% por la mano de obra necesaria para

la instalación, tal como se observa en el Tabla 26.

3.11.1 Umbral de Rentabilidad

RENTABILIDAD

Desembolso inicial -S/ 19,846

Flujo de caja 1 S/ 347,930





K 10%

VAN 5 años S/ 742,235.40

TIR 5 años 1735%

Tabla 27: Análisis de Rentabilidad


174

*Flujo de caja: se entiende por flujo de caja los flujos de entradas y salidas de

caja o efectivo, en un período dado.

La rentabilidad de este proyecto se prevé que será alta, ya que mediante el

cálculo del VAN (Valor Actual Neto) se comprueba que se recupera la

inversión inicial en los tres primeros años y, además, se obtienen unos

beneficios actualizados de S/.742,235.40 SOLES en el quinto año.

Otro requisito que debe de cumplirse para que este proyecto sea factible es

que la TIR (Tasa Interna de Rentabilidad) sea mayor que k (coste de

oportunidad del capital), lo que supondría que dicho proyecto tiene una

rentabilidad mayor a la requerida: El proyecto tiene una rentabilidad del

1735% %. Y 1735% % > 10% (el requisito se cumple)

Según datos del IDEA (Instituto para la Diversificación y Ahorro de la

Energía), con una gestión inteligente de los electrodomésticos se pueden

obtener ahorros de hasta un 30% de consumo de energía. “El consumo de

energía en una casa estándar puede reducirse hasta un 10% de media” si los

equipos que tenemos instalados se usan para lo que realmente se adquirieron,

aseguran desde HogarTec.

3.11.2 Proyección de ahorros

En el supuesto de que sucedieran una serie de eventos infortuitos, la escuela

perdería las siguientes cantidades de dinero en las que se encuentran valorizados

los diferentes equipos con los que cuentan los laboratorios.

EQUIPOS DE COMPUTO DE LABORATORIOS

MARCA CANTIDAD PRECIO INVERSION

TOTAL LABORATORIO

Hp (core I5) 26 S/ 3,500.00 S/

91,000.00 L1

EPSON (Proyector Bright Link 475WIT)

1 S/ 4,000.00 S/

4,000.00

Hp (core I7) 25 S/ 4,000.00 S/

100,000.00 L2


1 S/ 4,000.00 S/

4,000.00

Hp (core I7) 25 S/ 4,000.00 S/

100,000.00 L3

175


1 S/ 4,000.00 S/

4,000.00

Lenovo (core I5) 26 S/ 2,500.00 S/

65,000.00 L4

ESPON (Proyector H434A) 1 S/ 1,500.00 S/

1,500.00

Intel (core 2 Dual) 4 S/ 2,000.00 S/

8,000.00

L5

Hp (core I5) 3 S/ 3,500.00 S/

10,500.00

Lenovo (core I5) 4 S/ 2,500.00 S/

10,000.00

SONY (Proyector VPL – EX276)

1 S/ 1,600.00 S/

1,600.00

Hp (core I5) 2 S/ 3,500.00 S/

7,000.00

jefatura EPSON (Proyector Powerlite X14)

2 S/ 2,500.00 S/

5,000.00

EPSON (Impresora L355) 1 S/ 500.00 S/

500.00

TOTAL S/.

412,100.00

Tabla 28: Análisis de Rentabilidad


DEPRECIACIÓN LINEA DE EQUIPOS DE

LABORATORIO

COSTO DE EQUIPOS S/. 412,100.00

VALOR RESIDUAL S/. 105,500.00

VIDA UTIL (AÑOS) 5

DEPRESIACION ANUAL S/. 61,320.00 Tabla 29: Depreciación de Equipos de Laboratorio


176

3.11.3 Periodo de tiempo estimado para la rentabilidad

FLUJO DE CAJA AÑO 0 AÑO 1 AÑO 2 AÑO 3 AÑO 4 AÑO 5

(-) Inversión S/ 19,846 S/ - S/ - S/ - S/ - S/ -

Activos Fijos Laboratorio S/ 350,780 S/ 289,460 S/ 228,140 S/ 166,820 S/ 105,500

(-) Costes Totales S/ 1,570 S/ 1,588 S/ 1,607 S/ 1,625 S/ 1,643

Servicios de hosting S/ 840 S/ 840 S/ 840 S/ 840 S/ 840

Remplazo S/ 350 S/ 359 S/ 368 S/ 376 S/ 385

Costos de mantenimiento S/ 380 S/ 390 S/ 399 S/ 409 S/ 418

(-)Depreciaciones S/ 1,280 S/ 1,280 S/ 1,280 S/ 1,280 S/ 1,280

FLUJO DE CAJA -S/ 19,846 S/ 347,930 S/ 286,592 S/ 225,254 S/ 163,915 S/ 102,577

Tabla 30: Flujo de Caja


177

Desglose de Costos de Mantenimiento

MANTENIMIENTO

COSTO

MENSUAL

S/.

PREVENTIVO

380.00

Limpieza de ventiladores

10.00

Limpieza de placas

20.00

Limpieza de sensores

20.00

Revisión de conectores

30.00

Remplazo de componentes

50.00

Optimización de código

150.00

CORRECTIVO

100.00

Tabla 31: Costos de Mantenimiento


3.12 Beneficios

3.12.1 Beneficios Tangibles

Mejorar los servicios brindados dentro de los ambientes de los

laboratorios de la escuela de Ingeniería en Computación e

Informática.

Reducir en cierta medida los gatos por consumo de luz a través

del control de la iluminación y aires acondicionados,

generando un mayor ahorro para la institución.

Controlar desde cualquier lugar en donde se encuentre, las

luces, aires acondicionados y sistemas de seguridad.

Reducir el riesgo de robos, ya que se podrá vigilar los

ambientes a través de cámaras de video.

178

Actuar a tiempo en caso de algún siniestro.

3.12.2 Beneficios intangibles

Proyecto que podría servir de base para el desarrollo otros,

donde se busquen nuevas formas de instalaciones

pertenecientes a la domótica.

Mejorar el confort en personas que hacen uso de estas

instalaciones, tan solo con acceso a internet.

Enfocar más estudios y desarrollo de proyectos con estas

nuevas tecnologías.

179

CAPITULO IV

CONCLUSIONES

180

4. CAPITULO IV: CONCLUSIONES

Se identificaron las deficiencias que presenta el Laboratorio de Computación

e Informática de la Facultad de Ciencias Físicas y Matemáticas a través de

observaciones y conversaciones con alumnos, docentes y personal

administrativo los cuales nos permitieron tener una mayor claridad al

momento de elegir que elementos controlar.

Se identificaron los eventos de actuación para cada tipo de escena, los cuales

nos permitieron tener un mejor control sobre los diferentes elementos

(sensores, actuadores, etc.), así como manejar de manera más eficientes

nuestros recursos.

El diseño del esquema de intercambio de información entre los elementos que

componen el sistema inmótico, nos permite que el usuario sepa en lapso de

segundos de tiempo lo que está ocurriendo en el edificio.

Se configuró la placa Arduino para que establezca comunicación con la shield

GSM y se envíen los mensajes de alerta a los números telefónicos

establecidos indicando dónde y qué ocurrió.

La interfaz gráfica y desarrollada para la aplicación mediante la cual se

controla y monitorea los elementos que se encuentran distribuidos en los

diferentes ambientes, es fácil y sencilla de utilizar, donde cualquier usuario

sin muchos conocimientos informáticos podría hacer uso.

La construcción de la maqueta que representa una copia fiel de la distribución

de los ambientes de los laboratorios nos permitió implementar el prototipo y

desarrollar las pruebas necesarias del mismo.

181

Los sensores que recogen la información que posteriormente activaran

determinadas alarmas funcionaron de manera eficiente permitiendo avisar en

el preciso instante en el que ocurre un evento.

Las pruebas funcionales nos permitieron afinar y mejorar el funcionamiento

del sistema inmótico desarrollado para el laboratorio.

El diseño del prototipo del sistema inmótico, nos permite mejorar la

seguridad, puesto que se detectará a tiempo cualquier siniestro; así como del

mismo modo se tendrá controlada la iluminación y confort (temperatura)

mediante el uso de la aplicación web, el cual nos permitirá vigilar y controlar

los diferentes aparatos conectados a este.

182

CAPITULO V

RECOMENDACIONES

183

5. CAPITULO V: RECOMENDACIONES

Integrar el sistema de seguridad al sistema de alertas de la policía y bomberos.

Alimentar los dispositivos electrónicos a través de paneles solares para reducir el

consumo de energía eléctrica.

Agregar al sistema el control de flujo de agua, a través del sensor de flujo YF

S201, para ayudarnos a tomar decisiones como el cierre de válvulas ante posibles

fugas.

Agregar control de persianas a través de servomotores y relees que nos permitirán

abrirlas y cerrarlas, tanto de manera presencial como remota.

184

6. BIBLIOGRAFIA

AENOR Peru. (2019). AENORPERU. Obtenido de

http://www.aenorperu.com/certificaci%C3%B3n/tecnologia-de-la-informacion/

AENOR PERU. (s.f.). Obtenido de http://www.aenorperu.com/otros-servicios/gestion-

energetica/

Arduino.cc. (2019). Obtenido de https://store.arduino.cc/usa/

Arduino.cc. (2019). Obtenido de https://store.arduino.cc/usa/arduino-nano

Arduino.cc. (2019). Arduino. Obtenido de https://www.arduino.cc/

Asociación Española de Domótica e Inmótica - CEDOM. (s.f.). CEDOM Asociación

Española de Domótca e Inmótica. Obtenido de http://www.cedom.es/es

Baldeón, D., & Congacha, D. (2014). Estudio y diseño de un sistema domótico aplicado en

el edificio de laboratorios para la facultad de mecánica. Riobamba - Ecuador.

Riobanba.

Carrillo , M., & Vite, C. (2015). Aplicacion de una red neuronal para el control domótico

de encendido de luces en una vivienda de la Urbanización Santa Angela. Chiclayo.

CENELEC European Committee for Electrotechnical Standardization . (2017). CENELEC.

Obtenido de https://www.cenelec.eu

Chasquero, M., & Guerrero, L. (2015). Mejoramiento de la eficiencia eléctrica en el Jockey

Club de Chiclayo con aplicación de domótica. Pimentel - Perú”. Pimentel.

Cisco - CCNA. (2012). CISCO. Obtenido de

http://blog.utp.edu.co/ee973/files/2012/04/capitulo09-ethernet.pdf

Committed to connecting the world. (2017). ITU. Obtenido de

https://www.itu.int/es/Pages/default.aspx

Comunicación Serie Arduino. (2 de Julio de 2016). Obtenido de

https://aprendiendoarduino.wordpress.com/tag/rs232/

Cuevas, J., Martínez, J., & Merino, P. (2002). El Protocolo x10: Una solución Antigua.

Malaga-España.

185

Diaz , A. (2010). DISEÑO DE UN SISTEMA AUTOMATIZADO DE SEGURIDAD CONTRA

INTRUSION EN UN EDIFICIO DE DEPARTAMENTOS UTILIZANDO EL

ESTANDAR DE TECNOLOGÍA INALAMBRICA ZIGBEE. Lima.

Diputacion de Badajoz. (s.f.). Las Tecnologías WIFI y WIMAX. Obtenido de http://www.dip-

badajoz.es/agenda/tablon/jornadaWIFI/doc/tecnologias_wifi_wmax.pdf

Domínguez, H. M., & Sáez Vacas, F. (2006). Domotica: Un enfoque Sociotecnico. Madrid:

E.T.S.I. de Telecomunicación.

EPSIG. (s.f.). Uniersidad de Oviedo. Obtenido de

http://isa.uniovi.es/docencia/AutomEdificios/transparencias/Generalidades2.pdf

Escuela politecnica Nacional. (6 de octubre de 2007). Obtenido de

http://clusterfie.epn.edu.ec/ibernal/html/CURSOS/Oct06Marzo07/ComInalam/TRa

bajos/Trabajo2/Proyecto2%20grupo5.pdf

Glen M., M., & Moreno, J. (23 de 5 de 2012). Wiki de Sistemas de Transmisión IUE.

Obtenido de https://sx-de-tx.wikispaces.com/ZIGBEE

HogarTec. (2012). HogarTec Expertos en Sistemas Domoticos. Obtenido de

http://hogartec.es/las-arquitecturas-del-sistema-de-domotica/

Ingeniería de Sistemas y Automática . (s.f.). Automatizacion integral de Edificios. Obtenido

de http://isa.uniovi.es/docencia/AutomEdificios/transparencias/LonWorks.pdf

Insituto Nacional de la Calidad. (2016). INACAL INSTITUTO NAIONAL DE CALIDAD.

Obtenido de

https://tiendavirtual.inacal.gob.pe/0/modulos/TIE/TIE_DetallarProducto.aspx?PRO

=4708

International Electrotechnical Commission. (2017). IEC. Obtenido de http://www.iec.ch/

KNX, A. (20 de 10 de 2014). KNX. Obtenido de https://www.knx.org/knx-en/index.php

Lledó, E. (2012). Diseño de un sistema de control domótico basado en la plataforma

Arduino. Valencia.

Lonworks.es. (s.f.). lonworks.es. Obtenido de www.lonworks.es

186

López Jimeno, C., Hidobro, J. M., Novel, B., & Calafat, C. (2007). La Domótica como

solucion del futuro. Madrid, España.

Martín Moreno, J., & Ruiz-Fernandez, D. (20 de julio de 2007). Respositorio iinstitucional

de la Univercidad de Alicante. Obtenido de

https://rua.ua.es/dspace/bitstream/10045/1109/1/InformeTecZB.pdf

Ministerio del Ambiente. (2014). GESTIÓN Y MANEJO DE LOS RESIDUOS DE

APARATOS ELECTRICOS Y ELECTRONICOS. Obtenido de

http://www.minam.gob.pe/calidadambiental/wp-

content/uploads/sites/22/2014/02/RAEE.pdf

ORDOÑEZ ARIZA, L. J., & VILLAGRAN SOLORZANO, S. (2010). APLICACIÓN

DOMOTICA CONTROLADA REMOTAMENTE DESDE UN WEB SERVER. Bogota

.

Ramirez Suarez, A. (02 de junio de 2013). Comunicacion por Protocolo RS-232. Obtenido

de https://extropynow.weebly.com/uploads/1/6/4/1/16411724/mikroc-u_i-rs232-

protocol.pdf

Rodríguez, W. (2012). Sistema de control domótico utilizando una central IP PBX basado

en software libre. Lima.

the Abdus Salam international Center for Theoretical Physics. (2012). EsLaRed- Fundación

Escuela Latinoamericana de Redes. Obtenido de

http://www.eslared.org.ve/walc2012/material/track1/05-

Introduccion_a_las_redes_WiFi-es-v2.3-notes.pdf

Unitel – Soluciones e infraestructuras Tecnológicas. (2019). Obtenido de https://unitel-

tc.com/normas-sobre-cableado-estructurado/

Vásquez, E., & Ortiz, G. (s.f.). Plan Estratégico de la Facultad de Ciencias Físicas y

Matemáticas. Lambayeque, Lambayeque, Perú.

187

ANEXOS

188

ANEXO N° 1

ATmega2560-Arduino Pin Mapping

Anexo1: Arduino Mega 2560 PIN diagrama

Fuente: https://www.arduino.cc/en/Hacking/PinMapping2560

https://www.arduino.cc/en/Hacking/PinMapping2560

https://www.arduino.cc/en/uploads/Hacking/PinMap2560big.png

189

ANEXO N° 2

Arduino Mega 2560 tabla de mapeo de PINES

Pin Number Pin Name Mapped Pin Name

1 PG5 ( OC0B ) Digital pin 4 (PWM)

2 PE0 ( RXD0/PCINT8 ) Digital pin 0 (RX0)

3 PE1 ( TXD0 ) Digital pin 1 (TX0)

4 PE2 ( XCK0/AIN0 )

5 PE3 ( OC3A/AIN1 ) Digital pin 5 (PWM)

6 PE4 ( OC3B/INT4 ) Digital pin 2 (PWM)

7 PE5 ( OC3C/INT5 ) Digital pin 3 (PWM)

8 PE6 ( T3/INT6 )

9 PE7 ( CLKO/ICP3/INT7 )

10 VCC VCC

11 GND GND

12 PH0 ( RXD2 ) Digital pin 17 (RX2)

13 PH1 ( TXD2 ) Digital pin 16 (TX2)

14 PH2 ( XCK2 )

15 PH3 ( OC4A ) Digital pin 6 (PWM)

16 PH4 ( OC4B ) Digital pin 7 (PWM)

17 PH5 ( OC4C ) Digital pin 8 (PWM)

18 PH6 ( OC2B ) Digital pin 9 (PWM)

19 PB0 ( SS/PCINT0 ) Digital pin 53 (SS)

190

20 PB1 ( SCK/PCINT1 ) Digital pin 52 (SCK)

21 PB2 ( MOSI/PCINT2 ) Digital pin 51 (MOSI)

22 PB3 ( MISO/PCINT3 ) Digital pin 50 (MISO)

23 PB4 ( OC2A/PCINT4 ) Digital pin 10 (PWM)

24 PB5 ( OC1A/PCINT5 ) Digital pin 11 (PWM)

25 PB6 ( OC1B/PCINT6 ) Digital pin 12 (PWM)

26 PB7 ( OC0A/OC1C/PCINT7 ) Digital pin 13 (PWM)

27 PH7 ( T4 )

28 PG3 ( TOSC2 )

29 PG4 ( TOSC1 )

30 RESET RESET

31 VCC VCC

32 GND GND

33 XTAL2 XTAL2

34 XTAL1 XTAL1

35 PL0 ( ICP4 ) Digital pin 49

36 PL1 ( ICP5 ) Digital pin 48

37 PL2 ( T5 ) Digital pin 47

38 PL3 ( OC5A ) Digital pin 46 (PWM)

39 PL4 ( OC5B ) Digital pin 45 (PWM)

40 PL5 ( OC5C ) Digital pin 44 (PWM)

41 PL6 Digital pin 43

42 PL7 Digital pin 42

191

43 PD0 ( SCL/INT0 ) Digital pin 21 (SCL)

44 PD1 ( SDA/INT1 ) Digital pin 20 (SDA)

45 PD2 ( RXDI/INT2 ) Digital pin 19 (RX1)

46 PD3 ( TXD1/INT3 ) Digital pin 18 (TX1)

47 PD4 ( ICP1 )

48 PD5 ( XCK1 )

49 PD6 ( T1 )

50 PD7 ( T0 ) Digital pin 38

51 PG0 ( WR ) Digital pin 41

52 PG1 ( RD ) Digital pin 40

53 PC0 ( A8 ) Digital pin 37








61 VCC VCC

62 GND GND

63 PJ0 ( RXD3/PCINT9 ) Digital pin 15 (RX3)

64 PJ1 ( TXD3/PCINT10 ) Digital pin 14 (TX3)

65 PJ2 ( XCK3/PCINT11 )

192

66 PJ3 ( PCINT12 )

67 PJ4 ( PCINT13 )

68 PJ5 ( PCINT14 )

69 PJ6 ( PCINT 15 )

70 PG2 ( ALE ) Digital pin 39

71 PA7 ( AD7 ) Digital pin 29








79 PJ7

80 VCC VCC

81 GND GND

82 PK7 ( ADC15/PCINT23 ) Analog pin 15







193


90 PF7 ( ADC7 ) Analog pin 7


92 PF5 ( ADC5/TMS ) Analog pin 5

93 PF4 ( ADC4/TMK ) Analog pin 4





98 AREF Analog Reference

99 GND GND

100 AVCC VCC

Anexo 2: Arduino Mega 2560 tabla de mapeo de PINES

Fuente: https://www.arduino.cc/en/Hacking/PinMapping2560

ANEXO N° 3

https://www.arduino.cc/en/Hacking/PinMapping2560

194

Programación del Arduino

Programación Arduino Nano

#include <Keypad.h>

#include <LiquidCrystal.h>

const byte ROWS = 4;

const byte COLS = 4;

char keys[ROWS][COLS] = {

{'D','C','B','A'},

{'#','9','6','3'},

{'0','8','5','2'},

{'*','7','4','1'}

};

byte rowPins[ROWS] = {13,12, 11, A0};

byte colPins[COLS] = {A1,A2, A3,A4};

char password[16]={" "};

char realpass[16]={"123456 "};// CLAVE DEL USUARIO 1

boolean checkpass=false;

char password2[16]={" "};

char realpass2[16]={"098765 "};// CLAVE DEL USUARIO 2

boolean checkpass2=false;

int aaa=0,bbb=0,ccc=0,ddd=0;

int a4=0,b4=0,c4=0,d4=0;

char tecla;

int usu=0;

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

LiquidCrystal lcd(2, 4, 7, 8, 9, 10);

/*En esta funcion se deberá registrar todos los parametros de configuración del arduino

para los datos que se mostraran en la pantalla LCD, el cual se ejecutará una sola vez, al

arrancar el arduino */

void setup() {

Serial.begin(9600);

195

pinMode(3,OUTPUT);

pinMode(5,OUTPUT);

pinMode(6,OUTPUT);

lcd.begin(16, 2);

lcd.setCursor(0, 0);

lcd.print(" BIENVENIDO ");


lcd.print(" USUARIO ");

digitalWrite(3,0);//r (255 off)

digitalWrite(5,1);//verde (255 off)


delay(500);

lcd.clear();

}

unsigned long res1;

void loop() {

/*En la primera parte se muestra el mensaje de inicio de la pantalla LCD que espera que

se ingrese una opción (ID del usuario) para poder mostrar el siguiente mensaje*/

part1:

/////////////////////////////////////////////////////////////////////////////////////////////////////////


lcd.print("INGRESE USUARIO");


lcd.print(" ");


res1=millis();

do{

check_serial();

tecla=keypad.getKey();

196

if((millis()-res1)>2000)

{

if(analogRead(A7)>500){Serial.print("W");}

if(analogRead(A7)<=500){Serial.print("X");}

res1=millis();

}

}while(!(tecla=='1' || tecla=='2'));

if (tecla=='1'){usu=1;}

if (tecla=='2'){usu=2;}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

/*En la segunda parte se muestran las diferentes alarmas con sus respectivos estados en

la pantalla lcd en las posiciones antes ya definidas.*/

part2:


lcd.print("SIST. ANTIRROBO");


lcd.print(" ");


delay(2000);

lcd.clear();

///////////////////////////////////////////////////////////////////////////////////////////////////////////

do{check_serial();


if(a4){lcd.print("INT: ON ");}else{lcd.print("INT:OFF");}

if(b4){lcd.setCursor(8, 0);lcd.print("EXT: ON ");}else{lcd.setCursor(8,

0);lcd.print("EXT:OFF");}


if(c4){lcd.print("FUE: ON ");}else{lcd.print("FUE:OFF");}

if(d4){lcd.setCursor(8, 1);lcd.print("HUM: ON ");}else{lcd.setCursor(8,

1);lcd.print("HUM:OFF");}

check_serial();


197

// if(digitalRead(13)==1){Serial.print("W");}

}while(!(tecla=='A' || tecla=='B' || tecla=='C' || tecla=='D' || tecla=='*'));

/*Dependiendo de la tecla que se presione se cambiara el estado previa confirmación

de la contraseña. Si se presiona a la tecla * regresa a la pantalla de inicio.*/

if(tecla=='*'){goto part1;}

if (tecla=='A'){aaa=1;}else{aaa=0;}

if (tecla=='B'){bbb=1;}else{bbb=0;}

if (tecla=='C'){ccc=1;}else{ccc=0;}

if (tecla=='D'){ddd=1;}else{ddd=0;}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*Se deberá ingresar la contraseña de usuario y con la tecla # comfirmar la contraseña

que esta intentando activar o desactivar para poder registrar el cambio o de caso contrario

con la tecla * se podra regresar al menu anterior */

part3:

for(int j=0;j<16;j++){password[j]=' ';}

delay(1000);


lcd.print(" PASSWORD: ");


lcd.print(" ");


delay(1000);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Si se presiona la lecla * se regresa a la parte 2

int i=0;

do{check_serial();


if(tecla && tecla!='#' && tecla!='*'){ password[i]=tecla;lcd.print(password[i]);i++;}

}while(!(tecla=='#' || tecla=='*'));

if(tecla=='*'){goto part2;}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

198

int b=1,bb=1;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*Comprobación de las contraseñas ingresadas con las que se encuentran registradas en

la base de datos*/

if(usu==1){

for(i=0;i<16;i++){if(password[i]==realpass[i]){b*=1;}else{b*=0;}}

if(b==0){goto part3;}

}

if(usu==2){

for(i=0;i<16;i++){if(password[i]==realpass2[i]){bb*=1;}else{bb*=0;}}

if(bb==0){goto part3;}

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*Obtención de datos en caso de que algún usario modificara el estado de una alarma a

traves del tablero*/

char cod='z';

int q1,q2,q3,q4;

if(aaa==1){q1=!a4;

if(usu==1){

if(q1){cod='b';}else{cod='a';}

}else{

if(q1){cod='j';}else{cod='i';}

}

}

if(bbb==1){q2=!b4;

if(usu==1){

if(q2){cod='d';}else{cod='c';}

}else{

if(q2){cod='l';}else{cod='k';}

}

}

199

if(ccc==1){q3=!c4;

if(usu==1){

if(q3){cod='f';}else{cod='e';}

}else{

if(q3){cod='n';}else{cod='m';}

}

}

if(ddd==1){q4=!d4;

if(usu==1){

if(q4){cod='h';}else{cod='g';}

}else{

if(q4){cod='p';}else{cod='o';}

}

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Serial.print("$");

Serial.println(cod);

}

/*Funcion que lee el archivo xml, que contiene la contrasela de cada usuario para luego

comprarla con la que se ingresa */

void check_serial()

{

if(Serial.available()>0)

{

char z=Serial.read();

switch(z)

{

case 'P': digitalWrite(3,0);//r (255 off)



break;

200

case 'Q': digitalWrite(3,1);//r (255 off)



break;

case 'R': digitalWrite(3,1);//r (255 off)



break;

case '$': delay(500);

//char tt=' ';//Serial1.print('$');

realpass[0]=Serial.read();






realpass2[0]=Serial.read();






do{

Serial.read();

}while(!(Serial.available()==0));

break;

/* En caso se presione # se confirma el ingreso de la contraseña para el cambio de estado

de la alarma. */

case '#': delay(5);

char ttt=Serial.read();

switch(ttt)

201

{

case 'a': a4=0;

break;

case 'b': a4=1;

break;

case 'c': b4=0;

break;

case 'd': b4=1;

break;

case 'e': c4=0;

break;

case 'f': c4=1;

break;

case 'g': d4=0;

break;

case 'h': d4=1;

break;

}

break;

}

}

Programación Arduino Mega Hijo

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

//Ultimo codigo arduino 9/10/10

#include <SPI.h>

#include <Ethernet.h>

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

float data[29]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int sms_ok=0;

int sms1,sms2,sms3,sms4,sms5,sms6,sms7,sms8;

// if(data[1]<25){Serial.println("ALARMA DE FUEGO EN EL LABORATORIO 1");}

202

// if(data[9]<25){Serial.println("ALARMA DE FUEGO EN EL

LABORATORIO 2");}


LABORATORIO 3");}


LABORATORIO 4");}

// if(data[2]==1){Serial.println("ALARMA DE ROBO INTERNA POR

DETECCION DE MOVIMIENTO");}

// if(data[4]==1){Serial.println("ALARMA DE ROBO INTERNA EN LA

PUERTA");}

// if(data[22]>0){Serial.println("ALARMA DE ROBOT EXTERNO");}

// if(data[12]>80){Serial.println("ALARMA DE HUMO");}

#define SERIAL_RX_BUFFER_SIZE 128

#define SERIAL_TX_BUFFER_SIZE 128

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

char devices1[]={'e','f','d','c','b','p','q','o','n','@','@'}; //led

int dev_prev_stat1[]={0,0,0,0,0,0,0,0,0,0,0};

char devices2[]={'a','m','i','j','@','u','@','@'}; //ventiladores

int dev_prev_stat2[]={0,0,0,0,0,0,0,0};

char devices3[]={'B','C','D','E','z'}; //Alarmas

int dev_prev_stat3[]={0,0,0,0,0};

char pass1[6]="";

char pass2[6]="";

char cel1[9]="";

char cel2[9]="";

//-------------------------------------------------------------------------------------------------------

-----------*/

#define MAX_STRING_LEN 20

char tagStr[MAX_STRING_LEN] = "";

char dataStr[MAX_STRING_LEN] = "";

char tmpStr[MAX_STRING_LEN] = "";

char endTag[3] = {'<', '/', '\0'};

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

int len; int temp;

int count=0;

boolean tagFlag = false;

boolean dataFlag = false;

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

// Configuracion del Ethernet Shield

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFF, 0xEE}; // Direccion MAC

byte ip[] = { 192,168,0,107}; // Direccion IP del Arduino

byte server[] = { 3,85,14,104 }; // Direccion IP del servidor

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

//String location1 = ;

//String location2 = ;//ventiladores

203

//String location3 = ;// alarmas 5

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

EthernetClient client;

char inString[64]; // string for incoming serial data///64

int stringPos = 0; // string index counter

boolean startRead = false; // is reading?

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

void setup() {

Serial.begin(9600);

Serial2.begin(9600);

Serial1.begin(9600);//gsm

Ethernet.begin(mac, ip); // Inicializamos el Ethernet Shield

delay(500); // Esperamos 1 segundo de cortesia

sms1=sms2=sms3=sms4=sms5=sms6=sms7=sms8=sms_ok=0;

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

void connectAndRead4()

/* Esta función me permite conectarse al archivo xml para poder leer y extraer los

números telefónicos y contraseñas del personal autorizado para apagar el sistema desde

el tablero; dicho archivo es leído a través del método GET */

{

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

client.print("GET ");

client.println(F("http://3.85.14.104/tesis/Pag/Usu.xml HTTP/1.0"));

client.println();

while(client.connected() && !client.available()) delay(1); //waits for data

////////////////////

char inChar;

do{

inChar=client.read();

//Serial.print(inChar);

}while(!(inChar=='$'));

cel1[0]=client.read();









204

client.read();

do{




pass1[0]=client.read();






client.read();

do{













client.read();

do{










client.read();

do{

client.read();

}while(!(client.available()==0));

for(int i=0;i<9;i++)

{

Serial.print(cel1[i]);

205

}

Serial.println("");


{

Serial.print(pass1[i]);

}

Serial.println("");


{

Serial.print(cel2[i]);

}

Serial.println("");


{

Serial.print(pass2[i]);

}

Serial.println("");

client.stop();

client.flush();

////////////////////////

}else{/*return "connection failed";*/}

}

/* Esta función me permite conectarse al archivo xml para poder leer y extraer los estados

de los archivos test.xml, testA.xml y testAl.xml. */

void connectAndRead(int a){

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

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

//Serial.println("connected");

client.print("GET ");

if(a==1){client.println(F("http://3.85.14.104/tesis/Pag/test.xml HTTP/1.0"));}

if(a==2){client.println(F("http://3.85.14.104/tesis/Pag/testA.xml HTTP/1.0"));}

if(a==3){client.println(F("http://3.85.14.104/tesis/Pag/testAl.xml HTTP/1.0"));}

client.println();

while(client.connected() && !client.available()) delay(1); //waits for data

while (client.connected() || client.available()){xmlread(a);}

}else{/*return "connection failed";*/}

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

void xmlread(int b){

206

//En este método se encarga de separar todo lo que este en”>” o “ <”

if (client.available()) {

char inChar = client.read();

if (inChar == '<') {

addChar(inChar, tmpStr);

tagFlag = true;

dataFlag = false;

}

else if (inChar == '>') {


if (tagFlag) {

strncpy(tagStr, tmpStr, strlen(tmpStr)+1);

}

clearStr(tmpStr);

tagFlag = false;

dataFlag = true;

}

else if (inChar != 10)

{

if (tagFlag)

{


if ( tagFlag && strcmp(tmpStr, endTag) == 0 )

{

clearStr(tmpStr);

tagFlag = false;

dataFlag = false;

}

}

if (dataFlag) {

addChar(inChar, dataStr);

}

}

if (inChar == 10 ) {

if (matchTag("<state>")) {

// Serial.print("state: ");

//Serial.println(dataStr);

// Serial.print("length--");

//Serial.println(strlen(dataStr));

count=count+1;

// Serial.println(count);

devicescontrol(count,dataStr,b);

if(b==1){temp=11;}

if(b==2){temp=8;}

207

if(b==3){temp=5;}

if(count==temp)

{

count=0;

clearStr(tmpStr);

clearStr(tagStr);

clearStr(dataStr);

client.stop();

client.flush();

// Serial.println("disconnecting.");

}

}

clearStr(tmpStr);

clearStr(tagStr);

clearStr(dataStr);

tagFlag = false;

dataFlag = false;

}

}

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

// Se etiene que volver a limpiar la cadena donde almacenan los datos de cada xml.

void clearStr (char* str) {

int len = strlen(str);

for (int c = 0; c < len; c++) {

str[c] = 0;

}

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

void addChar (char ch, char* str) {

char tagMsg = "<ERROR>";//*

char dataMsg = "-ERROR";//*

if (strlen(str) > MAX_STRING_LEN - 2) {

if (tagFlag) {

clearStr(tagStr);

strcpy(tagStr,tagMsg);

}

if (dataFlag) {

clearStr(dataStr);

strcpy(dataStr,dataMsg);

}

208

clearStr(tmpStr);

tagFlag = false;

dataFlag = false;

}

else {

str[strlen(str)] = ch;

}

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

boolean matchTag (char* searchTag) {

if ( strcmp(tagStr, searchTag) == 0 ) {

return true;

} else {

return false;

}

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

/* Compara los estados extraidos del xml (on u off) para luego enviarlo al arduino mega

padre.*/

void devicescontrol(int devicescount, char *devicestate,int c)

{

if(c==1)

{

if(!strncmp("ON",devicestate,2))

{

if(dev_prev_stat1[devicescount-1]==0){/*Serial.println(devices1[devicescount-

1]);*/Serial2.write(devices1[devicescount-1]);dev_prev_stat1[devicescount-

1]=1;}//code_list()== ardu.print();

}

else if(!strncmp("OFF",devicestate,3))

{




}

}

if(c==2)

{


{




}


{

209




}

}

if(c==3)

{


{




}


{




}

}

}

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

/*-------------------------------------------------------------------------------------------------------

-------------------------------------------------------*/

unsigned long temppp=millis(),temppp2=millis();

/*Esta función se ejecuta constantemente y contiene la llamada a las demás funciones */

void loop() {

delay(1000);

getdat();

Serial.println("inicio del httpreq");

httpRequest();

delay(300);//Serial.println("3era"); //era 500

delay(1000);// era 1000

connectAndRead(1); Serial.println(1);//connect to the server and read the output

connectAndRead(2); Serial.println(2);//connect to the server and read the output

connectAndRead(3);Serial.println(3); //connect to the server and read the output

connectAndRead4();Serial.println(4);

delay(1000);

210

Serial.println(data[27]);

captura_mensajes();

mostrar_mensajes_a_enviar();

if((millis()-temppp2)>60000)

{

if(sms_ok==1){

mensaje_sms();//mensaje_sms2();

temppp2=millis();

}

}

if((millis()-temppp)>10000)

{

Serial2.print('$');

Serial2.print(pass1[0]);











Serial2.println(pass2[5]);

delay(100);

temppp=millis();

}

}

/* Esta función envía los valores que captura el arduino hacia la aplicación web que serán

recibidos por el archivo salvardatos.php. */

void httpRequest() {

//Serial.println("inicio del httpreq");

if (client.connect(server, 80)) { // Conexion con el servidor

// Serial.println("antes del get");

client.print("GET /tesis/bd/salvardatos.php?valor1="); // Enviamos los datos por GET

client.print(data[0]);

client.print("&valor2="); // Enviamos los datos por GET





211


















































212



client.println(" HTTP/1.0");

client.println("User-Agent: Arduino 1.0");

client.println();

// Serial.println("Conectado");

} else {

// Serial.println("Fallo en la conexion");

}

if (!client.connected()) {

// Serial.println("Disconnected!");

}

client.stop();

client.flush();

// delay(3000); // era3000

}

void getdat()

{

char dat[200]="";

char a;

int i=0,j=0,k=0;

//Serial.println("adios");

char st[]=" ";

unsigned long time1=millis();

Serial2.write('A');

do{

if (Serial2.available()>0){

a= Serial2.read();

dat[i++]=a;

//Serial.print(a);

}

}while(!(Serial2.available()==0 && (millis()-time1)>2000));

i=j=k=0;

//ardu.println(dat);

Serial.println("");

for(i=0;i<200;i++)

{

if(dat[i]==',')

{

data[k++]=atof(st);

for(int w=0;w<7;w++)

{st[w]=' ';}

213

j=0;

i++;

}

if(k!=30)

{st[j++]=dat[i];}

}

for(i=0;i<29;i++)

{Serial.print(data[i]);

Serial.print(",");

//data[i]=0;

}

Serial.println();

//data[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

//1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

//511.1,113.3,61.98,400.9,36.87,44.55,12.07,73.19,93.46,841.3,36.20,991.4,96.34,11.3

0,98.61,98.93,85.48,435.6,30.40,95.12,865.3,41.15,5.841,

}

/*Funcion utilizada pata realizar pruebas para envio de mensajes*/

void test()

{

int b=1;

Serial.println("Enviando SMS...");

if(data[1]<25){b*=0;}

if(data[9]<25){b*=0;}

if(data[10]<25){b*=0;}

if(data[11]<25){b*=0;}

if(data[2]==1){b*=0;}

if(data[4]==1){b*=0;}

if(data[22]>0){b*=0;}

if(data[12]>150){b*=0;}

if(b==0){

Serial1.print("AT+CMGF=1\r"); //Configura el modo texto para enviar o recibir

mensajes

delay(1000);

Serial1.print("AT+CMGS=\"");

Serial1.print(cel1[0]);









Serial1.println("\""); //Numero al que vamos a enviar el mensaje

214

delay(1000);

Serial1.println("ACTIVACION DE ALARMA EN LABORATORIOS");

Serial.println("ACTIVACION DE ALARMA EN LABORATORIOS");

delay(100);

Serial1.println((char)26); //Comando de finalización ^Z

delay(100);

Serial1.println();

delay(5000); // Esperamos un tiempo para que envíe el SMS

Serial.println("SMS enviado");

}//do{Serial.read();}while((Serial.available()==0));

}

void captura_mensajes()

{

if(sms_ok==0){

sms1=sms2=sms3=sms4=sms5=sms6=sms7=sms8=0;

}

if(data[27]==1 && sms_ok==0){

sms_ok=1;

if(data[1]<80){sms1=1;}

if(data[9]<80){sms2=1;}

if(data[10]<80){sms3=1;}

if(data[11]<80){sms4=1;}

if(data[2]==1){sms5=1;}

if(data[4]==1){sms6=1;}

if(data[22]==0){sms7=1;}

if(data[12]>150){sms8=1;}

}

}

void mostrar_mensajes_a_enviar()

{

Serial.print("sms1=");

Serial.print(sms1);

Serial.print(" ");


Serial.print(sms2);

Serial.print(" ");


Serial.print(sms3);

Serial.print(" ");


Serial.print(sms4);

Serial.print(" ");


Serial.print(sms5);

Serial.print(" ");


215

Serial.print(sms6);

Serial.print(" ");


Serial.print(sms7);

Serial.print(" ");


Serial.println(sms8);

}

void mensaje_sms()

{

int b=1;

Serial.println("Enviando SMS...");

if(sms1==1){b*=0;}

if(sms2==1){b*=0;}

if(sms3==1){b*=0;}

if(sms4==1){b*=0;}

if(sms5==1){b*=0;}

if(sms6==1){b*=0;}

if(sms7==1){b*=0;}

if(sms8==1){b*=0;}

if(b==0){


mensajes

delay(1000);












delay(1000);

// Serial1.println("ACTIVACION DE ALARMA EN LABORATORIOS");

/////////////////////////////////////////////

if( sms1==1){Serial1.println("AF LAB 1");Serial.println("ALARMA DE

FUEGO EN EL LABORATORIO 1");}







216

if( sms5==1){Serial1.println("ARI Mov");Serial.println("ALARMA DE

ROBO INTERNA POR DETECCION DE MOVIMIENTO");}

if( sms6==1){Serial1.println("ARI Puerta");Serial.println("ALARMA DE

ROBO INTERNA EN LA PUERTA");}

if( sms7==1){Serial1.println("ARE");Serial.println("ALARMA DE

ROBOT EXTERNO");}

if( sms8==1){Serial1.println("AH");Serial.println("ALARMA DE

HUMO");}

delay(1000);


delay(1000);

Serial1.println();


Serial.println("SMS enviado1");


mensajes

delay(1000);












delay(1000);

// Serial1.println("ACTIVACION DE ALARMA EN LABORATORIOS");

/////////////////////////////////////////////









if( sms5==1){Serial1.println("ARI Mov");Serial.println("ALARMA DE

ROBO INTERNA POR DETECCION DE MOVIMIENTO");}

if( sms6==1){Serial1.println("ARI Puerta");Serial.println("ALARMA DE

ROBO INTERNA EN LA PUERTA");}

if( sms7==1){Serial1.println("ARE");Serial.println("ALARMA DE

ROBOT EXTERNO");}

217

if( sms8==1){Serial1.println("AH");Serial.println("ALARMA DE

HUMO");}

delay(1000);


delay(1000);

Serial1.println();


Serial.println("SMS enviado 2");

sms_ok=0;

sms1=sms2=sms3=sms4=sms5=sms6=sms7=sms8=0;

}else{Serial.println("SMS falló por no entrar en ninguna de las

condiciones");sms_ok=0;}

//do{Serial.read();}while((Serial.available()==0));

}

Programación Arduino Mega Padre

#include "DHT.h"

#define DHTPIN1 7

#define DHTPIN2 12

#define DHTPIN3 11

#define DHTPIN4 10

#define DHTPIN5 9

#define DHTTYPE DHT22

DHT dht1(DHTPIN1, DHTTYPE);





float t1,t2,t3,t4,t5;// temperaturas

float

v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15,v16,v17,v18,v19,v20,v21,v22,v2

3,v24,v25,v26,v27,v28,v29;

int p=0,q=0,r=0,s=0;

int ex1=0;

int led[24]={ 2 , 28 , 30 , 32 ,

34, 38 , 40 , 42 ,

44, 48 , 50 , 52 ,

3 , 25 , 29 , 31 ,

33, 37 , 39 , 41 ,

45, 47 , 49 , 51 };

int pul[9]={61 , 62 , 63 , 64 ,

65, 66 , 67 , 68 ,

60 };/*{ 8 , 9 , 10 , 11 ,

218

12, 12 , 7 , 6 ,//ojo 12

5 , 6 };*/

int pul_val[9];

int flag1=0, flag2=1;

int band_int=0,band_ext=0,band_fue=0,band_hum=0,band_buzz=0;

int btn_int=0,btn_ext=0,btn_fue=0,btn_hum=0,btn_buzz=0;

int act_id=0;

/*En esta función se inicializan las variales y las velocidades de transmisión entre

arduinos y el monitor serial */

void setup() {

v1=v2=v3=v4=v5=v6=v7=v8=v9=v10=v11=v12=v13=v14=v15=v16=v17=v18=v19=

v20=v21=v22=v23=v24=v25=v26=v27=v28=v29=0;//"I,D,H,F,S,J,K,L,M,C,B,A,G,6,

5,4,1,0,3,7,2,8,T"

t1=t2=t3=t4=t5=0;

Serial2.begin(9600);//uno

Serial1.begin(9600);//nano

Serial.begin(9600);//depurar

ini_leds();

ini_puls();

dht1.begin();

dht2.begin();

dht3.begin();

dht4.begin();

dht5.begin();

}

long tiempoUltimaLectura=0;

//Funcion que se repite indefinidas veces

void loop() {

if(Serial1.available()>0)

{

/* Si el arduino nano esta enviando datos, se lee y guarda en la variable de tipo char.

Las variables ‘w’ ‘y’ ‘x’ son provenientes del arduino nano, para saber si alguien abrió

el sensor magnético */

char y=Serial1.read();

if(y=='W'){v5=1;}

if(y=='X'){v5=0;}

if(y=='$'){ // llega del nano es como enter

delay(10);

/* Dependiendo del valor de ‘y’ se determina si se activó o desactivó una alarma y

quien fue la persona que realizo la acción. */

y=Serial1.read();

Serial.println(y);

switch(y){

case 'a': btn_int=1;

act_id=1;

break;

219

case 'b': btn_int=1;

act_id=2;

break;

case 'c': btn_ext=1;

act_id=3;

break;

case 'd': btn_ext=1;

act_id=4;

break;

case 'e': btn_fue=1;

act_id=5;

break;

case 'f': btn_fue=1;

act_id=6;

break;

case 'g': btn_hum=1;

act_id=7;

break;

case 'h': btn_hum=1;

act_id=8;

break;

case 'i': btn_int=1;

act_id=9;

break;

case 'j': btn_int=1;

act_id=10;

break;

case 'k': btn_ext=1;

act_id=11;

break;

case 'l': btn_ext=1;

act_id=12;

break;

case 'm': btn_fue=1;

act_id=13;

break;

case 'n': btn_fue=1;

act_id=14;

break;

case 'o': btn_hum=1;

act_id=15;

break;

case 'p': btn_hum=1;

act_id=16;

break;

}

}

220

goto here; }

/* Si el arduino mega hijo tiene datos, se llen los datos y se actualizan en la variable X

para activar o desactivar las alarmas desde la aplicación */

if(Serial2.available()>0)

{//Serial.println("holis");

char x=Serial2.read();

if(x=='$'){

//unsigned long time1=millis();

char tt=' ';

delay(100);

Serial1.print('$');

do{

tt=char(Serial2.read());

Serial.print(tt);

Serial1.print(tt);

}while(!(Serial2.available()==0));

Serial2.flush();

goto here;

}


{

// sensors

if(x=='a'+i){digitalWrite(led[i], !digitalRead(led[i]));goto here;}}//a--x

//abc def ghi jkl mno pqr

//18 1-18 0-17

if(x=='A'){txtsend();if(btn_int==1){p++;}

if(btn_ext==1){q++;}

if(btn_fue==1){r++;}

if(btn_hum==1){s++;}

if(p>=4 || q>=4 || r>=4 || s>=4){p=q=r=s=0;}

goto here;}// sensors

if(x=='B'){if(band_int==1){band_int=0;Serial1.print("#a");Serial.print("#a");}else{ban

d_int=1;Serial1.print("#b");Serial.print("#b");}goto here;}// sensors

if(x=='C'){if(band_ext==1){band_ext=0;Serial1.print("#c");Serial.print("#c");}else{ba

nd_ext=1;Serial1.print("#d");Serial.print("#d");}goto here;}// sensors

if(x=='D'){if(band_fue==1){band_fue=0;Serial1.print("#e");Serial.print("#e");}else{ba

nd_fue=1;Serial1.print("#f");Serial.print("#f");}goto here;}// sensors

if(x=='E'){if(band_hum==1){band_hum=0;Serial1.print("#g");Serial.print("#g");}else{

band_hum=1;Serial1.print("#h");Serial.print("#h");}goto here;}// sensors

221

if(x=='y'){/*tone(4, 2000, 500)*/;goto here;}

if(x=='z'){noTone(4);band_buzz=0;goto here;}

}

here:

leer_pul();

drive_led();

if (flag1==1){delay(1000);}

///////////////////////////////////////////////////////////////////

if(band_int){//si esta activa la alarma interna//*arreaglar esta alarma

if(v5){tone(4, 2000);band_buzz=1;}// si alguien abre la puerta se activa el

buzzer

if(digitalRead(8)==1) {//si hay movimiento

tone(4, 2000);band_buzz=1;

}

if(analogRead(A5)<500){//si es de noche LDR

if(digitalRead(8)==1) {//si hay movimiento

tone(4, 2000);//activa el buzzer

band_buzz=1;

v3=1;

// ex=1;//digitalWrite(led[3],1);//prende led

}else{/*digitalWrite(led[3],0);*/}//apaga led

}

}else{v3=0;}

if(band_ext){// si esta activa la alarma externa

if(digitalRead(13)==0){tone(4, 2000);band_buzz=1;}// si detecta el laser activa

el buzzer// 1 para pruebas y 0 para real

}

if(band_fue){// si esta activa la alarma externa

//if(analogRead(A0)<25 ||analogRead(A1)<25 || analogRead(A2)<25 ||

analogRead(A3)<25){tone(4, 2000);band_buzz=1;}// si detecta el fuego activa el buzzer

if(v2<25 ||v10<25 || v11<25 || v12<25){tone(4, 2000);band_buzz=1;}// si detecta

el fuego activa el buzzer

}

if(band_hum){// si esta activa la alarma externa

if(analogRead(A15)>80){tone(4, 2000);band_buzz=1;}// si detecta el laser

activa el buzzer// estaba en 80

222

}

////////////////////////////////////////////////////////////////////////////////////////////////////

if(millis()-tiempoUltimaLectura>5000)

{

t1 = dht1.readTemperature(); //Leemos la temperatura en grados Celsius





if(t1>35){digitalWrite(41,1);}else{digitalWrite(41,0);}





if(band_int==1 || band_ext==1 || band_fue==1 ||

band_hum==1){Serial.println("verde");Serial.println(band_int);Serial.println(band_ext

);Serial.println(band_fue);Serial.println(band_hum);Serial1.print('Q');}// verde

// if(x=='R'){Serial1.print('R');goto here;}// azul

if(band_int==0 && band_ext==0 && band_fue==0 &&

band_hum==0){Serial.println("Rojo");Serial.println(band_int);Serial.println(band_ext)

;Serial.println(band_fue);Serial.println(band_hum);Serial1.print('P');}// rojo

tiempoUltimaLectura=millis(); //actualizamos el tiempo de la última lectura

}

tasks();

////////////////////////////////////////////////////////////////////////////////////

}

//Inicializa los leds como salidas

void ini_leds()

{


{

pinMode(led[i],OUTPUT);

digitalWrite(led[i],LOW);

}

}

//Inicializa los pulsadores como entradas

void ini_puls()

{


{

pinMode(pul[i],INPUT_PULLUP);

pul_val[i]=0;

223

}

}

//Lee los pulsadores que sirven para prender o apagar los focos leds

void leer_pul()

{

flag1=0;


{

pul_val[i]=digitalRead(pul[i]);

if(pul_val[i]==0){flag1=1;}

}

}

void mos_pul()

{


{

Serial2.print(pul_val[i]);

Serial2.print(" ");

}

Serial2.println("");

}

void drive_led()

{

//if(pul_val[0]==0){digitalWrite(led[1],!digitalRead(led[1]));}



// if(pul_val[3]==0){digitalWrite(led[15],!digitalRead(led[15]));}






}

//Se envían las mediciones de los sensores al arduino hijo.

void txtsend()

{

Serial2.print(v1);

Serial2.print(",");

Serial2.print(v2);

Serial2.print(",");

Serial2.print(v3);

Serial2.print(",");

Serial2.print(v4);

224

Serial2.print(",");

Serial2.print(v5);

Serial2.print(",");

Serial2.print(v6);

Serial2.print(",");

Serial2.print(v7);

Serial2.print(",");

Serial2.print(v8);

Serial2.print(",");

Serial2.print(v9);

Serial2.print(",");

Serial2.print(v10);

delay(100);

Serial2.print(",");

Serial2.print(v11);

Serial2.print(",");

Serial2.print(v12);

Serial2.print(",");

Serial2.print(v13);

Serial2.print(",");

Serial2.print(int(v14));

Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


delay(100);

Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");


Serial2.print(",");

225


Serial2.print(",");


Serial2.print(",");

Serial2.flush();

Serial.print(v1);

Serial.print(",");

Serial.print(v2);

Serial.print(",");

Serial.print(v3);

Serial.print(",");

Serial.print(v4);

Serial.print(",");

Serial.print(v5);

Serial.print(",");

Serial.print(v6);

Serial.print(",");

Serial.print(v7);

Serial.print(",");

Serial.print(v8);

Serial.print(",");

Serial.print(v9);

Serial.print(",");

Serial.print(v10);

delay(100);

Serial.print(",");

Serial.print(v11);

Serial.print(",");

Serial.print(v12);

Serial.print(",");

Serial.print(v13);

Serial.print(",");

Serial.print(int(v14));

Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


delay(100);

Serial.print(",");

226


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.print(",");


Serial.println(",");

Serial.flush();

act_id=0;

//v5=0;//borrado

delay(1000);

}

//Se asigna los valores de los sensores a las las variables

void tasks()

{

v1=t1; // lab1

v2=analogRead(A3);//fuego cod 2

v3=digitalRead(8); // movimiento cod3

v4=analogRead(A5); //ldr cod4

v5=v5;//luego borrar; //magnetico cod 5

v6=t2; //temp lab 2 cod 6

v7=t3; //temp lab3 cog 7

v8=t4; //temp lab 4 cod8

v9=t5;// tempe jefatura

v10=analogRead(A2); //fuego lab 2

v11=analogRead(A1); //fuego lab 3

v12=analogRead(A0);//fuego lab 4

v13=analogRead(A15); //humo lab3

/////////////////////////////////////////////

v14=2;

if(pul_val[6]==0 && (digitalRead(led[4])==0)){v14=1;}


//v14=digitalRead(led[4]); //led lab1

////////////////////////////////////////////////////////////////////////////////////////////

v15=2;



227


/////////////////////////////////////////////// /////////////////////////////////////////////

v16=2;




////////////////////////////////////////////////////////////////////////////////////////////

v17=2;




////////////////////////////////////////////////////////////////////////////////////////////

v18=2;




////////////////////////////////////////////////////////////////////////////////////////////

v19=2;



//v19=digitalRead(led[15]); //led jefatura

////////////////////////////////////////////////////////////////////////////////////////////

v20=2;



//v20=digitalRead(led[16]); //led pasillo 1

////////////////////////////////////////////////////////////////////////////////////////////

v21=2;



//v21=digitalRead(led[14]); //led pasillo 2

////////////////////////////////////////////////////////////////////////////////////////////

v22=2;



//v22=digitalRead(led[13]); //led baño

///////////////////////////////////////////////

v23=digitalRead(13);//laser cod 14

v24=2;//band_int;

if(btn_int==1 && (band_int==0)){

v24=1;

if(p>=2){btn_int=0;p=0;}

}

if(btn_int==1 && (band_int==1)){

v24=0;

228

if(p>=2){btn_int=0;p=0;}

}

v25=2;//band_ext;

if(btn_ext==1 && (band_ext==0)){

v25=1;

if(q>=2){btn_ext=0;q=0;}

}

if(btn_ext==1 && (band_ext==1)){

v25=0;

if(q>=2){btn_ext=0;q=0;}

}

v26=2;//band_fue;

if(btn_fue==1 && (band_fue==0)){

v26=1;

if(r>=2){btn_fue=0;r=0;}

}

if(btn_fue==1 && (band_fue==1)){

v26=0;

if(r>=2){btn_fue=0;r=0;}

}

v27=2;//band_hum;

if(btn_hum==1 && (band_hum==0)){

v27=1;

if(s>=2){btn_hum=0;s=0;}

}

if(btn_hum==1 && (band_hum==1)){

v27=0;

if(s>=2){btn_hum=0;s=0;}

}

v28=band_buzz;

if(band_buzz){digitalWrite(led[17],1);}else{digitalWrite(led[17],0);}

v29=act_id;

}

facultad de ciencias físicas y matemáticas escuela profesional ...

Documents

Transcript of facultad de ciencias físicas y matemáticas escuela profesional ...