How to Use the Binary Numeral System for Microcontroller Addressing and GPIO

The binary numeral system is a base-2 counting method that uses only two digits, 0 and 1, to represent all numerical values and logic states in digital electronics. In a physical circuit, this system dictates how microcontrollers translate raw 0V and 3.3V/5V pin states into memory addresses, sensor resolutions, and logic registers. Makers most commonly confuse pure binary with hexadecimal (which is simply a human-readable shorthand for binary) or Binary-Coded Decimal (BCD), which restricts 4-bit chunks to base-10 digits.

The Core Mechanism: Base-2 Math on the Bench

Unlike the base-10 system that uses place values of 1, 10, 100, and 1000, binary uses powers of two: 1, 2, 4, 8, 16, 32, 64, and 128. In digital logic, a '0' represents a low voltage (typically 0V or ground) and a '1' represents a high voltage (3.3V or 5V, depending on the logic family). When you string these bits together, you create bytes that map directly to hardware registers.

Worked Numeric Example: Calculating an I2C Hardware Address

Let us calculate the hardware I2C address for an NXP PCA9685 16-channel PWM driver, a common module used for controlling servos and LEDs. The chip has a fixed base address of 0x40 (which is 64 in decimal, or 1000000 in 7-bit binary).

The breakout board features 6 address jumpers labeled A0 through A5. These represent the binary offset you can add to the base address. Suppose you bridge A0, A2, and A4 to ground (logic 1), leaving A1, A3, and A5 open (logic 0).

• A0 (1s place): 1
• A1 (2s place): 0
• A2 (4s place): 1
• A3 (8s place): 0
• A4 (16s place): 1
• A5 (32s place): 0

Your binary offset is 010101. Converting this to decimal: 16 + 4 + 1 = 21. You add this offset to the base address: 64 + 21 = 85 in decimal. In hexadecimal, 85 is 0x55. This is the exact value you must pass to Wire.beginTransmission(0x55) in your Arduino sketch to communicate with this specific board.

Where You Meet This in Practice

You will encounter the binary numeral system constantly when moving beyond basic digitalWrite() commands into direct hardware manipulation.

1. GPIO Port Manipulation (Bitmasking)

Writing to pins one by one is slow. On an ATmega328P (Arduino Uno), you can write to an entire 8-bit port simultaneously using binary bitmasks. If you want to set Pin 3 (which maps to bit 3 of PORTD) high without disturbing the other pins, you use a bitwise OR operation: PORTD |= (1 << 3). The expression (1 << 3) shifts the binary 1 three places to the left, creating 00001000. This directly flips the physical voltage on that specific pin high in a single clock cycle.

2. ADC Resolution and Sensor Precision

Analog-to-Digital Converters (ADCs) measure voltage by dividing it into binary steps. A standard 10-bit ADC (like the one built into the Arduino Uno) yields 2^10 = 1,024 discrete steps. With a 5V reference, each binary step represents 4.88mV. If you need finer resolution, you must upgrade to a chip with a higher binary bit-width, which exponentially increases the number of steps.

3. DIP Switches on Motor Drivers

Stepper motor drivers like the TB6600 use binary DIP switches to set microstepping and current limits. Flipping switch 1, 2, and 3 to 'ON' might represent 111 in binary (decimal 7), which the driver's internal logic maps to a specific current threshold (e.g., 2.0A). Misreading the LSB/MSB orientation on the silkscreen is the number one cause of 'my motor is stuttering' support tickets.

Decision Path: Selecting Binary ADC Resolution for Sensor Projects

Choosing the right external ADC requires matching your sensor's noise floor to the binary resolution of the chip. Buying a 24-bit ADC for a noisy potentiometer is a waste of money, as environmental noise will obscure the lower bits. Use this decision table to select the correct part.

Common Confusions: Hex, BCD, and Gray Code

When reading datasheets, you will see binary represented in other formats. Understanding the difference prevents critical wiring and coding errors.

Hexadecimal (Base-16)

Hex is not a different physical logic system; it is a compression layer for human readability. Because 4 binary bits perfectly map to 16 states (0-15), engineers group binary into nibbles. The binary 1111 1010 is cumbersome to read, but in hex, it is simply 0xFA. If a datasheet lists an I2C address as 0x48, the microcontroller is still physically toggling pins in binary (1001000).

Binary-Coded Decimal (BCD)

BCD uses 4 binary bits to represent base-10 digits (0 through 9). The binary states 1010 through 1111 are considered invalid in BCD. You will encounter this when driving 7-segment displays using chips like the CD4511 BCD-to-7-segment decoder. If you send a pure binary value of 12 (1100) to a BCD chip, the display will typically go blank or show an error pattern, because 12 is not a valid single base-10 digit.

Gray Code

In standard binary, transitioning from 3 (011) to 4 (100) requires all three bits to flip simultaneously. In mechanical rotary encoders, physical switch bounce means the bits never flip at the exact same microsecond, causing the microcontroller to read phantom intermediate states (like 111 or 000). Gray code solves this by ensuring only one bit changes at a time between any two adjacent values. Always check if your encoder outputs standard binary or Gray code before writing your interrupt routines.

FAQ: Binary Numeral System in the Workshop