Mastering MicroPython Keystrokes

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. Handling keystrokes in MicroPython is a crucial aspect when dealing with user input on devices such as development boards with built - in buttons or external keyboards. This blog will guide you through the fundamental concepts, usage methods, common practices, and best practices of handling keystrokes in MicroPython.

Table of Contents#

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

1. Fundamental Concepts of MicroPython Keystrokes#

What are Keystrokes in MicroPython?#

In the context of MicroPython, keystrokes refer to the actions of pressing and releasing buttons or keys on a device. These keystrokes can be used to trigger specific functions or actions within a MicroPython program. For example, a single - button press on a development board can be used to turn on an LED, or a sequence of keystrokes on an external keyboard can be used to navigate through a menu.

Input Devices#

The input devices for keystrokes in MicroPython can vary. Common input devices include:

  • Built - in Buttons: Many development boards, such as the Raspberry Pi Pico, have built - in buttons that can be used as input sources.
  • External Switches: You can connect external switches to the GPIO (General - Purpose Input/Output) pins of a microcontroller to expand the input options.
  • External Keyboards: Some MicroPython - enabled devices support the connection of external keyboards, allowing for more complex user input.

Digital Input#

When a button is pressed, it typically changes the electrical state of a GPIO pin. In MicroPython, this is represented as a digital input. A pin can be in either a high (1) or low (0) state, depending on whether the button is pressed or not.

2. Usage Methods#

Setting up a GPIO Pin for Button Input#

The first step in handling keystrokes is to set up a GPIO pin as an input. Here is an example using the Raspberry Pi Pico:

import machine
import time
 
# Define the GPIO pin connected to the button
button_pin = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)
 
while True:
    if button_pin.value() == 0:
        print("Button is pressed!")
        time.sleep(0.2)  # Debounce the button

In this code:

  1. We import the machine and time modules. The machine module is used to interact with the hardware, and the time module is used for adding delays.
  2. We define a GPIO pin (pin 2 in this case) as an input with a pull - up resistor. A pull - up resistor ensures that the pin is normally high when the button is not pressed.
  3. In the infinite loop, we continuously check the value of the pin. If the value is 0, it means the button is pressed, and we print a message. We also add a small delay to debounce the button.

Handling Multiple Buttons#

If you have multiple buttons, you can set up multiple GPIO pins and check their values independently.

import machine
import time
 
# Define GPIO pins for two buttons
button1_pin = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)
button2_pin = machine.Pin(3, machine.Pin.IN, machine.Pin.PULL_UP)
 
while True:
    if button1_pin.value() == 0:
        print("Button 1 is pressed!")
        time.sleep(0.2)
    if button2_pin.value() == 0:
        print("Button 2 is pressed!")
        time.sleep(0.2)

3. Common Practices#

Button Debouncing#

Button debouncing is a common issue when dealing with mechanical buttons. When a button is pressed or released, the electrical contact can bounce, causing multiple false readings. To prevent this, we add a small delay after detecting a button press.

import machine
import time
 
button_pin = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)
 
last_press_time = 0
debounce_delay = 200  # milliseconds
 
while True:
    if button_pin.value() == 0:
        current_time = time.ticks_ms()
        if current_time - last_press_time > debounce_delay:
            print("Button is pressed!")
            last_press_time = current_time
        time.sleep_ms(20)

Detecting Long Presses#

You can also detect long presses by measuring the time the button is held down.

import machine
import time
 
button_pin = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)
long_press_duration = 2000  # milliseconds
 
while True:
    if button_pin.value() == 0:
        press_start_time = time.ticks_ms()
        while button_pin.value() == 0:
            current_time = time.ticks_ms()
            if current_time - press_start_time > long_press_duration:
                print("Long press detected!")
                while button_pin.value() == 0:
                    pass  # Wait for the button to be released
                break
        time.sleep(0.2)

4. Best Practices#

Modular Code#

When dealing with multiple buttons and complex functionality, it is best to write modular code. For example, you can create functions to handle button presses.

import machine
import time
 
button_pin = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)
 
def handle_button_press():
    print("Button is pressed!")
 
last_press_time = 0
debounce_delay = 200
 
while True:
    if button_pin.value() == 0:
        current_time = time.ticks_ms()
        if current_time - last_press_time > debounce_delay:
            handle_button_press()
            last_press_time = current_time
        time.sleep_ms(20)

Error Handling#

In a real - world application, it is important to handle errors gracefully. For example, if there is an issue with the GPIO pin or the button, the program should not crash. You can use try - except blocks to handle exceptions.

import machine
import time
 
try:
    button_pin = machine.Pin(2, machine.Pin.IN, machine.Pin.PULL_UP)
    while True:
        if button_pin.value() == 0:
            print("Button is pressed!")
            time.sleep(0.2)
except Exception as e:
    print(f"An error occurred: {e}")

5. Conclusion#

Handling keystrokes in MicroPython is an essential skill for creating interactive applications on microcontrollers. By understanding the fundamental concepts, using the right usage methods, following common practices, and implementing best practices, you can effectively handle user input from buttons and keys. Whether you are building a simple IoT device or a complex control system, the ability to handle keystrokes will greatly enhance the user experience.

6. References#

2025-10