INSTITUTO DE EDUCACION SUPERIOR TECNOLOGICO
PUBLICO ANDRES AVELINO CACERES DOREGARAY
PROGRAMA DE ESTUDIOS ELECTRONICA INDUSTRIAL
MICROCONTROLADORES I
INFORME DE APLICACIÓN CON MICROCONTROLADORES
TITULO:
RELOJ EN TIEMPO REAL EN ESP32 SINCRONIZADO POR
INTERNET CON VISUALIZACION EN UNA PANTALLA OLED
Realizado por: Kevin Sanchez Loayza
Docente: ING. Juan Luis Merlo Galvez
Semestre: Tercero
Turno: Vespertino
Tema: Programación en microcontrolador ESP32
Fecha: 13-05-2024
CAJAS, HUANCAYO
2024
RESUMEN
El presente informe trata sobre la construcción de un reloj en tiempo real, para lo cual se usó
el RTC (reloj en tiempo real) que viene incorporado en el microcontrolador esp32, para este
proyecto se usó el módulo esp32 devkit v1, la sincronización del reloj se usó un servidor NTP
comunicado mediante una red local wifi al esp32su. En la programación del módulo ESP32 se
usó el IDE Arduino. Además, para la visualización del reloj se uso la pantalla oled 0.96´´
SSD1306 de 7 pines y la comunicación se hizo mediante el protocolo SPI.
Contenido
RESUMEN.....................................................................................................................................2
1. INTRODUCCION....................................................................................................................4
2. OBJETIVOS............................................................................................................................4
3. MARCO TEORICO..................................................................................................................5
3.1. ESP32............................................................................................................................5
3.2. PROGRAMACION EN ESP32..........................................................................................6
3.3. IDE ARDUINO................................................................................................................6
3.4. PLANTALLA OLED 0.96´´ SPI..........................................................................................7
3.5. CONEXIÓN DE LA PANTALLA OLED AL ESP32..............................................................10
3.6. Network Time Protocol (NTP).....................................................................................11
4. EQUIPOS Y MATERIALES.....................................................................................................13
4.1. EQUIPOS.....................................................................................................................13
4.2. MATERIALES Y PRESUPUESTO....................................................................................13
5. PROCEDIMIENTO................................................................................................................14
5.1. FUNCIONAMIENTO DE CODIGO..................................................................................15
6. CONCLUCION......................................................................................................................18
BIBLIOGRAFÍA.............................................................................................................................19
ANEXOS......................................................................................................................................20
1. INTRODUCCION
El presente proyecto se basa en la aplicación de microcontroladores esp32, para este caso se
realizo un reloj en tiempo real con visualización en una pantalla oled.
En primer lugar se presenta los objetivos del informe
Seguido el marco teórico, aquí expondremos algunos puntos sobre los esp32, la pantalla oled y
el protocolo NTP. También se verá aquí el conexionado del módulo con la pantalla.
Luego, se presentará la explicación del funcionamiento del código.
Finalmente, se tiene las conclusiones y anexos del proyecto.
2. OBJETIVOS
construir un reloj digital en tiempo real utilizando el microcontrolador ESP32 y una
pantalla OLED.
Realizar el programa utilizano el IDE Arduino
3. MARCO TEORICO
1.1. ESP32
El ESP32 es en realidad una serie de chips microcontroladores producidos por Espressif
Systems en Shanghai. Está disponible en varios módulos de bajo costo.
MODULO ESP32
Hay muchos módulos ESP32 disponibles para experimentadores.
Muchas de estas placas tienen un conector micro-USB integrado que simplificará la
programación. Algunas placas no tienen esta característica y requieren un adaptador FTDI
externo para su programación.
La mayoría de estas placas se basan en el chip ESP32-WROOM. Como la placa ESP32 DEV KIT,
que se muestra a continuación.
CARACTERISTICAS Y COMPARACION CON ARDUINO UNO
Parameter ESP32 ARDUINO UNO
Processor Xtensa dual-core ATMega328P
Number of Cores 2 1
Architecture 32 bit 8 bit
Operating Voltage 2.2 to 3.6V 5V
CPU Frequency 160 or 240 MHz 16 MHz
WiFi YES NO
Bluetooth YES NO
RAM 512 KB 2 KB
Flash 16 MB 32 KB
GPIO pins 36 14
Busses SPI,I²C,UART,I2S,CAN SPI,I²C,UART
ADC Pins 18 6
DAC Pins 2 0
USB Conector Micro Type B
UART 3 1
SPI 3 1
I²C 2 1
1.1. PROGRAMACION EN ESP32
Se pueden utilizar C++ y MicroPython para programar el ESP32. Soporta múltiples entornos de
programación:
IDE de Arduino
PlatformIO IDE (código VS)
LUA
MicroPython
Espressif IDF (Marco de desarrollo de IoT)
javascript
Para utilizar plenamente las funciones, se debe utilizar ESP-IDF. Puede consultarlo en detalle
1.2. IDE ARDUINO
Para poder trabajar con ESP32, deberá agregar una fuente adicional al Administrador de placas
IDE de Arduino y luego instalar las placas ESP32.
En realidad, esto es mucho más simple de lo que parece gracias a Espressif, quien ha
proporcionado un enlace a un archivo JSON, es un formato de archivo de texto que permite
compartir información estructurada entre computadoras. En este sentido, es similar a XML.
PASOS PARA SU INSTALACION
Esto es lo que debe hacer para instalar las placas ESP32 en el IDE de Arduino:
1. Abra el IDE de Arduino. Asegúrese de tener la versión 1.8 o superior; de lo contrario,
actualice su IDE con la última versión.
2. Haga clic en el menú Archivo en la barra de menú superior.
3. Haga clic en el elemento del menú Preferencias . Esto abrirá un cuadro de diálogo de
Preferencias.
4. Debería estar en la pestaña Configuración en el cuadro de diálogo Preferencias de
forma predeterminada.
5. Busque el cuadro de texto titulado " URL del administrador de tableros adicionales ".
6. Si ya hay texto en este cuadro, agregue una coma al final y luego siga el siguiente paso.
7. Pegue el siguiente enlace en el cuadro de
texto: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/
package_esp32_index.json
8. Haga clic en el botón Aceptar para guardar la configuración.
1.3. PLANTALLA OLED 0.96´´ SPI
OLED o diodo emisor de luz orgánico es una tecnología de visualización avanzada que utiliza
una película de compuesto orgánico entre dos electrodos (ánodo y cátodo) y cuando se aplica
voltaje a través de los electrodos, la película orgánica emite luz.
La principal ventaja de una pantalla OLED es que emite su propia luz y no necesita otra fuente
de retroiluminación. Debido a esto, las pantallas OLED suelen tener mejor contraste, brillo y
ángulos de visión en comparación con las pantallas LCD.
Otra característica importante de las pantallas OLED son los niveles de negro profundo. Dado
que cada píxel emite su propia luz en una pantalla OLED, para producir color negro, el píxel
individual se puede apagar.
Este módulo de visualización consta de una pantalla OLED monocromática con una resolución
de 128 x 64 píxeles. Mide 0,96” en diagonal. Esta pantalla OLED utiliza el controlador IC OLED
SSD1306.
Las pantallas OLED SSD1306 tienen tres tipos de interfaces de comunicación:
Interfaz paralela 6800 de 8 bits, SPI de 3 o 4 hilos y I2C
De estos, los OLED tipo I 2 C y SPI son muy comunes. Es posible cambiar la configuración de SPI
a I 2 C y viceversa (tienes soldar/desoldar algunas resistencias SMD). El modelo que tengo
utiliza comunicación SPI de 4 cables.
Pin (Alternative Names) Description
GND Ground
VCC Power Supply
D0 (SCK, SCL, CLK) Clock
D1 (MOSI, SDA) Data
RES (RST) Reset
DC (A0) Data / Command Selection
CS Chip Select
Número de Nombre del
Otros nombres Uso
PIN PIN
1 Gnd tierra Pin de tierra del módulo
2 VDD Vcc, 5V Pin de alimentación (3-5 V tolerable)
Actúa como pin del reloj. Utilizado tanto
3 SCK D0,SCL,CLK
para I2C como para SPI
Pin de datos del módulo. Utilizado tanto
4 ASD D1,MOSI
para IIC como para SPI
PRIMERO,
5 RES Restablece el módulo (útil durante SPI)
REINICIAR
Pin de comando de datos. Utilizado para el
6 DC A0
protocolo SPI
Útil cuando se utiliza más de un módulo bajo
7 CS Seleccionar chip
el protocolo SPI
1.4. CONEXIÓN DE LA PANTALLA OLED AL ESP32
Para conectar una pantalla OLED con ESP32, Lo primero que hay que entender es que la
interfaz de comunicación es SPI. Entonces, ubicar los Pinout del ESP32 e identifiquar los pines
SPI.
En la siguiente imagen, HSPI y VSPI están disponibles en la placa de desarrollo ESP32 para la
interfaz SPI . Usemos el periférico VSPI.
En el cuadro se muestra los pines para VSPI en ESP32
VSPI Pin GPIO Pin
VSPI_MOS GPIO 23
I
VSPI_MIS GPIO 19
O
VSPI_CLK GPIO 18
VSPI_CS GPIO 5
ESP32 tiene un total de 4 periféricos SPI. (SPI0, SPI1, HSPI y VSPI). SPI0 está dedicado a SPI
Flash IC. SPI1 comparte el hardware con SPI0. Esto deja a HSPI y VSPI para interconectar
dispositivos SPI.
CONEXIONADO
conexiones entre ESP32 y el módulo de pantalla OLED. En total, tenemos que realizar siete
conexiones ya que se trata de una pantalla SPI OLED.
OLED Display ESP32
GND GND
VCC 3.3V
D0 (SCK) GPIO 18
D1 (MOSI) GPIO 23
RES GPIO 17
DC GPIO 16
CS GPIO 5
DIAGRAMA DE CONEXIONADO
1.5. Network Time Protocol (NTP)
NTP es un protocolo de Internet estándar que se usa ampliamente para sincronizar los relojes
de las computadoras con una red de referencia. Con una precisión de aproximadamente 50 ms
en la red de área amplia (WAN) y menos de 5 ms en la red de área local (LAN), sincroniza la
época de todos los dispositivos en red con UTC.
Para obtener la fecha y hora con nuestro ESP32 a través del servidor NTP, el servidor
funcionará en el modelo cliente-servidor. Usaremos el servidor NTP: pool.ntp.org, que es de
fácil acceso para todos en todo el mundo. Nuestra placa de desarrollo ESP32 será el cliente y
se conectará al servidor NTP a través de UDP en el puerto 123. A través de este puerto, el
servidor (pool.ntp.org) podrá conectarse con el cliente. El ESP32 enviará una solicitud al
servidor después de que se establezca la conexión. Cuando el NTP reciba la solicitud,
transmitirá la marca de tiempo que contiene la información relativa a la hora y la fecha.
Si su país observa el horario de verano (haga clic aquí para comprobarlo), tendrá que
incorporarlo en el código del programa agregando 3600 (en segundos); de lo contrario, será
reemplazado por un 0. Pakistán no observa el horario de verano, por lo que agregaremos 0. en
la variable de compensación de luz diurna en el código.
Para la compensación UTC, haga clic aquí para verificar su zona horaria y agregue la
compensación en el código del programa convirtiéndolo en segundos.
Por ejemplo, para Estados Unidos el UTC es -11:00, por lo que al convertirlo en segundos
queda:
-39600 (-11* 60 *60).
Para Pakistán, la compensación UTC es +05:00, por lo que en nuestro código especificaremos
la compensación GMT, que es la misma que la compensación UTC en segundos, como 18000
(5* 60 *60).
PROCESO DE TRABAJO DEL SERVIDOR NTC
El desplazamiento UTC (o desplazamiento horario ) es una cantidad de tiempo que se resta o
se suma a la hora universal coordinada (UTC) para especificar la hora solar local (que puede no
ser la hora civil actual , ya sea hora estándar o horario de verano). ).
Horario de verano
Varias regiones del mundo utilizan el horario de verano (DST) y el desplazamiento UTC durante
esta temporada generalmente se obtiene agregando una hora a la hora estándar local. La hora
de Europa Central UTC+01:00 se reemplaza por la hora de verano de Europa Central
UTC+02:00 , y la hora estándar del Pacífico UTC−08:00 se reemplaza por la hora de verano del
Pacífico UTC−07:00 .
2. EQUIPOS Y MATERIALES
2.1. EQUIPOS
Item cantidad equipo
01 1 Multímetro
02 Laptop, IDE Arduino
2.2. MATERIALES Y PRESUPUESTO
Item Cantidad dispositivo Precio(soles)
01 01 protoboard 10
02 01 ESP32 devkit v1 60
03 01 Oled 0.96´´ 35
04 01 Cable micro USB 5
El costo total asciende a 110 soles.
3. PROCEDIMIENTO
3.1. CODIGO
4. #include <WiFi.h>
5. #include <time.h>
6. #include <SPI.h>
7. #include <Wire.h>
8. #include <Adafruit_GFX.h>
9. #include <Adafruit_SSD1306.h>
10.#define SCREEN_WIDTH 128
11.#define SCREEN_HEIGHT 64
12.
13.#define OLED_MOSI 23
14.#define OLED_CLK 18
15.#define OLED_DC 16
16.#define OLED_CS 5
17.#define OLED_RESET 17
18.
19.Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,
20. OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);
21.
22.const char* ssid = "HONOR X6a Plus";
23.const char* password = "kuki2223";
24.
25.long GMTOffset = -18000;
26.int daylightOffset = 0;
27.void setup() {
28.Serial.begin(115200);
29.display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
30.display.clearDisplay();
31.display.display();
32.delay(1000);
33.display.clearDisplay();
34.display.setTextSize(1);
35.display.setCursor(0,0);
36.display.setTextColor(WHITE);
37.
38.WiFi.begin(ssid, password);
39. while (WiFi.status() != WL_CONNECTED) {
40. delay(1000);
41. Serial.println("Connecting...");
42. }
43.
44. Serial.println("Connected to Wi-Fi!");
45.
46.configTime(GMTOffset, daylightOffset, "pool.ntp.org","time.nist.gov");
47.}
48.
49.void loop() {
50.time_t rawtime = time(nullptr);
51.struct tm* timeinfo = localtime(&rawtime);
52.
53.Serial.print("Time: ");
54.Serial.print(timeinfo->tm_hour);
55.Serial.print(":");
56.Serial.print(timeinfo->tm_min);
57.Serial.print(":");
58.Serial.println(timeinfo->tm_sec);
59.
60.display.clearDisplay();
61.display.setTextSize(3);
62.display.setTextColor(WHITE);
63.display.setCursor(0,25);
64.display.print(timeinfo->tm_hour);
65.display.print(":");
66.if( timeinfo->tm_min <10)
67.display.print("0");
68.display.print(timeinfo->tm_min);
69.
70.display.setTextSize(2);
71.display.setCursor(90,30);
72.display.print(":");
73.if( timeinfo->tm_sec <10)
74.display.print("0");
75.display.print(timeinfo->tm_sec);
76.display.display();
77.
78.delay(1000);
79.
80.}
81.
5.2. FUNCIONAMIENTO DE CODIGO
Importación librerías time y WiFi
Incluiremos dos bibliotecas, WiFi.h y tieme.h. La biblioteca WiFi.h es necesaria ya que
queremos que nuestra placa de desarrollo ESP32 se conecte a la red local. Además, podremos
acceder al servidor NTP a través de Internet, por lo que esta biblioteca es imprescindible. En
segundo lugar, la biblioteca time.h manejará las estructuras de tiempo y es vital para la
sincronización del servidor NTP.
Primero, definiremos las bibliotecas necesarias al comienzo del código. Definiremos dos
bibliotecas: WiFi.h y time.h. La primera biblioteca es necesaria para que nuestra placa ESP32
pueda conectarse con la red WIFI local y, por lo tanto, conectarse con el servidor NTP. Además,
la biblioteca time nos ayudará a lograr la sincronización NTP y obtener la hora.
Luego, crearemos dos variables globales de tipo char que contendrán las
credenciales de red a través de las cuales se conectará nuestro módulo ESP32. estos se
nombran ssid y pasword. Para garantizar una conexión exitosa, reemplace sus valores con sus
credenciales de red.
A continuación, definiremos dos variables mas para el GMT y para la compensación de
horario de verano en segundos. Hemos especificado las compensaciones para Perú, pero
puede cambiarlas según su zona horaria para obtener la hora correcta.
Dentro de nuestra función setup(), inicializaremos la comunicación serie a una
velocidad de 112500 baudios.
Además, también inicializaremos la pantalla OLED usando display.begin(). Asegúrese
de especificar la dirección correcta de su pantalla. En nuestro caso, es 0X3C.
Primero, estableceremos el tamaño del texto usando setTextSize() y pasaremos el
tamaño como parámetro dentro de él. A continuación, controlaremos el color del texto usando
la función setTextColor() y se usara WHITE como argumento. Usaremos la función setCursor()
para indicar la posición de los ejes x e y desde donde debe comenzar el texto.
Usaremos la biblioteca Arduino time.h para convertir la hora de época a la hora actual
y recuperar horas, minutos y segundos individuales. Primero, crearemos una estructura tm
llamada timeinfo que se configurará en la función localtime(). Esta función toma el parámetro
&rawtime. Luego imprimiremos la hora, minuto y segundo individuales en el monitor serial en
un formato HH:MM:SS. Esto se logra accediendo al puntero timeinfo de la estructura tm y
obteniendo horas, minutos y segundos individuales usando el operador de flecha en tm_hour,
tm_min y tm_sec en consecuencia.
Ahora mostraremos estas mismas horas, minutos y segundos en la pantalla OLED.
Primero, borraremos el búfer, luego estableceremos el tamaño del texto usando setTextSize()
y pasaremos el tamaño como un parámetro dentro de él. A continuación, controlaremos el
color del texto usando la función setTextColor() y pasando BLANCO como argumento.
Usaremos la función setCursor() para indicar la posición de los ejes x e y desde donde debe
comenzar el texto. Al usar print() en el objeto de visualización, pasaremos timeinfo->tm_hour
para mostrar la hora actual. Esto será seguido por ":" De manera similar, mostraremos los
minutos usando print() en el objeto de visualización, pasaremos timeinfo->tm_min para
mostrar el minuto actual. Esto nuevamente será seguido por un ":"
Ahora, configuraremos el tamaño de fuente en 2 para mostrar los segundos; de lo
contrario, el reloj no se mostrará correctamente en el OLED debido a su tamaño. Establezca el
cursor también. Ahora, al usar print() en el objeto de visualización, pasaremos timeinfo-
>tm_sec para mostrar el segundo actual. Además, también agregaremos una condición para el
minuto y el segundo. Si el número es menor que 10, mostraremos los minutos/segundos
precedidos por un 0.
Además, agregaremos un retraso de 1 segundo después del cual loop() se ejecutará
nuevamente para que el reloj se actualice cada segundo.
6. CONCLUCION
En conclusión, el servidor NTP juega un papel crucial en la obtención de la fecha y hora
actuales de nuestra placa de desarrollo ESP32, que está conectada a una conexión WIFI
estable. Al consultar el servidor NTP, nos aseguramos de que nuestro dispositivo ESP32 tenga
acceso a información horaria precisa y sincronizada. Esto nos permite mostrar la hora correcta
a los usuarios, registrar eventos con marcas de tiempo precisas y coordinar actividades con
otros dispositivos en un entorno de red. La capacidad del servidor NTP para proporcionar
datos de tiempo altamente precisos mejora la confiabilidad y funcionalidad de nuestros
proyectos ESP32, lo que lo convierte en un componente esencial para un cronometraje
preciso.
BIBLIOGRAFÍA
«ESP32 Pinout Reference: Which GPIO pins should you use?,» [En línea]. Available:
https://randomnerdtutorials.com/esp32-pinout-reference-gpios/.
«ESP32 Web Server - Arduino IDE,» [En línea]. Available:
https://randomnerdtutorials.com/esp32-web-server-arduino-ide/.
«espressif/arduino-esp32,» GitHub, [En línea]. Available:
https://github.com/espressif/arduino-esp32.
«IoT Sharing,» [En línea]. Available: http://www.iotsharing.com/search/label/ESP32.
«ESP32 – techtutorialsx,» [En línea]. Available: https://techtutorialsx.com/category/esp32/.
https://circuitdigest.com/article/ssd1306-oled-display
https://dronebotworkshop.com/esp32-intro/
ANEXOS
