Unsigned binary is a base-2 numbering system that represents only zero and positive integers, using every available bit to calculate magnitude without reserving a bit for a negative sign.
In embedded systems and digital logic, this isn't just abstract computer science theory. It dictates the physical limits of your Analog-to-Digital Converters (ADCs), the overflow points of your hardware timers, and the exact data types (uint8_t, uint16_t) you must declare in your C/C++ firmware. When you ask "what is unsigned binary" on the workbench, you are really asking how a microcontroller interprets raw voltage levels and clock ticks into usable, non-negative numbers.
The Core Math: Unsigned vs. Signed Binary Ranges
To understand unsigned binary, you have to look at how microcontrollers allocate memory. In an unsigned system, an 8-bit register can hold values from 00000000 (0) to 11111111 (255). Every single bit contributes to the positive magnitude. In a signed system (using Two's Complement), the Most Significant Bit (MSB) is hijacked to act as a sign flag, cutting your maximum positive range in half.
| Bit-Width | C/C++ Data Type | Unsigned Range | Signed Range (Two's Complement) | Common Hardware Application |
|---|---|---|---|---|
| 8-bit | uint8_t / int8_t |
0 to 255 | -128 to 127 | I2C register addresses, 8-bit PWM duty cycle |
| 10-bit | Stored in 16-bit | 0 to 1,023 | -512 to 511 | Arduino Uno (ATmega328P) ADC peripheral |
| 12-bit | Stored in 16-bit | 0 to 4,095 | -2,048 to 2,047 | ESP32 SAR ADC, STM32 high-res ADC |
| 16-bit | uint16_t / int16_t |
0 to 65,535 | -32,768 to 32,767 | Hardware timers, 16-bit I2C sensors (e.g., BH1750) |
| 32-bit | uint32_t / int32_t |
0 to 4,294,967,295 | -2,147,483,648 to 2,147,483,647 | millis() timestamps, 32-bit ARM Cortex-M registers |
Worked Example: Mapping a 12-Bit ESP32 ADC
Let's look at a real-world scenario: reading a potentiometer wired to GPIO 34 on an ESP32-WROOM-32. The ESP32 features a 12-bit Successive Approximation Register (SAR) ADC. According to the ESP32 Technical Reference Manual, this ADC is strictly unsigned.
The Setup:
- Resolution: 12-bit (Unsigned range: 0 to 4095)
- Reference Voltage (VREF): Nominally 3.3V
- Measured ADC Value: 2048
The Math:
To convert the unsigned binary value back to a physical voltage, we use the ratio of the reading to the maximum possible unsigned value, multiplied by the reference voltage.
Voltage = (ADC_Value / Max_Unsigned_Value) * VREF
Voltage = (2048 / 4095) * 3.3V = 1.650V
If this ADC were signed 12-bit, the maximum positive value would be 2047. A reading of 2048 would be interpreted as a negative number (-2048), completely breaking your voltage calculation. This is why hardware manufacturers default to unsigned binary for physical measurements like voltage and light intensity.
Where You Meet This in Practice
Understanding unsigned binary prevents catastrophic logic bugs in three common embedded scenarios:
1. Hardware Timers and PWM Overflow
Microcontrollers use hardware timers to generate PWM signals or track time. An 8-bit timer counts from 0 to 255. Think of an 8-bit timer like a mechanical car odometer that rolls over from 999 back to 000. When the timer hits 255 and ticks one more time, it overflows to 0. If you attempt to calculate the elapsed time by subtracting the start time from the end time using signed math, a rollover will result in a massive negative number instead of the correct small positive delta. Always use uint8_t or uint32_t for timer math so the C++ compiler handles the underflow/overflow wrap-around correctly.
2. I2C and SPI Sensor Registers
When you read a 16-bit digital light sensor (like the BH1750) over I2C, it sends two bytes: High and Low. You combine them using bit-shifting: uint16_t lux = (high << 8) | low;. If you mistakenly declare lux as a signed int16_t, any light level above 32,767 lux (direct sunlight) will flip the MSB to 1. Your firmware will interpret bright sunlight as a negative number (e.g., -25,536), causing your if (lux > threshold) logic to fail silently.
3. Memory Addresses and Pointers
Memory addresses cannot be negative. The C standard integer types define uintptr_t as an unsigned integer type capable of holding a pointer. Attempting to do pointer arithmetic with signed integers can lead to undefined behavior when crossing memory boundaries.
Common Confusions and Debugging Traps
The most common mistake makers and junior engineers make is confusing unsigned binary with signed binary (Two's Complement). Binary is just the base-2 language; "signed" and "unsigned" are the lenses through which the compiler interprets that language.
- The Trap: You read a raw byte from an I2C register:
10000000(Hex0x80). - Unsigned Interpretation: 128. (Correct for a PWM duty cycle or a temperature sensor offset).
- Signed Interpretation: -128. (Correct for a signed accelerometer axis reading).
The hardware doesn't know the difference. The silicon just stores high and low voltages. It is entirely up to your firmware's variable declaration (uint8_t vs int8_t) to assign meaning. If you cast a uint16_t sensor reading into an int8_t to save RAM, you will truncate the upper byte and potentially flip the sign bit, destroying your data.
Frequently Asked Questions
Can an unsigned binary number ever be negative?
No. By definition, unsigned binary lacks a sign bit. However, if you force an unsigned variable into a signed context in your code (e.g., printing a uint16_t using a signed format specifier like %d instead of %u in C), the serial monitor will display a negative number. The data isn't negative; your display function is just misinterpreting the bits.
Why do microcontrollers default to unsigned for hardware registers?
Because physical states in a circuit don't go below zero. A memory address cannot be -4. A PWM duty cycle cannot be -50%. A timer cannot tick backwards into negative time. Using unsigned binary maximizes the positive range for these physical parameters without wasting a bit on a useless negative sign.
How do I handle negative sensor readings if my ADC is unsigned?
You must add a DC offset in hardware. For example, if you want to measure an AC audio signal swinging from -1V to +1V with a 0-3.3V unsigned ADC, you use an op-amp summing circuit to add a +1.65V bias. The ADC will read 0V as 1.65V (mid-scale, ~2048). In firmware, you subtract 2048 from the unsigned reading to reconstruct the signed, centered waveform.
