What Does 'b' Mean in Binary? 0b Prefixes, Hex B, and Bits

In embedded programming and digital electronics, "b" in binary most commonly refers to the 0b prefix used to denote a binary literal (like 0b1010), though it also refers to the hexadecimal digit 'B' (which equals 1011 in binary) or lowercase 'b' denoting bits in serial data rates. When you are writing firmware for an Arduino or ESP32, understanding which "b" you are dealing with is the difference between successfully toggling a hardware register and spending three hours debugging a serial buffer overflow.

The 0b Prefix: Writing Binary Literals in C/C++

In C and C++ (the languages underlying the Arduino IDE and ESP-IDF), the compiler needs to know what base a number is written in. By default, 140 is decimal. 0x8C is hexadecimal. But when you are manipulating hardware registers, you need to see the exact bit pattern. That is where the 0b prefix comes in. It tells the compiler, "Treat the following digits as base-2."

What this changes in a real circuit is profound: using the 0b prefix to write directly to a microcontroller's hardware port register changes the physical voltage state of multiple GPIO pins simultaneously in a single clock cycle. This bypasses the sequential, pin-by-pin overhead of standard digitalWrite() functions, which is critical when driving high-speed shift registers or generating precise software-based PWM signals.

Worked Numeric Example: Configuring an 8-Bit Port

Let's look at a real-world scenario on an ATmega328P (Arduino Uno). You want to set physical pins 2, 3, and 7 HIGH on PORTD, while leaving the others LOW.

• Bit Position: 7 6 5 4 3 2 1 0
• Target State: 1 0 0 0 1 1 0 0

Here is how you write that to the PORTD register using three different numerical bases:

// Binary literal (Most readable for pin mapping)
PORTD = 0b10001100; 

// Hexadecimal equivalent (Compact, common in datasheets)
PORTD = 0x8C;       

// Decimal equivalent (Hardest to visualize bitwise)
PORTD = 140;        

All three lines compile to the exact same machine code, but the 0b prefix allows you to visually map the code directly to the physical silicon pins. For deeper register manipulation on 32-bit architectures like the ESP32, you will use similar bitwise operations with 0b masks on registers like GPIO.out_w1ts (Espressif GPIO API Reference).

Hexadecimal 'B' to Binary Translation

The second time you will search for "b in binary" is when reading component datasheets. Integrated circuits like the MPU6050 accelerometer or the PCA9685 PWM driver document their I2C registers in hexadecimal. The hex digit B (or b) represents the decimal value 11.

Because hex is base-16 and binary is base-2, every single hex digit maps perfectly to a 4-bit binary "nibble." The hex digit B always translates to the binary nibble 1011.

The Lowercase 'b' Trap: Bits vs. Bytes in Serial Comms

What people most commonly confuse with binary literals is the unit notation for data rates. In serial communications (UART, SPI, I2C) and networking, a lowercase 'b' stands for bits, while an uppercase 'B' stands for Bytes. Confusing the two leads to an off-by-a-factor-of-eight error in your payload calculations, often resulting in dropped packets or buffer overflows.

Take the standard Arduino Serial baud rate of 115,200 bps (bits per second). Many beginners assume this means they can send 115,200 characters (Bytes) per second. This is physically impossible due to UART framing overhead.

In a standard 8N1 UART configuration (8 data bits, No parity, 1 stop bit), every Byte you send is wrapped in a 1-bit start frame and a 1-bit stop frame. That means it takes 10 bits of wire time to transmit 1 Byte of payload data.

• Wire Speed: 115,200 bits per second (bps)
• Frame Size: 10 bits per Byte
• Actual Payload Throughput: 115,200 / 10 = 11,520 Bytes per second (B/s)

If you are writing a Python script on a Raspberry Pi to read serial data from an ESP32, and you allocate a buffer expecting 115 kilobytes a second, your script will choke. Always size your serial buffers based on 'B' (Bytes), not 'b' (bits).

Quick Reference: 'B' Conversions and Prefixes

Keep this table at your bench when translating between datasheets, logic analyzer outputs, and your C++ IDE.