Interfacing an Absolute Angular Position Sensor with ESP32: AS5600 Wiring and Math

How Absolute Angular Position Sensors Work (and What They Output)

Absolute angular position sensors determine the exact rotational angle of a shaft (0° to 360°) the millisecond they receive power, eliminating the homing routines required by incremental quadrature encoders. They achieve this using Hall-effect or magnetoresistive elements arranged in a circular array beneath the silicon. When a diametrically magnetized rotor spins above the IC, the changing magnetic flux vector shifts the voltage potential across the Hall plates, which an internal DSP resolves into a precise digital angle.

The physical output you read depends entirely on the sensor model and your configured interface. Analog variants output a ratiometric voltage (typically 10% to 90% of VCC, yielding 0.33V to 3.0V on a 3.3V supply) representing the mechanical sweep. Digital variants output raw integer registers via I2C (usually 12-bit, yielding 0-4095) or SPI (14-bit, yielding 0-16383). You never receive a direct "degree" string over the wire; you receive a raw binary count that your microcontroller must mathematically scale into physical units.

Hardware Specs and Pinout Reference

Before wiring your breadboard, you need to select the right IC for your mechanical tolerance and bus speed. The AMS AS5600 is the undisputed king of hobbyist and light-industrial robotics due to its low cost and dual I2C/analog outputs, but higher-resolution SPI alternatives exist for gimbal stabilization and BLDC commutation.

For the remainder of this guide, we will interface the AS5600, as its I2C implementation covers 90% of DIY embedded projects. Below is the strict pinout for a standard 3.3V ESP32 setup.

Interfacing the AS5600: Raw-to-Degree Math and ESP32 Code

The AS5600 stores the current angle across two 8-bit registers: ANGLE (0x0E) for the high byte and ANGLE (0x0F) for the low byte. (Note: Registers 0x0C and 0x0D hold the raw unadjusted angle, while 0x0E and 0x0F hold the angle adjusted by your ZPOS and MANG configuration registers. Always read 0x0E/0x0F for calibrated data).

The Raw-to-Unit Math

Because the sensor is 12-bit, the maximum raw value is 4095 (0xFFF). To convert this raw integer into physical degrees, you apply a simple scaling factor:

Angle (Degrees) = (Raw_Value * 360.0) / 4096.0

This yields a resolution of exactly 0.08789° per LSB. If you need radians for kinematic calculations, multiply the degree output by π / 180.

Calibration and Scaling

Out of the box, the sensor's "zero" is dictated by the physical orientation of the IC relative to the magnet. If your mechanical assembly requires a specific zero-point (e.g., a robot arm joint where 0° is perfectly vertical), you have two choices:

1. Hardware Register (ZPOS): Write a 12-bit offset to the ZPOS (Zero Position) register. The IC will subtract this internally and output the adjusted angle in registers 0x0E/0x0F. This is ideal if you want to offload math from the ESP32.
2. Software Offset: Read the raw angle at your mechanical zero, store it as zero_offset, and subtract it in your loop. Handle the 360° wrap-around using modulo arithmetic: angle = (raw_angle - zero_offset + 4096) % 4096.

Complete ESP32 I2C Implementation

The following code uses the standard Espressif I2C driver via the Arduino Wire library. It includes error handling for I2C bus lockups, a common issue on breadboards with long jumper wires.

#include <Wire.h>

#define AS5600_ADDRESS 0x36
#define REG_ANGLE_HIGH 0x0E
#define REG_ANGLE_LOW  0x0F
#define REG_STATUS     0x0B

float zero_offset_deg = 0.0; // Set during homing routine

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22); // SDA, SCL for standard ESP32 DevKit
  Wire.setClock(400000); // 400kHz I2C Fast Mode
  
  // Verify sensor presence
  Wire.beginTransmission(AS5600_ADDRESS);
  if (Wire.endTransmission() != 0) {
    Serial.println("FATAL: AS5600 not found on I2C bus. Check wiring.");
    while(1); 
  }
  Serial.println("AS5600 initialized.");
}

void loop() {
  uint16_t raw_angle = readAS5600Angle();
  
  // Convert to degrees
  float current_deg = (raw_angle * 360.0) / 4096.0;
  
  // Apply software zero-offset with 360 wrap-around
  float adjusted_deg = current_deg - zero_offset_deg;
  if (adjusted_deg < 0) adjusted_deg += 360.0;
  if (adjusted_deg >= 360.0) adjusted_deg -= 360.0;
  
  Serial.printf("Raw: %04d | Deg: %6.2f\n", raw_angle, adjusted_deg);
  delay(10); // 100Hz polling rate
}

uint16_t readAS5600Angle() {
  Wire.beginTransmission(AS5600_ADDRESS);
  Wire.write(REG_ANGLE_HIGH);
  if (Wire.endTransmission(false) != 0) return 0; // I2C Error
  
  Wire.requestFrom(AS5600_ADDRESS, 2);
  if (Wire.available() < 2) return 0; // Timeout
  
  uint8_t high_byte = Wire.read();
  uint8_t low_byte = Wire.read();
  
  // Combine into 12-bit integer (high byte only uses lower 4 bits)
  return ((high_byte & 0x0F) << 8) | low_byte;
}

Defeating Magnetic Interference and Mechanical Runout

The most common reason makers abandon absolute magnetic encoders is noisy data. If your angle reading jitters by ±2° or drifts when your motors spin, you are fighting magnetic interference or mechanical eccentricity.

Common Interference Sources

• BLDC Motor Stators: The neodymium magnets inside a nearby brushless motor will easily saturate the AS5600's Hall array. You must maintain at least 15mm of physical separation, or interpose a mu-metal magnetic shield between the motor and the sensor.
• Unshielded High-Current PWM Wires: While DC current creates a static field that can be zeroed out, high-frequency PWM wires driving steppers or heaters create alternating magnetic fields. Route high-current pairs as twisted pairs to cancel their magnetic emissions.
• Incorrect Magnet Type: You must use a diametrically magnetized cylinder (poles on the curved sides). Standard axial disc magnets (poles on the flat faces) will not generate the rotating vector field the IC expects, resulting in massive non-linearity and dead zones.

Verifying the Air Gap via AGC

The AS5600 features an Automatic Gain Control (AGC) register (0x1A) that compensates for temperature and air gap variations. The AGC value ranges from 0 to 255.
If you read an AGC value near 255, your magnet is too far away (the IC is maxing out its internal amplifier, leading to noise). If the AGC reads near 0, the magnet is too close (the Hall array is saturating). For a standard 6x2.5mm neodymium rotor, the optimal air gap is 1.0mm to 2.0mm, which typically yields an AGC reading between 40 and 120 at room temperature.

Mechanical Runout (Eccentricity)

If your diametric magnet is not mounted perfectly on the center axis of rotation, the sensor will track a slightly elliptical path rather than a perfect circle. This introduces a sinusoidal error into your angle reading—often called "swash" or eccentricity error. In high-precision applications (like robotic arm inverse kinematics), a 0.5mm offset can introduce up to 3° of peak-to-peak error.
The Fix: If you cannot machine the shaft tighter, map the error. Rotate the shaft through 360° using a precision optical encoder as a reference, record the AS5600 deviation at every 10°, and apply a software lookup table (LUT) or Fast Fourier Transform (FFT) harmonic compensation in your ESP32 code to subtract the runout profile.