Binary and Decimal in Electronics: When to Use Base-2 vs Base-10

Binary is a base-2 numbering system using only 0s and 1s to map directly to electrical states (low/high), while decimal is the base-10 system humans use for everyday counting and thresholds. In a real circuit or microcontroller installation, choosing between binary and decimal dictates whether you manipulate individual hardware pins and bitwise flags (binary) or calculate human-readable sensor thresholds and UI outputs (decimal). Makers most commonly confuse pure binary with Binary-Coded Decimal (BCD), or they mistakenly treat hexadecimal literals in code as decimal values, leading to off-by-magnitude errors in motor speeds or PWM duty cycles.

The Core Difference: Base-2 Hardware vs Base-10 Humans

At the silicon level, a microcontroller like the ATmega328P (Arduino Uno) or the ESP32-WROOM-32 has no concept of the number 'ten'. It only understands voltage thresholds. A pin reading below ~1.5V is a logical 0; a pin reading above ~3.0V (on a 5V system) is a logical 1. Binary simply strings these physical realities together into usable data. A single byte is just eight physical wires or flip-flops holding high or low states.

Decimal, conversely, is an abstraction layer. When you write analogWrite(9, 153); to set a PWM duty cycle, the compiler translates that base-10 human-readable number into the binary sequence 10011001 to load into the timer's hardware register.

Think of it like a single light switch versus a dimmer dial. The switch is purely binary (on/off). The dimmer dial is calibrated 0-10 for human convenience (decimal), even though the underlying circuit is still just varying a voltage. The friction in embedded systems happens when you try to use the 'dial' to configure a 'switch'.

Worked Example: Configuring an MCP23017 I2C Address

Let's look at a real bench scenario. You are wiring an MCP23017 16-channel I2C I/O expander to an ESP32. You already have an OLED display on the I2C bus at address 0x3C. The MCP23017 has a default base address of 0x20 (decimal 32), but you need to change it to 0x25 (decimal 37) to avoid a future collision with a sensor you plan to add.

The chip has three hardware address pins: A0, A1, and A2. These pins accept binary inputs to offset the base address.

1. Identify the offset: Target address (37 decimal) minus Base address (32 decimal) = 5.
2. Convert to binary: The decimal value 5 translates to the binary sequence 101 (4 + 0 + 1).
3. Map to hardware: Reading right-to-left (A0 to A2), we assign the bits:
   • A0 = 1 (Connect to 3.3V / HIGH)
   • A1 = 0 (Connect to GND / LOW)
   • A2 = 1 (Connect to 3.3V / HIGH)
4. Write the firmware: In your Arduino/ESP32 code, you can initialize the chip using either format, but one is vastly clearer for debugging.

// BAD: Using decimal for hardware addresses obscures the pin states
Wire.beginTransmission(37); 

// GOOD: Using hexadecimal or binary literals maps to the datasheet
Wire.beginTransmission(0x25); // Hex is standard for I2C addresses

Where You Meet Binary and Decimal in Practice

Understanding binary and decimal conversions isn't just academic; it dictates how you physically wire boards and write firmware. Here is where each system dominates on the workbench:

Where Binary Rules

• DIP Switches and Jumpers: Setting the baud rate on an RS-485 module or the micro-stepping resolution on an A4988 stepper driver. You are physically toggling base-2 bits.
• Port Register Manipulation: Writing directly to PORTD on an AVR microcontroller to update 8 pins simultaneously. You must use binary masks (e.g., PORTD = 0b10100000;) to avoid overwriting adjacent pins.
• Network Subnetting: Configuring static IPs and subnet masks for ESP32 MQTT nodes. A subnet mask of 255.255.255.0 is actually 11111111.11111111.11111111.00000000 in binary.

Where Decimal Rules

• Sensor Thresholds: Triggering a relay when a BME280 reads > 25°C, or shutting down a motor if a current sensor reads > 12 Amps.
• PID Tuning: Calculating Proportional, Integral, and Derivative constants for a 3D printer hotend or a balancer robot.
• Timing and Delays: Using delay(1000); for a 1-second pause. Humans parse base-10 milliseconds instantly.

Decision Tree: Binary vs Decimal in Firmware and Hardware

Use this decision path to choose the correct number format for your code and wiring. Follow the logic down to the default pick.

Common Pitfalls and How to Avoid Them

Confusing these number systems is the root cause of some of the most frustrating 'ghost in the machine' bugs in embedded electronics. Here are the three most common traps and how to fix them.

1. The Binary-Coded Decimal (BCD) Trap

Real-Time Clock (RTC) modules like the ubiquitous DS3231 do not store time in pure binary or standard decimal. They use BCD. In BCD, each decimal digit is stored in its own 4-bit nibble. If the time is 59 seconds, the register holds 0101 1001 (Hex 0x59).

If you read 0x59 and treat it as a standard hexadecimal/binary number, your math will tell you it's 89 seconds. You must decode it using bitwise shifts:

// Correct BCD to Decimal conversion for RTC chips
byte bcdSeconds = readRegister(0x00);
byte decimalSeconds = ((bcdSeconds >> 4) * 10) + (bcdSeconds & 0x0F);

2. The C++ Octal Leading Zero Trap

In C and C++ (the languages underlying Arduino and ESP-IDF), placing a leading zero before a number tells the compiler it is an octal (base-8) number, not decimal.

If you write int delayTime = 015; intending a 15-millisecond delay, the compiler reads it as octal 15, which equals decimal 13. Your timing will be slightly off. Never pad decimal numbers with leading zeros in firmware.

3. Bitwise Math vs Standard Math

Beginners often try to use decimal addition to combine binary flags. If a status register returns 0b00000100 (decimal 4) and you want to add the 0b00000010 (decimal 2) flag, adding them as decimals (4 + 2 = 6) happens to work. But if the flag is already set and you add it again, decimal math yields 8, corrupting the register. Always use the bitwise OR operator (|) for flags, as detailed in the Arduino Bit Math documentation.