Raspberry pi pico analog Input/Output Example

The following short Python programs will demonstrate essential operation of the Raspberry Pi Pico board. These assume one or more analog input circuits are externally attached to an ADC input. Each can be run by copying the program into code.py on the CIRCUITPY drive offered by the board. The text can be pasted directly from this page, or each file can be downloaded from the CircuitPython sample code folder on this site.

Analog Input

Demonstration of reading a single analog input channel and applying thresholding with hysteresis. For sample circuits, please see Exercise: Analog Sensing with the Pico.

Direct download: analog_input.py.

# analog_input.py

# Raspberry Pi Pico - Analog Input demo

# Read an analog input with the ADC, drive the onboard LED, and print messages
# to the serial console only when the input state changes.

import board
import time
import analogio
import digitalio

#---------------------------------------------------------------
# Set up the hardware: script equivalent to Arduino setup()

# Set up built-in green LED for output.
led = digitalio.DigitalInOut(board.LED)  # GP25
led.direction = digitalio.Direction.OUTPUT

# Set up an analog input on ADC0 (GP26), which is physically pin 31.
# E.g., this may be attached to photocell or photointerrupter with associated pullup resistor.
sensor = analogio.AnalogIn(board.A0)

# These may be need to be adjusted for your particular hardware.  The Pico has
# 12-bit analog-to-digital conversion so the actual conversion has 4096 possible
# values, but the results are scaled to a 16-bit unsigned integer with range
# from 0 to 65535.
lower_threshold =  8000
upper_threshold = 45000

#---------------------------------------------------------------
# Run the main loop: script equivalent to Arduino loop()

# The following logic detects input transitions using a state machine with two
# possible states.  The state index reflects the current estimated state of the
# input.  The transition rules apply hysteresis in the form of assymmetric
# thresholds to reduce switching noise: the sensor value must rise higher than
# the upper threshold or lower than the lower threshold to trigger a state
# change.
state_index = False

while True:

    # Read the sensor once per cycle.
    sensor_level = sensor.value

    # uncomment the following to print tuples to plot with the mu editor
    # print((sensor_level,))
    # time.sleep(0.02)  # slow sampling to avoid flooding
    
    if state_index is False:
        if sensor_level < lower_threshold:
            led.value = True
            state_index = True
            print("On")

    elif state_index is True:
        if sensor_level > upper_threshold:
            led.value = False
            state_index = False
            print("Off")

    

Analog Input Speed Test

Direct download: ain_speed_test.py.

# ain_speed_test.py

# Raspberry Pi Pico - Analog Input Speed Test

# Read an analog input with the ADC and measure the number of conversions
# possible per second from CircuitPython.  The underlying hardware
# on the RP2040 chip is rated up to 500 kS/sec.

# Result: actual single-channel conversion rates run about 63 kS/sec.
# As a control case, an empty loop runs at around 192 kHz.

import board
import time
import analogio

#---------------------------------------------------------------
# Set up an analog input on ADC0 (GP26), which is physically pin 31.
# E.g., this may be attached to photocell or photointerrupter with associated pullup resistor.
sensor = analogio.AnalogIn(board.A0)

#---------------------------------------------------------------
# Run the main loop: script equivalent to Arduino loop()

while True:

    # Read a single ADC channel many times in a tight loop.
    num_samples = 100000    
    start = time.monotonic_ns()
    for i in range(num_samples):
        sensor_level = sensor.value
    end = time.monotonic_ns()
    elapsed = 1e-9 * (end - start)
    rate = num_samples / elapsed
    print(f"Read {num_samples} samples in {elapsed} seconds, {rate} samples/sec.")

    # Pause briefly.
    time.sleep(1)
    
    # Control case: null loop
    start = time.monotonic_ns()
    for i in range(num_samples):
        pass
    end = time.monotonic_ns()
    elapsed = 1e-9 * (end - start)
    rate = num_samples / elapsed    
    print(f"Performed empty loop {num_samples} times in {elapsed} seconds, {rate} loops/sec.")

    # Pause briefly.
    time.sleep(1)

Gesture Game

Filtering of analog signals typically assumes a constant sampling rate. However, not every activity in the system needs to run at this rate, so in practice this usually means that the signal processing activity is interleaved with other computation.

The following example highlights a strategy for interleaving multiple activities running at different rates. The main event loop of the system is kept cycling quickly and polling other objects to allow them to update their state at independent rates. The accelerometer signal processing runs at 100 Hz, the LED blink logic runs at a variable rate but typically around 1-2 Hz, and the main game logic runs at only 2Hz. The game logic implements a state machine which responds to a timed series of tilts of the accelerometer.

A sample circuit for connecting a three-channel analog accelerometer, useful for measuring tilt and motion.

Direct downloads:

  • gestures.py (to be copied into code.py on CIRCUITPY)
  • biquad.py (to be copied to CIRCUITPY without changing name)
  • linear.py (to be copied to CIRCUITPY without changing name)
# gestures.py

# Raspberry Pi Pico - Accelerometer Processing Demo

# Read an analog accelerometer input with the ADC and detect patterns of motion.
# Drive the onboard LED and print messages to indicate state.
# Assumes a three-axis analog accelerometer is connected to the three ADC inputs.

import board
import time
import analogio
import digitalio

# Import filters from the 'signals' directory provided with the course.  These
# files should be copied to the top-level directory of the CIRCUITPY filesystem
# on the Pico.

import linear
import biquad

#---------------------------------------------------------------

# Coefficients for Low-Pass Butterworth IIR digital filter, generated using
# filter_gen.py.  Sampling rate: 100.0 Hz, frequency: 20.0 Hz.  Filter is order
# 4, implemented as second-order sections (biquads). Reference:
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.butter.html
low_pass_100_20 = [
    [[ 1.00000000, -0.32897568,  0.06458765],   # A coeff for section 0
     [ 0.04658291,  0.09316581,  0.04658291]],  # B coeff for section 0
    [[ 1.00000000, -0.45311952,  0.46632557],   # A coeff for section 1
     [ 1.00000000,  2.00000000,  1.00000000]],  # B coeff for section 1
]

#---------------------------------------------------------------
class Accelerometer:
    def __init__(self):
        """Interface to a three-axis analog accelerometer including input calibration
        and filtering."""

        self.x_in = analogio.AnalogIn(board.A0)
        self.y_in = analogio.AnalogIn(board.A1)
        self.z_in = analogio.AnalogIn(board.A2)
        self.sampling_interval = 10000000           # period of 100 Hz in nanoseconds
        self.sampling_timer = 0
        self.raw  = [0, 0, 0]           # most recent raw value
        self.grav = [0.0, 0.0, 0.0]     # current calibrated and smoothed value

        # create a set of filters to smooth the input signal
        self.filters = [biquad.BiquadFilter(low_pass_100_20) for i in range(3)]
        
    def poll(self, elapsed):
        """Polling function to be called as frequently as possible from the event loop
        to read and process new samples.

        :param elapsed: nanoseconds elapsed since the last cycle.
        """

        self.sampling_timer -= elapsed
        if self.sampling_timer < 0:
            self.sampling_timer += self.sampling_interval

            # read the ADC values as synchronously as possible
            self.raw = [self.x_in.value, self.y_in.value, self.z_in.value]

            # apply linear calibration to find the unit gravity vector direction
            self.grav = [linear.map(self.raw[0], 26240, 39120, -1.0, 1.0),
                         linear.map(self.raw[1], 26288, 39360, -1.0, 1.0),
                         linear.map(self.raw[2], 26800, 40128, -1.0, 1.0)]

            # pipe each calibrated value through the filter
            self.grav = [filt.update(sample) for filt, sample in zip(self.filters, self.grav)]
            
#---------------------------------------------------------------
class Blinker:
    def __init__(self):
        """Interface to the onboard LED featuring variable rate blinking."""
        # Set up built-in green LED for output.
        self.led = digitalio.DigitalInOut(board.LED)  # GP25
        self.led.direction = digitalio.Direction.OUTPUT
        self.update_timer = 0
        self.set_rate(1.0)
            
    def poll(self, elapsed):
        """Polling function to be called as frequently as possible from the event loop
        with the nanoseconds elapsed since the last cycle."""
        self.update_timer -= elapsed
        if self.update_timer < 0:
            self.update_timer += self.update_interval
            self.led.value = not self.led.value

    def set_rate(self, Hz):
        self.update_interval = int(500000000 / Hz) # blink half-period in nanoseconds
        
#---------------------------------------------------------------
class Logic:
    def __init__(self, accel, blinker):
        """Application state machine."""
        self.accel   = accel
        self.blinker = blinker
        self.update_interval = 500000000           # period of 2 Hz in nanoseconds
        self.update_timer    = 0

        # initialize the state machine
        self.state = 'init'
        self.state_changed = False
        self.state_timer = 0

    def poll(self, elapsed):
        """Polling function to be called as frequently as possible from the event loop
        with the nanoseconds elapsed since the last cycle."""
        self.update_timer -= elapsed
        if self.update_timer < 0:
            self.update_timer += self.update_interval
            self.tick()            # evaluate the state machine

    def transition(self, new_state):
        """Set the state machine to enter a new state on the next tick."""
        self.state         = new_state
        self.state_changed = True
        self.state_timer   = 0
        print("Entering state:", new_state)

    def tick(self):
        """Evaluate the state machine rules."""

        # advance elapsed time in seconds        
        self.state_timer += 1e-9 * self.update_interval  
        
        # set up a flag to process transitions within a state clause
        entering_state = self.state_changed
        self.state_changed = False
        
        # select the state clause to evaluate
        if self.state == 'init':
            self.transition('idle')

        elif self.state == 'idle':
            if entering_state:
                self.blinker.set_rate(0.5)

            if self.accel.grav[1] < -0.5:
                self.transition('right')

        elif self.state == 'right':
            if entering_state:
                self.blinker.set_rate(1.0)

            if self.state_timer > 2.0:
                self.transition('idle')

            if self.accel.grav[1] > 0.5:
                self.transition('left')

        elif self.state == 'left':
            if entering_state:
                self.blinker.set_rate(2.0)

            if self.state_timer > 2.0:
                self.transition('idle')

            if self.accel.grav[0] < -0.5:
                self.transition('win')
                
        elif self.state == 'win':
            if entering_state:
                self.blinker.set_rate(4.0)

            if self.state_timer > 2.0:
                self.transition('idle')
                
#---------------------------------------------------------------
class Status:
    def __init__(self, accel, blinker, logic):
        """Debugging information reporter."""
        self.accel    = accel
        self.blinker  = blinker
        self.logic    = logic
        # self.update_interval = 1000000000           # period of 1 Hz in nanoseconds
        self.update_interval = 100000000           # period of 10 Hz in nanoseconds        
        self.update_timer = 0

    def poll(self, elapsed):
        """Polling function to be called as frequently as possible from the event loop
        with the nanoseconds elapsed since the last cycle."""
        self.update_timer -= elapsed
        if self.update_timer < 0:
            self.update_timer += self.update_interval
            print(tuple(self.accel.grav))
            # print(tuple(self.accel.raw))
                    
#---------------------------------------------------------------
# Initialize global objects.
accel   = Accelerometer()
blinker = Blinker()
logic   = Logic(accel, blinker)
status  = Status(accel, blinker, logic)

#---------------------------------------------------------------
# Main event loop to run each non-preemptive thread.

last_clock = time.monotonic_ns()

while True:
    # read the current nanosecond clock
    now = time.monotonic_ns()
    elapsed = now - last_clock
    last_clock = now

    # poll each thread
    accel.poll(elapsed)
    logic.poll(elapsed)
    blinker.poll(elapsed)
    status.poll(elapsed)

Source: Raspberry pi pico analog Input/Output Example

Scroll to Top
Read previous post:
BRIDGETEK-INTRODUCES-NEW-PANL-HARDWARE-FOR-THE-CONTROLLING-OF-SMART-DEVICES
BRIDGETEK INTRODUCES NEW PANL HARDWARE FOR THE CONTROLLING OF SMART DEVICES

Bridgetek has further extended the scope of possibilities addressed by its PanL home automation connectivity platform – with release of the...

Close