A Practical Explanation of Binary Numbers for Microcontroller Builders

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 mathematical concept changes abstract code into concrete voltage thresholds—telling a microcontroller whether a sensor reads HIGH or LOW based on physical electrical potential. The most common mistake makers and students make is confusing binary values (the pure math of 0s and 1s) with binary logic levels (the physical voltages, like 3.3V CMOS versus 5V TTL, that actually represent those 0s and 1s on the wire).

The Core Concept: Base-2 Math on the Bench

Think of binary like a row of light switches on a wall, where each switch controls a specific bank of lights. Unlike a dimmer switch (which is analog and can be anywhere from 0% to 100%), these switches only have two states: completely OFF (0) or completely ON (1). The position of the switch determines its 'weight' or how much power it controls. The switch on the far right controls a single bulb, the next one controls two, the next four, and so on, doubling each time.

In digital electronics, we group these switches into 'bits'. An 8-bit grouping is a byte. Here is how the positional weights map out for a standard 8-bit register:

When you write 0b10000000 in C++ or MicroPython, you are flipping only the 7th bit ON, yielding a decimal value of 128. The 0b prefix is the standard compiler hint that the following digits are binary, not decimal.

Worked Numeric Example: Decoding an 8-Bit Bitmask

Let's look at a real numeric example you might encounter when reading a status byte from an I2C sensor or configuring a motor driver. Suppose your logic analyzer captures the following 8-bit binary sequence from a data line:

1 1 0 0 1 0 1 0

To understand what this means in decimal (base-10), we align it with our weight table and add up the values where the bit is a 1:

1. Bit 7 is 1 (Weight: 128)
2. Bit 6 is 1 (Weight: 64)
3. Bit 5 is 0 (Weight: 0)
4. Bit 4 is 0 (Weight: 0)
5. Bit 3 is 1 (Weight: 8)
6. Bit 2 is 0 (Weight: 0)
7. Bit 1 is 1 (Weight: 2)
8. Bit 0 is 0 (Weight: 0)

Adding the active weights together: 128 + 64 + 8 + 2 = 202. Therefore, the binary byte 0b11001010 is exactly equal to the decimal number 202. If this byte represented a PWM duty cycle on an 8-bit timer, your output would be running at roughly 79% capacity (202 / 255).

Where You Meet Binary in Practice

You don't just use binary for math; you use it to manipulate hardware directly. Here are the three most common places you will write binary literals on the workbench:

1. Direct Port Manipulation (GPIO Registers)

When you use digitalWrite(pin, HIGH) on an Arduino or ESP32, the framework does a lot of background work. For high-speed applications, you bypass this and write directly to the hardware registers. On the ESP32, setting a pin high instantly is done via the GPIO.out_w1ts register. Writing 0b00000000000000000000000000000100 (or 1 << 2) sets GPIO 2 high without touching the state of the other 31 pins.

2. I2C and SPI Addressing

I2C devices use a 7-bit address. However, the physical protocol sends 8 bits. The 8th bit is the Read/Write flag. If your sensor's datasheet says the address is 0x68 (binary 1101000), the actual byte sent on the wire to write to it is 11010000 (0xD0), and to read from it is 11010001 (0xD1). Understanding this binary shift prevents endless 'device not found' I2C scanning errors.

3. DIP Switches on Motor Drivers

Stepper motor drivers (like the TB6600) and DMX lighting decoders use physical DIP switches to set microstepping or universe addresses. The switches are literal binary inputs. Switch 1 ON and Switch 2 OFF means binary 01 (decimal 1). Reading the silk-screen on the PCB requires you to mentally convert those physical switch states into a binary byte.

Bench Scenario: Driving Relays via a 74HC595 Shift Register

To see how binary translates to physical hardware—and how easily it goes wrong—let's walk through a classic workbench scenario.

The Setup: You are using an ESP32 DevKit v1 to control an 8-channel 5V relay module. Because the ESP32 lacks enough free GPIO pins, you route the data through a 74HC595 shift register. The ESP32 sends a single byte serially, and the 74HC595 latches it to 8 parallel output pins (Q0 through Q7), which drive the relay optoisolators.

The Numbers: You want to turn ON Relay 1 (connected to Q0) and Relay 8 (connected to Q7), while keeping the rest OFF. You calculate your binary bitmask: Q7 is the Most Significant Bit (MSB), Q0 is the Least Significant Bit (LSB). The binary string is 10000001. In decimal, this is 129. You write shiftOut(dataPin, clockPin, MSBFIRST, 129); in your code.

The Outcome: You upload the code. The shift register clicks, but Relay 1 and Relay 8 stay OFF. Instead, Relays 2, 3, 4, 5, 6, and 7 turn ON with a loud clack.

What Went Wrong: You fell victim to Active-LOW logic. Most cheap 8-channel relay modules are designed to trigger when the input pin is pulled to GND (LOW), not when it is driven HIGH. In the physical circuit, a binary 0 turns the relay ON, and a binary 1 turns it OFF. Furthermore, your bitwise endianness was flipped relative to the board's silk-screen numbering.

The Fix: You need to invert your binary logic. To turn ON Q0 and Q7, you need to send binary 0 to those positions and 1 to the rest. The correct binary mask is 01111110, which is decimal 126. In C++, the cleanest way to handle this without doing mental math every time is to use the bitwise NOT operator (~) on your original intent, combined with the correct bit order:

// Define the relays we WANT to turn on (Active HIGH logic in our minds)
byte intendedState = 0b10000001; 

// Invert it for the Active-LOW relay module hardware
byte actualOutput = ~intendedState; 

// Shift it out to the 74HC595
shiftOut(dataPin, clockPin, MSBFIRST, actualOutput);

Troubleshooting Binary Logic Errors (FAQ)

Understanding binary isn't just about passing a computer science exam; it is the literal language your microcontroller uses to interact with the physical world. By mastering bitmasks, recognizing active-low hardware quirks, and respecting logic voltage thresholds, you bridge the gap between writing code and successfully driving real-world electronics.