Register bit manipulation patterns in Embedded C

Introduction

We use register bit manipulation to control hardware by turning specific bits on or off. This helps us manage devices like LEDs, sensors, or motors directly.

Turning an LED on or off by setting or clearing a bit in a control register.

Checking if a button is pressed by reading a specific bit in an input register.

Configuring a hardware timer by setting bits in its control register.

Enabling or disabling interrupts by changing bits in an interrupt register.

Clearing error flags by resetting bits in a status register.

Syntax

Embedded C

/* Define a register as a variable */
volatile unsigned int REGISTER;

/* Set a bit (turn bit ON) */
REGISTER |= (1U << BIT_POSITION);

/* Clear a bit (turn bit OFF) */
REGISTER &= ~(1U << BIT_POSITION);

/* Toggle a bit (flip bit) */
REGISTER ^= (1U << BIT_POSITION);

/* Check a bit (test if bit is ON) */
if (REGISTER & (1U << BIT_POSITION)) {
    // bit is ON
} else {
    // bit is OFF
}

Use volatile keyword for hardware registers to prevent compiler optimizations.

Bits are counted from 0 (least significant bit) upwards.

Examples

This turns ON bit 3 in CONTROL_REGISTER.

Embedded C

volatile unsigned int CONTROL_REGISTER = 0x00;

// Set bit 3
CONTROL_REGISTER |= (1U << 3);

This turns OFF bit 7 in STATUS_REGISTER.

Embedded C

volatile unsigned int STATUS_REGISTER = 0xFF;

// Clear bit 7
STATUS_REGISTER &= ~(1U << 7);

This flips bit 0 in FLAG_REGISTER from 1 to 0 or 0 to 1.

Embedded C

volatile unsigned int FLAG_REGISTER = 0x0F;

// Toggle bit 0
FLAG_REGISTER ^= (1U << 0);

This checks if bit 4 is ON in INPUT_REGISTER.

Embedded C

volatile unsigned int INPUT_REGISTER = 0x10;

// Check if bit 4 is ON
if (INPUT_REGISTER & (1U << 4)) {
    // bit 4 is ON
} else {
    // bit 4 is OFF
}

Sample Program

This program shows how to set, clear, toggle, and check bits in a simulated 8-bit register. It prints the register value after each operation and checks if a specific bit is ON or OFF.

Embedded C

#include <stdio.h>
#include <stdint.h>

int main() {
    volatile uint8_t REGISTER = 0x00; // 8-bit register initialized to 0

    printf("Initial REGISTER value: 0x%02X\n", REGISTER);

    // Set bit 2
    REGISTER |= (1U << 2);
    printf("After setting bit 2: 0x%02X\n", REGISTER);

    // Clear bit 2
    REGISTER &= ~(1U << 2);
    printf("After clearing bit 2: 0x%02X\n", REGISTER);

    // Toggle bit 1
    REGISTER ^= (1U << 1);
    printf("After toggling bit 1: 0x%02X\n", REGISTER);

    // Toggle bit 1 again
    REGISTER ^= (1U << 1);
    printf("After toggling bit 1 again: 0x%02X\n", REGISTER);

    // Check bit 0
    if (REGISTER & (1U << 0)) {
        printf("Bit 0 is ON\n");
    } else {
        printf("Bit 0 is OFF\n");
    }

    // Set bit 0
    REGISTER |= (1U << 0);
    printf("After setting bit 0: 0x%02X\n", REGISTER);

    // Check bit 0 again
    if (REGISTER & (1U << 0)) {
        printf("Bit 0 is ON\n");
    } else {
        printf("Bit 0 is OFF\n");
    }

    return 0;
}

Important Notes

Time complexity for bit manipulation operations is O(1) because they use simple bitwise operators.

Space complexity is O(1) as no extra memory is needed beyond the register variable.

A common mistake is forgetting to use parentheses around bit shifts, which can cause wrong results.

Use bit manipulation when you need fast, low-level control of hardware or flags. For complex data, consider other data structures.

Summary

Register bit manipulation lets you control hardware by changing specific bits.

Use bitwise operators: OR (|) to set, AND (&) with NOT (~) to clear, XOR (^) to toggle, and AND (&) to check bits.

Always count bits from 0 starting at the least significant bit.