How to Write and Use Binary for 20 in Digital Logic and Microcontrollers

The binary for 20 is 10100, a base-2 numerical representation where the 16-bit and 4-bit positional weights are high (1) while the 8, 2, and 1 positions are low (0).

In a physical digital circuit, sending this binary sequence to a microcontroller port or shift register forces exactly the 3rd and 5th output pins (zero-indexed) to go HIGH (VCC), energizing the specific relays, LEDs, or logic gates attached to those traces while keeping the rest LOW (GND). Understanding how to map this decimal value to physical hardware states is a foundational skill for embedded systems and digital logic design.

The Direct Answer: Binary for 20 and How It Works

Digital logic relies on powers of two. To convert decimal 20 to binary, we subtract the largest power of 2 that fits into our number, mark that bit as a 1, and repeat the process with the remainder.

• 16 fits into 20. (Remainder: 4) → Bit 4 is 1
• 8 does not fit into 4. → Bit 3 is 0
• 4 fits into 4. (Remainder: 0) → Bit 2 is 1
• 2 does not fit into 0. → Bit 1 is 0
• 1 does not fit into 0. → Bit 0 is 0

Reading from highest bit to lowest, we get 10100. In microcontroller programming, we rarely use 5-bit variables; we pad this to a standard 8-bit byte: Decimal 20 = Binary 00010100 = Hex 0x14. When a microcontroller pushes this byte to an output register, the physical voltage on pins 2 and 4 rises to the logic HIGH threshold (typically 3.3V or 5V, depending on your board's VCC), while pins 0, 1, 3, 5, 6, and 7 remain at 0V.

Worked Example: Driving a 74HC595 Shift Register with Binary 20

Let's look at a real-world bench scenario. You are building an automated irrigation controller using an ESP32-WROOM-32, but you've run out of GPIO pins. You decide to use a Texas Instruments SN74HC595 8-bit shift register to control eight 5V solenoid valves via a ULN2803A Darlington transistor array.

You need to open Valve 3 (connected to shift register output Q2) and Valve 5 (connected to output Q4) simultaneously, leaving all others closed. Here is the exact pin-to-weight mapping for the 74HC595:

To achieve this, we send the binary for 20 (00010100) to the shift register. Here is the exact wiring and C++ code to execute this on an ESP32:

// ESP32 Shift Register Control for Binary 20
const int dataPin = 13;  // SER (Pin 14 on 74HC595)
const int latchPin = 12; // RCLK (Pin 12 on 74HC595)
const int clockPin = 14; // SRCLK (Pin 11 on 74HC595)

void setup() {
  pinMode(dataPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void loop() {
  // Open Valves 3 and 5 (Decimal 20)
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, 0b00010100); // Binary for 20
  digitalWrite(latchPin, HIGH);
  
  delay(5000); // Keep valves open for 5 seconds
  
  // Close all valves (Decimal 0)
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, 0b00000000);
  digitalWrite(latchPin, HIGH);
  
  delay(10000); // Wait 10 seconds before next cycle
}

In this code, 0b00010100 tells the compiler to interpret the literal as binary. The shiftOut function pulses the clock pin 8 times, pushing the 1s into the Q2 and Q4 positions, which then drive the base of the Darlington pairs, pulling the solenoid gates to ground and opening the valves.

Where You Meet Binary 20 in Practice

Beyond shift registers, you will encounter the binary representation of 20 in several specific hardware configuration scenarios:

• DMX512 Lighting Addresses: In stage lighting, fixtures are assigned a starting address using a bank of 9 or 10 physical DIP switches. To set a moving head spotlight to DMX address 20, you flip switches 5 (value 16) and 3 (value 4) to the ON position. The internal microcontroller reads this physical binary 10100 on boot.
• Stepper Motor Microstepping: Many TB6600 or DRV8825 stepper motor drivers use a 3-switch or 6-switch block to set current limits and microstep resolution. While 20 isn't a direct microstep divisor, configuring a custom current decay table via an I2C digital potentiometer often requires writing specific binary bytes to the wiper register.
• Parallel EEPROM Addressing: When writing data to a legacy 28C64 parallel EEPROM, the address bus (A0-A12) must be set to write to specific memory locations. To write to memory address 20, the microcontroller must drive address lines A4 and A2 HIGH, matching the 10100 binary pattern.

Common Confusions: Binary 20 vs. Hexadecimal and BCD

People commonly confuse binary 20 with hexadecimal 20 and Binary-Coded Decimal (BCD) 20. This confusion leads to off-by-magnitude errors that can brick configurations or trigger the wrong hardware outputs.

If you are reading a datasheet for an I2C sensor and it says 'set the configuration register to 20', it almost always means decimal 20 (0x14 in hex). If you accidentally type 0x20 in your Arduino code, you are sending decimal 32, which will configure the sensor incorrectly. Always verify whether the documentation implies decimal, hex, or raw binary.