How to Clear a Bit in Embedded C: Simple Syntax and Example

To clear a bit in embedded C, use the bitwise AND operator & with the negation of a bit mask. For example, variable &= ~(1 << bit_position); clears the bit at bit_position in variable.

Syntax

The syntax to clear a bit uses the bitwise AND operator & combined with the bitwise NOT operator ~ and a bit mask created by shifting 1 to the target bit position.

• variable: The number or register where you want to clear a bit.
• bit_position: The zero-based position of the bit to clear (0 for least significant bit).
• 1 << bit_position: Creates a mask with only the target bit set to 1.
• ~(1 << bit_position): Inverts the mask so the target bit is 0 and others are 1.
• variable &= ~(1 << bit_position);: Clears the target bit while keeping others unchanged.

c

variable &= ~(1 << bit_position);

Example

This example shows how to clear the 3rd bit (bit position 2) of an 8-bit variable. It prints the value before and after clearing the bit.

c

#include <stdio.h>

int main() {
    unsigned char variable = 0b00001111; // binary 00001111 (decimal 15)
    int bit_position = 2; // clear the 3rd bit (counting from 0)

    printf("Before clearing bit %d: 0x%02X\n", bit_position, variable);

    // Clear the bit
    variable &= ~(1 << bit_position);

    printf("After clearing bit %d: 0x%02X\n", bit_position, variable);

    return 0;
}

Output

Before clearing bit 2: 0x0F
After clearing bit 2: 0x0B

Common Pitfalls

Common mistakes when clearing bits include:

• Using |= instead of &=, which sets bits instead of clearing.
• Not negating the mask with ~, which can clear the wrong bits.
• Using the wrong bit position (off by one errors).
• Forgetting that bit positions start at 0 for the least significant bit.

c

#include <stdio.h>

int main() {
    unsigned char variable = 0b00001111;
    int bit_position = 2;

    // Wrong: sets the bit instead of clearing
    variable |= (1 << bit_position);
    printf("Wrong way (sets bit): 0x%02X\n", variable);

    // Correct: clears the bit
    variable &= ~(1 << bit_position);
    printf("Correct way (clears bit): 0x%02X\n", variable);

    return 0;
}

Output

Wrong way (sets bit): 0x0F
Correct way (clears bit): 0x0B

Quick Reference

Remember these quick tips when clearing bits in embedded C:

• Use variable &= ~(1 << bit_position); to clear a bit.
• Bit positions start at 0 from the right (least significant bit).
• Negate the mask with ~ to clear, not set.
• Use parentheses to ensure correct operator precedence.

Key Takeaways

Use bitwise AND with negated mask to clear a specific bit in embedded C.

Bit positions start at 0 from the least significant bit (rightmost).

Always negate the mask with ~ to clear bits, not set them.

Common mistake: using |= instead of &= clears bits incorrectly.

Use parentheses to avoid operator precedence errors.