Mastering MicroPython Switches: A Comprehensive Guide

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. One of the common hardware components used in microcontroller projects is a switch. Switches are essential for user input, allowing devices to respond to physical interactions. In this blog post, we will explore the fundamental concepts of using switches with MicroPython, how to use them, common practices, and best practices to ensure reliable and efficient operation.

Table of Contents#

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

Fundamental Concepts of MicroPython Switches#

What is a Switch?#

A switch is a simple electromechanical device that can open or close an electrical circuit. There are different types of switches, such as push - button switches, toggle switches, and slide switches. In the context of MicroPython and microcontrollers, switches are used to detect user input. When a switch is pressed or toggled, it changes the electrical state of a pin on the microcontroller, which can be read by the MicroPython code.

Digital Input Pins#

Microcontrollers have digital input pins that can be used to read the state of a switch. When a switch is connected to a digital input pin, the pin can sense whether the switch is open (high impedance or logic high) or closed (connected to ground or logic low). MicroPython provides an easy - to - use API to read the state of these digital input pins.

Usage Methods#

Connecting a Switch to a Microcontroller#

Let's assume we are using a push - button switch with a microcontroller. The switch is typically connected between a digital input pin and ground. A pull - up resistor is often used to ensure that the pin reads a high state when the switch is open. When the switch is pressed, the pin is connected to ground, and the pin reads a low state.

Reading the Switch State in MicroPython#

The following is a simple example of reading the state of a switch connected to pin GP0 on a Raspberry Pi Pico using MicroPython:

import machine
import time
 
# Define the pin connected to the switch
switch_pin = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP)
 
while True:
    # Read the state of the switch
    switch_state = switch_pin.value()
    if switch_state == 0:
        print("Switch is pressed")
    else:
        print("Switch is not pressed")
    time.sleep(0.1)

In this code:

  1. We first import the machine and time modules. The machine module provides access to the hardware pins, and the time module is used for adding delays.
  2. We define the pin connected to the switch as an input pin with a pull - up resistor.
  3. In the infinite loop, we read the state of the switch using the value() method. If the state is 0, it means the switch is pressed; otherwise, it is not pressed.
  4. We add a 100 - millisecond delay using time.sleep(0.1) to avoid reading the switch state too frequently.

Common Practices#

Debouncing#

Mechanical switches can suffer from contact bounce, which means that when the switch is pressed or released, the electrical contact may make and break several times in a short period. This can cause the microcontroller to detect multiple presses or releases when only one action was intended.

To solve this problem, we can implement debouncing. Here is an example of debouncing a switch:

import machine
import time
 
switch_pin = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP)
last_state = switch_pin.value()
debounce_time = 20  # Debounce time in milliseconds
last_debounce_time = 0
 
while True:
    current_state = switch_pin.value()
    current_time = time.ticks_ms()
 
    if current_state != last_state:
        last_debounce_time = current_time
 
    if (current_time - last_debounce_time) > debounce_time:
        if current_state != switch_pin.value():
            if current_state == 0:
                print("Switch is pressed")
            else:
                print("Switch is released")
            last_state = current_state

In this code, we keep track of the last state of the switch and the last time the state changed. If the state has changed and a certain debounce time has passed, we consider the change valid.

Using Interrupts#

Instead of continuously polling the switch state in a loop, we can use interrupts to detect when the switch state changes. Interrupts allow the microcontroller to respond immediately to a change in the switch state without wasting CPU time in a polling loop.

import machine
 
def switch_callback(pin):
    print("Switch state changed")
 
switch_pin = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP)
switch_pin.irq(trigger=machine.Pin.IRQ_FALLING | machine.Pin.IRQ_RISING, handler=switch_callback)

In this code, we define a callback function switch_callback that will be called when the switch state changes. We then configure the pin to generate an interrupt on both falling and rising edges and set the callback function as the handler.

Best Practices#

Power Management#

When using switches in battery - powered applications, it is important to minimise power consumption. One way to do this is to use low - power sleep modes between switch state checks. For example, some microcontrollers support deep - sleep modes where most of the hardware is turned off, and the microcontroller wakes up only when an interrupt occurs.

Error Handling#

In real - world applications, it is important to handle errors gracefully. For example, if the switch connection is loose or there is a hardware failure, the code should be able to detect and handle such situations. You can add error - handling code in your MicroPython script to log errors or take appropriate actions.

Code Modularity#

Write modular code that separates the switch - reading logic from the main application logic. This makes the code easier to understand, test, and maintain. For example, you can create a class or a function that encapsulates the switch - reading and debouncing logic.

Conclusion#

In this blog post, we have explored the fundamental concepts of using switches with MicroPython, including how to connect a switch to a microcontroller, read its state, and deal with common issues such as contact bounce. We have also discussed common practices like debouncing and using interrupts, as well as best practices for power management, error handling, and code modularity. By following these guidelines, you can build reliable and efficient MicroPython projects that use switches as user input devices.

References#

  1. MicroPython official documentation: https://docs.micropython.org/
  2. Raspberry Pi Pico MicroPython SDK: https://datasheets.raspberrypi.org/pico/raspberry-pi-pico-python-sdk.pdf
2025-10