Un reloj en tiempo real (RTC) es un reloj de computadora para mantener el tiempo y es una de las funciones de microcontrolador más populares. Los microcontroladores sin RTC integrado requieren un chip RTC externo para mantener el tiempo. Normalmente, los microcontroladores de gama media a alta tienen un RTC incorporado porque el control del tiempo es necesario para muchas aplicaciones integradas.
Los RTC cuentan segundos, minutos, horas, días, meses y años. También se pueden utilizar para la fecha actual y para medir intervalos de tiempo.
El módulo de máquina MicroPython proporciona una clase RTC que configura y utiliza un puerto integrado con soporte RTC. MicroPython también proporciona un módulo "ntptime" que sincroniza la hora con la ayuda de una fuente de reloj o un servidor.
En este artículo, exploraremos el módulo RTC de MicroPython y aprenderemos cómo configurar y obtener la hora en ESP8266 y ESP32.
Módulo de máquina
MicroPython consta de varios módulos específicos de hardware. El módulo de la máquina es el más importante porque gestiona las funcionalidades básicas del hardware y los periféricos de hardware integrados de los puertos compatibles.
El módulo tiene varias clases para controlar entradas/salidas digitales, señales de salida de dispositivos externos, modulación de ancho de pulso, conversión analógica a digital, periféricos ADC, UART, SPI, I2C, I2S, temporizador, RTC, temporizador de vigilancia y tarjeta SD.
Clase RTC
El módulo de máquina MicroPython para la clase RTC se utiliza para configurar y administrar el reloj en tiempo real de los puertos compatibles. Se importa a un script MicroPython usando esta instrucción:
de importación de máquina rtc
Alternativamente, la clase RTC se importa automáticamente cuando se importa el módulo de la máquina de la siguiente manera:
máquina de importación
Después de importar el módulo, debe crear una instancia de un objeto de la clase RTC con la ayuda del método constructor. El método constructor de la clase RTC tiene este prototipo:
clase máquina.RTC(id=0,…)
El constructor utiliza el parámetro "id", que identifica el RTC integrado (si hay varios RTC en el puerto admitido). Si solo hay uno, no es necesario pasar el id como argumento. Los parámetros restantes del método constructor utilizado para establecer la hora en el RTC son opcionales.
Este es un ejemplo válido de creación de instancias de un objeto RTC:
rtc = máquina.RTC
La clase RTC proporciona estos métodos para mantener la configuración de fecha y hora...
RTC.init (fecha y hora) : se utiliza para inicializar el objeto RTC. Toma la fecha y hora actuales como argumento. El tiempo de los datos se pasa como una tupla de 8 con este formato: (año, mes, día (, hora (, minuto (, segundo (, microsegundo (, tzinfo)))))). La tupla debe tener los elementos año, mes y día. El resto son opcionales y pueden ser aprobados o no dependiendo de la solicitud.
RTC.datetime((datetimetuple)) : se utiliza para obtener o configurar la fecha y hora del RTC.
- Si se llama sin argumentos, este método devuelve la fecha y hora actuales mantenidas por el RTC en forma de 8 tuplas.
- Si se usa para establecer la fecha y la hora, el método toma una tupla de 8 como argumento.
La tupla debe seguir este formato: (año, mes, día, día de la semana, horas, minutos, segundos, subsegundos). Dependiendo del puerto, los subsegundos de la tupla pueden ser milisegundos o microsegundos.
RTC.deinit : Restablece la hora del RTC al 1 de enero de 2015 y reinicia el RTC.
RTC.now : Obtiene la fecha y hora actuales del RTC, que se devuelve como una tupla de 8.
La clase RTC proporciona estos métodos para configurar los ajustes de alarma...
RTC.alarm(id, time, *, repetir=False) : se utiliza para configurar la alarma en RTC. La identificación debe pasarse como argumento si hay varios RTC integrados en un puerto; de lo contrario no es necesario. La hora se puede pasar como valor de milisegundos o como tupla de fecha y hora. Si el tiempo pasa en milisegundos, la alarma se puede repetir estableciendo el argumento de la palabra clave repetir en Verdadero. Los milisegundos se cuentan a partir de la fecha y hora actuales del RTC.
RTC.alarm_left(alarm_id=0) : devuelve el número de milisegundos de la alarma.
RTC.cancel(alarm_id=0) : se utiliza para cancelar una alarma en ejecución.
La clase RTC proporciona estos métodos para configurar una interrupción...
RTC.irq(*, trigger, handler=None, wake=machine.IDLE) : crea un objeto de interrupción que se activa con la alarma RTC. Se requieren tres parámetros: disparador, controlador y activación. El disparador siempre está configurado en RTC.ALARM0. El controlador es una función de devolución de llamada que se ejecuta como una rutina de servicio de interrupción. La activación especifica el modo de suspensión desde el cual la interrupción RTC puede reactivar el puerto.
Sincronización horaria mediante ntptime
No siempre es necesario configurar manualmente la hora en RTC. MicroPython proporciona el módulo ntptime, que es útil para sincronizar la hora, mantener el estándar UTC y proporcionar la hora exacta. El módulo se basa en el protocolo de tiempo de red (NTP).
El protocolo NTP sincroniza la hora RTC de una computadora/controlador con un servidor o una fuente de reloj remota. El módulo facilita la calibración precisa de la hora RTC. Sin embargo, la tarjeta debe estar conectada a Internet a través de Ethernet o WiFi para unirse al servidor NTP.
El módulo se importa a un script MicroPython mediante esta instrucción:
importar tiempo ntp
El módulo proporciona estos métodos...
ntptime.settime : se utiliza para sincronizar la hora local mantenida por RTC o una fuente de reloj interna con la hora estándar UTC. Algunos módulos MicroPython ntptime específicos del puerto permiten que el método settime tome dos argumentos, zona horaria y servidor. El módulo ntptime del firmware oficial de MicroPython no acepta ningún argumento. La época estándar UTC es el 1 de enero de 1970 a las 00:00:00. El servidor host utilizado por el módulo ntptime de MicroPython es "pool.ntp.org"
ntptime.time : devuelve el número de segundos que han transcurrido desde la época UTC. El valor devuelto es un número entero.
Nuevamente, asegúrese de que la tarjeta esté conectada a Internet a través de Ethernet o WiFi para acceder al servidor NTP.
RTC en ESP8266 y ESP32
ESP8266 y ESP32 tienen RTC integrados únicos. A continuación se muestra un ejemplo válido de cómo crear una instancia de un objeto RTC, configurar la hora y recuperar la fecha y hora actuales en ESP8266 y ESP32.
RTC en ESP8266 y ESP32
ESP8266 y ESP32 tienen RTC integrados únicos. A continuación se muestra un ejemplo válido de cómo crear una instancia de un objeto RTC, configurar la hora y recuperar la fecha y hora actuales en ESP8266 y ESP32.
importación de máquina RTC
rtc = RTC
rtc.datetime((2022, 7, 25, 1, 1, 30, 42, 0)) # establecer fecha y hora
print(rtc.datetime) # obtener fecha y hora
Aquí hay un ejemplo válido de cómo configurar la hora RTC usando el servidor NTP en ESP8266 y ESP32:
importación de máquina RTC
red de importación
importar tiempo ntp
estación = red.WLAN(red.STA_IF)
estación.activa (Verdadero)
station.connect(ssid, contraseña) #reemplace con su SSID y contraseña de WiFi
rtc = RTC
ntptime.settime
imprimir(rtc.fechahora)
Visualización de la hora local usando el módulo ESP8266
La hora devuelta por el servidor NTP es la hora UTC. Para cambiar la hora, convierta la marca de tiempo UTC a la marca de tiempo local. Dado que MicroPython es un subconjunto de Python, no tiene una función o método directo para convertir la hora UTC a otra zona horaria. Por lo tanto, es necesario utilizar el módulo de temporización del firmware MicroPython.
Para este proyecto, mostraremos UTC y la hora local con la ayuda de MicroPython y ESP8266.
Componentes necesarios
1ESP8266 /ESP32x1
2. Computadora/portátil x1
3. Cable USB (para conectar la placa ESP a una computadora) x1
Conexiones de circuito
No hay conexiones de circuito para este proyecto. Simplemente conecte el ESP8266/ESP32 a su computadora usando el cable USB. Además, asegúrese de que uPyCraft IDE o Thonny IDE esté instalado en su computadora y cargue el firmware MicroPython para ESP8266/ESP32 (aprenda cómo hacerlo aquí).
Luego inicie el IDE de uPyCraft. Seleccione el puerto de comunicación serie navegando a Herramientas->Serial y seleccione la placa navegando a Herramientas->Placa. Después de cargar el firmware de MicroPython, debería tener boot.py en la pestaña del dispositivo.
Cree un nuevo archivo navegando a Archivo->Nuevo y guarde el archivo como main.py. Copie el siguiente script en main.py. Haga clic en el botón "Descargar y ejecutar" para ejecutar el script.
Secuencia de comandos MicroPython
Cómo funciona el proyecto
ESP8266 se conecta al servidor NTP y obtiene la hora UTC, que se utiliza para configurar la fecha y hora RTC. Luego, la hora UTC se convierte a la hora local (IST en este caso) utilizando funciones del módulo de hora. La hora local la imprime la consola. Finalmente, el RTC se actualiza con la hora local.
Código
El script MicroPython importa la clase RTC de los módulos de máquina, red, ntptime y time. A continuación, se crea una instancia de un objeto de la clase WLAN del módulo de red.
La función definida por el usuario, conectar, está configurada para conectarse a WiFi. La función de desconexión está configurada para desconectar el ESP8266/ESP32 de WiFi. Para comprender estas funciones, consulte Cómo conectar ESP8266 y ESP32 con WiFi .
El ESP8266/ESP32 se conecta a WiFi llamando a la función de conexión. Debes pasar el SSID y la clave/contraseña de red de tu WiFi personal como argumentos.
Se crea una instancia de un objeto de la clase RTC utilizando el método machine.RTC. La hora UTC actual se configura para el RTC ESP8266/ESP32 llamando a ntptime.settime. La hora UTC configurada en el RTC ESP8266/ESP32 se recupera en una tupla y se muestra en la consola.
Para convertir UTC a hora local, utilice el módulo de hora de MicroPython (obtenga más información aquí) . MicroPython es un subconjunto del módulo de tiempo estándar de Python y contiene algunas funciones aplicables a aplicaciones integradas.
La hora UTC se obtiene en segundos de la época UTC llamando al método ntptime.time. La hora UTC actual se almacena en una variable de segundos. La diferencia horaria de la zona horaria se almacena en la variable timezone_hour. Puede cambiar el valor de la diferencia horaria de la zona horaria en horas según su país o zona horaria.
Ver cómo:
- La diferencia de zona horaria se convierte a un valor en segundos y se almacena en la variable timezone_sec.
- La hora local en segundos se obtiene sumando la diferencia horaria de la zona horaria en segundos a la hora UTC obtenida del RTC.
- Luego, la fecha y hora locales se obtienen pasando los segundos actualizados como argumento del método time.localtime.
- La hora devuelta por time.localtime se almacena en una tupla.
- La tupla se utiliza para mostrar la hora local en la consola. Luego, la tupla se reformatea y se usa para actualizar la fecha y hora del RTC a la hora local.
- Por último, desconecte el ESP8266/ESP32 de WiFi llamando a la función de desconexión.
Resultados
