The binary number for 3 is 11 (typically written as 00000011 in an 8-bit byte), representing a state where the 1s and 2s place values are logic HIGH while all higher bits are logic LOW. In decimal, it is simply 3; in hexadecimal, it is 0x03. But on the workbench, this number is more than just math. In a physical circuit, writing a binary 3 to an 8-bit microcontroller port drives exactly two adjacent pins to your logic high voltage (e.g., 3.3V or 5V), while the remaining six pins stay at 0V. Understanding how this specific bit pattern behaves is critical when you move from blinking single LEDs to manipulating entire hardware ports, driving shift registers, or configuring DACs.
The Math Behind the Binary Number for 3
Binary is a base-2 numbering system where each column represents a power of 2, starting from 2^0 (1) on the far right. To represent the decimal number 3, we need to add the 1s place and the 2s place together (1 + 2 = 3). Therefore, the two rightmost bits are set to 1, and all other bits are 0.
| Bit Position (8-bit) | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| Weight | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| Value for 3 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
Worked Numeric Example: Binary 3 in a 4-Bit R-2R DAC
Let us look at what happens when you feed the binary number for 3 into a physical Digital-to-Analog Converter (DAC). A common hobbyist DAC is the R-2R resistor ladder. If you build a 4-bit R-2R DAC using 10kΩ (R) and 20kΩ (2R) resistors, and you drive it with a 5.0V logic reference, the analog output voltage is determined by the binary input.
The formula for an R-2R DAC output is:
V_out = V_ref × (Decimal Value / 2^n)
For our 4-bit system (n = 4, so 2^4 = 16 steps) and a 5.0V reference:
- Binary Input:
0011(Decimal 3) - Calculation: 5.0V × (3 / 16)
- Result: 0.9375V
If you measure the output with your multimeter, you will read exactly 0.937V (accounting for standard 1% resistor tolerances). If you change the input to binary 4 (0100), the voltage jumps to 1.25V. This is how digital logic physically becomes analog voltage.
Where You Meet Binary 3 in Practice
You rarely think about the number 3 when toggling a single pin, but the moment you start working with buses, ports, and registers, binary 3 shows up constantly.
Direct Port Manipulation on AVRs
On an Arduino Uno (ATmega328P), the digital pins 0 through 7 map directly to the hardware register PORTD. If you want to turn on exactly Pin 0 (RX) and Pin 1 (TX) simultaneously without using the slower digitalWrite() function, you write binary 3 directly to the port:
PORTD = 0b00000011;
0b00000011 to PORTD forces the hardware UART pins (RX/TX) HIGH. If you do this while Serial.begin(9600) is active, you will clash with the hardware serial peripheral, corrupt your USB data stream, and potentially backfeed voltage into your USB-to-serial chip. Always mask your bits (e.g., PORTD = (PORTD & 0xFC) | 0x03;) or avoid PORTD if serial communication is running.
Shifting Data into a 74HC595
When you run out of GPIO pins, you use a shift register like the 74HC595. To turn on the first two LEDs connected to outputs Q0 and Q1, you shift out the binary number for 3. Using the Arduino shiftOut() function, the code looks like this:
shiftOut(dataPin, clockPin, MSBFIRST, 3);
Under the hood, the microcontroller pulses the clock pin 8 times. Because we specified MSBFIRST (Most Significant Bit First), it pushes five 0s, followed by two 1s into the 74HC595's internal D-type flip-flops. When you pulse the latch pin, Q0 and Q1 snap to 5V, sinking current through your LEDs.
Common Confusions: Decimal 11 vs. Binary 11 and Endianness
When reading schematics or debugging logic analyzer traces, the binary number for 3 is a frequent source of errors for beginners.
Confusion 1: Reading "11" as Eleven. In standard decimal math, "11" means eleven. In binary, 11 means three. If you write int x = 11; in C++, the compiler assumes decimal eleven (which is 1011 in binary). To explicitly tell the compiler you mean the binary number for 3, you must use the 0b prefix: int x = 0b11;. Alternatively, hex is often preferred in embedded systems because it maps cleanly to 4-bit nibbles: int x = 0x03;.
Confusion 2: Bit Endianness (MSB vs LSB). When you send binary 00000011 over an SPI bus or into a shift register, which bit goes first? If your hardware expects LSBFIRST (Least Significant Bit First), the 1 on the far right is transmitted on the very first clock edge. If it expects MSBFIRST, the 0 on the far left goes first. Sending binary 3 with the wrong endianness to a device expecting LSB-first will result in the device reading the bits in reverse, completely altering the command.
Frequently Asked Questions
How do I write the binary number for 3 in Arduino C++?
You have three valid options depending on your coding style. You can use the binary literal prefix: 0b00000011 (or just 0b11). You can use the hexadecimal equivalent: 0x03. Or, you can simply use the decimal integer: 3. The compiler converts all three into the exact same machine code. Most embedded engineers prefer 0x03 or 0b00000011 because it makes the bit-mask intent obvious to anyone reading the code.
Why does my logic analyzer show binary 3 as a hex 0x03?
Logic analyzers (like the Saleae Logic Pro or cheap 8-channel clones) sample 8, 16, or 32 channels simultaneously. Displaying raw binary for a 16-bit bus results in a massive string of 1s and 0s that is hard for the human eye to parse. Because one hexadecimal digit perfectly represents exactly four binary bits (a nibble), the software groups the binary data into hex. Binary 0000 0011 cleanly translates to hex 0 and 3, displayed as 0x03.
What happens if I send the binary number for 3 to a 2-bit system?
Binary 11 is the absolute maximum value a 2-bit system can hold (representing decimal 3). If you attempt to write a larger number, like decimal 4 (100), to a 2-bit register, the most significant bit is truncated, and the register will overflow, wrapping around or simply latching the lower two bits depending on the specific hardware architecture. Binary 3 fits perfectly into a 2-bit, 4-bit, 8-bit, or 32-bit system without overflow.
