Why bitwise operations are essential in embedded in Embedded C

Introduction

Bitwise operations let you work directly with individual bits. This is very useful in embedded systems where memory and speed are limited.

Setting or clearing a specific hardware control bit in a register.

Checking the status of a sensor by reading a single bit.

Packing multiple small values into one byte to save memory.

Creating flags to track multiple states efficiently.

Performing fast arithmetic or logic operations on bits.

Syntax

Embedded C

/* Example of bitwise operations in embedded C */
#include <stdint.h>

// Define a register as an 8-bit unsigned integer
uint8_t register_value = 0b00001111;

// Set bit 7
register_value |= (1 << 7);

// Clear bit 3
register_value &= ~(1 << 3);

// Toggle bit 0
register_value ^= (1 << 0);

// Check if bit 2 is set
if (register_value & (1 << 2)) {
    // bit 2 is set
}

Note 1: Bitwise operators work on bits, not whole numbers.

Note 2: Shifting (<<, >>) moves bits left or right, useful for setting or checking specific bits.

Examples

Setting bit 0 when register is empty sets the first bit to 1.

Embedded C

uint8_t register_value = 0b00000000;
// Set bit 0
register_value |= (1 << 0);

Clearing bit 7 when all bits are 1 turns off the highest bit.

Embedded C

uint8_t register_value = 0b11111111;
// Clear bit 7
register_value &= ~(1 << 7);

Toggling bit 3 flips it from 1 to 0.

Embedded C

uint8_t register_value = 0b00001000;
// Toggle bit 3
register_value ^= (1 << 3);

Checking bit 2 returns true because bit 2 is 1.

Embedded C

uint8_t register_value = 0b00000100;
// Check bit 2
if (register_value & (1 << 2)) {
    // bit 2 is set
}

Sample Program

This program shows how to set, clear, toggle, and check bits in a control register. It prints the register value after each operation.

Embedded C

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

int main() {
    uint8_t control_register = 0b00000000;

    printf("Initial control register: 0x%02X\n", control_register);

    // Set bit 5 to enable a feature
    control_register |= (1 << 5);
    printf("After setting bit 5: 0x%02X\n", control_register);

    // Clear bit 5 to disable the feature
    control_register &= ~(1 << 5);
    printf("After clearing bit 5: 0x%02X\n", control_register);

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

    // Check if bit 0 is set
    if (control_register & (1 << 0)) {
        printf("Bit 0 is set.\n");
    } else {
        printf("Bit 0 is not set.\n");
    }

    return 0;
}

Important Notes

Time complexity of bitwise operations is O(1) because they work directly on bits.

Space complexity is O(1) as no extra memory is needed.

Common mistake: forgetting to use parentheses around bit shifts can cause wrong results.

Use bitwise operations when you need fast, low-level control of hardware or memory.

Summary

Bitwise operations let you control individual bits efficiently.

They are essential in embedded systems for hardware control and saving memory.

Common operations include setting, clearing, toggling, and checking bits.