Mastering the Binary Range in Microcontroller ADC and PWM

The binary range is the finite span of discrete integer values a digital system or register can represent, strictly bounded by its bit depth from zero up to 2ⁿ - 1. When you read an analog sensor, parse an I2C register, or set a motor speed via PWM, your microcontroller is not dealing in smooth, continuous physical quantities like voltage or RPM; it is dealing in rigid, quantized integer steps. Misunderstanding the boundaries of this range is one of the most common reasons DIY builds exhibit erratic behavior, silent overflows, or completely fried logic pins.

The Math Behind the Limits (And Why It Bites You)

Every digital system relies on a fixed number of bits to store data. The maximum value you can achieve in an unsigned binary range is calculated as 2ⁿ - 1, where n is the bit depth. We subtract one because the count includes zero. An 8-bit system gives you 256 distinct steps (0 to 255). A 10-bit system gives you 1024 steps (0 to 1023). A 12-bit system yields 4096 steps (0 to 4095).

What this changes in a real circuit is your measurement resolution and your scaling factors. The binary range acts as the denominator when translating physical reality into digital logic.

Where You Meet This in Practice

You will collide with binary range limits in three primary areas of embedded electronics:

1. Analog-to-Digital Converters (ADC): When using analogRead(), the returned integer is strictly bound by the silicon's bit depth. The Arduino analogRead documentation explicitly notes that standard AVRs return 10-bit values, while newer ARM and ESP boards default to 12-bit or higher.
2. Pulse Width Modulation (PWM): When you call analogWrite() or use the LEDC peripheral on an ESP32, the duty cycle is defined by the binary range. An 8-bit PWM range (0-255) means a value of 127 is roughly a 50% duty cycle. If you feed it 300, it will overflow or truncate, resulting in unpredictable motor speeds or LED flicker.
3. Sensor Registers (I2C/SPI): Digital sensors like the BME280 or MPU6050 store data in 8-bit or 16-bit registers. If a sensor outputs a 16-bit signed value, its binary range is -32,768 to 32,767. Reading it into an unsigned 16-bit integer variable will mangle negative readings into massive positive numbers.

Real-World Scenario Walkthrough: The 10-Bit vs 12-Bit Trap

Abstract definitions only get you so far. Here is exactly how ignoring the binary range ruins a weekend project.

Setup: You have a working 12V battery monitor built on an Arduino Uno (ATmega328P). It uses a voltage divider to step 12V down to a safe 4.5V, feeding it into pin A0. The code uses the map() function to convert the ADC reading back to battery voltage, and triggers a low-battery relay if the reading drops below a specific threshold. You decide to upgrade the project to an ESP32 for WiFi data logging, keeping the exact same voltage divider hardware and copying the code over.

Numbers: The Arduino Uno has a 10-bit ADC (binary range 0 to 1023). At 12.0V input, the divider outputs 4.5V. The Uno reads this as (4.5 / 5.0) * 1023 = 920. Your code triggers the low-battery relay if the raw ADC value drops below 850 (which represents ~11.1V).
The ESP32 has a 12-bit ADC (binary range 0 to 4095) and a 3.3V logic reference. Because 4.5V exceeds the 3.3V maximum, the ESP32 pin saturates. Even if you fixed the voltage divider to output a max of 3.3V (representing 14V), a 12.0V input would now yield an ADC reading of (3.3 / 3.3) * 4095 = 4095.

Outcome: Upon powering up the ESP32, the serial monitor shows an ADC reading of 4095. The low-battery relay immediately clicks off, and the system shuts down, even though the battery is fully charged.

What went wrong: The hardcoded threshold of 850 was tied to the Arduino's 10-bit binary range. The ESP32's 12-bit binary range shifted the entire numeric scale upward by a factor of four. Furthermore, the hardware voltage divider was pushing 4.5V into a 3.3V-tolerant pin, causing the ADC to hard-clip at its absolute maximum binary limit (4095). To fix this, the hardware divider had to be recalculated for a 3.3V max output, and the software threshold had to be updated to 3400 to match the new 12-bit scale.

Signed vs. Unsigned: The Hidden Range Shift

What people commonly confuse the binary range with is the physical range (e.g., assuming 0-1023 means 0-5V directly). But a more dangerous confusion is mixing up unsigned and signed binary ranges.

An 8-bit unsigned integer has a binary range of 0 to 255. An 8-bit signed integer (using two's complement) has a binary range of -128 to 127. If you are reading a bidirectional current sensor (like the ACS712) that outputs a negative voltage for reverse current, and you store that data in an unsigned variable, a -5A reading will wrap around and appear as a massive positive number (e.g., 250). Always check the sensor datasheet to see if the I2C/SPI payload requires an int8_t / int16_t (signed) or a uint8_t / uint16_t (unsigned) variable type.

Quick Reference: Common Microcontroller Binary Ranges

Keep this table handy when migrating code between different development boards. Note that some modern microcontrollers allow you to artificially restrict or expand their binary range via software APIs, but the silicon's native hardware limit remains fixed.

For deeper architectural details on the RP2040's specific ADC implementation, refer to the official Raspberry Pi RP2040 documentation. For ESP32 specific ADC non-linearities and attenuation settings, check the Espressif ESP-IDF ADC API reference.

FAQ: Binary Range Edge Cases