How to Do Binary: Base-2 Math and Bitwise Logic for Makers

Think of an 8-bit binary number as a row of eight physical toggle switches on a workbench, where each switch is either flipped UP (1) or DOWN (0). The rightmost switch is worth 1, the next is worth 2, then 4, 8, 16, 32, 64, and 128. When you understand how to do binary math, you stop fighting the hardware and start speaking its native language.

The Core Definition and What It Changes

In decimal (base-10), we use ten symbols (0-9). In binary (base-2), we only use two (0 and 1). Every time a column exceeds 1, it rolls over to the next column. This isn't just abstract math; it maps directly to the physical reality of transistors inside an ATmega328P or ESP32. A transistor is either conducting (1/HIGH) or cut off (0/LOW).

When you write code for a microcontroller, you are ultimately flipping these microscopic switches. If you don't know how to do binary bitwise operations, you will inevitably overwrite critical configuration bits when trying to change a single setting in a hardware register. Knowing binary allows you to use masks and shifts to alter exactly one switch without disturbing the other seven in the row.

How to Do Binary: A Worked Numeric Example

Let's look at a concrete numeric example using an 8-bit register. Suppose you read a status byte from a sensor, and the microcontroller returns the decimal value 173. You need to isolate the lower four bits to check a specific fault code.

Now, we want to extract only the rightmost four bits (the lower nibble). We do this using a bitwise AND operation with a mask. A bitwise AND outputs a 1 only if both corresponding bits are 1.

• Target Value: 10101101 (Decimal 173)
• Mask: 00001111 (Decimal 15)
• Operation: 10101101 & 00001111
• Result: 00001101

The result is 00001101, which converts back to decimal 13 (8 + 4 + 1). By applying the mask, we successfully stripped away the upper four bits (1010) without altering the lower four. This exact operation is how you extract specific data fields from sensor payloads.

Where You Meet Binary in Practice

You will encounter binary logic constantly on the bench. Here are the most common physical and software implementations:

1. GPIO Port Manipulation: Setting a specific pin HIGH on an Arduino without affecting adjacent pins using PORTD |= (1 << PD5);.
2. Shift Registers: Clocking data into a 74HC595 to control eight LEDs using only three microcontroller pins.
3. DIP Switches: Reading a bank of physical toggle switches to set a device's I2C address or baud rate.
4. IP Subnetting: Calculating network boundaries for ESP32 IoT devices connecting to local MQTT brokers.

For a deeper look at how these base-2 principles map to physical logic gates, the SparkFun Binary Tutorial provides an excellent visual breakdown of how binary translates to physical voltage levels.

Real-World Scenario: Debugging an I2C Register

Abstract math is fine, but binary mistakes cause real hardware bugs. Here is a walkthrough of a common failure mode when configuring an MPU6050 accelerometer over I2C using an ESP32.

The Setup: You need to configure the PWR_MGMT_1 register (Address 0x6B). Your goal is to wake the sensor up (clear the SLEEP bit) and set the clock source to the PLL with X-axis gyroscope reference.

The Numbers:

• Bit 6 is the SLEEP bit (1 = sleep, 0 = awake).
• Bits 2, 1, and 0 are the CLKSEL bits. We want 001 (PLL).
• The sensor's default reset state is 01000000 (Hex 0x40, Decimal 64). The sensor is asleep.

The Mistake (What Went Wrong):
The developer wants to set the clock to 001. They write a quick line of code to OR the current value with 1:
Wire.write(0x40 | 0x01);

The Outcome:
The math executes as 01000000 | 00000001, resulting in 01000001 (Hex 0x41). The ESP32 sends 0x41 to the sensor. The clock source is updated, but Bit 6 remains HIGH. The sensor stays in sleep mode. The developer spends three hours wondering why the I2C bus is returning zeros for all accelerometer data.

The Fix:
Because the default state of the other bits in this specific register doesn't matter for basic operation, the correct move is to simply overwrite the byte with 0x00 (wake up, internal clock) or 0x01 (wake up, PLL clock). If you must preserve other bits, you use a read-modify-write cycle with an AND mask to clear the sleep bit first:

1. Read current register: 01000000
2. AND with inverse sleep mask (10111111): results in 00000000
3. OR with clock select (00000001): results in 00000001
4. Write 0x01 back to the register.

Common Confusions: Binary vs. Hexadecimal vs. BCD

When reading datasheets, you will see binary, hexadecimal, and BCD used interchangeably. Here is how to tell them apart and what people commonly confuse them with.

System	Base	Symbols	Example (Value 13)	Primary Use Case
Binary	2	0, 1	00001101	Hardware registers, bitwise logic
Hexadecimal	16	0-9, A-F	0x0D	Datasheets, memory addresses
BCD	10 (encoded)	0-9 (per nibble)	0001 0011	RTC modules, 7-segment displays

The Hexadecimal Confusion: Hex is not a different physical state; it is just a shorthand for binary. Because 1101 in binary is exactly 13 in decimal, and 'D' in hex, engineers use hex to avoid writing out long strings of 1s and 0s. Every hex digit maps perfectly to four binary bits (a nibble).

The BCD Confusion: Binary Coded Decimal (BCD) is where most beginners trip up. In pure binary, 1101 is 13. In BCD, the byte is split into two 4-bit chunks, each representing a single decimal digit. So, decimal 13 in BCD is 0001 (1) and 0011 (3), resulting in 00010011. If you try to read a DS3231 Real Time Clock module's seconds register as pure binary instead of BCD, your clock will read '19 seconds' when it is actually '13 seconds' (because 00010011 in pure binary is 19). The All About Circuits digital textbook provides a rigorous breakdown of why BCD exists and how to decode it in C++.

FAQ: Bitwise Operations on the Bench