Mastering MicroPython Time Format

MicroPython is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimised to run on microcontrollers and in constrained environments. One of the essential aspects of programming with MicroPython is dealing with time. Time management is crucial for various applications, such as real - time data logging, scheduling tasks, and synchronising events. In this blog post, we will explore the fundamental concepts of MicroPython time format, its usage methods, common practices, and best practices.

Table of Contents#

  1. Fundamental Concepts of MicroPython Time Format
  2. Usage Methods
  3. Common Practices
  4. Best Practices
  5. Conclusion
  6. References

1. Fundamental Concepts of MicroPython Time Format#

Time Representation in MicroPython#

MicroPython uses a few different ways to represent time:

1. time Module#

The time module in MicroPython provides basic time - related functions. It has a function time() which returns the number of seconds since an epoch (a fixed point in time). The epoch on MicroPython systems is usually 1st January 2000, 00:00:00 UTC.

import time
 
# Get the current time in seconds since the epoch
current_time = time.time()
print(f"Current time in seconds since epoch: {current_time}")

2. Tuple Representation#

MicroPython also represents time as a tuple of seven integers (year, month, day, hour, minute, second, weekday, yearday).

  • year: The year (e.g., 2024).
  • month: The month (1 - 12).
  • day: The day of the month (1 - 31).
  • hour: The hour (0 - 23).
  • minute: The minute (0 - 59).
  • second: The second (0 - 59).
  • weekday: The day of the week (0 - 6, where 0 is Monday).
  • yearday: The day of the year (1 - 366).

The localtime() function in the time module can be used to convert the seconds since the epoch to a tuple.

import time
 
current_time = time.time()
local_time_tuple = time.localtime(current_time)
print(f"Local time tuple: {local_time_tuple}")

2. Usage Methods#

Getting the Current Time#

As shown above, you can use the time() function to get the current time in seconds since the epoch and localtime() to get the current time as a tuple.

import time
 
# Get current time in seconds
seconds_since_epoch = time.time()
print(f"Seconds since epoch: {seconds_since_epoch}")
 
# Get current time as a tuple
current_time_tuple = time.localtime()
print(f"Current time tuple: {current_time_tuple}")

Setting the Time#

Some MicroPython boards allow you to set the time. For example, on the Pyboard, you can use the machine.RTC() (Real - Time Clock) class.

import machine
 
# Initialize the RTC
rtc = machine.RTC()
 
# Set the time (year, month, day, weekday, hour, minute, second, subsecond)
rtc.datetime((2024, 10, 1, 2, 12, 30, 0, 0))
 
# Get the updated time
updated_time = rtc.datetime()
print(f"Updated time: {updated_time}")

Formatting Time for Display#

You can format the time tuple into a human - readable string. For example, to create a string in the format YYYY - MM - DD HH:MM:SS.

import time
 
current_time_tuple = time.localtime()
formatted_time = "{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(
    current_time_tuple[0], current_time_tuple[1], current_time_tuple[2],
    current_time_tuple[3], current_time_tuple[4], current_time_tuple[5]
)
print(f"Formatted time: {formatted_time}")

3. Common Practices#

Time - Based Loops#

You can use time functions to create loops that run for a specific duration or at a specific interval.

import time
 
# Run a loop for 10 seconds
start_time = time.time()
while time.time() - start_time < 10:
    print("Running...")
    time.sleep(1)

Scheduling Tasks#

You can schedule tasks to run at specific times. For example, to run a task every 5 minutes:

import time
 
interval = 5 * 60  # 5 minutes in seconds
last_run_time = time.time()
 
while True:
    current_time = time.time()
    if current_time - last_run_time >= interval:
        print("Running scheduled task...")
        last_run_time = current_time
    time.sleep(1)

4. Best Practices#

Error Handling#

When dealing with time - related operations, it's important to handle errors. For example, if you are setting the time on the RTC and there is an issue with the hardware, it may raise an exception.

import machine
 
try:
    rtc = machine.RTC()
    rtc.datetime((2024, 10, 1, 2, 12, 30, 0, 0))
except Exception as e:
    print(f"Error setting time: {e}")

Energy Efficiency#

In battery - powered MicroPython devices, be mindful of the time functions you use. Functions like time.sleep() can help save energy by putting the device in a low - power state for a specified duration.

import time
 
while True:
    # Do some work
    print("Doing work...")
    # Sleep for 10 seconds to save energy
    time.sleep(10)

5. Conclusion#

Understanding and effectively using the MicroPython time format is essential for developing robust and efficient applications on microcontrollers. We have covered the fundamental concepts of time representation, usage methods, common practices, and best practices. By following these guidelines, you can ensure that your time - related operations are accurate, reliable, and energy - efficient.

6. References#

2025-10