AS5600 Super Smooth Rotary Encoder

Rotate the path of least resistance

by Liz Clark

published September 10, 2025, last edited October 14, 2025

posted in Sensors CircuitPython STEMMA Raspberry Pi/ RP2040

Save Download

New

Beginner

Project guide

Overview

Build the path of least resistance with this super smooth rotary encoder. This project uses an AS5600 magnetic angle sensor with a QT Py RP2040 running CircuitPython code to measure the change in magnetic field from a magnet that is being rotated directly above the sensor. When the magnet is rotated, the QT Py RP2040 sends out USB HID commands to raise or lower the volume on a connected device.

The secret sauce for the project is a print in place bearing. This piece attaches to the encoder knob and seats the magnet. This allows you to turn the magnet directly over the AS5600 when you rotate the knob.

Magnet

You'll need a diametrically polarized magnet for this project, like this one on DigiKey. This means that the magnet is polarized across the diameter. This allows the AS5600 to sense the rotating magnetic field above it.

1 x Diametrically Polarized Magnet

0.315" Dia x 0.098" H (8.00mm x 2.50mm)

Buy Now

Parts

Demo Video of a hand turning a magnet behind the sensor board and getting a reading to appear on the display screen connected to the board.

Adafruit AS5600 Magnetic Angle Sensor

Add rotational sensing - without a mechanical connection - with the Adafruit AS5600 Magnetic Angle Sensor. Featuring the classic

guides with product

$5.95

In Stock

Add to Cart

Video of hand holding a QT Py PCB in their hand. An LED glows rainbow colors.

Adafruit QT Py RP2040

What a cutie pie! Or is it... a QT Py? This diminutive dev board comes with one of our new favorite chip, the RP2040. It's been made famous in the new

guides with product

$9.95

In Stock

Add to Cart

Angled shot of STEMMA QT / Qwiic JST SH 4-pin Cable.

STEMMA QT / Qwiic JST SH 4-pin Cable - 100mm Long

This 4-wire cable is a little over 100mm / 4" long and fitted with JST-SH female 4-pin connectors on both ends. Compared with the chunkier JST-PH these are 1mm pitch instead of...

$0.95

In Stock

Add to Cart

Black Nylon Screw and Stand-off Set with M2.5 Threads, kit box

Black Nylon Machine Screw and Stand-off Set – M2.5 Thread

Totaling 380 pieces, this M2.5 Screw Set is a must-have for your workstation. You'll have enough screws, nuts, and hex standoffs to fuel your maker...

guides with product

$16.95

In Stock

Add to Cart

Angled shot of coiled pink and purple USB cable with USB A and USB C connectors.

Pink and Purple Woven USB A to USB C Cable - 1 meter long

This cable is not only super-fashionable, with a woven pink and purple Blinka-like pattern, it's also made for USB C for our modernized breakout boards, Feathers, and...

Out of Stock

1 x 8 mm M3 screw

8 mm long M3 screw

Buy Now

4 x 25 mm M3 screws

25 mm long M3 screws

Buy Now

Page last edited September 05, 2025

Text editor powered by tinymce.

Circuit Diagram

fritzing diagram with the qt py rp2040 and as5600 connected with a stemma qt cable

Plug the AS5600 breakout into the STEMMA QT port on the QT Py RP2040 with a STEMMA QT cable.

Page last edited September 05, 2025

Text editor powered by tinymce.

3D Printing

You can 3D print all of the parts for this project. They are designed to be connected together with M3 screws.

The STL files can be downloaded directly below or from Printables.

as5600_rotary_encoder_CAD.zip

Printables Download

The star of the enclosure is a print in place bearing. The magnet is seated in the cutout of the center of the bearing. This allows it to rotate over the AS5600 sensor.

slicer settings for printing the bearing .12 layer height, 4 bottom and top shells, 10% infill

All of the parts print well with standard slicer settings. However, the bearing needs some special settings so that it doesn't fuse:

0.12mm layer height
4 top shell layers
4 bottom shell layers
10% infill

Page last edited September 05, 2025

Text editor powered by tinymce.

Install CircuitPython

CircuitPython is a derivative of MicroPython designed to simplify experimentation and education on low-cost microcontrollers. It makes it easier than ever to get prototyping by requiring no upfront desktop software downloads. Simply copy and edit files on the CIRCUITPY drive to iterate.

CircuitPython Quickstart

Follow this step-by-step to quickly get CircuitPython running on your board.

Download the latest version of CircuitPython for this board via circuitpython.org

install_circuitpython_on_rp2040_RP2040_UF2_downloaded.jpg

Click the link above to download the latest CircuitPython UF2 file.

Save it wherever is convenient for you.

To enter the bootloader, hold down the BOOT/BOOTSEL button (highlighted in red above), and while continuing to hold it (don't let go!), press and release the reset button (highlighted in red or blue above). Continue to hold the BOOT/BOOTSEL button until the RPI-RP2 drive appears!

If the drive does not appear, release all the buttons, and then repeat the process above.

You can also start with your board unplugged from USB, press and hold the BOOTSEL button (highlighted in red above), continue to hold it while plugging it into USB, and wait for the drive to appear before releasing the button.

A lot of people end up using charge-only USB cables and it is very frustrating! Make sure you have a USB cable you know is good for data sync.

install_circuitpython_on_rp2040_RP2040_bootloader_drive.jpg

You will see a new disk drive appear called RPI-RP2.

Drag the adafruit_circuitpython_etc.uf2 file to RPI-RP2.

The RPI-RP2 drive will disappear and a new disk drive called CIRCUITPY will appear.

That's it, you're done! :)

Safe Mode

You want to edit your code.py or modify the files on your CIRCUITPY drive, but find that you can't. Perhaps your board has gotten into a state where CIRCUITPY is read-only. You may have turned off the CIRCUITPY drive altogether. Whatever the reason, safe mode can help.

Safe mode in CircuitPython does not run any user code on startup, and disables auto-reload. This means a few things. First, safe mode bypasses any code in boot.py (where you can set CIRCUITPY read-only or turn it off completely). Second, it does not run the code in code.py. And finally, it does not automatically soft-reload when data is written to the CIRCUITPY drive.

Therefore, whatever you may have done to put your board in a non-interactive state, safe mode gives you the opportunity to correct it without losing all of the data on the CIRCUITPY drive.

Entering Safe Mode

To enter safe mode when using CircuitPython, plug in your board or hit reset (highlighted in red above). Immediately after the board starts up or resets, it waits 1000ms. On some boards, the onboard status LED (highlighted in green above) will blink yellow during that time. If you press reset during that 1000ms, the board will start up in safe mode. It can be difficult to react to the yellow LED, so you may want to think of it simply as a slow double click of the reset button. (Remember, a fast double click of reset enters the bootloader.)

In Safe Mode

If you successfully enter safe mode on CircuitPython, the LED will intermittently blink yellow three times.

If you connect to the serial console, you'll find the following message.

Copy Text

Auto-reload is off.
Running in safe mode! Not running saved code.

CircuitPython is in safe mode because you pressed the reset button during boot. Press again to exit safe mode.

Press any key to enter the REPL. Use CTRL-D to reload.

Auto-reload is off.
Running in safe mode! Not running saved code.

CircuitPython is in safe mode because you pressed the reset button during boot. Press again to exit safe mode.

Press any key to enter the REPL. Use CTRL-D to reload.

You can now edit the contents of the CIRCUITPY drive. Remember, your code will not run until you press the reset button, or unplug and plug in your board, to get out of safe mode.

Flash Resetting UF2

If your board ever gets into a really weird state and CIRCUITPY doesn't show up as a disk drive after installing CircuitPython, try loading this 'nuke' UF2 to RPI-RP2. which will do a 'deep clean' on your Flash Memory. You will lose all the files on the board, but at least you'll be able to revive it! After loading this UF2, follow the steps above to re-install CircuitPython.

Download flash erasing "nuke" UF2

Page last edited September 05, 2025

Text editor powered by tinymce.

Code the Encoder

Once you've finished setting up your QT Py RP2040 with CircuitPython, you can access the code and necessary libraries by downloading the Project Bundle.

To do this, click on the Download Project Bundle button in the window below. It will download to your computer as a zipped folder.

Download Project Bundle

Copy Code

# SPDX-FileCopyrightText: Copyright (c) 2025 Liz Clark for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""AS5600 Encoder"""
import usb_hid
import board
from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode
import adafruit_as5600

i2c = board.STEMMA_I2C()
sensor = adafruit_as5600.AS5600(i2c)
enc_inc = ConsumerControlCode.VOLUME_INCREMENT
enc_dec = ConsumerControlCode.VOLUME_DECREMENT
cc = ConsumerControl(usb_hid.devices)

last_val = sensor.angle

THRESHOLD = sensor.max_angle // 2 # default max_angle is 4095
# you can change the max_angle. ex: sensor.max_angle = 1000

MIN_CHANGE = 25  # minimum change to register as movement
# increase to make less sensitive, decrease to make more sensitive

while True:
    enc_val = sensor.angle
    if abs(enc_val - last_val) >= MIN_CHANGE or abs(enc_val - last_val) > THRESHOLD:
        # Calculate the difference
        diff = enc_val - last_val
        # Check for wraparound
        if diff > THRESHOLD:
            # Wrapped from ~4095 to ~0 (actually turning backwards)
            cc.send(enc_dec)
        elif diff < -THRESHOLD:
            # Wrapped from ~0 to ~4095 (actually turning forwards)
            cc.send(enc_inc)
        elif diff > 0:
            # Normal forward rotation
            cc.send(enc_inc)
        else:
            # Normal backward rotation (diff < 0)
            cc.send(enc_dec)
        last_val = enc_val

# SPDX-FileCopyrightText: Copyright (c) 2025 Liz Clark for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""AS5600 Encoder"""
import usb_hid
import board
from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode
import adafruit_as5600

i2c = board.STEMMA_I2C()
sensor = adafruit_as5600.AS5600(i2c)
enc_inc = ConsumerControlCode.VOLUME_INCREMENT
enc_dec = ConsumerControlCode.VOLUME_DECREMENT
cc = ConsumerControl(usb_hid.devices)

last_val = sensor.angle

THRESHOLD = sensor.max_angle // 2 # default max_angle is 4095
# you can change the max_angle. ex: sensor.max_angle = 1000

MIN_CHANGE = 25  # minimum change to register as movement
# increase to make less sensitive, decrease to make more sensitive

while True:
    enc_val = sensor.angle
    if abs(enc_val - last_val) >= MIN_CHANGE or abs(enc_val - last_val) > THRESHOLD:
        # Calculate the difference
        diff = enc_val - last_val
        # Check for wraparound
        if diff > THRESHOLD:
            # Wrapped from ~4095 to ~0 (actually turning backwards)
            cc.send(enc_dec)
        elif diff < -THRESHOLD:
            # Wrapped from ~0 to ~4095 (actually turning forwards)
            cc.send(enc_inc)
        elif diff > 0:
            # Normal forward rotation
            cc.send(enc_inc)
        else:
            # Normal backward rotation (diff < 0)
            cc.send(enc_dec)
        last_val = enc_val

Upload the Code and Libraries to the QT Py RP2040

After downloading the Project Bundle, plug your QT Py RP2040 into the computer's USB port with a known good USB data+power cable. You should see a new flash drive appear in the computer's File Explorer or Finder (depending on your operating system) called CIRCUITPY. Unzip the folder and copy the following items to the QT Py RP2040's CIRCUITPY drive.

lib folder
code.py

Your QT Py RP2040 CIRCUITPY drive should look like this after copying the lib folder and code.py file:

How the Code Works

At the top of the code, the AS5600 is instantiated over I2C. enc_inc and enc_dec are setup to send the Consumer Control message for volume increase and volume decrease. cc is setup as a Consumer Control USB HID device.

Download File

Copy Code

i2c = board.STEMMA_I2C()
sensor = adafruit_as5600.AS5600(i2c)
enc_inc = ConsumerControlCode.VOLUME_INCREMENT
enc_dec = ConsumerControlCode.VOLUME_DECREMENT
cc = ConsumerControl(usb_hid.devices)

i2c = board.STEMMA_I2C()
sensor = adafruit_as5600.AS5600(i2c)
enc_inc = ConsumerControlCode.VOLUME_INCREMENT
enc_dec = ConsumerControlCode.VOLUME_DECREMENT
cc = ConsumerControl(usb_hid.devices)

Variables

A few variables are created before the loop. last_val will hold the last sensor angle reading. THRESHOLD takes the maximum angle of the AS5600 (4095) and divides it by 2 with //. MIN_CHANGE is a user defined value that affects the sensitivity of the encoder. You can increase the value to make the encoder less sensitive or decrease the value to make it more sensitive.

Download File

Copy Code

last_val = sensor.angle

THRESHOLD = sensor.max_angle // 2 # default max_angle is 4095
# you can change the max_angle. ex: sensor.max_angle = 1000

MIN_CHANGE = 25  # minimum change to register as movement
# increase to make less sensitive, decrease to make more sensitive

last_val = sensor.angle

THRESHOLD = sensor.max_angle // 2 # default max_angle is 4095
# you can change the max_angle. ex: sensor.max_angle = 1000

MIN_CHANGE = 25  # minimum change to register as movement
# increase to make less sensitive, decrease to make more sensitive

The Loop

In the loop, the angle is measured with the sensor. If the angle compared to the last measurement is greater than the value of MIN_CHANGE or THRESHOLD, then a volume increase or volume decrease Consumer Control message is sent depending on the direction of the rotation.

The logic used takes wraparound into account, since the measured angle could, for example, jump from 0 to 359 degrees or vice versa when being rotated. The code is setup to pay attention to the direction of the rotation and base the sent Consumer Control message on that value.

Download File

Copy Code

while True:
    enc_val = sensor.angle
    if abs(enc_val - last_val) >= MIN_CHANGE or abs(enc_val - last_val) > THRESHOLD:
        # Calculate the difference
        diff = enc_val - last_val
        # Check for wraparound
        if diff > THRESHOLD:
            # Wrapped from ~4095 to ~0 (actually turning backwards)
            cc.send(enc_dec)
        elif diff < -THRESHOLD:
            # Wrapped from ~0 to ~4095 (actually turning forwards)
            cc.send(enc_inc)
        elif diff > 0:
            # Normal forward rotation
            cc.send(enc_inc)
        else:
            # Normal backward rotation (diff < 0)
            cc.send(enc_dec)
        last_val = enc_val

while True:
    enc_val = sensor.angle
    if abs(enc_val - last_val) >= MIN_CHANGE or abs(enc_val - last_val) > THRESHOLD:
        # Calculate the difference
        diff = enc_val - last_val
        # Check for wraparound
        if diff > THRESHOLD:
            # Wrapped from ~4095 to ~0 (actually turning backwards)
            cc.send(enc_dec)
        elif diff < -THRESHOLD:
            # Wrapped from ~0 to ~4095 (actually turning forwards)
            cc.send(enc_inc)
        elif diff > 0:
            # Normal forward rotation
            cc.send(enc_inc)
        else:
            # Normal backward rotation (diff < 0)
            cc.send(enc_dec)
        last_val = enc_val

Page last edited September 05, 2025

Text editor powered by tinymce.

Assembly

all of the 3d printed parts and electronic components knolled

Magnet and Bearing

the bearing attached to the knob with an m3 screw

Attach the bearing to the knob with an 8 mm long M3 screw.

Insert the diametrically polarized magnet into the center cutout over the screw in the bearing. The magnet will fit snugly into the cutout and stick to the stainless steel M3 screw.

Electronics

the as5600 attached to the sensor mount with m2.5 screws

the back view of the as5600 attached to the sensor mount

Attach the AS5600 to the sensor mount with four M2.5 screws and nuts. The front AS5600 text label on the board silk should be facing away from the two mounting hole standoffs that are slightly taller.

Insert the QT Py RP2040 into the QT Py mount.

the as5600 connected to the qt py with a stemma qt cable

Connect the AS5600 to the QT Py RP2040 with a STEMMA QT cable.

Component Sandwich

the semi-assembled encoder with four m3 screws

Now you'll stack the components together inside the enclosure with four 25 mm M3 screws securing everything.

four m3 screws threaded about one quarter way into the enclosure

Start by threading the M3 screws into the bottom enclosure. Insert the QT Py holder with the mounting holes aligned with the USB port facing towards the cut out in the enclosure.

the sensor mount screwed into the enclosure

Insert the sensor mount by aligning the screw holes with the enclosure and QT Py mounting holes. There is a longer set of stand-offs on the mount. Those should be opposite of the USB cutout so that the AS5600 silkscreen text is facing towards the USB cutout.

Continue to thread the M3 screws into the sensor mount standoffs.

the bearing mounting holes aligned with the sensor mount

Line up the bearing mounting holes with the sensor mounting holes. Continue to thread the M3 screws.

the m3 screws fully threaded into the enclosure

Once the M3 screws are fully threaded into the enclosure, the assembly is complete!

If you are concerned about screws on your desk surface, you can add some bumpers to the bottom of the case.

Page last edited September 05, 2025

Text editor powered by tinymce.

Use

Plug the encoder assembly into a known good data USB C cable. Plug the other end of the cable into a computer or tablet. When you turn the encoder, you'll be able to adjust the volume on the device.

Going Further

The code is meant as a simple example. You could change it to send different HID inputs, maybe for a video game, or change out the QT Py RP2040 for an ESP32-S2 or S3 to try sending commands over Bluetooth instead of USB. If you do build on this, consider documenting it as an Adafruit Playground note!

Page last edited September 05, 2025