Explain Binary Numbers: Practical Applications in Microcontrollers and Logic ICs

Binary is a base-2 numbering system that uses only two digits, 0 and 1, to represent all data and logic states in digital electronics. In a physical circuit, this abstract math translates directly into voltage thresholds: a logic '1' might be 3.3V, and a logic '0' might be 0V. Understanding this translation is what separates someone who just copies Arduino code from someone who can debug a frozen I2C bus with an oscilloscope. When you explain binary numbers to a fellow maker, you aren't just teaching math; you are teaching them how silicon interprets the physical world.

The Core Mechanism: Base-10 vs. Base-2

Humans use base-10 (decimal) because we have ten fingers. Each positional column is a power of 10 (1s, 10s, 100s). Digital silicon uses base-2 because a transistor only has two reliable, easily distinguishable states: fully off (cutoff) and fully on (saturation). Each positional column in binary is a power of 2.

Let's look at a worked numeric example to convert the decimal value 173 into an 8-bit binary number. We map out the powers of 2 from left (Most Significant Bit, MSB) to right (Least Significant Bit, LSB):

The final binary string is 10101101. In C++ or Arduino IDE, you would write this as 0b10101101 or 0xAD in hexadecimal. If you send this byte to an 8-bit shift register like the 74HC595, pins Q7, Q5, Q3, Q2, and Q0 will output HIGH, while the others remain LOW.

Where You Meet This in Practice

You interact with binary numbers every time you manipulate hardware registers, configure communication buses, or set physical DIP switches. Here is where binary moves from theory to the workbench:

• GPIO Port Manipulation: Calling digitalWrite(5, HIGH) on an ATmega328P takes roughly 50 clock cycles because the function has to parse the pin number and look up the port. Writing PORTD |= (1 << 5); directly sets the binary bit for pin D5 in a single clock cycle. This is critical for high-speed bit-banging protocols like WS2812B LED control.
• I2C Addressing: Every I2C slave device has a 7-bit binary address. When the master initiates a transfer, it sends this 7-bit address followed by a 1-bit Read/Write flag, forming an 8-bit binary byte on the SDA line.
• Stepper Driver DIP Switches: Drivers like the TB6600 use physical switches to set microstepping and current limits. These switches are just physical inputs to an internal binary decoder. Setting S1=OFF, S2=ON, S3=ON might represent the binary sequence 100 to the driver's logic gate, selecting 1/16 microstepping.

Real-World Scenario Walkthrough: The I2C Address Collision

To truly explain binary numbers, we have to look at what happens when you misinterpret them in a real circuit. Here is a common bench failure involving binary address mapping.

The Setup: You are building a data logger using an ESP32 DevKit v1 and need to read 8 channels of analog sensors. Since the ESP32's internal ADC is notoriously noisy, you decide to use two external ADS1115 16-bit ADCs on the same I2C bus.

The Numbers: The first ADS1115 has its ADDR pin tied to GND, giving it the default I2C address of 0x48 (binary 1001000). The second ADS1115 needs a different address. You tie its ADDR pin to the SDA line, expecting it to take address 0x4B (binary 1001011) based on a misread forum post that assumed the addresses increment sequentially based on pin names.

The Outcome: You upload your code, but the serial monitor only shows data from the first ADC. The second ADC reads zero, and the I2C scanner sketch only finds one device at 0x48. Occasionally, the entire I2C bus locks up.

What Went Wrong: The binary address mapping for the ADS1115 ADDR pin is hardcoded in the silicon, and it does not follow a simple sequential binary count based on pin names. According to the Texas Instruments ADS1115 datasheet, the address mapping is strictly defined: GND = 0x48, VDD = 0x49, SDA = 0x4A, and SCL = 0x4B.

By tying the ADDR pin to SDA, you forced the chip's internal binary address to 0x4A (binary 1001010). However, your Arduino code was polling 0x4B (binary 1001011). When the ESP32 sent the address byte 1001011 over the bus, the second ADS1115 didn't recognize its own binary address. It remained silent, and the bus pulled high. The master eventually timed out or misinterpreted bus capacitance as a NACK (Not Acknowledged) bit, crashing the transaction. The fix was simply changing the Wire library address parameter from 0x4B to 0x4A.

Common Confusions: Binary vs. Hexadecimal vs. BCD

When people learn binary, they frequently confuse it with two related numbering formats used in embedded systems:

1. Hexadecimal (Base-16): Hex is not a different physical logic state; it is simply a human-friendly compression of binary. Because 16 is a power of 2 ($2^4$), exactly four binary bits map to one hex digit. The binary string 1010 1101 is much easier to read as 0xAD. Microcontrollers don't "think" in hex; the compiler translates your hex back into binary before flashing the silicon.
2. Binary Coded Decimal (BCD): This is where hobbyists get trapped. BCD uses 4 binary bits to represent only the decimal digits 0 through 9. The binary states for 10 through 15 (1010 to 1111) are considered invalid in BCD. Real-time clock (RTC) modules like the DS3231 store time in BCD. If you read the seconds register and get 0x59 in hex, that means 59 seconds. If you mistakenly treat 0x59 as pure binary/hex and convert it to decimal, your code will think it is the 89th second of the minute, breaking your time-stamp logic. You must use a BCD-to-decimal conversion function to parse it correctly.

FAQ: Binary in the Physical Circuit

Mastering binary numbers is the bridge between writing software and engineering hardware. Once you stop seeing 0b10101101 as just a math problem and start seeing it as eight distinct physical transistors turning on and off, debugging complex embedded systems becomes significantly more intuitive.