DC Motor Examples - Raspberry Pi Pico

The following short Python programs will demonstrate essential operation of the Raspberry Pi Pico board. These assume one or DC motor actuators are externally attached. 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.

Related Pages

• CircuitPython pwmio module

• Raspberry Pi Pico

• CircuitPython Guide

Sample MOSFET Motor Driver Circuit

Sample MOSFET driver circuit. Note that any GPIO pin may be used to control the IRLB8721PBF MOSFET transistor driver. The circuit is shown with a battery for motor power, but a an 5 or 12V adapter is also suitable if appropriate for the chosen motor. Please be careful with the power wiring, motor voltages can destroy the Pico. The IRLB8721PBF is specifically selected because it will operate with the Pico 3.3V output signals.

Sample TB6612 Motor Driver Circuit

The lab currently stocks Pololu TB6612FNG dual motor driver modules.

Sample motor driver circuit. The TB6612 is a dual H-bridge driver capable of operating two motors bidirectionally. Note that any six GPIO pins may be used to control the TB6612. Please be careful with the power wiring, motor voltages can destroy the Pico.

Sample DRV8833 Motor Driver Circuit

The lab previously stocked DRV8833 carrier boards.

Sample driver circuit. Note that any four GPIO pins may be used to control the DRV8833 dual motor driver. Please be careful with the power wiring, motor voltages can destroy the Pico.

Pump Control Example

This self-contained example operates one DC motor in a single direction at variable speed. This is usually all that is needed for operating pumps or fans. For bidirectional control, please see the DRV8833 examples. The example uses GP22 for output, but any of the GPIO outputs can be programmed for pulse-width-modulation (PWM) output.

Direct download: pump_control.py.

# pump_control.py

# Demonstrate variable-speed single-directional control of a DC motor driven via
# a MOSFET transistor driver circuit.  For a reversible motion, please see the
# DRV8833 example, but some applications (e.g. pumps and fans) only require a
# single direction of rotation at variable speed.

# Related documentation:
# https://circuitpython.readthedocs.io/en/latest/shared-bindings/pwmio/index.html#module-pwmio

# ----------------------------------------------------------------
# Import standard Python modules.
import time, math

# Load the CircuitPython hardware definition module for pin definitions.
import board

# Load the CircuitPython pulse-width-modulation module for driving hardware.
import pwmio

# ----------------------------------------------------------------
# Initialize hardware.

# Create a PWMOut object on GP22.  This will create a pulsing signal with
# variable duty cycle.  The switching rate of 20kHz is chosen to be
# supra-audible.
pwm = pwmio.PWMOut(board.GP22, duty_cycle=0, frequency=20000)

# Utility function to calculate and apply a new duty cycle setting.  Converts a
# unit-range (0.0 to 1.0) pwm_level to a 16-bit integer representing a fraction
# needed by the PWM driver.
def set_motor_speed(pwm_device, pwm_level):
    pwm_device.duty_cycle = min(max(int(pwm_level * 2**16), 0), 2**16-1)
    print("Applied duty cycle of %d for pwm_level %f" % (pwm_device.duty_cycle, pwm_level))
          
# ----------------------------------------------------------------
# Enter the main event loop.
while True:

    # Turn the motor on halfway.
    set_motor_speed(pwm, 0.5)
    time.sleep(1.0)

    # Turn the motor off again.
    set_motor_speed(pwm, 0.0)
    time.sleep(1.0)

    # Turn the motor on a little faster.
    set_motor_speed(pwm, 0.75)
    time.sleep(1.0)

    # Turn the motor off again.
    set_motor_speed(pwm, 0.0)
    time.sleep(1.0)
    
    # Turn the motor full.
    set_motor_speed(pwm, 1.0)
    time.sleep(1.0)

    # Turn the motor off again.
    set_motor_speed(pwm, 0.0)
    time.sleep(1.0)

Dual Spin Example

This self-contained example operates two small DC motors.

Direct download: dual_spin.py.

# dual_spin.py
#
# Raspberry Pi Pico - DC motor motion demo
#
# Demonstrates operating two DC motors driven by a DRV8833.
#
# This assumes a Pololu DRV8833 dual motor driver has been wired up to the Pico as follows:
#   Pico pin 24, GPIO18   -> AIN1
#   Pico pin 25, GPIO19   -> AIN2
#   Pico pin 26, GPIO20   -> BIN2
#   Pico pin 27, GPIO21   -> BIN1
#   any Pico GND          -> GND

# DRV8833 carrier board: https://www.pololu.com/product/2130

################################################################
# CircuitPython module documentation:
# time    https://circuitpython.readthedocs.io/en/latest/shared-bindings/time/index.html
# math    https://circuitpython.readthedocs.io/en/latest/shared-bindings/math/index.html
# board   https://circuitpython.readthedocs.io/en/latest/shared-bindings/board/index.html
# pwmio   https://circuitpython.readthedocs.io/en/latest/shared-bindings/pwmio/index.html

################################################################################
# print a banner as reminder of what code is loaded
print("Starting dual_spin script.")

# load standard Python modules
import math, time

# load the CircuitPython hardware definition module for pin definitions
import board

# load the CircuitPython pulse-width-modulation module for driving hardware
import pwmio

#--------------------------------------------------------------------------------
# Class to represent a single dual H-bridge driver.

class DRV8833():
    def __init__(self, AIN1=board.GP18, AIN2=board.GP19, BIN2=board.GP20, BIN1=board.GP21, pwm_rate=20000):
        # Create a pair of PWMOut objects for each motor channel.
        self.ain1 = pwmio.PWMOut(AIN1, duty_cycle=0, frequency=pwm_rate)
        self.ain2 = pwmio.PWMOut(AIN2, duty_cycle=0, frequency=pwm_rate)

        self.bin1 = pwmio.PWMOut(BIN1, duty_cycle=0, frequency=pwm_rate)
        self.bin2 = pwmio.PWMOut(BIN2, duty_cycle=0, frequency=pwm_rate)

    def write(self, channel, rate):
        """Set the speed and direction on a single motor channel.

        :param channel:  0 for motor A, 1 for motor B
        :param rate: modulation value between -1.0 and 1.0, full reverse to full forward."""

        # convert the rate into a 16-bit fixed point integer
        pwm = min(max(int(2**16 * abs(rate)), 0), 65535)

        if channel == 0:
            if rate < 0:
                self.ain1.duty_cycle = pwm
                self.ain2.duty_cycle = 0
            else:
                self.ain1.duty_cycle = 0
                self.ain2.duty_cycle = pwm
        else:
            if rate < 0:
                self.bin1.duty_cycle = pwm
                self.bin2.duty_cycle = 0
            else:
                self.bin1.duty_cycle = 0
                self.bin2.duty_cycle = pwm


#--------------------------------------------------------------------------------
# Create an object to represent a dual motor driver.
print("Creating driver object.")
driver = DRV8833()

#--------------------------------------------------------------------------------
# Begin the main processing loop.  This is structured as a looping script, since
# each movement primitive 'blocks', i.e. doesn't return until the action is
# finished.

print("Starting main script.")
while True:
    # initial pause
    time.sleep(2.0)

    print("Testing motor A.")
    driver.write(0, 1.0)
    time.sleep(2.0)

    driver.write(0, 0.0)
    time.sleep(2.0)

    driver.write(0, -1.0)
    time.sleep(2.0)
    
    driver.write(0, 0.0)
    time.sleep(2.0)

    print("Testing motor B.")    
    driver.write(1, 1.0)
    time.sleep(2.0)

    driver.write(1, 0.0)
    time.sleep(2.0)

    driver.write(1, -1.0)
    time.sleep(2.0)
    
    driver.write(1, 0.0)
    time.sleep(2.0)

    print("Ramp test.")

    for i in range(10):
        driver.write(0, i*0.1)
        driver.write(1, i*0.1)
        time.sleep(0.5)

    driver.write(0, 0.0)
    driver.write(1, 0.0)
    time.sleep(2.0)
        
    for i in range(10):
        driver.write(0, -i*0.1)
        driver.write(1, -i*0.1)
        time.sleep(0.5)
        
    driver.write(0, 0.0)
    driver.write(1, 0.0)
    time.sleep(2.0)

tb6612 module

This module provides a class for controlling a TB6612 dual H-bridge DC motor driver. This device can drive two low-power DC motor bidirectionally with variable speed. Note that this file will normally be copied to the top-level folder of the CIRCUITPY filesystem so it can be imported by other scripts.

class tb6612.TB6612

This class represents a single dual H-bridge driver. It configures two pins for PWM output and four pins as digital output and can be used to control two DC motors bidirectionally at variable speed.

N.B. this does not implement any other timing process, it simply sets motor PWM levels but does not apply feedback, duration, or trajectory.

Direct download: tb6612.py.

# tb6612.py
#
# Raspberry Pi Pico - TB6612 dual H-bridge motor driver support
#
# This module provides a class for controlling a TB6612 dual H-bridge DC motor driver.
# This device can drive two low-power DC motors bidirectionally with variable speed.
#
# A typical usage requires six digital outputs.  The defaults assumes a Pololu
# TB6612 dual motor driver has been wired up to the Pico as follows:

#   Pico pin 11, GPIO8    -> PWMA
#   Pico pin 12, GPIO9    -> AIN2
#   Pico pin 14, GPIO10   -> AIN1
#
#   Pico pin 15, GPIO11   -> BIN1
#   Pico pin 16, GPIO12   -> BIN2
#   Pico pin 17, GPIO13   -> PWMB
#
#   any Pico GND          -> GND

# TB6612 carrier board: https://www.pololu.com/product/713

################################################################
# CircuitPython module documentation:
# time      https://docs.circuitpython.org/en/latest/shared-bindings/time/index.html
# math      https://docs.circuitpython.org/en/latest/shared-bindings/math/index.html
# board     https://docs.circuitpython.org/en/latest/shared-bindings/board/index.html
# pwmio     https://docs.circuitpython.org/en/latest/shared-bindings/pwmio/index.html
# digitalio https://docs.circuitpython.org/en/latest/shared-bindings/digitalio/index.html
#
# Driver lifecycle documentation:
# https://docs.circuitpython.org/en/latest/docs/design_guide.html#lifetime-and-contextmanagers
#
################################################################################
# load standard Python modules
import math, time

# load the CircuitPython hardware definition module for pin definitions
import board

# load the CircuitPython pulse-width-modulation module for driving hardware
import pwmio

#  load the CircuitPython basic digital pin support for driving hardware
import digitalio

#--------------------------------------------------------------------------------
class TB6612:
    def __init__(self,
                 PWMA=board.GP8,  AIN1=board.GP10, AIN2=board.GP9,   # control pins for motor A
                 PWMB=board.GP13, BIN1=board.GP11, BIN2=board.GP12,  # control pins for motor B
                 pwm_rate=20000):
        """This class represents a single dual H-bridge driver.  It configures
        two pins for PWM output and four pins for digital output and can be used
        to control two DC motors bidirectionally at variable speed.

        N.B. this does not implement any other timing process, it simply sets
        motor PWM levels but does not apply feedback, duration, or trajectory.

        """`
        # The PWM pins are used to control driver output power.
        self.pwma = pwmio.PWMOut(PWMA, duty_cycle=0, frequency=pwm_rate)
        self.pwmb = pwmio.PWMOut(PWMB, duty_cycle=0, frequency=pwm_rate)

        # The IN pins are used to set direction.
        self.ain1 = digitalio.DigitialInOut(AIN1)
        self.ain2 = digitalio.DigitialInOut(AIN2)
        self.bin1 = digitalio.DigitialInOut(BIN1)
        self.bin2 = digitalio.DigitialInOut(BIN2)

        for pin in [self.ain1, self.ain2, self.bin1, self.bin2]:
            pin.switch_to_output(value=False)
        return

    def write(self, channel, rate):
        """Set the speed and direction on a single motor channel.

        :param int channel:  0 for motor A, 1 for motor B
        :param float rate: modulation value between -1.0 and 1.0, full reverse to full forward."""

        # convert the rate into a 16-bit fixed point integer
        pwm = min(max(int(2**16 * abs(rate)), 0), 65535)

        # the direction control pins are always driven with opposite polarity
        if channel == 0 or channel == 'A' or channel == 'a':
            self.pwma.duty_cycle = pwm
            if rate < 0:
                self.ain1 = False
                self.ain2 = True
            else:
                self.ain1 = True
                self.ain2 = False
        else:
            self.pwmb.duty_cycle = pwm
            if rate < 0:
                self.bin1 = False
                self.bin2 = True
            else:
                self.bin1 = True
                self.bin2 = False

    def deinit(self):
        """Manage resource release as part of object lifecycle."""
        self.pwma.deinit()
        self.ain1.deinit()
        self.ain2.deinit()

        self.pwmb.deinit()
        self.bin1.deinit()
        self.bin2.deinit()

        self.pwma = None
        self.ain1 = None
        self.ain2 = None

        self.pwmb = None
        self.bin1 = None
        self.bin2 = None

    def __enter__(self):
        return self

    def __exit__(self):
        # Automatically deinitializes the hardware when exiting a context.
        self.deinit()

drv8833 module

This module provides a class for controlling a DRV8833 dual H-bridge DC motor driver. This device can drive two low-power DC motor bidirectionally with variable speed. Note that this file will normally be copied to the top-level folder of the CIRCUITPY filesystem so it can be imported by other scripts.

class drv8833.DRV8833

This class represents a single dual H-bridge driver. It configures four pins for PWM output and can be used to control two DC motors bidirectionally at variable speed.

N.B. this does not implement any other timing process, it simply sets motor PWM levels but does not apply feedback, duration, or trajectory.

Direct download: drv8833.py.

# drv8833.py
#
# Raspberry Pi Pico - dual H-bridge motor driver support
#
# This module provides a class for controlling a DRV8833 dual H-bridge DC motor driver.
# This device can drive two low-power DC motor bidirectionally with variable speed.
#
# A typical usage requires four digital outputs.  The defaults assumes a Pololu
# DRV8833 dual motor driver has been wired up to the Pico as follows:
#   Pico pin 24, GPIO18   -> AIN1
#   Pico pin 25, GPIO19   -> AIN2
#   Pico pin 26, GPIO20   -> BIN2
#   Pico pin 27, GPIO21   -> BIN1
#   any Pico GND          -> GND

# DRV8833 carrier board: https://www.pololu.com/product/2130

################################################################
# CircuitPython module documentation:
# time    https://circuitpython.readthedocs.io/en/latest/shared-bindings/time/index.html
# math    https://circuitpython.readthedocs.io/en/latest/shared-bindings/math/index.html
# board   https://circuitpython.readthedocs.io/en/latest/shared-bindings/board/index.html
# pwmio   https://circuitpython.readthedocs.io/en/latest/shared-bindings/pwmio/index.html
#
# Driver lifecycle documentation:
# https://circuitpython.readthedocs.io/en/latest/docs/design_guide.html#lifetime-and-contextmanagers
#
################################################################################
# load standard Python modules
import math, time

# load the CircuitPython hardware definition module for pin definitions
import board

# load the CircuitPython pulse-width-modulation module for driving hardware
import pwmio

#--------------------------------------------------------------------------------
class DRV8833:
    def __init__(self,
                 AIN1=board.GP18, AIN2=board.GP19,  # control pins for motor A
                 BIN2=board.GP20, BIN1=board.GP21,  # control pins for motor B
                 pwm_rate=20000):
        """This class represents a single dual H-bridge driver.  It configures four pins
        for PWM output and can be used to control two DC motors bidirectionally
        at variable speed. 

        N.B. this does not implement any other timing process, it simply sets
        motor PWM levels but does not apply feedback, duration, or trajectory.
        """
        self.ain1 = pwmio.PWMOut(AIN1, duty_cycle=0, frequency=pwm_rate)
        self.ain2 = pwmio.PWMOut(AIN2, duty_cycle=0, frequency=pwm_rate)

        self.bin1 = pwmio.PWMOut(BIN1, duty_cycle=0, frequency=pwm_rate)
        self.bin2 = pwmio.PWMOut(BIN2, duty_cycle=0, frequency=pwm_rate)

    def write(self, channel, rate):
        """Set the speed and direction on a single motor channel.

        :param int channel:  0 for motor A, 1 for motor B
        :param float rate: modulation value between -1.0 and 1.0, full reverse to full forward."""

        # convert the rate into a 16-bit fixed point integer
        pwm = min(max(int(2**16 * abs(rate)), 0), 65535)

        if channel == 0 or channel == 'A' or channel == 'a':
            if rate < 0:
                self.ain1.duty_cycle = pwm
                self.ain2.duty_cycle = 0
            else:
                self.ain1.duty_cycle = 0
                self.ain2.duty_cycle = pwm
        else:
            if rate < 0:
                self.bin1.duty_cycle = pwm
                self.bin2.duty_cycle = 0
            else:
                self.bin1.duty_cycle = 0
                self.bin2.duty_cycle = pwm

    def deinit(self):
        """Manage resource release as part of object lifecycle."""
        self.ain1.deinit()
        self.ain2.deinit()
        self.bin1.deinit()
        self.bin2.deinit()
        self.ain1 = None
        self.ain2 = None
        self.bin1 = None
        self.bin2 = None
        
    def __enter__(self):
        return self

    def __exit__(self):
        # Automatically deinitializes the hardware when exiting a context. 
        self.deinit()