Essential Bitwise Operations for Embedded Firmware Developers

In embedded systems, a single bit can change everything — from enabling a GPIO pin to configuring an entire peripheral. Bitwise operations are the building blocks of firmware engineering. Whether you’re writing register-level drivers, optimizing memory, or debugging hardware behavior, mastering these operations is non-negotiable.

binary illustration

In this guide, we’ll cover the six essential bitwise operations every firmware engineer must know:

1. Setting a bit
2. Clearing a bit
3. Toggling a bit
4. Checking a bit
5. Counting set bits
6. Working with bit masks

1. Setting a Bit

To set a bit (make it 1) at a specific position, use the bitwise OR (|) operation.

// Set the n-th bit in reg
reg = reg | (1 << n);

Example:

uint8_t reg = 0b00001010;   // Initial register
reg = reg | (1 << 3);       // Set bit 3
// Result: 0b00011010

2. Clearing a Bit

To clear a bit (make it 0), use the bitwise AND (&) with the complement of the mask.

// Clear the n-th bit in reg
reg = reg & ~(1 << n);

Example:

uint8_t reg = 0b00001010;   // Initial register
reg = reg & ~(1 << 1);      // Clear bit 1
// Result: 0b00001000

3. Toggling a Bit

To invert a bit (switch 0 → 1 or 1 → 0), use the bitwise XOR (^).

// Toggle the n-th bit in reg
reg = reg ^ (1 << n);

Example:

uint8_t reg = 0b00001010;   // Initial register
reg = reg ^ (1 << 1);       // Toggle bit 1
// Result: 0b00001000

4. Checking a Bit

To test whether a bit is set, use the bitwise AND (&).

// Check if n-th bit is set
if (reg & (1 << n)) {
    // Bit is set
}

Example:

uint8_t statusReg = 0b00001010;
if (statusReg & (1 << 3)) {
    // Bit 3 is set
}

5. Counting Set Bits

Sometimes you need to know how many bits are 1 (e.g., population count).

int countBits(uint32_t reg) {
    int count = 0;
    while (reg) {
        count += reg & 1;   // Check LSB
        reg >>= 1;          // Shift right
    }
    return count;
}

Example:

uint8_t val = 0b10101010; // Four 1s
int count = countBits(val); 
// count = 4

6. Working with Bit Masks

Masks allow you to manipulate multiple bits at once, making them powerful for working with registers and flags.

Example:

#define DATA_READY_FLAG (1 << 0) // bit mask 

unsigned char status_register = 0x01; // Assume data ready
if (status_register & DATA_READY_FLAG) {
    // Data is ready
}

Key Takeaways

• Set / Clear / Toggle bits → use |, &~, ^
• Check bits → use &
• Count bits → shift and count
• Masks → handle groups of bits in one shot

Think of bitwise operations as your firmware superpower: they give you precise control over the hardware.

Final Words

If you’re new to firmware development, practice these bitwise tricks until they become second nature. They’re the foundation for GPIO toggling, interrupt configuration, and register manipulation in real-world microcontrollers.

In the next article of this series, we’ll dive into: Registers and Bitfields: Practical Manipulation Techniques etc…

Stay tuned!