A lower PWM frequency can dramatically improve the slow-speed operation of brushed DC motors. Set your motor controller's PWM frequency below 100Hz and test to see if performance improves.

Jump to the Code Examples section to see how it's done.

Works with:

• CRICKIT FeatherWing
• CRICKIT for Circuit Playground Express
• DC Motor + Stepper FeatherWing
• Motor/Stepper/Servo Shield
• DRV8871 DC Motor Driver Breakout
• DRV8833 DC/Stepper Motor Driver Breakout
• TB6612 1.2A DC/Stepper Motor Driver Breakout
• L9110H H-Bridge Motor Driver
• L293D Dual H-Bridge Motor Driver

Supporting code libraries:

• Adafruit Crickit for CircuitPython
• Adafruit Motor for CircuitPython
• Adafruit MotorKit for CircuitPython
• Adafruit MotorShield for Arduino

Parts

The StringCar racer robot was bouncing off the string when accelerating and braking. At slow speed, the precariously balanced car’s pulley dramatically changed speed and disengaged from the string without warning. To avoid sudden starts and stops, the car's CircuitPython code gradually ramped the motor voltage up and down using PWM (Pulse-Width Modulation) signals, so why was the car so jumpy?

It became obvious that the car's brushed direct-current (DC) motor didn’t have enough torque to run reliably at speeds less than 200RPM without some sort of gearing arrangement. A geared motor for the StringCar was too heavy and difficult to balance, so another solution was needed.

After some experimentation, the solution was to adjust one of the PWM signal characteristics. No need to add a gearbox or change hardware; we'll just apply a simple change in the CircuitPython code.

This guide will elaborate on the solution, examine some commonly available motors, and provide programming examples that will improve the low-speed performance of your robot’s brushed DC motors. First, we’ll look at the motors’ love/hate relationship with PWM and how to make them friends again.

Brushed DC motors have an affinity for direct current. They are designed to spin in proportion to the applied DC voltage. For example, a miniature 6-volt DC motor runs at its full rated speed when supplied with power from four AA batteries (four times 1.5 volts equals 6 volts). The motor will run slower with three AA batteries (4.5 volts) or even slower with two AA batteries (3 volts). When the speed of a robot's DC motor needs to be controlled by software, swapping batteries in and out just won't do.

To control the motor with software like CircuitPython, a special signal called Pulse Width Modulation (PWM) is used. Microcontrollers such as the Feather M4 Express send a software-controlled PWM signal to an external breakout board in order to control motor speed. To cause the motor to spin, the microcontroller furnishes the external motor controller board a pulsing signal which in turn sends a high-power pulse to the attached motor. The width of each pulse is set by the program code to adjust the amount of energy for the controller board to send to the attached motor. A pulse with a long duration imparts more energy to the motor, increasing the speed of the motor. A short duration pulse reduces the available energy and the motor spins more slowly. The motor sees changes in pulse energy just like when batteries are added or removed. With a little math, the pulse energy can be expressed as an “equivalent voltage” similar to battery voltage. Let’s get to know the PWM signal better.

When a controller is sending the full voltage of the power source to the motor, the motor sees a PWM signal with a duty cycle of 100%. For example, if the controller output is always at the power supply voltage level, the duty cycle is 100%; if at full voltage for 5 milliseconds (ms) during a 10ms interval period , the duty cycle calculates to 50%. A full voltage pulse for 2ms during the 10ms period has a duty cycle of 20%.

PWM equivalent voltage is equal to the power supply voltage times the duty cycle. If the power source is 5 volts, a duty cycle of 100% has an equivalent voltage of:

5v * (100% / 100) = 5 volts

A duty cycle of 20% produces the equivalent voltage:

5v * (20% / 100) = 1.0 volts

As the PWM duty cycle changes, the motor reacts to the equivalent voltage and spins the motor at a speed that is proportional to that value. A lower duty cycle slows the motor; a higher duty cycle increases motor speed.

In CircuitPython's motor control libraries, the motor’s PWM duty cycle ratio is usually called the motor’s throttle, expressed as a numeric value between 0 and 1.0 where a value of 0 stops the motor and 1.0 runs the motor at full speed. Forward motor direction is a positive throttle value (0 to +1.0). Reverse direction is a negative value (0 to -1.0).

While duty cycle controls the motor’s speed, the PWM signal’s frequency effects the efficiency of a brushed DC motor, particularly when the PWM duty cycle is less than 30%. Why does the PWM frequency play a role? 

After calculating the PWM Equivalent Voltage, we generally assume that the motor will operate ideally and respond as if it was connected to a non-PWM power source providing the voltage. But that's not the case. For example, a Yellow-TT motor will spin if a single 1.5-volt battery is connected, but will not turn until the PWM Equivalent Voltage coming from a Motor FeatherWing reaches 2.0 volts. And when it does start, it suddenly rotates at 4000 RPM. Why is that?

Since a brushed DC motor’s internal rotor consists of two or more coils of wire wound around laminated magnetic core material, the motor acts like an inductor. Depending on size of the rotor coil, it may take a few milliseconds for the energy to build sufficiently to turn the shaft.

Rotor coil inductance becomes a primary factor to consider when using PWM for motor speed control. The motor coil works best when the applied voltage is relatively steady since it needs time for its magnetic field to reach the needed strength. At higher PWM frequencies, the pulses from the motor controller board are changing too quickly to provide enough energy to spin the motor until the equivalent voltage reaches 2.0 volts.

When the PWM frequency is lowered, the motor’s coils extract more energy from the pulsed PWM signal. That means that the motor will start spinning at a lower equivalent voltage and will operate with improved torque at low speeds. The following graph compares the Yellow-TT motor's speed response when the default PWM frequency of 1600Hz is changed to 25Hz.

The spin threshold at 25Hz starts at 0.3 volts, increasing the useable motor speed range to as low as 100 RPM. The Yellow-TT gearbox reduces the motor’s RPM by a factor of 48, so the attached wheel will be turning at 2 RPM or about 0.6cm/sec. A velocity like that will make it much easier for your robot to sneak up on the cat.

How do we choose the best PWM frequency for our robot’s motors?

Motor manufactures’ data sheets provide excellent performance information about a motor’s optimum operating parameters such as voltage and current at the motor’s rated speed. Most manufacturers also provide tables and graphs that show how the motor responds to different voltages and the corresponding changes to RPM, torque, and power. However, very little information is available about how a particular motor responds to PWM signals.

We already know that PWM duty cycle can control a motor’s speed, but to understand what happens when the PWM frequency is varied, we need a way to measure the motor’s frequency response — much like that used to characterize an audio speaker (another electromagnetic device). If we have the motor’s frequency response spectrum, picking the best-performing PWM frequency is straightforward.

The PWM frequency response spectrum for the Yellow-TT motor shows the motor speed (the red line) as the PWM frequency is swept from 25Hz to 2000Hz. The throttle is held at 0.150 during the frequency sweep creating an equivalent voltage of 0.750 volts. At a PWM frequency of 25Hz, the chart shows the motor spinning at 4000 RPM. The speed reduces quickly as the frequency increases, dropping to one-half of the initial RPMs at 340Hz and completely stopping when the PWM frequency reaches 1200Hz. The chart indicates that a PWM frequency of 340Hz or lower will work nicely with low motor throttle settings.

Test the frequency you selected with the motor attached to your robot and operating with its normal power supply source. PWM frequencies of 60Hz or lower can cause mechanical vibration depending on the motor and the quality of its gearbox. Adjust the PWM frequency for the best balance of vibration and low-speed operation.

Frequency response charts for a variety of popular brushed DC motors can be found in the Motor Performance Charts section.

DIY: Finding the Optimal PWM Frequency

If you don't have a PWM frequency response chart for your motor, the simplest way to pick an optimal PWM frequency is to watch your robot motors in action at different PWM frequencies. Start at the lowest possible value (usually about 25Hz) and work up to the maximum (2100Hz). Choose the frequency that provides the best balance of torque throughout the desired speed range while balancing the motor chatter that can happen at lower frequencies.

Most small brushed DC motors will operate nicely with a PWM frequency of 50Hz to 100Hz. Projects that don't use gearbox motors, such as the StringCar racer, seem to work best at 25Hz.

After characterizing a few brushed DC motors from the workshop inventory, the results concluded that a low PWM frequency will improve a motors' low-speed performance and overall speed range. All motors saw a significant reduction of spin threshold voltage when changing the PWM frequency from the MotorKit library's default of 1600Hz to a more compatible 25Hz.

The following charts show each motor's speed, power, and current characteristics as the motor tester swept through PWM Equivalent Voltage values and PWM frequencies. Let's walk through the first, the 1:20 Gearmotor with Encoder, to learn how to read each motor's chart collection. Click on the chart image for an enlarged view.

1:20 Gearmotor with Encoder

The 1:20 gearmotor combines a high quality motor and gearbox with a quadrature magnetic encoder to measure motor shaft RPM and direction. It's quiet and smooth.

The two charts on the left show the results of sweeping the PWM equivalent voltage from 0 to 5 volts using a PWM frequency of 25Hz and 1600Hz. At the lower PWM frequency, the motor started spinning very slowly at 0.1 volts compared to 1.4 volts at the higher frequency.

The right-hand charts show the motor's response to changing the PWM frequency when the throttle was held at 0.150 (0.75 volts). The first of the two frequency response charts is a closeup of the PWM frequency spectrum from 20Hz to 600Hz; it's a detailed view of the frequency response chart just below it. The motor spins the fastest when the PWM frequency is 20Hz. It drops to 50% of that speed at 142Hz and completely stops spinning when the frequency reaches 508Hz. Note that the motor continues to draw current at frequencies above 508Hz even when not spinning.

130-Size Toy/Hobby Motor

RF-300-EH-1D390 CD Spindle Motor

RF-300FA-12350 CD Spindle Motor

RF-500TB-12560 BoomerPong StringCar Motor

RF-500TB-18280 String Car M0 Express Motor

Servo DC Motor

Blue TT Motor

Yellow TT Motor

Uxcell-ux0188 Motor

The following CircuitPython code examples will sweep an attached motor's duty cycle from 0% to 100% in 2% increments in one direction. Each step of the duty cycle will hold for 1 second. The motor stops at the end of the code. During execution, the code prints the duty cycle as a throttle value for display in the REPL's Serial and Plotter windows. 

The first portion of each example imports the needed libraries and instantiates the motor controller with a new PWM frequency. Change the frequency value to select the one that works best for the attached motor.

Each motor controller is implemented differently, so refer to the example's code description to change the controller's frequency. The examples describe the frequency setting techniques when using:

• Crickit FeatherWing and Crickit for Circuit Playground Express
• Motor FeatherWing and Motor Shield
• Breakout Boards and H-Bridge Chips

Crickit FeatherWing and Crickit for Circuit Playground Express

Upon initiation, the Crickit library sets the DC motor PWM frequency to 50Hz, useful for most brushed DC motors like the Yellow TT motor. It is possible to override the default if a custom PWM frequency is needed while still preserving the ability to use the Crickit library's motor statements such as motor.throttle.

The Crickit library also initially sets the controller's decay mode to FAST_DECAY. We'll change the decay mode to SLOW_DECAY to take advantage of the resultant performance improvement.

The Crickit uses two internal GPIO pins for each of the two DC motor controllers. The internal pins reserved for the motor controllers are 18, 19, 22, and 23. This is the section of the example code that changes the PWM to a custom value:

Line 1 defines the constant used for the custom PWM frequency value, followed by a constant that defines the controller's decay mode. A throttle holding constant (THROTTLE_HOLD) of 1 second is used later in the example code. The next lines define names for the two Crickit motor controllers. Defining the names also instantiates the motor pin definitions that will be changed.

In lines 8 and 9, the decay mode is set for each motor instance using the decay mode constant defined earlier. Next we'll access each motor controller pin individually and reset the default PWM frequency. For example, the first pin of DC_Motor_1's controller is updated in line 12:

ss.set_pwm_freq(22, PWM_FREQ)

The PWM frequency of each pin is then set to the custom value stored in the PWM_FREQ constant.

Example code for the Crickit FeatherWing and Circuit Playground Express Crickit:

Motor FeatherWing and MotorShield

Upon instantiation, the adafruit_motorkit MotorKit class sets the DC motor PWM frequency to a default of 1600Hz and the controller's decay mode to FAST_DECAY. Changing the frequency and decay mode to a custom value is accomplished using a MotorKit parameter after instantiation.

The first line defines the constant used for the custom PWM frequency value. A constant value for the decay mode is defined as SLOW_DECAY, followed by a throttle holding constant (THROTTLE_HOLD) that's used later in the example code. Line 6 is the typical statement used to instantiate the Motor FeatherWing or Shield. Line 7 updates the MotorKit PWM frequency parameter with the custom value stored in the PWM_FREQ constant.

After the motor is instantiated in line 9, the controller's decay mode is set to SLOW_DECAY.

Example code for Motor FeatherWing and MotorShield:

Breakout Boards and H-Bridge Chips

The adafruit_motor library's DCMotor class is the one to use with Adafruit motor controller breakout boards and H-bridge integrated circuits. Upon instantiation, the library works with the pwmio.PWMOut class to define which GPIO pins to use to drive the motor, set the 500Hz default PWM frequency and FAST_DECAY controller mode. We'll change the default frequency when the GPIO pins are defined and will change the controller's decay mode to SLOW_DECAY.

Refer to your selected breakout board's or H-bridge chip's learning guide for how to properly connect it to a microcontroller.

The first line defines the constant used for the custom PWM frequency value. Next, a constant value for the controller's mode is defined as SLOW_DECAY, followed by a throttle holding constant (THROTTLE_HOLD) that's used later in the example code. The two GPIO pins needed for the motor controller are defined next. Choose two pins that have their own unused PWM channel.

Lines 6 and 7 use pwmio.PWMOut to establish the pins and set the custom PWM frequency. After the motor is instantiated as motor1 in line 8, the controller's decay mode is set to SLOW_DECAY.

Example code for breakout motor controller boards:

Using the Adafruit_Motor_Shield_V2_Library

To adjust the PWM frequency of the Motor Shield or Motor FeatherWing, refer to the Arduino code example for the Adafruit_Motor_Shield_V2_Library: 

DC Motor Test Example

Using this library, the frequency can be changed from the default 1600Hz by including the new value in the begin statement:

AFMS.begin(100); // Set the PWM frequency to 100Hz

Note that, at this time, the library does not provide a parameter for changing the default controller decay mode from FAST_DECAY to SLOW_DECAY.

Using the analogWrite() Function

The PWM frequency of microcontroller GPIO pins using the analogWrite() function is fixed and cannot be changed. PWM signals sent directly to a motor controller breakout from GPIO pins will default to a frequency of 490Hz to 1000Hz depending on the microcontroller board used. See Arduino Reference: analogWrite() for more information.

To fully characterize a motor’s frequency response curve scientifically, an appliance for measuring motor performance is essential. At a minimum, measuring motor RPM under load while varying the PWM frequency will yield the frequencies where motor speed begins to drop and stall. A more sophisticated testing appliance adds sensors for measuring voltage, current, power, and torque.

The motor tester used for this Learning Guide consisted of six fundamental components:

• Test Motor
• Brake/Load Motor and Torque Converter
  • Custom FeatherWing 24-bit ADC for load cells
• RPM Sensors
  • Magnetic RPM Sensor (Pololu #1523)
  • Optical Sensor (Adafruit #3986 with #3782)
• INA260 Voltage and Current Sensor
  • Custom FeatherWing for INA260 sensor
• Motor FeatherWing
• Feather M4 Express

The motor tester's code, written in CircuitPython, exercises the test motor, applies a braking current to the brake motor to simulate a load, and measures the current drawn by the test motor. In addition, motor speed and torque are recorded throughout the test.

The data used to create the collection of performance charts for this learning guide were captured by this apparatus.

Mabuchi Motor Model Designation Reference

Wikipedia: DC Electromagnetic Motor

Wikipedia: Electrical Impedance

Wikipedia: Resistance Inductance (RL) Circuit

Coil Inductance Calculator