Exploring MicroPython with Potentiometers

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. A potentiometer, on the other hand, is a three - terminal resistor with a sliding or rotating contact that forms an adjustable voltage divider. When combined, MicroPython and potentiometers offer a simple yet powerful way to interact with electronic circuits, enabling projects that can sense and respond to physical changes. This blog will guide you through the fundamental concepts, usage, common practices, and best practices of using a potentiometer with MicroPython.

Table of Contents#

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

Fundamental Concepts#

What is a Potentiometer?#

A potentiometer is a variable resistor. It has three pins: two outer pins are connected to the ends of a resistive track, and the middle pin is the wiper. As the wiper moves along the resistive track, the resistance between the wiper and one of the outer pins changes. This change in resistance can be used to measure a physical quantity such as position, angle, or pressure, or to control the voltage in a circuit.

How MicroPython Interacts with Potentiometers#

MicroPython provides an easy way to interface with potentiometers through the Analog - to - Digital Converter (ADC). The ADC on a microcontroller can read the voltage at the wiper pin of the potentiometer and convert it into a digital value. This digital value can then be used in your MicroPython code for further processing.

Usage Methods#

Hardware Setup#

To use a potentiometer with a MicroPython - enabled microcontroller, you need to connect the potentiometer to the microcontroller. Typically, the two outer pins of the potentiometer are connected to the power supply (e.g., 3.3V and GND), and the middle pin (wiper) is connected to an ADC pin on the microcontroller.

Code Example#

The following is a simple MicroPython code example for reading the value from a potentiometer connected to an ADC pin on a Raspberry Pi Pico:

import machine
 
# Initialize the ADC pin
adc = machine.ADC(machine.Pin(26))
 
while True:
    # Read the ADC value
    adc_value = adc.read_u16()
    print(f"ADC value: {adc_value}")

In this code:

  1. We first import the machine module, which provides access to the hardware features of the microcontroller.
  2. We initialise an ADC object, specifying the pin number (26 in this case) where the potentiometer's wiper is connected.
  3. In the infinite loop, we read the ADC value using the read_u16() method, which returns a 16 - bit unsigned integer representing the voltage at the ADC pin.
  4. We then print the ADC value to the console.

Common Practices#

Calibration#

The raw ADC value may not directly represent the physical quantity you want to measure. You may need to calibrate the ADC value. For example, if you want to map the ADC value to a percentage (0 - 100%), you can use the following formula:

import machine
 
adc = machine.ADC(machine.Pin(26))
 
while True:
    adc_value = adc.read_u16()
    percentage = (adc_value / 65535) * 100
    print(f"Percentage: {percentage:.2f}%")

Using the Value for Control#

You can use the potentiometer value to control other components in your circuit. For example, you can use the potentiometer to control the brightness of an LED:

import machine
import time
 
adc = machine.ADC(machine.Pin(26))
led = machine.PWM(machine.Pin(15))
led.freq(1000)
 
while True:
    adc_value = adc.read_u16()
    duty_cycle = int((adc_value / 65535) * 65535)
    led.duty_u16(duty_cycle)
    time.sleep(0.1)

In this code, we use Pulse - Width Modulation (PWM) to control the brightness of an LED connected to pin 15. The duty cycle of the PWM signal is adjusted based on the potentiometer value.

Best Practices#

Debouncing#

When reading the potentiometer value, you may encounter electrical noise or mechanical vibrations that can cause the ADC value to fluctuate. To reduce this noise, you can implement a simple debouncing algorithm. For example, you can take multiple readings and calculate the average:

import machine
import time
 
adc = machine.ADC(machine.Pin(26))
 
def read_adc_average(num_readings):
    total = 0
    for _ in range(num_readings):
        total += adc.read_u16()
        time.sleep(0.01)
    return total / num_readings
 
while True:
    average_value = read_adc_average(5)
    print(f"Average ADC value: {average_value}")

Error Handling#

When working with hardware, errors can occur. You should implement error handling in your code. For example, if the ADC pin is not working correctly, your code should handle the error gracefully.

import machine
 
try:
    adc = machine.ADC(machine.Pin(26))
    while True:
        adc_value = adc.read_u16()
        print(f"ADC value: {adc_value}")
except Exception as e:
    print(f"An error occurred: {e}")

Conclusion#

Using a potentiometer with MicroPython is a straightforward and powerful way to add interactivity to your electronic projects. By understanding the fundamental concepts, following the usage methods, and implementing common and best practices, you can effectively use potentiometers to sense physical changes and control other components in your circuits. Whether you are a beginner or an experienced maker, potentiometers and MicroPython offer a great combination for exploring the world of electronics.

References#

2025-10