Sistema Automatico de Control de Iluminación Via Servidor Web

INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA

UNIDAD PROFESIONAL “ADOLFO LÓPEZ MATEOS”
ZACATENCO
“SISTEMA AUTOMÁTICO DE CONTROL DE ILUMINACIÓN VÍA SERVIDOR WEB”
SEMINARIO
PARA OBTENER EL TÍTULO DE:
INGENIERO EN COMUNICACIONES Y ELECTRÓNICA
PRESENTAN:
CESAR ALEXANDER GARCÍA GÓMEZ

DAVID ADRIAN GARCÍA GÓMEZ
LUIS ALBERTO ORTÍZ SÁNCHEZ
ASESORES:
ING. ARTURO A. HIT ESPINOSA

ING. GUILLERMO M. ESCARCEGA CARRERA
Ciudad de México, mayo de 2019

SISTEMA AUTOMÁTICO DE CONTROL DE ILUMINACIÓN VÍA SERVIDOR WEB
INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.2

INSTITUTO POLITÉCNICO NACIONAL Prohibición de Uso de Obra.
PRESENTE
Bajo protesta de decir verdad, los que suscriben Cesar Alexander García Gómez, David Adrian García
Gómez y Luis Alberto Ortíz Sánchez, manifestamos ser autores y titulares de los derechos morales y
patrimoniales de la obra titulada: “SISTEMA AUTOMÁTICO DE CONTROL DE ILUMINACIÓN VÍA
SERVIDOR WEB” en adelante “La Tesis” y de la cual se adjunta copia en 2 CDs, para efecto
del resguardo de la biblioteca y para cumplir con el trámite de titulación, por lo que por medio de la
presente y con fundamento en el artículo 27 fracción II, inciso b) de la Ley Federal del Derecho de Autor,
se prohíbe el uso y/o explotación de “La Tesis” a el Instituto Politécnico Nacional, en adelante
El IPN, en las formas y medios descritos en el fundamento legal citado, en virtud de que cualquier
utilización por una persona física o moral distinta de los autores puede afectar o violar derechos
autorales, industriales, secretos industriales, convenios o contratos de confidencialidad o en general
cualquier derecho de propiedad intelectual de terceros distintos a los autores de “La Tesis”.
En virtud de lo anterior, El IPN deberá reconocer en todo momento nuestra calidad de autores de “La
Tesis” y limitarse a su uso en la forma arriba señalada.
Ciudad de México a 1° agosto de 2019.
ATENTAMENTE
César Alexander García Gómez
David Adrián García Gómez
Luis Alberto Ortíz Sánchez

ÍNDICE
Objetivo ......................................................................................................................................................... 7
Índice de Diagramas y Figuras ..................................................................................................................... 8
Índice de Tablas .......................................................................................................................................... 10
Planteamiento de problema ........................................................................................................................ 11
Justificación ................................................................................................................................................. 12
Alcance........................................................................................................................................................ 13
Introducción ................................................................................................................................................. 14
Capítulo 1) NODEMCU, Placa de desarrollo con el Módulo WiFi ESP8266 ............................ 15
1.1) Conceptos generales ........................................................................................................................... 15

1.2) Lenguaje script Lua .............................................................................................................................. 16
1.3) NodeMCU como placa de desarrollo ................................................................................................... 16
1.3.1) Primera Generación V0.9 ............................................................................................................ 18
1.3.2) Segunda Generación V1.0 / V2 ................................................................................................... 18
1.3.3) Tercera Generación V1.0 / V3 ..................................................................................................... 19
1.4) Pinout del NodeMCU ........................................................................................................................... 22
Capítulo 2) Atributos en la programación del Módulo ESP8266 en entorno Arduino ......... 23
2.1) Designación de Pines .......................................................................................................................... 23

2.2) Yielding ................................................................................................................................................ 23
2.3) Funciones de Tiempo .......................................................................................................................... 24
2.4) Salidas y Entradas Digitales ................................................................................................................ 24
2.5) Salidas PWM ....................................................................................................................................... 24
2.6) Entradas Analógicas ............................................................................................................................ 25
2.7) Interrupciones ...................................................................................................................................... 25
2.8) Comunicación ...................................................................................................................................... 25
2.8.1) Puerto Serie ................................................................................................................................. 25
2.8.2) I2C ............................................................................................................................................... 26
2.8.3) SPI ............................................................................................................................................... 26
2.8.4) WiFi .............................................................................................................................................. 26
2.9) Librerías de Arduino ............................................................................................................................. 27
Capítulo 3) Proceso de Programación del Módulo ESP8266 con el IDE de Arduino ........... 28
3.1) Instalación del Módulo ESP8266 en IDE de Arduino ..................................................................... 28
Capítulo 4) Sistema de Ficheros ........................................................................................................ 31
4.1) Esquema de la memoria Flash ....................................................................................................... 31

4.2) Limitaciones del sistema de ficheros .............................................................................................. 32
4.3) Cargar ficheros al sistema de archivos .......................................................................................... 32
4.4) Principales objetos del sistema de ficheros SPIFFS ...................................................................... 32

Capítulo 5) Módulo Dimmer AC para Arduino y Fuente de Alimentación AC-DC................. 34
5.1) Descripción general del módulo Dimmer AC para Arduino ........................................................... 34

5.2) Especificaciones técnicas ............................................................................................................... 35
5.3) Descripción general de la fuente de Alimentación AC-DC ............................................................. 36
5.4) Especificaciones técnicas ............................................................................................................... 36
Capítulo 6) Programación HTML ........................................................................................................ 37
6.1) Herramientas para desarrollo web ................................................................................................ 37

6.2) XAMPP ........................................................................................................................................... 37
6.2.1) APACHE ................................................................................................................................. 38
6.2.2) MySQL .................................................................................................................................... 38
6.2.3) PHP ........................................................................................................................................ 38
6.2.4) Perl ......................................................................................................................................... 38
6.3) HTML .............................................................................................................................................. 39
6.4) CSS ................................................................................................................................................. 39
6.4.1) BOOTSTRAP.......................................................................................................................... 39
6.5) Tipos de lenguaje de programación ............................................................................................... 40
6.5.1) Lenguajes compilados ............................................................................................................ 40
6.5.2) Lenguajes interpretados ......................................................................................................... 40
6.6) JavaScript ....................................................................................................................................... 41
6.7) AJAX ............................................................................................................................................... 41
6.8) FRAMEWORK ................................................................................................................................ 43
6.9) Web Service.................................................................................................................................... 44
6.9.1) Protocolo SOAP ..................................................................................................................... 44
6.9.2) Protocolo REST ...................................................................................................................... 44
6.10) Dominios Web .............................................................................................................................. 45
6.11) Tipos de dominios ......................................................................................................................... 45
6.11.1) TLD: Top Level Domain........................................................................................................ 45
6.11.2) ccTLD: Country Code Top Level Domain ............................................................................. 45
6.11.3) gTLD: Generic Top Level Domain ........................................................................................ 45
6.11.4) Dominios de segundo nivel .................................................................................................. 46
6.11.5) Subdominios ......................................................................................................................... 46
6.12) Cómo registrar un dominio Web ................................................................................................... 46
6.13) Alojamiento Web........................................................................................................................... 46
6.14) Pasos para registrar dominio en Hostinger .................................................................................. 46
Capítulo 7) Base de datos (SQL y PHP) ........................................................................................... 48
7.1) Funcionamiento del Sitio Web ....................................................................................................... 48

7.1.1) Inicio de Sesión ...................................................................................................................... 49
7.1.2) CRUD de los dispositivos ....................................................................................................... 49
7.1.3) Funcionalidades ..................................................................................................................... 51
7.1.4) Funcionamiento Web Service ................................................................................................. 51
7.1.5) Diagrama general de funcionamiento del sistema ................................................................. 52
Capítulo 8) Metodología para el desarrollo del Dispositivo ....................................................... 53
8.1) Diseño y construcción del dispositivo de Control de Iluminación ........................................................ 53

8.2) Componentes del dispositivo del Control de Iluminación. ................................................................... 53
8.3) Funcionamiento del Servidor Web....................................................................................................... 55

8.4) Formato de la cadena de texto enviada al módulo ESP8266 ............................................................. 55

8.5) Diseño del sistema del dispositivo de Control de Iluminación ............................................................. 56
8.6) Detector de cruce por cero .................................................................................................................. 57
8.7) Control de operación............................................................................................................................ 57
8.8) Programa principal y control de interrupciones ................................................................................... 58
8.9) Encendido / Apagado, Control de Intensidad ...................................................................................... 58
8.10) Login de ingreso al Servicio Web saci-site ........................................................................................ 59
Capítulo 9) Análisis e Interpretación de Resultados .................................................................... 61
9.1) Implementación del modo WebClient .................................................................................................. 61

9.2) Dificultades solucionadas en modo Client ........................................................................................... 61
9.3) Análisis costo beneficio........................................................................................................................ 64
9.4) Costo total del sistema instalado ......................................................................................................... 64
9.5) Propuesta de Mejoras .......................................................................................................................... 64
9.6) Autoevaluación .................................................................................................................................... 65
Capítulo 10) Conclusiones y Referencias adicionales................................................................. 66
GLOSARIO ............................................................................................................................................... 67
ANEXOS.................................................................................................................................................... 69
BIBLIOGRAFÍA........................................................................................................................................ 78

Objetivo.
Diseñar un sistema de control de iluminación con microcontrolador y un módulo wifi ESP8266 mediante un
Servidor Web.

Índice de Diagramas y Figuras.

Fig. 1) ESP8266 NodeMCU........................................................................................................................ 15
Fig. 2) Firmware NodeMCU ........................................................................................................................ 15
Fig. 3) ESP8266-Lua .................................................................................................................................. 16
Fig. 4) Descripción de pines ESP8266 NodeMCU V2 ............................................................................... 17
Fig. 5) Descripción de pines ESP12E ........................................................................................................ 17
Fig. 6) Módulos del ESP8266 ..................................................................................................................... 18
Fig. 7) Placa devkit v0.9 ............................................................................................................................. 18
Fig. 8) Placa ESP8266-NodeMCU-V2 (vista frontal) .................................................................................. 19
Fig. 9) Placa ESP8266-NodeMCU-V2 (vista trasera) ................................................................................ 19
Fig. 10) Configuraciones de Pines del ESP8266 NodeMCU V2 ................................................................ 19
Fig. 11) Placa ESP8266-NodeMCU-V3 (vista frontal) ................................................................................ 20
Fig. 12) Placa ESP8266-NodeMCU-V3 (vista trasera) .............................................................................. 20
Fig. 13) Configuraciones de Pines del ESP8266 NodeMCU V3 ................................................................ 20
Fig. 14) Comparativo entre versiones de Node MCU ESP8266 ................................................................ 21
Fig. 15) Chip ESP8266 NodeMCU entre V2 y V3 ...................................................................................... 21
Fig. 16) Comunicación entre ESP8266 y Arduino ...................................................................................... 23
Fig. 17) Comunicación WiFi con Arduino IDE ............................................................................................ 26
Fig. 18) Programación del ESP8266 con Arduino IDE ............................................................................... 28
Fig. 19) Configuración del ESP8266 con Arduino IDE ............................................................................... 28
Fig. 20) URLs Adicionales de Tarjetas ....................................................................................................... 29
Fig. 21) Gestor de Tarjetas en Arduino IDE ............................................................................................... 29
Fig. 22) Búsqueda del paquete de placas .................................................................................................. 29
Fig. 23) Disponibilidad de las placas basadas en ESP8266 ...................................................................... 30
Fig. 24) Esquema de la memoria Flash ...................................................................................................... 31
Fig. 25) Módulo Dimmer AC ....................................................................................................................... 34
Fig. 26) Diagrama eléctrico Módulo Dimmer AC ........................................................................................ 35
Fig. 27) Módulo Step Down AC-DC ............................................................................................................ 36
Fig. 28) Herramientas de desarrollo Web................................................................................................... 37
Fig. 29) Panel de Control de XAMMP para iniciar diferentes módulos ...................................................... 37
Fig. 30) Lenguajes de Programación para desarrollo Web ........................................................................ 38
Fig. 31) Documento HTML con contenido marcado para el desarrollo de una página web ...................... 39
Fig. 32) BOOTSTRAP Framework ............................................................................................................. 39
Fig. 33) Diferencia entre Lenguaje Compilado e Interpretado ................................................................... 40
Fig. 34) Proceso de solicitud en JavaScript ............................................................................................... 41
Fig. 35) Esquema Petición – Respuesta utilizando AJAX .......................................................................... 42

Fig. 36) Cuadro comparativo de los modelos de aplicación (Clásico vs AJAX) ......................................... 42
Fig. 37) Comunicación Síncrona y Asíncrona del modelo de Aplicación AJAX ......................................... 43
Fig. 38) Diferentes Frameworks para Aplicaciones Web ........................................................................... 44
Fig. 39) Tipos de Dominios ......................................................................................................................... 45
Fig. 40) Registro de Dominio de acuerdo con el tipo de implementación utilizada.................................... 46
Fig. 41) Insertar datos en MySQL – PHP a través de Servidor en Hostinger ............................................ 47
Fig. 42) Registro de dominio saci.site ........................................................................................................ 47
Fig. 43) Registro de dominio en Hostinger completado ............................................................................. 47
Fig. 44) Diagrama Entidad – Relación para la base de datos ILU ............................................................. 48
Fig. 45) Funcionamiento de un Servidor Web ............................................................................................ 48
Fig. 46) Inicio de sesión y registro de usuarios .......................................................................................... 49
Fig. 47) Ejemplo de CRUD en registrador de dominios Hostinger ............................................................. 50
Fig. 48) Configuración Web de Funcionalidades de la base de datos ....................................................... 51
Fig. 49) Funcionamiento del Sistema de Control de Iluminación ............................................................... 52
Fig. 50) Diagrama de partes de dispositivos electrónicos .......................................................................... 53
Fig. 51) Componentes del dispositivo de Control de Iluminación .............................................................. 54
Fig. 52) Configuración del Access Point del ESP8266 hacia la red WiFi requerida .................................. 54
Fig. 53) Comunicación inicial en el puerto serie con el ESP8266 .............................................................. 54
Fig. 54) Ejemplos de lectura de la liga JSON a través del Servidor Web hacia el ESP8266 .................... 55
Fig. 55) Envío de datos del Servido Web una vez configurado el Access Point en el ESP8266 .............. 56
Fig. 56) Diagrama de bloques del sistema ................................................................................................. 56
Fig. 57) Diagrama eléctrico de la fuente AC-DC ........................................................................................ 57
Fig. 58) Forma de onda del cruce por cero y de la onda rectificada de la fuente de poder ....................... 57
Fig. 59) Señal PWM con un ciclo de trabajo del 50% y voltaje aplicado a la carga................................... 58
Fig. 60) Página de Acceso al Servicio Web ............................................................................................... 59
Fig. 61) Error de Acceso al Servicio Web................................................................................................... 60
Fig. 62) Acceso a la página de configuración de los dispositivos de iluminación ...................................... 60
Fig. 63) Concepto WebClient y servidor PHP ............................................................................................ 61
Fig. 64) WebClient – PHP -User ................................................................................................................. 61
Fig. 65) Manipulación de Dispositivos de Iluminación vía Servidor Web ................................................... 62
Fig. 66) Lectura de datos vía Consola de la liga JSON ............................................................................. 62
Fig. 67) Comprobación de Control de Dispositivo de Iluminación.............................................................. 63
Fig. 68) Comprobación Alimentación 5V a la placa de desarrollo ESP8266 ............................................. 63
Fig. 69) Comprobación Alimentación 5V a la Fuente StepDown AC-DC ................................................... 63

Índice de Tablas.
Tabla 1) Características entre versiones de Node MCU ESP8266............................................................ 21
Tabla 2) Designación de pines en ESP8266 .............................................................................................. 23
Tabla 3) Variable de estado del ESP8266 ................................................................................................. 27
Tabla 4) Opciones de Modo del ESP8266 ................................................................................................. 27
Tabla 5) Tamaños memoria Flash ESP8266 ............................................................................................. 31
Tabla 6) Modos de apertura de ficheros ..................................................................................................... 33
Tabla 7) Operaciones CRUD ...................................................................................................................... 49
Tabla 8) Frameworks de acuerdo con el lenguaje empleado .................................................................... 50

Planteamiento de problema.
El presente trabajo está enfocado a los temas de seguridad y eficiencia en la energía eléctrica mediante
el diseño e implementación de un sistema de control de iluminación a través de un servidor web disponible
en Internet implementado al mercado de los hogares y a las necesidades de la tecnología moderna en
cuestión de domótica.
Se han revisado los antecedentes en cuestión de iluminación y cómo la evolución tecnológica ha dado
paso a soluciones actualmente propuestas por cualquier sistema domótico, así como los fundamentos
propuestos para dichas soluciones y ahora se introduce al presente trabajo con su justificación y alcance.
Como siguiente punto, se detallan las bases técnicas a utilizar para llevar a cabo la implementación del
trabajo mediante el análisis del uso del microcontrolador y sus prestaciones a los requerimientos del
sistema, así como de las herramientas que han soportado la programación correspondiente para poder
realizar la comunicación correcta entre nuestro dispositivo en conjunto con la red WiFi que cada usuario
tiene en su respectivo espacio de trabajo.
Posteriormente se expone la fase de diseño que comprende la fuente de poder, detector de cruce por cero,
circuito de fuerza, microcontrolador y el código de programación de dicho microcontrolador, así como
también la explicación del control de operación del dispositivo.
Por último, se muestran los resultados de las pruebas de funcionamiento del dispositivo demostrando su
desempeño en su fase de demostración.

Justificación.
La presente investigación se concretó debido a la necesidad que se presenta en la forma de implementar
un sistema central de gestión y control de servicios aplicables, según las especificaciones requeridas por
cada usuario.
No sólo oficinas, hoteles, colegios y viviendas particulares pueden requerir los servicios que proporciona
la domótica y esto se debe que es flexible, versátil y adaptable a cualquier necesidad, a cualquier tipo de
espacio y a cualquier actividad que se vaya a desarrollar.
Un sistema domótico proporciona diferentes beneficios y ventajas inalcanzables mediante una instalación
tradicional. Entre las principales razones de contar con un Sistema Inteligente, serían: comodidad,
seguridad, confort, información, ahorro energético. Estas cinco razones mencionadas se pueden unificar
en una sola: aumento de la calidad de vida.
En la investigación se aplicó conocimientos adquiridos durante la formación académica y con la factibilidad

tanto económica como tecnológica que se pudo conseguir, permitimos que este problema sea solucionado
al lograr el desarrollo y crecimiento completo de nuestro diseño sin mayores dificultades.

Alcance.
Debido a su versatilidad funcional, su uso no se reduce a las instalaciones simples y limitadas, sino que
también proporciona soluciones para sistemas complejos ya sea en una sencilla casa como en un edificio
de oficinas, la demanda para el confort y la funcionalidad en la gestión del aire acondicionado, iluminación
y sistemas de control de accesos está creciendo, al mismo tiempo que el uso eficiente de la energía cada
vez toma más conciencia. Mayores comodidades y seguridad combinadas con un menor consumo
energético sólo pueden ser mejoradas con control inteligente y la supervisión de todos los productos
involucrados.
Una de las principales causas del limitado desarrollo tecnológico en nuestro país es la falta de presupuesto.
Es aquí donde nuestro diseño tiene una ventaja sobresaliente ya que desarrollamos nuestro dispositivo en
base a componentes genéricos de muy bajo costo y que además utiliza programación abierta la cual puede
hacer que nuevas ideas se implementen y mejoren un sistema de control como el que nosotros hemos
realizado y así poder crear nuevas oportunidades dentro del mercado debido al mejoramiento y ventajas
que ofrece la domótica día a día.
El uso irracional de la energía es un factor limitante en cuanto a la adquisición de equipos que pueden
mejorar los servicios, pero su mantenimiento y consumo eléctrico compensan su rendimiento es por eso
que se busca siempre optimizar recursos.
Nosotros estamos de acuerdo que al ofrecer una tecnología que se mejore día con día, se garantiza
siempre mejorar servicios y corregir errores, es por esa razón que es necesario siempre innovar sistemas
que son obsoletos en comparación con otros. En nuestro caso en particular, se propuso aplicar un diseño
con la última tendencia del avance tecnológico, es decir, a automatizar una instalación en cuanto a confort
y facilidad en actividades diarias del usuario, buscando siempre la optimización.

Introducción.
Dentro del primer capítulo, se determina el problema, el cual radica en la mejora de un sistema domótico
(inicialmente de iluminación), haciendo más eficiente la automatización de servicios, confort y seguridad
de dicho sistema.
En el capítulo dos se describen las bases teóricas para entender lo que posteriormente se plantea como
solución al problema, se presentan los diferentes componentes que se emplean para el diseño de nuestro
dispositivo haciendo una introducción para entender mejor el funcionamiento y conocer las ventajas y
desventajas que ofrece nuestro sistema domótico.
En el capítulo tres es decir se describe el proceso de diseño e implementación desarrollado para resolver
el problema planteado.
En el capítulo cuatro se revisan los resultados obtenidos mediante la ejecución de diferentes pruebas de
control mediante la interfaz de usuario desarrollada y verificar el comportamiento que muestra la
comunicación y almacenamiento de información dentro de la base de datos creada para tener el último
estado de los dispositivos conectados al sistema domótico.
Dentro de las conclusiones que se determinan al final de nuestro trabajo, se refieren principalmente a las
necesidades que los usuarios tendrían en cuanto a automatización de servicios en relación con las
especificaciones de los dispositivos que se quieren controlar. Además, se realizan recomendaciones con
el fin de dar la solución apropiada al problema.
En el Alcance se indican los pasos a seguir para realizar el diseño de proyecto, averiguando lo que quiere
el cliente y posteriormente llevando a cabo la elección, ubicación y función de los productos a instalar,
realizando también el presupuesto de la automatización domótica del espacio requerido.

Capítulo 1) NODEMCU, Placa de desarrollo con el Módulo WiFi ESP8266.
En este proceso, nosotros vamos a revisar la primera placa de desarrollo basada en el ESP8266, de las
múltiples disponibles en el mercado iniciando por la más conocida como NodeMCU.
NodeMCU es una placa de desarrollo en el ESP12E el cuál, es probablemente el módulo más popular que
integra el SoC ESP8266. Sin embargo, a pesar de la popularidad de las placas NodeMCU, también existe
cierto grado de desconcierto respecto a la terminología utilizada (Lua, Lolin, etc.) y en ocasiones, se aúnan
hasta el punto de poder ser utilizados como sinónimos.
Fig. 1) ESP8266 NodeMCU.
Lo primero que se debe considerar es que a diferencia de Arduino donde hay una compañía que pone un
cierto orden en los diseños y modelos disponibles, las placas de desarrollo basadas en ESP8266 han
evolucionado poco a poco pero con distintos fabricantes.
Esto al final de cuentas, conlleva a una situación más complicada si nos concretáramos a revisar las
descripciones de algunos vendedores dentro de las cuales, se mezclan conceptos y contribuyen a generar
aún más desorden.
Por esta razón, vamos a revisar y tener un poco más de orden alrededor del NodeMCU donde se reitera
que es una de las placas de desarrollo basadas en ESP8266 más populares y uno de los pilares
fundamentales en los que se ha basado el ambiente del ESP8266 durante toda su evolución.
1.1) Conceptos generales.
El firmware NodeMCU fue creado poco después de aparecer el ESP8266, el día 30 de diciembre de 2013.
Para octubre de 2014 se publicó la primera versión del firmware NodeMCU en Github y dos meses más
tarde se publicaba la primera placa de desarrollo NodeMCU, denominada devkit v0.9, siendo también Open
Hardware.
Fig. 2) Firmware NodeMCU.
Durante ese tiempo, apenas había información sobre el ESP8266 aunado a que dicha información también
no era detallada y provocaba al final de cuentas muchas dudas al respecto. La mayoría del interés de la

comunidad se limitaba al ESP01, que se consideraba más un módulo Wifi barato para procesadores como
Arduino que una placa de desarrollo independiente.
En cuanto al firmware NodeMCU, este podía grabarse en un ESP8266, el cual, podía ser programarlo con
el lenguaje script Lua. La programación en Lua permitía la conexión y programación del ESP8266 de una
forma mucho más sencilla que las herramientas oficiales proporcionadas por Espressif.
1.2) Lenguaje script Lua.
Lua es un lenguaje de programación imperativo y estructurado, creado en 1993 por Roberto Ierusalimschy,
Luiz Henrique de Figueiredo y Waldemar Celes. Está basado en C y Perl, y está diseñado para ser muy
ligero. Ha sido implementado en diferentes dispositivos desde consolas de videojuegos hasta robots
industriales.
Fig. 3) ESP8266-Lua.
Con el paso del tiempo y la aparición de otras alternativas para programar ESP8266, especialmente con
C++ con el entorno del Arduino y otras como MicroPython, la aplicación mediante la programación en Lua
ha disminuido considerablemente.
A pesar de que la programación en Lua tenía aspectos interesantes, no es un lenguaje tan extendido como
C++ o Python. Además, nunca se pudo conseguir que fuera totalmente estable en el ESP8266. Por otro
lado, al ser un lenguaje interpretado en lugar de compilado, el rendimiento y aprovechamiento de los
recursos es inferior.
Para el año de 2015, el equipo de desarrollo original dejo de mantener el firmware de NodeMCU y aunque
sigue siendo mantenido por una comunidad de desarrolladores el interés en el firmware ha disminuido casi
por completo. Por esta razón, actualmente cuando se hace referencia al NodeMCU es en relación con la
placa de desarrollo que al mismo firmware.
1.3) NodeMCU como placa de desarrollo.
Básicamente, la placa de desarrollo NodeMCU está basada en el ESP12E y expone las funcionalidades y
capacidad del mismo, pero añadiendo las siguientes ventajas propias de placas de desarrollo:
• Puerto micro USB y conversor Serie-USB.

• Programación sencilla a través del Micro-USB.
• Alimentación a través del USB.
• Terminales (pines) para facilitar la conexión.
• LED y botón de reset integrados.

Fig. 4) Descripción de pines ESP8266 NodeMCU V2.
Dentro del ESP12E se cuentan con 22 pines donde se mantienen los 17 pines GPIO, el pin ADC, pero se
reducen los pines de alimentación a solamente 2 (Vcc y GND) y los de control a CHIP_EN (encender
apagar el ESP12E) y EXT_RSTB (para hacer reset).
En el módulo ESP12E tenemos disponibles la mayoría de pines “importantes” del SoC, mientras que el
módulo se encarga de conectar eléctricamente la mayoría de pines de alimentación y control. Este es uno
de los motivos del éxito y alta implementación del ESP12E, ya que nos ofrece todas las funciones del
ESP8266.
Fig. 5) Descripción de pines ESP12E.
Se tienen tres principales fabricantes de NodeMCU: Amica, Lolin/Wemos y DOIT/SmartArduino. Las placas
son muy idénticas, aunque pueden tener ciertas diferencias en la parte de la designación de los pines.

Por otro lado, se cuenta con tres versiones de la placa NodeMCU, que veremos a continuación. Las
designaciones entre las versiones también pueden llegar a generar cierta confusión, pero al final de
cuentas, en realidad es sencillo si se sigue correctamente la evolución desde el principio.
1.3.1) Primera Generación V0.9.
La versión original del NodeMCU se denominó devkit v0.9, y se montaba sobre un módulo ESP12 junto a
4MB de memoria flash (la memoria en el ESP8266 es externa y se conecta por el bus de comunicación
Serial Peripheral Interface (SPI)). El módulo ESP12 es similar al módulo ESP12E, pero carece de una
hilera de pines por lo que dispone de menos GPIO.
Fig. 6) Módulos del ESP8266.
La versión 0.9 en cuestión de diseño no contaba con la mejor presentación (amarilla-anaranjada y muy
ancha) con unas dimensiones de 47x21mm y la cual ocupaba 10 hileras de pines en una placa de
protoboard, por lo que la cubre por completo. Esto la hacía poco práctica en su uso porque no dejaba
pines libres en el protoboard para poder realizar conexiones.
Fig. 7) Placa devkit v0.9.
1.3.2) Segunda Generación V1.0 / V2.
La siguiente versión del NodeMCU es la v1.0 V2. Implementada por una compañía llamada Amica creada
por el alemán Gerwin Janssen, quien llevó a la fabricación de su propia versión mejorada de la V0.9. Al
final de este proceso, el diseño fue del agrado del equipo original de NodeMCU y la declararon versión
“oficial” de NodeMCU.
La principal diferencia de la versión v1.0 v2 se debe a que ahora se monta un ESP12E en lugar de un
ESP12, por lo que tiene más pines disponibles que el modelo original. Además, es más estrecha que la

versión 0.9, tapando sólo 8 hileras de un protoboard lo que deja una hilera adicional a cada lado para
realizar conexiones.
Figs. 8&9) Placa ESP8266-NodeMCU-V2.
Los tres fabricantes, Amica, Lolin/Wemos y DOIT/SmartArduino fabrican, o han fabricado en algún
momento, esta versión 2. Como el equipo de NodeMCU designó la versión de Amica como “oficial”, en
ocasiones se dice que Amica es el distribuidor oficial de NodeMCU. Esto al final de cuentas no debe ser
considerado así ya que es Open Hardware, y cualquier fabricante es tan válido como los demás.
Fig. 10) Configuraciones de Pines del ESP8266 NodeMCU V2.
1.3.3) Tercera Generación V1.0 / V3.
Básicamente el fabricante Lolin/Wemos decidió crear su propio diseño “mejorado” con unos cuantos
cambios menores. El cambio principal radica en que la versión 3 monta un conversor serial CH340G en
lugar del CP2102. El fabricante asegura que este cambio hace que el puerto USB sea más robusto.

Por otro lado, reutilizaron los dos pines reservados de la versión 2 para sacar uno de GND y un V-USB
que es una implementación de software solamente para un dispositivo USB de baja velocidad para los
microcontroladores AVR de Atmel, lo que hace posible construir USB Hardware con casi cualquier
microcontrolador AVR, que no requiere ningún chip adicional. En cuestión de las demás especificaciones
estas son las mismas. Por otro lado, la versión 3 vuelve a ser ancha y tapa toda la protoboard, lo cual es
un problema para poder realizar conexión entre los pines.
Figs. 11&12) Placa ESP8266-NodeMCU-V3.
Fig. 13) Configuraciones de Pines del ESP8266 NodeMCU V3.
Independientemente de las ventajas y desventajas que ofrece la versión 3, actualmente es considerada

como el modelo más vendido, aunque muchas personas aún siguen buscando la versión 2 porque son
prácticamente iguales en funcionalidades, pero está es más práctica en su uso ya que es más estrecha y,
por lo tanto, es más cómoda de utilizar.

Para la versión 3 que es un diseño creado por Lolin/Wemos, el mismo equipo de NodeMCU, lo ha indicado
como “no oficial” pero tomando en cuenta que es Open Hardware, el propio concepto de “no oficial” no
tiene mucho sentido y de igual forma, cada fabricante es libre de implementar su propio diseño en base a
las características principales que han ofrecido versiones previas.
Fig. 14) Comparativo entre versiones de Node MCU ESP8266.
Generación Versión Denominación Módulo Ancho Características
Primera 0.9 V1 ESP12 10 pines La original, no está a la venta
Segunda 1.0 V2 ESP12E 8 pines Versión “oficial”
Versión de Wemos/Lolin. Conversor

Tercera 1.0 V3 ESP12E 10 pines
CH340G
Tabla 1) Características entre versiones de Node MCU ESP8266.
La mejor forma de diferenciar entre una versión 2 y una versión 3 es observando el conversor serial que
cada uno tiene montado. El CP2102 que es cuadrado, o el CH340G que es más alargado.
Fig. 15) Chip ESP8266 NodeMCU entre V2 y V3.

1.4) Pinout del NodeMCU.
Como se ha explicado anteriormente, hay una gran variedad de pequeñas variaciones y fabricantes que
denominan igual (y en ciertas ocasiones de forma equivocada) a sus placas de desarrollo
independientemente si existen pequeñas diferencias entra las placas de desarrollo.
Entre las diferencias más comunes encontramos una relacionada con el nombre con el que han rotulado
cada pin. Otra diferencia es la posición del LED integrado en un pin diferente e inclusive hay casos en los
que hayan conectado los pines de forma distinta con el ESP12E. Pero revisando el pinout del ESP12E
nosotros tenemos que ser capaces de poder manejar cualquier placa NodeMCU aunque dichas
variaciones estén presentes.
Dentro de los siguientes apartados podremos revisar la parte de programación de una de las placas de
desarrollo basadas en ESP8266 con el entorno de Arduino.

Capítulo 2) Atributos en la programación del Módulo ESP8266 en entorno Arduino.

En este punto, nosotros entramos en detalle en la programación del ESP8266 con lo que vamos a iniciar
nuestro trabajo con una guía de programación del ESP8266 en el entorno Arduino donde podremos ver
las funciones principales y podremos hacer una comparación con sus equivalentes en un Arduino
convencional.
Ya hemos revisado anteriormente los detalles principales sobre el módulo ESP8266, así como sus
diferencias en base a la información del hardware del ESP8266, comparándolos con los de Arduino. Por
lo tanto, daremos inicio a nuestra guía de programación del ESP8266, indicando las distintas funciones del
ESP8266 y las similitudes y diferencias con la programación de un Arduino.
Fig. 16) Comunicación entre ESP8266 y Arduino.
2.1) Designación de Pines.
La designación de los pines está asociada en la implementación del ESP8266 en el entorno de Arduino,
según la siguiente tabla siguiente:
Alias GPIO Alias GPIO Alias GPIO

D0 3 D6 12 D12 12
D1 1 D7 13 D13 14
D2 16 D8 0 D14 4
D3 5 D9 2 D15 5
D4 4 D10 15
D5 14 D11 13
Tabla 2) Designación de pines en ESP8266.
Tomando en consideración la información anterior, podemos usar ambas designaciones indistintamente

para hacer referencia a un pin. Por ejemplo. Si se escribe “digitalWrite(D5, LOW)” sería lo mismo
que escribir “digitalWrite(14, LOW)” por lo que en ambos casos estaremos actuando en el pin
GPIO14.
Sin embargo, en la práctica, sabemos que no todos los fabricantes siguen el mismo criterio al momento de
identificar los pines en las placas. Por esa razón, al realizar la programación del ESP8266 se debe prestar
especial atención al pinout de la placa utilizada y tener presente posibles equivocaciones en la designación
para evitar cualquier problema de comunicación.
2.2) Yielding.
En relación con este concepto, se indica que es una de las diferencias más importantes respecto a un
Arduino donde el ESP8266 ejecuta muchas funciones relacionadas con mantener y gestionar la conexión

WiFI y la pila TC/IP. Si no se ejecutan dichas acciones se tendrían problemas de comunicación, bloqueos
e inclusive hasta reinicios.
Una de las recomendaciones es evitar bloqueos superiores a 100-200ms en la programación de nuestro

código. De hecho, si pasan 3 segundos sin llamar a estas funciones el WatchDog reiniciaría el ESP8266
e inclusive con el WatchDog desactivado, con una espera mayor de 8 segundos el ESP8266 se de igual
forma, se reiniciará automáticamente.
Las funciones del ESP8266 se ejecutan al final de cada loop, al llamar a la función: delay(), o con la
función desarrollada para el ESP8266 en Arduino yield(), que podríamos considerar equivalente a
delay(0).
Si al final de cuentas, dentro del código se tiene un proceso que requiera más de 100-200ms, se tendrá
que modificar para que incluya un delay() o un yield() dependiendo del caso que se tenga. Por otro
lado, tenemos otra función: delaymicroseconds() la cual no hace una llamada a la función yield()
y se debería evitar usar para esperas mayores a unos 20ms.
2.3) Funciones de Tiempo.
Las funciones de tiempo: millis() y micros() funcionan de la misma manera que en Arduino. También
funcionan de la misma forma las funciones: delay() y delayMicroseconds(), con las consideraciones
anteriores que se han indicado sobre el Yielding.
2.4) Salidas y Entradas Digitales.
Las entradas y salidas digitales (GPIO) se programan prácticamente igual que en cualquier Arduino. Así,
podemos cambiar el modo de un GPIO entre entrada o salida con la función: pinMode(pin, mode).
Dentro de “mode” tenemos diferentes opciones: OUTPUT, INPUT o INPUT_PULLUP. El pin 16 tiene un
modo adicional INPUT_PULLDOWN_16, pero no es frecuente su uso. Como en Arduino, por defecto todos
los pines se inicializan como INPUT.
Por otro lado, cuando el GPIO están en modo OUTPUT podemos utilizarlo como salida asignando un valor
(LOW o HIGH) igual que en Arduino con la función: digitalWrite(pin, output).
Por último, cuando el GPIO está en modo entrada podemos leer su valor igual que en Arduino con la
función: digitalRead(pin).
2.5) Salidas PWM.
La programación de salidas PWM (salidas analógicas) es muy parecida en Arduino sin embargo, el
ESP8266 no dispone de PWM por hardware sino que se realizar por software.
Esto supone un costo adicional que Arduino no tiene, sin embargo, también permite que podamos usar
PWM en cualquier GPIO. Para ello, igual que en Arduino, para usar una salida PWM se utiliza la función:
analogWrite(pin, value).
Por defecto el rango es de 10bits, por lo que “value” toma valores de 0-1023 (la mayoría de los modelos
de Arduino toman valores de 0-255) e inclusive podemos cambiar el rango hasta 14bits de salida con la
función: analogWriteRange(range).

La frecuencia por defecto es de 1kHz (el mínimo es 100Hz y el máximo es 40kHz) pero puede ser cambiado
con la función: analogWriteFreq(frequency).
Otra diferencia con un Arduino es si en el mismo programa queremos usar una salida PWM como digital
posteriormente, deberemos desactivar el PWM de forma explícita. Para ello simplemente ejecutamos la
función: analogWrite(pin, 0).
2.6) Entradas Analógicas.
El ESP8266 tiene una sola entrada analógica (ADC), que en el entorno Arduino se designa con A0. Para
poder leerlo se utiliza la misma función que en Arduino: analogRead(A0)
La respuesta dada es un valor de 10bits en el rango de 0-1023 (igual que en la mayoría de Arduinos), cuyo
voltaje es proporcional al voltaje en la entrada. Para el ESP8266 se cuenta con una entrada analógica
máxima de 1V, aunque muchas placas tienen un conversor para ampliarlo hasta 5V.
El ESP8266 también tiene un modo adicional que permite medir su voltaje de alimentación con la función
ADC_MODE(ADC_VCC). Esto puede ser de gran utilidad para el caso en que esté funcionando con
baterías. Mientras se use este modo el pin ADC real deberá estar desconectado y, lógicamente, no
podremos usarlo como entrada analógica.
2.7) Interrupciones.
El ESP8266 tiene interrupciones en todos los pines GPIO, excepto en el GPIO16 (D2). El uso es similar a
las interrupciones por hardware en Arduino con la siguiente función:
attachInterrupt(digitalPinToInterrupt(interruptPin), handler, FALLING);
Las opciones son: RISING, FALLING, CHANGE, ONLOW, ONHIGH, ONLOW_WE, ONHIGH_WE
2.8) Comunicación.
El ESP8266 se puede usar con un microcontrolador como Arduino conectado por puerto serie y manejarlo
con comandos “hayes” o programarlo directamente como si de un microcontrolador se tratara con el IDE
de Arduino utilizando el SDK configurado y el lenguaje de programación de Arduino (el core de Arduino).
El conjunto de comandos hayes es un lenguaje desarrollado por la compañía Hayes Communications que
prácticamente se convirtió en estándar abierto de comandos para configurar y parametrizar módems. Los
caracteres “AT”, que preceden a todos los comandos, significan “Atención”, e hicieron que se conociera
también a este conjunto de comandos como comandos “AT”.
2.8.1) Puerto Serie.
El uso del puerto serie en el ESP8266 es muy similar a su uso en Arduino y utiliza todas las funciones
empleadas para enviar y recibir datos (read, write, print, println, etc.) Los únicos detalles característicos
son los que están relacionados a funciones adicionales disponibles en el ESP8266, ya que el ESP8266
cuenta 2 puertos serie.
El primer puerto (UART0) está conectado a 2 parejas de pines. Por defecto se utilizan TX0 GPIO1 y RX0
GPIO3, pero puede cambiarse para que sea TX0 GPIO15 y RX0 GPIO13. Si queremos cambiar entre
ambas posibilidades usamos la función: Serial.swap().
El segundo puerto (UART1) está asociado a los pines TX1 GPIO2 y RX2 GPIO8. Pero el GPIO8 es usado
para la conexión con la memoria externa. Por tanto, el UART1 solo puede usarse para enviar datos. Las
funciones son mismas que las habituales, pero usando Serial1 en lugar de Serial. Por lo que se inicializaría
de esta forma: Serial1.begin(baud).

2.8.2) I2C.
El uso del I2C en el ESP8266 es similar en Arduino y utiliza las mismas funciones solamente la diferencia
radica en que el ESP8266 no dispone de hardware para comunicación I2C por lo que lo simula por
software.
Esto supone una carga de proceso adicional para el ESP8266 que en Arduino no se tiene, pero como
ventaja adicional podemos utilizar dos pines cualesquiera para la comunicación. Por defecto, los pines
empleados son SDA GPIO4 (D2) y SCL GPIO5 (D14). Pero podemos cambiarlo con la función:
Wire.begin(SDA, SCL). La velocidad máxima es de 450kHZ y por las demás características, la
programación es idéntica en Arduino.
2.8.3) SPI.
El ESP8266 tiene un SPI por hardware accesible para el usuario y su uso es similar y utiliza las mismas
funciones que en un Arduino. Los pines por defecto son MISO GPIO12 (D12), MOSI GPIO13 (D7), y CLK
GPIO14 (D13), SS GPIO15 (D10).
Adicionalmente, en el ESP8266 podemos cambiar la frecuencia del SPI de forma sencilla hasta 1Mhz con
la función: SPI.setFrequency(frequency)
2.8.4) WiFi.
Para tener acceso a las funcionalidades WiFi del ESP8266 se tiene que utilizar la librería ESP8266WiFi,
donde el funcionamiento es parecido a la librería de Arduino WiFi mediante el uso de la siguiente línea de
comando: #include <ESP8266WiFi.h>.
Fig. 17) Comunicación WiFi con Arduino IDE.
La funcionalidad WiFi es uno de los principales puntos de interés del ESP8266 y en el cual nosotros
estamos derivando el diseño de nuestro dispositivo de control de iluminación. Para este caso el ESP8266
actuará en modo estación (STA, Station), es decir, como un dispositivo que se conecta a un punto de
acceso (AP, Access Point).
Para conectarse a una red Wifi con el ESP8266 se necesita tener acceso a las funciones de la librería
ESP8266WiFi, que forma parte de la definición del ESP8266 que ya se tuvieron que haber descargado
con el gestor de placas al configurar el Arduino IDE. Simplemente usamos el método “Wifi.begin(…)”,
que tiene la siguiente definición:
WiFi.begin(ssid, password = null, channel = 0, bssid = null, connect = true)
- ssid: Nombre de la red WiFi a la que nos queremos conectar (max 32 char).
- password: Opcional, contraseña (mínimo 8 char y máximo 64).

- channel: Opcional, el canal de WiFi a emplear.

- Bssid: opcional, dirección MAC del punto de acceso.
- Connect: Indica si queremos conectar inmediatamente (si es false, sólo guarda los parámetros).
La función “WiFi.begin(…)” del ESP8266 guarda las credenciales indicadas en la memoria flash no
volátil (que se mantiene incluso aunque carguemos otro programa). Ante una falla en la conexión, el
ESP8266 se conectará automáticamente al último punto de acceso cuando esté disponible. Además, una
vez configurado, podemos volver a conectarnos llamando a la sobrecarga sin parámetros.
Las funciones “WiFi.begin(…)” devuelven el estado del ESP8266 para determinar cuándo se ha
establecido la conexión con la red configurada. También podemos obtenerlo en otro momento a lo largo
de nuestro programa con la función: WiFi.status(). Esta variable de estado del ESP8266 puede ser:
WL_CONNECTED Conexión establecida

WL_NO_SSID_AVAIL El SSID no se encuentra
WL_CONNECT_FAILED Contraseña incorrecta
WL_IDLE_STATUS Wi-Fi está cambiando entre estados
WL_DISCONNECTED El ESP8266 no está configurado en modo STA
Tabla 3) Variable de estado del ESP8266.
La función “WiFi.mode(WIFI_STA)” es opcional y sirve para dejar únicamente el modo STA y desactivar el
AP en caso de que se hubiera configurado previamente ya que, como se indicó previamente, el ESP8266
guarda la configuración del WiFi aunque lo reprogramemos. Las opciones de modos son:
WIFI_OFF Apagado
WIFI_STA Station
WIFI_AP Access point
WIFI_AP_STA Station+Acces Point
Tabla 4) Opciones de Modo del ESP8266.
2.9) Librerías de Arduino.
En general, las librerías de programación del ESP8266 no van a ser compatibles en Arduino. Si la librería
únicamente usa código de C++ por ejemplo, una librería de cálculo o se está utilizando funciones del
entorno para realizar el manejo del hardware, esta librería sí va a funcionar de la forma en que se espera.
Sin embargo, si accede a elementos internos de la arquitectura como timers, registros, o si se utilizan
códigos de ensamblador para acelerar ciertas tareas, la librería no va a funcionar a no ser que haya sido
adaptada específicamente para el ESP8266. Afortunadamente, la popularidad del ESP8266 ha hecho que
la misma comunidad haya desarrollado o adaptado la mayoría de las librerías disponibles en Arduino. Es
por eso que, dentro de las diferentes librerías disponibles, es nuestra responsabilidad tener que buscar
específicamente las compatibles con ESP8266.

Capítulo 3) Proceso de Programación del Módulo ESP8266 con el IDE de Arduino.
Fig. 18) Programación del ESP8266 con Arduino IDE.
La posibilidad de poder utilizar el módulo ESP8266 con el entorno de Arduino y todas las herramientas que
esto permite (IDEs, librerías, documentación, etc.) ha sido un éxito total en su implementación. Dicho éxito
se debe en gran parte a la comunidad desarrolladora aunado al apoyo con que se cuenta de parte del
fabricante Espressif.
Dentro de este punto, se revisará la configuración del Arduino IDE para poder programar el ESP8266 y las
placas basadas en este módulo, aunque también se puede utilizar cualquier otro IDE compatible con
Arduino como Visual Micro, Visual Studio Code o Atom, entre otros. Este proceso, únicamente es válido
para el módulo ESP8266 y no para el módulo ESP32.
3.1) Instalación del Módulo ESP8266 en IDE de Arduino.
Actualmente configurar el entorno de Arduino para funcionar con las placas de desarrollo de ESP8266 es
muy sencillo, gracias al soporte que tiene disponible como un paquete que podemos descargar y añadir al
gestor de placas.
Para poder programar las placas de desarrollo basadas en el ESP8266 se tiene que configurar la URL del
paquete para que podamos agregarlas al gestor de placas del IDE de Arduino. Por lo que se tiene que
acceder al menú de configuración y en “Gestor de URLs Adicionales de Tarjeta” hacemos clic:
Fig. 19) Configuración del ESP8266 con Arduino IDE.

Fig. 20) URLs Adicionales de Tarjetas.
Una vez completado el paso anterior, se procede a ir al gestor de tarjetas del IDE de Arduino y se realiza
la búsqueda del paquete de placas de desarrollo basadas en el ESP8266 y se instala.
Fig. 21) Gestor de Tarjetas en Arduino IDE.
Fig. 22) Búsqueda del paquete de placas.

Ya tenemos disponibles las placas de desarrollo basadas en el ESP8266 para programarlas con el
IDE de Arduino.
Fig. 23) Disponibilidad de las placas basadas en ESP8266.

Capítulo 4) Sistema de Ficheros.
Dentro de este capítulo, se revisará la forma de utilizar la memoria FLASH del ESP8266 para crear un
sistema de archivos de registro, utilizando el SPIFFS. Este sistema de archivo de registro puede guardar
todo lo que sucede en el ESP8266 y dejar disponible para consulta en cualquier momento, por medio de
un servidor Web.
Los programas de Arduino están compuestos por un solo fichero con extensión “ino”, aunque es posible
organizarlo en varios ficheros. El fichero principal siempre debe estar en una carpeta con el mismo nombre
que el fichero. Se hará uso de la librería FS.h, que facilita la gestión del sistema de archivos para
dispositivos integrados de almacenamiento FLASH NOR, con bus de comunicaciones SPI.
4.1) Esquema de la memoria Flash.
Aunque el sistema de archivos está almacenado en el mismo chip flash que el sketch, la programación de
un nuevo proyecto no modificará el contenido del sistema de archivos. Esto permite utilizar el sistema de
archivos para almacenar datos del sketch, archivos de configuración o contenido para el servidor web. El
siguiente diagrama ilustra el esquema o plantilla utilizado por el entorno Arduino:
|--------------|----------|--------------------|---|---|---|---|---|
^ ^ ^ ^ ^
Sketch Actualiz. OTA Sistema de ficheros EEPROM Config. WiFi (SDK)
Figura 24) Esquema de la memoria Flash.
Para poder utilizar las funciones del sistema de ficheros dentro del sketch, se debe incluir la siguiente línea
al sketch: #include "FS.h".
El tamaño del sistema de ficheros depende del tamaño del chip flash. Dependiendo de que tarjeta se ha
seleccionado en el IDE, se contará con las siguientes opciones de tamaño flash:
Tarjeta Tamaño chip flash, bytes Tamaño sistem. fich, bytes

Generic module 512k 64k, 128k
Generic module 1M 64k, 128k, 256k, 512k
Generic module 2M 1M
Generic module 4M 1M, 2M, 3M
Adafruit HUZZAH 4M 1M, 2M, 3M
ESPresso Lite 1.0 4M 1M, 2M, 3M
ESPresso Lite 2.0 4M 1M, 2M, 3M
NodeMCU 0.9 4M 1M, 2M, 3M
NodeMCU 1.0 4M 1M, 2M, 3M
Olimex MOD-WIFI-ESP8266(-DEV) 2M 1M
SparkFun Thing 512k 64k
SweetPea ESP-210 4M 1M, 2M, 3M
WeMos D1 & D1 mini 4M 1M, 2M, 3M
ESPDuino 4M 1M, 2M, 3M
WiFiduino 4M 1M, 2M, 3M
Tabla 5) Tamaños memoria Flash ESP8266.

4.2) Limitaciones del sistema de ficheros.
La implementación del sistema de archivos para ESP8266 tuvo que acomodarse a las restricciones del
chip, entre las cuales está su RAM limitada. SPIFFS fue seleccionado porque está diseñado para sistemas
pequeños, pero tiene como coste algunas simplificaciones y limitaciones.
SPIFFS es un sistema de archivos destinado a dispositivos flash SPI NOR en objetos incrustados. SIFFS
está diseñado con las siguientes características en consideración:
- Objetos pequeños (incrustados), RAM dispersa sin almacenamiento dinámico.

- Sólo se pueden borrar grandes áreas de datos (bloques).
- Ejecutar un borrado restablecerá todos los bits en bloque a unos.
- La escritura implementa de un uno a cero.
- Los ceros sólo se pueden implementar a los unos por borrar.
- Nivelación de desgaste
SPIFFS no soporta directorios, sólo almacena una lista plana de ficheros pero en contra de un sistema de
ficheros tradicional, el caracter '/' está permitido en los nombres de ficheros, por lo que las funciones que
se ocupan de listar directorios, por ejemplo, openDir("/website"), básicamente sólo filtra los nombres de
archivo y conserva los que comienzan con el prefijo solicitado ( /website/ ).
Como punto siguiente, existe una limitación a 32 caracteres en total en los nombres de ficheros. Un
caracter '\0' está reservado para la cadena C de terminación, lo que nos deja 31 caracteres para utilizar.
Esto significa que la recomendación es mantener los nombres de archivo cortos y no usar directorios
profundamente anidados, como la ruta completa de cada archivo (incluidos directorios, caracteres '/',
nombre base, punto y extensión) tiene que ser 31 caracteres como máximo.
4.3) Cargar ficheros al sistema de archivos.
Lo primero que se debe realizar es la descarga la herramienta ingresando en el link siguiente:

https://github.com/esp8266/arduino-esp8266fs-plugin/releases/latest
La siguiente acción para realizar es crear el directorio tools dentro del directorio de sketchs de Arduino y
se debe descomprimir la herramienta dentro de ese mismo directorio (la ruta debe quedar en
<home_dir>/Arduino/tools/ESP8266FS/tool/esp8266fs.jar) y procedemos a reiniciar el Arduino IDE.
Procedemos a abrir el sketch (o crear uno nuevo y guardarlo)

Después iremos al directorio del sketch (seleccionar Programa > Mostrar carpeta de programa) y se debe
crear un directorio llamado “data” y algún fichero que se quiera tener en el sistema de ficheros.
Importante recalcar que debemos estar seguros de tener la tarjeta seleccionada, el puerto (COM, TTY,
etc) y cerrar el Monitor Serie.
Como último paso, se selecciona en el menú de Arduino IDE en Herramientas > ESP8266 Sketch Data
Upload. Una vez elegida esta opción, se deberá ver el inicio de la carga de los ficheros al sistema de
ficheros de la memoria flash del ESP8266. Cuando este proceso concluya, la barra de estado del IDE
mostrará el mensaje “SPIFFS Image Uploaded”.
4.4) Principales objetos del sistema de ficheros SPIFFS.
SPIFFS.begin(). Este método monta el sistema de ficheros SPIFFS. Debe ser llamado antes de usar
cualquier otro API del sistema de ficheros y devuelve “true” si el sistema de archivos se ha montado
satisfactoriamente o “false” en caso contrario.
SPIFFS.end(). Este método desmonta el sistema de ficheros SPIFFS. Utilizar este método antes de
realizar una actualización OTA del SPIFFS.

SPIFFS.format(). Formatea el sistema de ficheros. Se puede llamar antes o después de llamar “begin” y
devuelve “true” si el formateo tuvo éxito.
SPIFFS.open(path, mode). Abre un fichero. path debe ser un camino absoluto comenzando con un slash
(p.ej. /dir/filename.txt). mode es una palabra que especifica el modo de acceso. Puede ser una de las
siguientes: «r», «w», «a», «r+», «w+», «a+». El significado de estos modos es el mismo que para la función
fopen en C.
Modo de Acceso Significado

Abre un fichero de texto para leerlo.
r
La secuencia se coloca en el comienzo del archivo.
Abre un fichero para lectura y escritura.
r+
Trunca en fichero con una longitud cero o crea un fichero de texto para escritura.
w
Abre para lectura y escritura.
w+ El fichero se crea si no existe, de lo contrario se trunca.
Abre el fichero para añadir (escribiendo al final del fichero).
a El fichero se crea si no existe.
La secuencia se coloca al final del archivo.
Abre el fichero para añadir (escribiendo al final del fichero).
El fichero se crea si no existe.
a+
La posición inicial para lectura es al comienzo del fichero, pero la salida es siempre añadida
al final del fichero.
Tabla 6) Modos de apertura de ficheros.

Capítulo 5) Módulo Dimmer AC para Arduino y Fuente de Alimentación AC-DC.
5.1) Descripción general del módulo Dimmer AC para Arduino.
Este módulo permite controlar cargas de voltaje alterno (220V AC) desde un microcontrolador como en
este caso, con el módulo ESP8266. Un Dimmer AC (a diferencia de un Relay) permite el control
regulado de voltaje AC, permitiendo obtener voltajes intermedios entre 0 y 220V AC y de esa forma variar
la intensidad de brillo en bombillas incandescentes, la velocidad en motores AC como ventiladores, la
potencia de un calentador resistivo entre otros.
Fig. 25) Módulo Dimmer AC.
Un dimmer integra dos etapas:
- Detector de cruce por zero.

- Triac.
El detector de cruce por cero es un circuito (normalmente un optoacoplador) que permite identificar el
instante en el que el voltaje alterno tiene un valor de 0V, es decir cuando el voltaje "cruza" de voltaje
positivo a negativo y viceversa.
Los triacs son dispositivos semiconductores (tiristor) que pueden permitir el paso de corriente AC mediante
una señal de disparo en cada semiciclo de corriente AC. Los Triac son el corazón de los Relay de estado
sólido o SSR. A diferencia de los relays mecánicos tradicionales un Triac puede activarse muy rápido
permitiendo el paso de una porción de la onda de voltaje alterno.
Para regular el voltaje AC el dimmer necesita sincronizar el cruce por cero con el microcontrolador y a
partir de ese instante decidir el momento de activación del Triac, de esa forma es posible regular que parte
de la onda senoidal estará activa. Esta técnica es conocida como control por ángulo de disparo y es la
más recomendada para variar el brillo en bombillas sin causar parpadeos.
Dentro del módulo tenemos dos grupos de conexiones:
- Potencia.
- Control.
En la parte de potencia son dos puntos de conexión donde se debe conectar el voltaje AC a las conexiones
"AC-IN", y la carga en las conexiones de "LOAD". En la parte de control se tienen 4 pines macho los cuales
se deben conectar "VCC" a 5V DC, "GND" a 0V (GND), "Z-C" es el pin de cruce por cero (zero-cross) y

debe ir conectado a una entrada digital "PWM" de la placa del módulo ESP8266 que en este caso, sería
el pin de control de disparo del triac (trigger) y debe ir conectado a una salida digital.
Un detalle importante que mencionar es con relación a que ciertas partes de este módulo estarán
conectadas a 220V AC, por lo que es muy peligroso si no se tiene el manejo correcto del voltaje AC. Por
esa razón, se debe tener mucho cuidado al realizar las conexiones y revisar detalladamente las conexiones
antes de alimentar el circuito a la red eléctrica.
5.2) Especificaciones técnicas.
Cambiar una carga de AC con un Arduino es bastante simple mediante el uso de un relé mecánico o un
relé de estado sólido con un triac aislado ópticamente. Se vuelve un poco más complicado si se necesita
atenuar una lámpara de AC con un Arduino ya que no es posible limitar la corriente a través de un Triac
debido a la gran potencia que el triac necesitaría disipar, lo que genera mucho calor y por lo tanto tampoco
es eficiente desde el punto de vista del uso de la energía. La forma correcta de hacerlo es a través del
control de fase donde el Triac está completamente abierto, pero solamente durante una parte de la onda
senoidal AC.
En teoría se podría dejar que un Arduino abra el Triac durante varios microsegundos, pero esto presentaría
un problema adicional ya que es impredecible el momento específico en que se abre el triac dentro de la
onda senoidal y, por lo tanto, el nivel de atenuación es impredecible. Es mandatorio poder contar con un
punto de referencia en la onda senoidal.
Como se ha mencionado previamente, se necesita un detector de cruce por cero. Este es un circuito que
indica al Arduino (u otro microcontrolador) cuando la onda senoidal pasa por cero y, por lo tanto, da un
punto definido en esa onda. Al abrir el Triac durante varios microsegundos después del cruce por cero, se
obtiene un nivel de atenuación predecible. A continuación, se indican los detalles técnicos del módulo
Dimmer AC:
- Voltaje de Control: 3.3-5V DC.

- Voltaje de Carga: 220V AC (máx.).
- Corriente nominal carga: 2A.
- Corriente máxima carga: 5A.
- Triac: BTA16-600B.
- Aislamiento óptico con: MOC3021 y 4N25.
Fig. 26) Diagrama eléctrico Módulo Dimmer AC.

5.3) Descripción general de la fuente de Alimentación AC-DC.
Este módulo de alimentación de AC-DC de potencia 5V 700mA es un módulo de potencia de nivel industrial
de tipo aislado que se puede utilizar en la conversión de potencia de AC-DC.
Cuando aparezcan situaciones de sobretensión, sobrecorriente y cortocircuito, este módulo ayudará a

proteger todo el dispositivo mediante el bloqueo. Esto se puede realizar aislando el voltaje alto y bajo y
además es compatible con la entrada de AC 85 ~ 265V y la salida de DC 5V.
Fig. 27) Módulo Step Down AC-DC.
5.4) Especificaciones técnicas.
A continuación, se indican los detalles técnicos del módulo Step Down AC-DC:
- Tensión de entrada: 85-264V AC.

- Tensión de salida: 3.1-3.5V.
- Corriente de entrada: 0.027mA.
- Corriente de salida: 700 mA.

Capítulo 6) Programación HTML.
6.1) Herramientas para desarrollo web.
El diseño efectivo y eficiente de sitios web puede ser una tarea compleja, difícil y larga de realizar. Es por
eso de la importancia de poder utilizar las herramientas que se conviertan en un elemento clave a la hora
de maximizar nuestros recursos.
Las fases de un desarrollo web, así como los lenguajes de programación usados, son muy extensas y
variadas, y por ello necesitamos herramientas específicas para cada una de ellas. En el desarrollo web
tenemos unas herramientas para el diseño, otras para la maquetación, otras para la programación, y para
la depuración.
Fig. 28) Herramientas de desarrollo Web.
Todas las herramientas que usemos son muy importantes, desde el Sistema Operativo hasta el comando
más insignificante, y por ello debemos elegir la más adecuada a nuestras necesidades y capacidades.
En este capítulo, conoceremos las principales herramientas existentes para poder desarrollar nuestro
proyecto web de forma práctica y sencilla.
6.2) XAMPP.
El nombre proviene del acrónimo de X (para sistemas operativos Windows, Linux y Mac OS), Apache,
Mysql, PHP, Perl. Se trata de un software libre que permite realizar pruebas en nuestra computadora
antes de ser subido a Internet.
Fig. 29) Panel de Control de XAMPP para inicializar diferentes módulos.

6.2.1) APACHE.
Es un software de servidor web gratuito y de código abierto. El nombre oficial es Apache HTTP Server y
permite a los propietarios de sitios web proporcionar contenido en la web.
El trabajo de un servidor es servir sitios web en Internet. Para lograr ese objetivo, actúa como un
intermediario entre el servidor y las máquinas de los clientes extrayendo el contenido del servidor en cada
solicitud de usuario y lo envía a la web.
El mayor desafío de un servidor web es servir a muchos usuarios diferentes de la web al mismo tiempo,
cada uno de los cuales solicita diferentes páginas. Los servidores web procesan archivos escritos en
diferentes lenguajes de programación como PHP, Python, Java y otros.
6.2.2) MySQL.
Es un sistema de administración de bases de datos relacional (RDBMS), compite con sistemas RDBMS
como Oracle, SQL Server y DB2. Utiliza el lenguaje de consulta estructurado (SQL), este lenguaje permite
crear bases de datos, así como agregar, manipular y recuperar datos en función de criterios específicos.
6.2.3) PHP.
Es un lenguaje de código abierto adecuado para el desarrollo web y que puede ser incrustado en HTML.
El código es ejecutado en el servidor, generando HTML y enviándolo al cliente.
Puede ser empleado en todos los sistemas operativos principales, incluyendo Linux, variantes de Unix,
Microsoft Windows, macOS, RISC OS y probablemente otros más. PHP admite la mayoría de los
servidores web de hoy en día, incluyendo Apache, IIS y muchos otros. De modo que, con PHP, se tiene la
libertad de elegir el sistema operativo y el servidor web.
6.2.4) Perl.
Es un lenguaje de programación práctico para extraer la información de archivos de texto y generar

informes a partir del contenido de los ficheros. Es un lenguaje interpretado, al igual que Javascript o ASP.
Esto quiere decir que el código de los scripts en Perl no se compila, sino que cada vez que se quiere
ejecutar se lee el código y se pone en marcha interpretando lo que hay escrito. Una diferencia fundamental
de Perl con respecto a otros lenguajes es que no limita el tamaño de los datos con los que trabaja, el límite
lo pone la memoria que en este momento se encuentre disponible.
Fig. 30) Lenguajes de Programación para desarrollo Web.

6.3) HTML.
Es el primer lenguaje que una persona debe conocer si desea comenzar a realizar páginas web. HTML
no es un lenguaje de programación, sino un lenguaje descriptivo, una serie de etiquetas que el navegador
interpretará de una u otra forma para mostrar distintos contenidos por pantalla
Es un lenguaje que pertenece a la familia de los “lenguajes de marcado” y es utilizado para la elaboración
de páginas web. Como se mencionó anteriormente, HTML no es un lenguaje de programación ya que no
cuenta con funciones aritméticas, variables o estructuras de control propias de los lenguajes de
programación, por lo que HTML genera únicamente páginas web estáticas, sin embargo, HTML se puede
usar en conjunto con diversos lenguajes de programación para la creación de páginas web dinámicas.
Fig. 31) Documento HTML con contenido marcado para el desarrollo de una página web.
Es el lenguaje de marcado descriptivo que se escribe en forma de etiquetas para definir la estructura de
una página web y su contenido como texto, de tal modo que HTML es el encargado de describir (hasta
cierto punto) la apariencia que tendrá la página web.
6.4) CSS.
CSS es un lenguaje de hojas de estilos creado para controlar el aspecto o presentación de los documentos
electrónicos definidos con HTML y XHTML. CSS es la mejor forma de separar los contenidos y su
presentación y es imprescindible para crear páginas web complejas.
Este lenguaje permite vincular los elementos HTML con plantillas de documento, que, además de contener
la información topográfica de los elementos visuales de la página, permiten separar completamente la
estructura de contenidos de su representación y presentación actuales, no sólo en el monitor sino en
cualquier pantalla (laptops, tablets, teléfonos móviles, entre otros).
6.4.1) BOOTSTRAP.
Es un framework CSS iniciado en el año 2011 por Twitter que permite dar forma a un sitio web mediante
librerías CSS que contienen tipografías, botones, cuadros, menús y otros elementos que pueden ser
utilizados en cualquier sitio web.
Fig. 32) BOOTSTRAP Framework.

Aunque fue iniciado por Twitter este fue liberado bajo licencia MIT y su desarrollo continúa en GitHub y es
una excelente herramienta para crear interfaces de usuario limpias y totalmente adaptables a cualquier
tipo de dispositivo y pantallas. Actualmente Boostrap es compatible con los siguientes navegadores:
- Google Chrome.
- Safari.
- Mozilla Firefox.
- Internet Explorer.
- Opera.
6.5) Tipos de lenguajes de programación.
Un lenguaje de programación es un lenguaje que permite a los desarrolladores escribir código fuente que
será analizado por un ordenador. El código fuente está escrito por el desarrollador, este es un conjunto
de acciones, llamadas instrucciones lo que permite dar órdenes al ordenador para operar el programa.
Dependiendo del código fuente, el ordenador realiza varias acciones, como abrir un menú, iniciar una
aplicación, efectuar búsquedas, entre otras.
Existen dos tipos de lenguajes, los lenguajes compilados e interpretados, sin embargo, ambos convierten
el código fuente a lenguaje máquina que son las instrucciones que entiende el computador (código binario
1 y 0).
Fig. 33) Diferencia entre Lenguaje Compilado e Interpretado.
6.5.1) Lenguajes compilados.
Son aquellos lenguajes que requieren de un compilador para traducirlo y crear un archivo independiente
que no necesita de ningún otro programa para ejecutarse, asimismo, este archivo se llama ejecutable.
6.5.2) Lenguajes interpretados.
Son aquellos que no necesitan ser pre-procesado mediante un copilador, eso significa que el ordenador
es capaz de ejecutar la sucesión de instrucciones dadas por el programador sin necesidad de leer y traducir
exhaustivamente todo el código. Entre los lenguajes interpretados más famosos se encuentran:
- PHP.
- ASP.
- Perl.
- Python.
- TCL.
- Bash.

Un programa escrito en un lenguaje compilado que posee la ventaja de no necesitar un programa anexo
para ser ejecutado una vez que ha sido compilado, además la ejecución se vuelve más rápida, sin
embargo, no es tan flexible como un programa escrito en lenguaje interpretado, ya que cada modificación
del archivo fuente requiere de la compilación del programa para aplicar los cambios.
6.6) JavaScript.
Es un lenguaje de programación interpretado utilizado en internet. Puede ejecutarse en Linux, Windows,

Aplle, entre otros. Gran parte de la programación en este lenguaje está centrada en describir objetos,
escribir funciones que respondan a movimientos del mouse, aperturas, utilización de teclas, cargas de
páginas entre otros.
Existen dos tipos de JavaScript, por un lado está el que se ejecuta en el cliente, este es el JavaScript
propiamente dicho, aunque técnicamente se denomina Navigator JavaScript pero también existe un
JavaScript que se ejecuta en el servidor, es más reciente y se denomina LiveWrite JavaScript.
Podemos identificar este lenguaje por sus etiquetas en archivos HTML como, por ejemplo:
<script type="text/javascript" src="micodigo.js"></script>

<script></script>
Fig. 34) Proceso de solicitud en JavaScript.
6.7) AJAX.
Se ocupa para cargar y presentar una página, luego mantenerse en esa página mientras scripts y rutinas
van al servidor buscado, en background, los datos que son usados para actualizar la página y sólo
mostrando u ocultando porciones de esta. Se define como una técnica que permite, mediante programas
escritos en Javascript, que un servidor y un navegador intercambien información, posiblemente en XML,
de forma asíncrona.
La diferencia es que con AJAX no es necesario recargar toda la página web, como ocurre cuando
pinchamos en un enlace o cuando pulsamos el botón submit de un formulario. Con AJAX es posible realizar
una conexión a un servidor desde dentro de una página web usando un programa Javascript. Dicho
servidor enviará una respuesta; esta respuesta se almacenará en una variable del programa Javascript y,
una vez almacenada en la variable, podremos hacer con ella lo que deseemos. AJAX contiene muchas
tecnologías:
- Presentación basada en estándares usando XHTML y CSS.

- Exhibición e interacción dinámicas usando el Modelo Objeto Documento.
- Exhibición y manipulación de datos usando XML y XLST.

- Recuperación de datos asincrónica usando XML Http Request.

- JavaScript.
Fig. 35) Esquema Petición-Respuesta utilizando AJAX.
Fig. 36) Cuadro comparativo de los modelos de Aplicación (Clásico vs AJAX).

En vez de cargar una página Web, al inicio de la sesión, el navegador carga el motor AJAX donde este es
el responsable por presentar la interfaz que el usuario visualiza y puede comunicarse con el servidor en
nombre del usuario.
El motor AJAX permite que la interacción del usuario con la aplicación suceda asincrónicamente
(independientemente con la comunicación del servidor).
Fig. 37) Comunicación Síncrona y Asíncrona del modelo de Aplicación Ajax.
Cada acción del usuario que generalmente generaría un requerimiento HTTP toma la forma de un llamado
JavaScript al motor Ajax. Cualquier respuesta a una acción del usuario que no requiera de un viaje de
vuelta al servidor (como una simple validación de datos, edición de datos en memoria, incluso algo de
navegación) es manejado por su cuenta.
6.8) FRAMEWORK.
Es una estructura conceptual y tecnológica de soporte definida, normalmente con artefactos o módulos de
software concretos, en base a la cual otro proyecto de software puede ser organizado y desarrollado.
Típicamente, puede incluir soporte de programas, librerías y un lenguaje interpretado entre otros
programas para ayudar a desarrollar y unir los diferentes componentes de un proyecto.

Buscando en la red se encuentra mucha información sobre los frameworks existentes para las diferentes
plataformas y lenguajes. Posiblemente uno de sus principales problemas es que haya demasiados pero
debido a la implementación de los estándares, podemos elegir entre diferentes opciones. Sin embargo, la
elección del framework concreto a utilizar se definirá en cuestión a:
- El tipo de aplicación a desarrollar.

- El lenguaje de programación y otras tecnologías concretas: base de datos, sistema operativo, entre
otros.
Existen diferentes frameworks orientados a diferentes lenguajes, funcionalidades, entre otros y si al final,
ninguno de ellos se adapta a las necesidades de desarrollo, siempre es mejor definir uno propio que
desarrollar.
Fig. 38) Diferentes Frameworks para Aplicaciones Web.
6.9) Web Service.
Es una vía de intercomunicación e interoperabilidad entre máquinas conectadas en Red. La interacción

se basa en el envío de solicitudes y respuestas entre un cliente y un servidor, que incluyen datos. El cliente
solicita información, enviando a veces datos al servidor para que pueda procesar su solicitud. El servidor
genera una respuesta que envía de vuelta al cliente, adjuntando otra serie de datos que forman parte de
esa respuesta y así podemos entender un servicio web como un tráfico de mensajes entre dos máquinas.
6.9.1) Protocolo SOAP.
Es un protocolo que define cómo deben de realizarse las comunicaciones entre máquinas. SOAP usa XML
como lenguaje de intercambio de datos con una estructura compleja que es capaz de albergar todo tipo
de datos sobre la solicitud o respuesta generada.
6.9.2) Protocolo REST.
Usa el propio protocolo HTTP para la comunicación entre máquinas. HTTP es ampliamente soportado por
todos los sistemas y de hecho para la transferencia de datos en la web se usa HTTP.
REST tiene a simplificar las cosas y en esa misma línea se suele usar un lenguaje diferente para
representación de los datos, el lenguaje JSON. En la actualidad, REST y JSON se han convertido en la
opción más sencilla y por tanto más recomendable para implementar un servicio web.

6.10) Dominios Web.
El dominio web es esencialmente el equivalente a una dirección física. Un navegador necesita un nombre
de dominio para dirigirte a un sitio web. Un sitio web consta de dos elementos principales, un dominio web
y un servidor web.
Un dominio web o dominio de internet es lo que las personas escriben para acceder a tu sitio, y apunta el
navegador web hacia el servidor que almacena esos recursos. Sin un dominio web, las personas tendrían
que recordar la dirección IP específica del servidor.
Un servidor web es una máquina física que aloja los archivos y las bases de datos que conforman el sitio
web y los envía a las personas a través de Internet cuando visitan un sitio desde algún ordenador.
Los registros de nombres de dominio son supervisados por una organización llamada ICANN la cual
especifica qué extensiones de dominios están disponibles y mantiene una base de datos centralizada de
dónde apuntan los dominios web.
6.11) Tipos de dominios.
Los dominios .com constituyen el 46.5% de todos los sitios web a nivel mundial, podemos encontrar otros
tipos de dominio como son .org y .net.
Fig. 39) Tipos de Dominios.
6.11.1) TLD: Top Level Domains.
Existen más de mil TLDs disponibles, pero los más comunes incluyen .com, .org, .net y .edu. La lista oficial
de TLDs es mantenida por una organización conocida como IANA. La lista de los TLDs también incluye
ccTLD y Gtld.
6.11.2) ccTLD: Country Code Top Level Domains.
Los ccTLDs usan solo dos letras y se basan en códigos internacionales de países, como .es para España
y .jp para Japón. Estos son utilizados para páginas dedicadas a ciertas regiones específicas.
6.11.3) gTLD: Generic Top Level Domains.
Muchos gTLDs están destinados a un caso de uso específico, como .edu, que está dirigido a instituciones
educativas por lo que no es necesario que cumplir con ningún criterio específico para registrar un gTLD,
motivo por el cual .com no sólo se utiliza con fines comerciales.

Como ejemplos gTLD incluyen .mil (militar) .gov (gobierno), .org (para organizaciones sin fines de lucro y
otras organizaciones) y .net.
6.11.4) Dominios de segundo nivel.
Son dominios que se encuentran directamente debajo de un dominio de nivel superior como por ejemplo,
las empresas británicas ocasionalmente usan .co.uk en lugar de .com, otro dominio de segundo nivel es
.gov.uk, que a menudo es utilizado por instituciones gubernamentales.
6.11.5) Subdominios.
Se pueden crear un subdominio que apunte a un directorio específico en el servidor. Esto puede ser muy
útil para sitios de campañas y otros tipos de contenidos web que deben mantenerse separados del sitio
principal.
Un ejemplo es Facebook, que utiliza developers.facebook.com para proporcionar información específica

para desarrolladores de aplicaciones y web que quieran usar la API de Facebook. Otro buen ejemplo es
support.google.com.
6.12) Cómo registrar un dominio Web.
Por lo general los proveedores de dominio te piden realizar una búsqueda de dominio que quieres registrar,
con la finalidad de poder revisar que esté disponible el nombre que se deseé. Después de ahí es sólo es
cuestión de ordenar y pagar.
Fig. 40) Registro de Dominio de acuerdo con el tipo de implementación utilizada.
6.13) Alojamiento Web.
Se requiere de un servidor web, ubicado en algún lugar del mundo y conectado a internet. Cuando se
escribe una URL en el navegador web, este envía una solicitud al servidor específico en el que está alojado
nuestro sitio. El servidor carga los archivos y los transmite por Internet al dispositivo que se está utilizando,
que a su vez descarga los archivos y los muestra.
6.14) Pasos para registrar dominio en Hostinger.
Todo sitio web necesita un nombre atractivo y para obtener uno se debe saber cómo comprar un dominio
ya que, en la actualidad, el registro de dominios se ha convertido en un procedimiento bastante simple.
Para el caso de los servidores de Hostinger, la ubicación de estos se reporta en Europa (Países bajos,
Lituania), Norte América (USA) y Asia (Singapur).

En resumen, para comprar un dominio se debe revisar los siguientes puntos:
1) Elegir un registrador de dominios confiable (como Hostinger).

2) Encontrar una herramienta de verificación de dominios disponibles.
3) Realizar una búsqueda de nombres de dominio.
4) Elegir la mejor opción disponible.
5) Realizar tu pedido y completar el registro del dominio.
6) Verificar la propiedad de tu nuevo dominio.
Fig. 41) Insertar datos en MySQL – PHP a través de servidor en Hostinger.
Aunque comprar nombres de dominio es la parte fácil, lo difícil es pensar en un buen nombre y elegir la
extensión correcta. En nuestro proyecto, el nombre del dominio que se eligió fue “saci.site”:
Fig. 42) Registro de dominio saci.site.
Fig. 43) Registro de dominio en Hostinger completado.

Capítulo 7) Base de datos en SQL y PHP.
En este capítulo se explica el diseño e implementación de la base de datos que se utiliza para el correcto
funcionamiento de nuestro proyecto. En la siguiente figura se muestra el diagrama de entidad-relación
para la base de datos ILU.
Fig. 44) Diagrama Entidad-Relación para la base de datos ILU.
En la tabla usuarios se encuentran todos los usuarios registrados que tienen acceso al sistema, en este
caso las columnas principales son IdUsuario, Nombre, Correo y Contraseña. Esta tabla se encuentra
relacionada con la tabla dispositivos, como se muestra en la figura un usuario puede tener múltiples
dispositivos, por lo que en esta tabla se guarda el IdUsuario y los dispositivos que este usuario tenga,
como valores principales podemos encontrar MAC, el estatus del dispositivo y el modo en el que se
encuentra.
En la tabla modos se encuentran los tipos de uso que se le puede dar a el dispositivo de iluminación, en
este caso solo tiene uno que es el modo de prender y apagar. Se pueden agregar más usos dependiendo
de los requerimientos.
La base de datos está orientada hacia una estructura simple debido al alcance del proyecto definido al
principio, sin embargo, con el diagrama, se pueden agregar más tablas volviendo más compleja su
estructura.
7.1) Funcionamiento del Sitio Web.
Se tratará el tema de la implementación de la base de datos a través del ingreso de datos por parte del
usuario final y administrando cada dispositivo a través de la página que se haya definido para dicho
proyecto.
Dentro de esta página web será posible desarrollar contenido en forma de texto, sonido, video, programas
adicionales, enlaces, imágenes y muchas otras cosas más y su lectura y manejo estarán adaptados a la
internet accediendo mediante un navegador web desde cualquier parte del mundo.
Fig. 45) Funcionamiento de un Servidor Web.

7.1.1) Inicio de Sesión.
Si el usuario ya cuenta con un usuario y contraseña sólo bastará con ingresar los datos con los que fue
registrado previamente. La página mantiene la sesión de usuario, por lo que esta no se cierra a menos
que usuario salga de ella.
En caso de que el usuario no se encuentre registrado, se procederá a capturar sus datos. Al terminar su
registro se tiene que dar un clic en “Enviar” y dicho registro quedará almacenado en la base de datos.
Fig. 46) Inicio de sesión y registro de usuarios.
7.1.2) CRUD de los dispositivos.
El concepto CRUD está estrechamente vinculado a la gestión de datos digitales. CRUD hace referencia
a un acrónimo en el que se reúnen las primeras letras de las cuatro operaciones fundamentales de
aplicaciones persistentes en sistemas de bases de datos:
- Create (Crear registros)

- Read bzw. Retrieve (Leer registros)
- Update (Actualizar registros)
- Delete bzw. Destroy (Borrar registros)
Dependiendo de la configuración regional, las operaciones CRUD pueden implementarse de diferentes

maneras, como lo muestra la siguiente tabla:
CRUD-Operation SQL RESTful HTTP XQuery

Create INSERT POST, PUT insert
Read SELECT GET, HEAD copy/modify/return
Update UPDATE PUT, PATCH replace, rename
Delete DELETE DELETE delete
Tabla 7) Operaciones CRUD.

Existen numerosos frameworks con un concepto CRUD basados en diferentes lenguajes y

plataformas. A continuación, presentamos algunos ejemplos:
Lenguaje o plataforma Framework
Java JDBC (The Java Database Connectivity), Hibernate, JBoss Seam, Isis
PHP Yii, CakePHP, Zikula, Symfony, TYPO3 Flow
Perl Catalyst, Gantry

Python Django, SQLAlchemy, web2py
Groovy Grails
.NET NHibernate, ADO.NET/Entity Framework
Ruby Ruby on Rails

JavaScript Backbone.js, AngularJS
Tabla 8) Frameworks de acuerdo al Lenguaje empleado.
Como cualquier CRUD, podemos crear, leer, actualizar y borrar datos de la base de datos, en este caso
serían los registros de los dispositivos configurados en nuestro proyecto.
Para buscar un dispositivo bastará con poner el nombre del dispositivo o la MAC del mismo y dar un clic
en el botón “Buscar” y se mostrarán los campos que coincidan con la búsqueda.
Para eliminar un dispositivo primero tenemos que buscar el dispositivo, una vez que coincida con el
dispositivo a eliminar se da clic en el botón de “Eliminar”, posteriormente se actualizará la página y ya no
se observará dicho dispositivo.
Para guardar un dispositivo nuevo se ingresa el nombre del dispositivo que se requiera y se le asigna el
número de la MAC del dispositivo a controlar y se da clic en el botón “Guardar” y este será dado de alta
en el listado de dispositivos.
Para actualizar un dispositivo primero tenemos que buscar el dispositivo a actualizar, una vez que coincida
la búsqueda con el dispositivo se procede a cambiar los parámetros que necesitamos y se da clic en el
botón “Guardar”.
Fig. 47) Ejemplo de CRUD en registrador de dominios de Hostinger.

7.1.3) Funcionalidades.
Dentro de la base de datos, se han dado de alta diferentes funcionalidades que se encuentran disponibles
para el control que cada usuario tendrá para los dispositivos que se requieran controlar:
1) Activar o Desactivar todos los dispositivos: Todos los dispositivos registrados se activan o se
desactivan dependiendo de lo que se requiera, un ejemplo práctico de esta funcionalidad es que
al momento de salir del hogar se apaguen todos los dispositivos de iluminación.
2) Activar o Desactivar algún dispositivo: Cada dispositivo cuenta con un botón de tipo “SLIDE”,
que activa o desactiva únicamente el dispositivo seleccionado lo cual conlleva a que se realice una
nueva actualización a la base de datos. Un ejemplo práctico de esta funcionalidad es el apagar o
prender la iluminación de un solo dispositivo.
3) Valor o Intensidad: Como tercera funcionalidad se ha agregado la posibilidad de regular la

intensidad de la luz, al regular el botón “SLIDE” de dicha funcionalidad, se actualiza el valor en la
base de datos.
Fig. 48) Configuración Web de Funcionalidades de la base Datos.
7.1.4) Funcionamiento Web Service.
Al realizar la configuración por medio de la página saci.site, los parámetros se actualizan en la base de
datos por lo que no existe un medio de control directo a los dispositivos, por lo que los dispositivos
conectados vía WiFi no pueden consultar directamente a la base de datos.
Para la solución de esta situación, se implementó un Web Service que consulta a la base de datos y
regresa los datos mediante un formato JSON con los parámetros que los dispositivos Wifi requieren revisar.
Como entrada para consultar es necesario tener la dirección MAC de cada dispositivo respetando la
siguiente estructura:
http://saci.site/codeigniter/index.php/welcome/getDispositivoByMAC/00:00:00:00:01

En la liga se puede observar que consta de la dirección del sitio, en este caso “saci.site”, seguido del
“index.php” que es la página que nos va a redirigir a los directorios y métodos que el Web Service contiene
después, se tiene el “welcome” que es la dirección del directorio y finalmente, viene el
“getDispositivoByMAC” que es el método que utilizaremos para extraer la información del dispositivo por
su “MAC Address”.
A la salida de esta consulta nos debe regresar los parámetros del dispositivo haciendo la consulta de la
siguiente forma:
{"idDispositivo":"38","IdUsuario":"18","IdModo":"1","NombreDispositivo":"PRUEBA","MAC":"00:00:00:
00:01","Valor":"98","Activo":"0"}
7.1.5) Diagrama general de funcionamiento del sistema.
Existen dos tipos de peticiones al servidor, la petición que genera el buscador a la página web y la petición
de la placa de desarrollo ESP8266. La primera puede ser por diferentes dispositivos como pueden ser
una PC, Laptop, Tablet o teléfono inteligente, esta petición primeramente pasa por el Access Point antes
de llegar a internet, de ahí es redireccionado al servidor de nuestro proveedor (en este caso es el servidor
de Hostinger) y posteriormente es enviada la página web index.php.
La segunda petición es por parte de la placa de desarrollo ESP8266, esta petición primeramente para por
el Access Point antes de llegar a Internet, de ahí es redireccionado al servidor de nuestro proveedor y
posteriormente se accede al Web Service que consulta al servidor. En la siguiente figura se muestra el
funcionamiento:
Fig. 49) Funcionamiento del Sistema de Control de Iluminación.

Capítulo 8) Metodología para el desarrollo del Dispositivo.
8.1) Diseño y construcción del dispositivo de Control de Iluminación.
Los dispositivos electrónicos se componen básicamente por las siguientes partes:
BLOQUE DE COMUNICACIÓN
FUENTE DE PODER CONTROL ILUMINACIÓN
Fig. 50) Diagrama de partes de dispositivos electrónicos.
Bloque de Control: Es la parte más importante del proyecto ya que aquí es donde se guarda el programa
principal con las instrucciones necesarias para que todo funcione de una manera organizada y adecuada.
Esta parte es básicamente una placa de desarrollo ESP8266 que es el encargado de procesar la
información, administrar las comunicaciones e interactuar con los dispositivos de iluminación a través del
módulo AC Dimmer.
Bloque de comunicación: Este bloque está formado por los módulos de comunicación conectados
directamente al bloque de control mediante la comunicación con el Servidor Web donde se permite la
interconexión con otros dispositivos.
Bloque de Iluminación: Permite la interacción de cada dispositivo de control con los dispositivos de
iluminación mientras permiten la recolección de estados de cada dispositivo controlado.
Fuente de poder: Es la parte que alimenta de energía al dispositivo de control, proporcionando los niveles
adecuados de voltaje y corriente para que este pueda funcionar de una manera correcta. Esta es una parte
muy importante y fundamental ya que el sistema necesita estar conectado permanentemente a la red
eléctrica.
8.2) Componentes del dispositivo de Control de Iluminación.
En este apartado, se muestran los elementos que conforman el dispositivo principal del sistema donde
iniciamos con la fuente StepDown AC-DC que alimenta de energía a la placa de desarrollo ESP8266 por
medio de la cual es usuario controla los dispositivos de iluminación, este nodo está encargado del envío y
recolección de estados de los dispositivos controlados.
Cuenta con dos tipos de comunicaciones hacia el exterior, una comunicación vía WiFi que une a la placa
a una red LAN por medio de un dispositivo central (Access Ponit) y este a su vez permite la interconexión
con Internet; la dirección IP local de placa es la 192.168.4.1 (por default, aunque esta puede ser
modificada). La segunda comunicación es hacia el módulo AC Dimmer que permite la comunicación con
los dispositivos de iluminación controlados.
Adicional, se ha configurado una conexión por medio de la placa como un puerto serial virtual por lo que
la comunicación de los datos enviados es serial con una velocidad de 115200 baudios, sin control de flujo,
8bits de datos, sin paridad y con 1bit de parada.

Dispositivo de Iluminación
Módulo AC Dimmer
Fuente StepDown AC-DC
Placa de desarrollo
ESP8266
Fig. 51) Componentes del dispositivo de Control de Iluminación.
Fig. 52) Configuración del Access Point del ESP8266 hacia la red WiFi requerida.
Fig. 53) Comunicación inicial en el puerto serie con el ESP8266.

8.3) Funcionamiento del Servidor Web.
Nosotros utilizamos el modo WebClient donde el módulo ESP8266 siempre se conectará con un servidor
Web cuya dirección nunca cambia. Nuestro Hosting será nuestro Server quien responderá a los
requerimientos del módulo ESP8266.
Nuestro servidor Web aloja una página PHP, dependiendo de la aplicación. PHP es dinámico y permite
mostrar contenidos que se modifican en nuestro sitio y procesar con código PHP dichos contenidos. Toda
petición a un servidor en internet siempre es respondida en lenguaje HTML que es la forma solicitada para
poder ser ejecutada desde cualquier navegador.
El propósito inicial es que un usuario ingrese al sitio donde se presenta un contenido PHP, en este caso,
un formulario de registro en el cual dicha información, será almacenada en la base datos para poder
acceder al siguiente contenido PHP donde se muestra la información del último estado de las salidas
configuradas y esto se actualiza dado que la información que se presenta no es siempre la misma.
Es aquí donde cada usuario puede modificar el estado de las salidas, las cuales se graban de manera
permanente en un archivo de texto, que aloja en una cadena, el estado de estas (activada, desactivada).
Esto no significa que inmediatamente dicha modificación se realice en el WebClient del módulo ESP8266.
El cliente se conectará al sitio cada determinado intervalo de tiempo y enviará una solicitud del tipo GET
donde requiere el estado de la salida que tiene asignada (foco). Dicha petición se procesa vía PHP leyendo
el archivo y devolviendo una cadena de texto de dicha salida hacia el Cliente junto con la indicación.
El cliente al recibir la cadena de texto deberá interpretar los datos requeridos para poder conocer la solicitud
hecha y hacer la comparación con el estado de su salida. Si existe cambio dentro de esta cadena, asumirá
que habrá que modificar la salida en su sistema y realizará dicho cambio, hasta que se vuelva a mandar
una nueva cadena de datos del sitio Web.
8.4) Formato de la cadena de texto enviada al módulo ESP8266.
El Webclient dentro del módulo ESP8266 leerá la cadena y entonces identificará la información que debe
modificar.
Cada vez que el usuario efectúe un cambio, la cadena guardada en el archivo del sitio será de la siguiente
forma:
http:// www.saci.site/saci/codeigniter/index.php/welcome/getDispositivoByMAC/bc:dd:c2:24:97:19
Fig. 54) Ejemplos de lectura de la liga JSON a través del Servidor Web hacia el ESP8266.

Fig. 55) Envío de datos del Servidor Web una vez configurado el Access Point en el ESP8266.
8.5) Diseño del sistema del dispositivo de Control de Iluminación.
Para el diseño de nuestro proyecto, se realizó el siguiente diagrama de bloques:
Fig. 56) Diagrama de bloques del sistema.

8.6) Detector de cruce por cero.
Este proceso fue diseñado con la finalidad de conseguir sincronizar el voltaje de línea y el módulo
programado PWM que como se muestra en la figura, controlará el disparo en el circuito de fuerza.
Fig. 57) Diagrama eléctrico de la fuente AC-DC.
En referencia a la figura anterior el detector de cruce por cero está conformado por D4, R1, R2 y Q1.
Cuando la onda es un tanto mayor que cero el transistor Q1 se satura obteniendo en la salida “zc” un
voltaje aproximadamente igual a cero. De lo contrario, cuando la onda es muy cercana a cero, el transistor
se abre permitiendo a la salida un pulso momentáneo a 5V como se observa en la siguiente figura:
Fig. 58) Forma de onda del cruce por cero y de la onda rectificada de la fuente de poder.
8.7) Control de operación.
El control que se ha definido es través de un servidor web donde el usuario realizar un registro que consta
de un correo electrónico y una contraseña que pueda incluir diferentes caracteres (mayúsculas,
minúsculas, signos o números). Una vez hecho este registro, el usuario se conecta a la página donde se
presentan las diferentes configuraciones de los dispositivos de iluminación a controlar. Las funciones
implementadas dentro de nuestro proyecto son las siguientes:
1) Agregar un Foco: Con esta función se incluirán los diferentes focos (botón agregar dispositivo) que
se quieren control a través de la gestión de su MAC Address en la cual cuando se
realice una solicitud de lectura o cambio de estado de cada dispositivo vía http,
hacia el servidor, dicha información sea almacenada dentro de la base de datos
que se tiene configurada para cada usuario registrado.
2) Encender/Apagar un Foco: Se realizará mediante la ejecución de una función (botón “SLIDE” de

Encendido) definida en la interfaz de usuario dentro del servidor web que
cada usuario tiene a su disposición.
3) Control de Intensidad de un Foco: El control de intensidad se lleva a cabo mediante la ejecución de

otra función (botón “SLIDE” de intensidad) dependiendo si se
desea aumentar o disminuir el nivel de intensidad del foco
seleccionado.

4) Control Grupal de Focos: Dentro de esta función (botón “SLIDE” de Activación - Desactivación
General), se permitirá controlar (encender, apagar, intensidad) todos los
focos sin importar el estado actual de cada foco.
5) Eliminar Foco configurado: Para el caso contrario en que se quiere excluir un foco de un grupo
definido por el usuario, se tiene una función que realice dicha acción
(botón eliminar dispositivo).
8.8) Programa principal y control de interrupciones.
El programa principal se puede dividir en dos etapas donde la primera se encarga de la espera por la
activación de alguna interrupción y dentro de la segunda, de la respuesta al servicio de una interrupción
previa.
Tanto para la activación de los dispositivos de entrada del sistema como el manejo de los requerimientos
de los periféricos internos del microcontrolador se manejan a través de interrupciones, como se dispone
de un solo vector de interrupción, es necesario que las rutinas de servicio sean lo más rápidas posibles.
Las interrupciones de cruce por cero y temporizadores están ligadas al diseño del PWM y su
procesamiento no toma mucho tiempo por lo que son servidas dentro de este control. Cuando ocurren
interrupciones debido a los dispositivos de entrada simplemente se activa una bandera para luego ser
reconocidas al volver al programa principal.
Ya en el programa principal si se da una interrupción, este consultará la acción ejecutada en la interfaz de

usuario para poder realizar la tarea correspondiente, ya sea el encendido/apagado de un dispositivo de
iluminación o aumento/disminución de intensidad luminosa, por ejemplo. Caso contrario, el sistema
quedará a la espera de una nueva acción dentro de un determinado tiempo donde si no se recibe otra
acción, el programa volverá a principal y descartará los datos recibidos hasta ese entonces.
8.9) Encendido / Apagado, Control de Intensidad.
El control de intensidad de luminosidad de los focos está dado mediante el recorte de voltaje eficaz que
reciben, esto se logra mediante el uso de un TRIAC cuya activación estará gobernada por el módulo PWM
como se puede observar en el ejemplo de la siguiente figura:
Fig. 59) Señal PWM con un ciclo de trabajo del 50% y el voltaje aplicado a la carga.

Para lograr el retardo requerido en el encendido y apagado de las luces (encendido progresivo y
desvanecimiento) bastará con ejecutar continuamente el algoritmo de aumento/disminución de un paso
interponiendo un retardo entre cada ejecución, con esto se consigue un barrido completo. Para el control
de intensidad dependerá de la ejecución del scroll definido para esta acción que tiene el usuario para poder
apreciar los pasos definidos y así poder ver el nivel de intensidad que se quiere tener.
8.10) Login de ingreso al Servicio Web de saci.site.
Es la primera página de nuestro servicio Web que se muestra al apuntar en el navegador a la dirección de
la “saci.site” y como se ha indicado anteriormente, consiste de un pequeño formulario en donde el usuario
tiene que ingresar específicamente dos datos para poder realizar el registro por primera vez dentro el sitio
(un correo electrónico y una contraseña). Una vez que esta información ya ha sido guardada en el servidor
web, cada vez que el usuario quiera ingresar al sitio de configuración, debe escribir los mismos datos que
dio de alta por primera vez, si la contraseña no es correcta la página devuelve un mensaje de error y se
recarga.
Los caracteres ingresados en la interfaz son ocultados visualmente y para su envío al servidor se deben
encriptar para seguridad del usuario. De esta manera se previene el ingreso a personas no autorizadas,
además se debe recordar que la única forma que el usuario pueda acceder a esta interfaz es mediante la
conexión directa a la LAN donde se encuentra el servidor.
El código fuente de esta página básicamente consiste en crear una sesión a nivel de aplicación con PHP,
es decir si el usuario ingresa una clave válida y se crea una sesión que vincula al dispositivo desde el que
se está ingresando y PHP en el servidor. Esta sesión es necesaria para que el usuario pueda continuar
utilizando la interfaz y siempre se verificará que el usuario haya iniciado sesión antes de cargar una nueva
página.
Con este método se evita que otro usuario pueda apuntar simplemente a la URL de la página en cuestión
y pueda interactuar con la interfaz, de modo que, si no inició sesión, el sistema lo regresa automáticamente
a la página de login.
Fig.60) Página de Acceso al Servicio Web.

Fig.61) Error de acceso al Servicio Web.
Fig.62) Acceso a la página de configuración de los dispositivos de iluminación.

Capítulo 9) Análisis e Interpretación de Resultados.
9.1) Implementación del modo WebClient.
La idea del proyecto fue modificar el estado de salidas digitales desde cualquier computadora o dispositivo
móvil, a través de internet, desde cualquier parte del mundo, utilizando la placa de desarrollo ESP8266 en
modo WebClient y la implementación de un servidor de Hosting.
Fig. 63) Concepto WebClient y servidor PHP.
No se trata de un acceso vía LAN, sino vía WAN, es decir con conectividad a Internet desde cualquier
dispositivo. Un usuario utilizará su navegador preferido y se conectará a un sitio que aloja una página Web
donde efectuará las modificaciones de 1 sola salida por cada módulo ESP8266 que tenga configurado.
Nuestro WebClient Arduino se conectará también a dicho sitio a intervalos regulares de tiempo y solicitará
por medio de consulta GET el estado de la salida la cual será modificada en el sitio remoto y confirmada
al sitio. De esta manera el usuario al actualizar la página sabrá si dichas modificaciones efectivamente se
han realizado.
9.2) Dificultades solucionadas en modo Client.
La aplicación sobre el módulo ESP8266 es de tipo WebClient y no Server, dado que en modo WebClient
no vamos a depender de las direcciones IP públicas que se modifican cada determinado tiempo si
tuviésemos el modo Server en Arduino.
Fig. 64) WebClient-PHP-User
Como se indicó anteriormente, cada módulo ESP8266 inicialmente se ha configurado como Access Point
permitiendo la interconexión con Internet. La dirección IP local de módulo es la 192.168.4.1 por default y
después, nuestro router le asigna una dirección IP al módulo ESP8266 para poder distinguirlo dentro de
nuestra red local. El router le asigna una dirección de IP de manera dinámica por medio del servicio de

DHCP, donde se asigna una dirección IP de acuerdo con la dirección física MAC del módulo ESP8266
identificada previamente por nosotros. Se puede también asignar una IP fija, pero como pueden existir
diferentes dispositivos conectados al router en una red local (dispositivos móviles, computadoras, tablets,
etc.) todos son de IP dinámica, por lo que pueden colisionar en algún momento con otras direcciones IP y
dejar de funcionar.
Hasta aquí podremos usar siempre nuestro sistema, pero de forma local, es decir vía LAN, si queremos
acceder a nuestro sistema desde fuera como internet, habrá que utlizar un puerto adicional en el módem
para redireccionar el tráfico de datos desde internet hacia la IP del módulo ESP8266. Esta función depende
también del módem y generalmente está en Port Forwarding que son los puertos 80 y el 5400.
Para acceder desde fuera de nuestra red, se necesita la IP pública del módem, y es dinámica. La opción
que acordamos utilizar fue un servicio de servidor DNS, esto es mediante la asignación de un nombre de
dominio (saci.site). Este servicio siempre se conecta a la IP modificada o no, con el nombre DNS.
Una vez contemplados todos estos detalles, nosotros hemos concretado de forma exitosa la comunicación
de nuestros dispositivos de iluminación con nuestro sitio web donde se realizaron diferentes pruebas de
control con diferentes dispositivos conectados y todas las lecturas de status se almacenan de forma
correcta dentro de nuestra base de datos:
Fig. 65) Manipulación de Dispositivos de Iluminación vía Servidor Web.
Fig. 66) Lectura de datos vía Consola de la liga JSON.

Fig.67) Comprobación Control Dispositivo de Iluminación.
Fig.68) Comprobación Alimentación 5V a la placa de desarrollo ESP8266.
Fig.69) Comprobación Alimentación 120V a la Fuente StepDown AC-DC.

9.3) Análisis costo beneficio.
Este proyecto tiene como objetivo principal mejorar la seguridad de un hogar cuando el usuario se
encuentra fuera del mismo aunado a hacer más eficiente el consumo de energía eléctrica, es decir, que
existe inicialmente una inversión económica de bajo costo llevando a un beneficio inmediato en el bolsillo
del usuario.
Los beneficios primordiales de la domótica es que ofrece un entorno más favorable y óptimo para una vida
lo más autónoma posible. El hecho de que los sistemas del hogar se pueden programar ya sea para que
realicen ciertas funciones con sólo tocar un botón o que las lleven a cabo en función de otras condiciones
del entorno, produce un aumento del confort y un ahorro de tiempo.
La posibilidad de poder ingresar desde cualquier parte del mundo por medio de Internet y poder acceder
a la interfaz, representan una gran ventaja ya que el usuario puede verificar y controlar dispositivos si así
lo quiere desde lugares muy alejados geográficamente.
En el tema de costos de los componentes utilizados para la construcción de los dispositivos de control,
siempre se hizo énfasis en contar con componentes de fácil acceso, excelente rendimiento y con capacidad
de ser configurados con código tipo OpenSource lo que llevó a un ahorro considerable en los costos ya
que los dispositivos que se adquieren con diferentes proveedores ya establecidos en el mercado, se les
oferta en un precio de hasta 4 veces mayor al que nosotros estamos ofreciendo.
9.4) Costo total del sistema instalado.
Para finalizar con el análisis costo beneficio del dispositivo de control, el precio total del dispositivo
configurado e instalado es aproximadamente de $500.00 pesos frente a todas las ventajas descritas
anteriormente, agregando el confort, la comodidad y el tiempo que el usuario se ahorra con la instalación
del sistema en su casa:
- Placa de desarrollo ESP8266 $ 90.00 pesos

- Módulo Dimmer AC-DC $ 270.00 pesos
- Fuente StepDown AC-DC $ 90.00 pesos
- Socket Foco $ 40.00 pesos
- Cableado $ 10.00 pesos
TOTAL $ 500.00 pesos
En relación al servicio del Servidor Web, se ha pagado una renta de $840.00 pesos por año. Dicho monto
tiene que ser cubierto por nuestra cuenta debido a que nosotros estaríamos dando el soporte y
mantenimiento del sitio web así como de los dispositivos que se puedan comercializar en el mercado
actual.
9.5) Propuesta de Mejoras.
Se recomienda mantener actualizado el sistema para corregir errores y si es necesario actualizar todo el
código por una versión más nueva, de esta manera se obtiene un mejor rendimiento con el mismo hardware
y se puede crear una aplicación de mayor dimensión mediante la implementación de más funciones de
control.
Cuando se trabaja con Arduino se recomienda investigar exhaustivamente sobre librerías que puedan
agilizar el desarrollo de la aplicación final, esto ahorrará mucho tiempo y permitirá enfocar los esfuerzos
en la aplicación final además que podría ser implementado para los sistemas operativo Android y iOS.
Continuar el desarrollo de control dentro del código implementado hasta el momento para poder concretar
el manejo de la Intensidad de los dispositivos de iluminación, así como la agrupación de dispositivos dentro
de la Interfaz de Usuario y permitir así, la ejecución grupal de diferentes funciones de control.

Extender la compatibilidad con asistentes personales como ALEXA, Google Asisstant, Siri, entre otros,
donde además se pueda implementar de mejor forma, el encriptado de los datos personales de cada
usuario, así como las configuraciones de cada Access Point que se quiera configurar.
Con este último punto, lo que queremos dar a entender es que el control de iluminación es sólo un ejemplo
de aquello que puede automatizarse en un sistema inteligente por lo que el área de desarrollo aquí es
enorme y con muchas opciones que se pueden desarrollar para ofrecer al mercado actual.
9.6) Autoevaluación.
El sistema instalado mejora notablemente la calidad de vida del usuario, reduciendo el nivel de
dependencia, el tiempo y la incomodidad en la realización de actividades cotidianas en su hogar.
Las herramientas de hardware revisadas durante el proceso de este proyecto permitieron obtener una red
básica de bajo tráfico para el control y recolección del status de diferentes dispositivos de control y que se
puede expandir a otros campos similares a la domótica.
Mediante algunas modificaciones en los dispositivos intervenidos, se logró un funcionamiento transparente

para el usuario beneficiado y los demás miembros de la familia, demostrando que no son necesarios
dispositivos especializados para la implementación del sistema.

Capítulo 10) Conclusiones y Referencias adicionales.
En este proyecto se ha abordado el tema de poder contar con un sistema automatizado. Concretamente,
se ha diseñado un sistema de iluminación inteligente, basado en un sistema de bajo costo, eficiente, y que
puede resultar de gran utilidad, para el usuario además de un ofrecer un ahorro de energía para su
beneficio.
El uso de esta forma de implementación para controlar las luces del hogar constituye un manejo eficiente
de esta unidad reutilizando su capacidad para controlar diferentes dispositivos en el presente sistema de
control de iluminación, evitando así el uso de unidades de control remoto dedicadas como lo ofrecen ciertos
fabricantes.
Se desarrolló un sistema económicamente accesible al mercado de los hogares que introduce la

innovación tecnológica y el concepto de domótica al alcance de todos con una visión a gran escala de la
tecnología de la iluminación que sea viable en el mercado.
Se revisaron las especificaciones de los componentes para escoger el dispositivo de control y la

programación implementada acorde a los requerimientos que tendría nuestro sistema. Para el dispositivo
de control, se ha tenido en cuenta el costo, su facilidad de integración, sus prestaciones y su grado de
extensión en el panorama actual.
También se revisó la información relacionada con el diseño y ejecución de los diferentes modelos de
iluminación inteligente tomándolos como base para poder implementar el hardware necesario mediante la
integración de diferentes componentes eléctricos y electrónicos además de haber conformado el software
requerido mediante el desarrollo de los archivos de gestión correspondientes.
En el caso del módulo ESP8266, se ha creado el Sketch necesario para implementar todos los
componentes software necesarios y finalmente, se ha creado una página Web con acceso desde cualquier
parte del mundo donde se ingresan los datos del usuario y una vez autenticado, se inicia la comunicación
a través de solicitudes y respuestas que el mismo dispositivo de control revisará y ejecutará a su salida
correspondiente.
Finalmente, con este proyecto se ha pretendido comprobar la utilidad de uno de los muchos servicios
posibles que pueden ser creados mediante la tecnología de sistemas inteligentes. La creciente evolución
de las ciudades hacia la inteligencia y la automatización da muestra del verdadero potencial de esta
tecnología.

GLOSARIO.
NodeMCU: Node Micro Controller Unit.

SoC: System on Chip.
ESP8266: Espressif Company for Node ESP8266.
Lua: Scripting language and means "Moon" in portuguese.
GitHub: Software Developer.
Phyton: Programming Language.
IDE Arduino: Integrated Development Environment Arduino.
USB: Universal Serial Bus.
LED: Light-Emitting Diode.
GPIO: General Purpose Input/Output.
CONT: Control.
TCP: Transmission Control Protocol.
PIC: Programmable Interface Controller and later Programmable Intelligent Computer.
CPU: Central Processor Unit.
Vcc: Positive DC voltage.
Vss: Negative DC voltage.
GND: Ground.
Vi: Input Voltage.
EXT_RSTB: External reset signal.
PWM: Pulse Width Modulation.
ADC: Analog-Digital Converter.
DAC: Digital-Analog Converter.
Dimmer: Device for regulating the intensity of an electric lighting unit.
StepDown Source: Device for serving to reduce or decrease voltage.
AP: Access Point.
SSID: Service Set Identifier.
MAC: Media Access Control.
WiFi: Wireless Fidelity.
SDK: Software Development Kit.
Baud: Common measure of symbol rate.
Amica: German company that designes IoT products.
Lolin/Wemos: Chinese company that designes cost-effective IoT products.
IEEE: Institute of Electrical and Electronics Engineers.
DOIT: Doctors of Intelligence and Tecnhnology.
Yielding: Flexible.
I2C: Inter-Integrated Circuit.
SPI: Serial Peripheral Interface.
SPIFFS: Serial Peripherical Interface Flash File System.
SDK: Software Development Kit.
Hayes:
FS.h: File System library.
XAMPP: Cross-Platform (X), Apache (A), MariaDB (M), PHP (P) and Perl (P).
RDBMS: Relational Database Management System.
DB2: Family of Relational Database Management System (RDBMS).
DBA: Data Base Administrator.
IIS: Internet Information Services.
SQL Server: Structured Query Language Server.
MySQL: Combination of "My", the name of co-founder Michael Widenius's daughter and SQL.
Javascript: Programming language commonly used in web development.
ASP: Active Server Page.
WWW: Wolrd Wide Web.

LAN: Local Area Network.

WAN: Wide Area Network.
HTML: Hypertext Markup Language.
HTTP: Hypertext Transfer Protocol.
DHCP: Dynamic Host Configuration Protocol.
SOAP: Simple Object Access Protocol.
DNS: Domain Name System.
XML: Extensible Markup Language.
Router: Networking device that forwards data packets between computer networks.
Modem: Hardware that allows a computer or other device (router or switch), to connect to the Internet.
IEEE 802.11: Is part of the IEEE 802 set of LAN protocols, and specifies the set of media access
control (MAC) and physical layer (PHY) protocols for implementing wireless local area
network (WLAN) Wi-Fi computer communication in various frequencies, including but
not limited to 2.4, 5, and 60 GHz frequency bands.
802.11g: Is a Wi-Fi standard developed by the IEEE for transmitting data over a wireless network. It
operates on a 2.4 GHz bandwidth and supports data transfer rates up to 54 Mbps
JSON: JavaScript Object Notation.
ICANN: Internet Corporation for Assigned Names and Numbers.
IANA: Internet Assigned Numbers Authority.
TLD: Top Level Domains.
ccTLD: Country Code Top Level Domains.
gTLD: Generic Top Level Domains.
URL: Uniform Resource Locator.
PHP: Hypertext Preprocessor.
AJAX: Asynchronous Javascript.
CRUD: Create, Read, Update and Delete for Data Base.

ANEXOS









BIBLIOGRAFÍA.
 http://mecabot-ula.org/tutoriales/arduino/practica-3-encender-un-led-y-cambiarle-su-intensidad-
usando-pwm/
 http://manueldelgadocrespo.blogspot.com/p/arduino-due.html
 https://www.lua.org/.
 https://hetpro-store.com/comandos-at-esp8266-esp8266ex/
 https://roboindia.com/tutorials/nodemcu-amica-esp8266-board-installation
 https://programarfacil.com/podcast/nodemcu-tutorial-paso-a-paso/
 http://androidcontrol.blogspot.com/2016/05/esp8266-wifi-control-relay.html
 https://github.com/nassir-malik/IOT-AC-Light-Dimmer-With-Alexa
 https://esp8266-arduino-spanish.readthedocs.io/es/latest/filesystem.html
 http://arduinoamuete.blogspot.com/2016/11/esp8266-diagnostico-wifi-y-direccion-mac.html
 http://www.sinaptec.alomar.com.ar/2017/06/tutorial-7-esp8266-guardar-ssid-y.html
 https://esp8266-arduino-spanish.readthedocs.io/es/latest/esp8266wifi/soft-access-point-
class.html
 https://www.luisllamas.es/programar-esp8266-con-el-ide-de-arduino/
 https://www.luisllamas.es/esp8266-nodemcu/
 https://www.luisllamas.es/como-conectar-un-esp8266-a-una-red-wifi-modo-sta/
 https://www.luisllamas.es/como-generar-una-red-wifi-con-el-esp8266-modo-ap/
 https://www.luisllamas.es/guia-de-programacion-del-esp8266-en-entorno-arduino/
 https://www.luisllamas.es/programar-esp8266-con-el-ide-de-arduino/
 https://www.luisllamas.es/como-emplear-el-esp8266-como-cliente-http/
 http://www.esploradores.com/practica-10-thinger-io-control-de-dispositivos-encendido-apagado-
yo-regulacion/
 https://www.luisllamas.es/como-emplear-el-esp8266-como-cliente-http/
 https://naylampmechatronics.com/blog/54_arduino-y-esp8266-como-cliente-web.html
 http://www.esploradores.com/practica-12-plus-1-websockets/
 https://github.com/jaimelaborda/Planta-Twittera/wiki/3.-Servidor-Web-control-de-un-LED

 https://arduinodiy.wordpress.com/2012/10/19/dimmer-arduino/
 https://robotdyn.com/catalog/ac-light-dimmer-module-1-channel-3-3v-5v-logic-ac-50-60hz-220v-
110v.html
 https://techtutorialsx.com/2016/07/17/esp8266-http-get-requests/
 http://www.esploradores.com/practica-15-comunicaciones-get-y-post/
 http://panamahitek.com/webclient-arduino-servidor-php-hosting-gratuito/
 https://github.com/bblanchon/ArduinoJson
 http://panamahitek.com/webclient-arduino-servidor-php-hosting-gratuito/
 https://www.ecured.cu/XAMPP
 https://www.hostinger.es/tutoriales/que-es-apache/
 La biblia de MySQL: Ian Gilfillan, Anaya multimedia
 https://php.net/manual/es/intro-whatis.php
 https://desarrolloweb.com/articulos/541.php
 http://www.acercadehtml.com/manual-html/que-es-html.html
 https://blog.makeitreal.camp/lenguajes-compilados-e-interpretados/
 https://www.ecured.cu/Lenguaje_interpretado
 https://www.ecured.cu/Lenguaje_de_programaci%C3%B3n_(inform%C3%A1tica)
 https://es.wikipedia.org/wiki/JavaScript
 https://www.um.es/docencia/barzana/DAWEB/Lenguaje-de-programacion-JavaScript-1.pdf
 http://www.maestrosdelweb.com/que-es-javascript/
 http://www.maestrosdelweb.com/ajax/
 https://raiolanetworks.es/blog/que-es-bootstrap/
 https://www.ecured.cu/Framework
 https://www.hostinger.mx/tutoriales/que-es-un-dominio-web

Sistema Automatico de Control de Iluminación Via Servidor Web

Cargado por

Copyright:

Formatos disponibles

Sistema Automatico de Control de Iluminación Via Servidor Web

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Sistema Automatico de Control de Iluminación Via Servidor Web

Cargado por

Copyright:

Formatos disponibles

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA

“SISTEMA AUTOMÁTICO DE CONTROL DE ILUMINACIÓN VÍA SERVIDOR WEB”

PARA OBTENER EL TÍTULO DE:

INGENIERO EN COMUNICACIONES Y ELECTRÓNICA

CESAR ALEXANDER GARCÍA GÓMEZ

ING. ARTURO A. HIT ESPINOSA

Ciudad de México, mayo de 2019

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.2

INSTITUTO POLITÉCNICO NACIONAL Prohibición de Uso de Obra.

Ciudad de México a 1° agosto de 2019.

César Alexander García Gómez

David Adrián García Gómez

Luis Alberto Ortíz Sánchez

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.3

Capítulo 1) NODEMCU, Placa de desarrollo con el Módulo WiFi ESP8266 ............................ 15

1.1) Conceptos generales ........................................................................................................................... 15

Capítulo 2) Atributos en la programación del Módulo ESP8266 en entorno Arduino ......... 23

2.1) Designación de Pines .......................................................................................................................... 23

3.1) Instalación del Módulo ESP8266 en IDE de Arduino ..................................................................... 28

Capítulo 4) Sistema de Ficheros ........................................................................................................ 31

4.1) Esquema de la memoria Flash ....................................................................................................... 31

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.4

Capítulo 5) Módulo Dimmer AC para Arduino y Fuente de Alimentación AC-DC................. 34

5.1) Descripción general del módulo Dimmer AC para Arduino ........................................................... 34

Capítulo 6) Programación HTML ........................................................................................................ 37

6.1) Herramientas para desarrollo web ................................................................................................ 37

Capítulo 7) Base de datos (SQL y PHP) ........................................................................................... 48

7.1) Funcionamiento del Sitio Web ....................................................................................................... 48

Capítulo 8) Metodología para el desarrollo del Dispositivo ....................................................... 53

8.1) Diseño y construcción del dispositivo de Control de Iluminación ........................................................ 53

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.5

8.4) Formato de la cadena de texto enviada al módulo ESP8266 ............................................................. 55

Capítulo 9) Análisis e Interpretación de Resultados .................................................................... 61

9.1) Implementación del modo WebClient .................................................................................................. 61

Capítulo 10) Conclusiones y Referencias adicionales................................................................. 66

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.6

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.7

Índice de Diagramas y Figuras.

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.8

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.9

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.10

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.11

En la investigación se aplicó conocimientos adquiridos durante la formación académica y con la factibilidad

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.12

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.13

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.14

Capítulo 1) NODEMCU, Placa de desarrollo con el Módulo WiFi ESP8266.

Fig. 1) ESP8266 NodeMCU.

1.1) Conceptos generales.

Fig. 2) Firmware NodeMCU.

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.15

1.2) Lenguaje script Lua.

1.3) NodeMCU como placa de desarrollo.

• Puerto micro USB y conversor Serie-USB.

INSTITUTO POLITÉCNICO NACIONAL – ESIME ZACATENCO Pág.16

Fig. 4) Descripción de pines ESP8266 NodeMCU V2.

Fig. 5) Descripción de pines ESP12E.