TIME
El módulo time (utime) de la librería estándar de MicroPython proporciona un conjunto de funciones para indicar el tiempo que el microcontrolador lleva encendido, medir intervalos de tiempo e introducir retardos (esperas) en la ejecución de los programas.
En total dispone de 11 métodos (funciones): time(), ticks_ms(), ticks_us(), ticks_cpu(), localtime(), mktime(), ticks_add(), ticks_diff(), sleep(), sleep_ms() y sleep_us().
TIEMPO QUE EL MICROCONTROLADOR LLEVA ENCENDIDO
- Las funciones time(), ticks_ms(), ticks_us() y ticks_cpu() indican el tiempo que el microcontrolador lleva encendido. Utilizan respectivamente como unidades segundos, milisegundos, microsegundos y nanosegundos. El tiempo máximo que pueden almacenar es 230 = 1.073.741.823 unidades. Cuando se rebasa este número la cuenta se reinicia, por lo tanto
- si se utiliza time() se reiniciará cada 34a 1m 9d 13h 37′ 3″,
- si se utiliza ticks_ms() se reiniciará cada 12d 10h 15′ 41″ 823ms,
- si se utiliza ticks_us() se reiniciará cada 17′ 53″ 741ms 823us y
- si se utiliza ticks_cpu()se reiniciará cada 1″ 73ms 741.823us.
import time a = time.time() # tiempo que lleva el microcontrolador encendido en segundos a = time.ticks_ms() # tiempo que lleva el microcontrolador encendido en milisegundos b = time.ticks_us() # tiempo que lleva el microcontrolador encendido en microsegundos c = time.ticks_cpu() # tiempo que lleva el microcontrolador encendido en nanosegundos print (a, "segundos,", b, "milisegundos,", c, "microsegundos y", d, "nanosegundos.")
El módulo time (utime) de la biblioteca estándar de Python, instalado en un ordenador o servidor, nos daría si lo consultáramos, la hora local del ordenador o servidor en vez del tiempo que pueda llevar el correspondiente equipo encendido.
- La función localtime() convierte el tiempo que el microcontrolador lleva encendido o un valor que se proporciona, de segundos a una tupla de 8 elementos que contiene: (año –en miles p.e. 2019-, mes –del 1 al 12-, día –del 1 al 31-, hora –de la 0 a la 23-, minuto –del 0 al 59-, segundo –del 0 al 59-, día de la semana –del 0 al 6 para lunes a domingo-, día del año –del 1 al 366-), partiendo del 1 de enero de 2000.
- La función mktime() realiza la función inversa de localtime() convirtiendo una tupla de 8 elementos (año, mes, día, hora, minuto, segundo, día de la semana, día del año), partiendo del 1 de enero de 2000 a segundos.
import time
time.localtime() # tiempo que lleva el microcontrolador encendido
# (año -en miles-, mes -del 1 al 12-, día -del 1 al 31-, hora -de la 0 a la 23-,
# minuto -del 0 al 59-, segundo -del 0 al 59-, día de la semana -del 0 al 6 para lunes a domingo-,
# día del año -del 1 al 366-), partiendo del 1 de enero de 2000.
time.localtime(1000) # 1000 segundos en (año, mes, día, hora, minuto, segundo, día de la semana, día del año),
# partiendo del 1 de enero de 2000.
time.mktime((2000, 1, 1, 0, 16, 40, 5, 1)) # convierte la tupla (año, mes, día, hora, minuto, segundo,
# día de la semana, día del año) en segundos
# partiendo del 1 de enero de 2000.
INTERVALOS DE TIEMPO
- La función ticks_add() suma un valor (positivo o negativo entero) a otro valor devuelto por ticks_ms(), ticks_us(), ticks_cpu() o ticks_add(). ticks_diff (delta, ticks) tiene el mismo significado que delta + ticks.
- La función ticks_diff() mide la diferencia de tiempo entre valores devueltos por ticks_ms(), ticks_us() o ticks_cpu(). El orden de los argumentos es el mismo que de una sustracción ticks_diff (ticks1, ticks2) tiene el mismo significado que ticks1 – ticks2.
"""
Nº de veces (ciclos) que el microcontrolador ESP32 puede ejecutar un bucle while... en 1 s.
El resultado será de aprox. 11.000 ciclos/s con una frecuencia del microcontrolador de 240 Mh.
Esto nos da idea de la extraordinaria velocidad del microcontrolador!!!
"""
import time
numeroCiclos = 0 #creamos y ponemos a 0 la variable numeroCiclos para contar los ciclos
tiempoLimite = time.ticks_add(time.ticks_ms(), 1000) #establecemos el tiempoLimite (actual + 1000 ms)
while time.ticks_diff(tiempoLimite, time.ticks_ms()) > 0: #comprobamos si el tiempoLimite se ha agotado
numeroCiclos += 1 #sumamos un ciclo
print (numeroCiclos) #imprimimos el numeroCiclos ralizados
RETARDOS (ESPERAS)
-
-
- Las funciones sleep(), sleep_ms() y sleep_us() introducen retardos (esperas) en la ejecución del programa por el microcontrolador, deteniéndola el tiempo que se especifique. Utilizan respectivamente como unidades segundos, milisegundos y microsegundos.
-
import time time.sleep(1) # interrumpe el procesamiento 1 segundo time.sleep_ms(750) # interrumpe el procesamiento 750 milisegundos time.sleep_us(250) # interrumpe el procesamiento 250 microsegundos
Los métodos sleep(), sleep_ms() y sleep_us() son retardos bloqueantes, es decir, el microcontroladador detiene la ejecución del programa durante el tiempo establecido y lo inhabilita para otras necesidades (p.e. no recibiría datos de entrada de sensores… excepto si se producen interrupciones, que son la detección de eventos externos programados de una forma especial, sobre unos pines determinados).
Lo adecuado con el uso de pequeños microcontroladores es programar las tareas de forma no bloqueante. Es decir, programar la ejecución de las tareas, sin que ello suponga que no podamos hacer nada más.
Para ello debemos evitar el uso de retardos y utilizar bucles, para comprobar si un intervalo de tiempo ha pasado y si es así realizar una determinada función.
Esto se puede entender muy bien con el siguiente ejemplo, un programa para hacer parpadear un LED cada 200 ms conectado en el GPIO_02 y otro LED cada 500 ms conectado en el GPIO_04. Utilizando los retardos sería muy complicado hacerlo, pero midiendo intervalos de tiempo resulta bastante simple:
from machine import Pin
import time
pin_02 = Pin(2, mode=Pin.OUT, value=1) # inicializamos el GPIO 02 como salida del LED 02 y lo encendemos
pin_04 = Pin(4, mode=Pin.OUT, value=1)
tiempoLimite_02 = time.ticks_add(time.ticks_ms(), 200) # definimos la variable tiempoLimite_02 para el LED 02
# y establecemos su valor (tiempo actual+200 ms)
tiempoLimite_04 = time.ticks_add(time.ticks_ms(), 500)
while True:
if time.ticks_diff(tiempoLimite_02, time.ticks_ms()) <= 0: #comprobamos si el tiempoLimite_02 se ha agotado
if pin_02.value() == 1: # si el tº se ha agotado y el LED 02 está encendido...
pin_02.off() # ... lo apagamos
else: # si el tº se ha agotado y el LED 02 no está encendido...
pin_02.on() # ...lo encendemos
tiempoLimite_02 = time.ticks_add(time.ticks_ms(), 200) #nuevo tiempoLimite_02 (tiempo actual+200 ms)
if time.ticks_diff(tiempoLimite_04, time.ticks_ms()) <= 0:
pin_04.off()
else:
pin_04.on()
tiempoLimite_04 = time.ticks_add(time.ticks_ms(), 500)
Si el contenido del artículo te ha parecido interesante y vas a hacer una compra en Amazon, puedes colaborar con el blog realizando la compra siguiendo el enlace que aparece a continuación. El precio es el mismo para ti, pero este blog recibira una pequeña comisión sobre tu compra.
4 Comments
Leave your reply.