Bit Mask Generator

Understanding Bit Masks and Bitwise Operations

Bit masks are fundamental tools in computer programming and digital systems, providing precise control over individual bits within binary data. A bit mask is a binary pattern used to selectively modify, extract, or test specific bits in a value through bitwise operations. These techniques are essential in hardware programming, embedded systems, graphics processing, network protocols, and performance-critical applications. Understanding bit masking enables efficient data manipulation, flag management, and low-level system programming. Modern processors are optimized for bitwise operations, making bit masks not only powerful but also extremely fast tools for data processing and control.

Fundamental Bit Masking Concepts

Real-World Applications

// Set pin 3 as output, others unchanged
gpio_direction |= (1 << 3);

// Clear pin 5, others unchanged  
gpio_output &= ~(1 << 5);

// Toggle pin 7
gpio_output ^= (1 << 7);

// Extract network portion of IP
network = ip_address & subnet_mask;

// Check if IP is in subnet
if ((ip & mask) == (subnet & mask)) {
    // IP is in this subnet
}

Advanced Bit Masking Techniques

// Create mask for bits start to end
mask = ((1 << (end - start + 1)) - 1) << start;

// Example: bits 3-6
// (1 << 4) - 1 = 15 = 0x0F
// 0x0F << 3 = 0x78 = 01111000

// Create mask for single bit n
mask = 1 << n;

// Check if number is power of 2
is_power_of_2 = (n & (n - 1)) == 0;

// Pack RGB values into single 32-bit integer
// Format: AARRGGBB (Alpha, Red, Green, Blue)
uint32_t pack_color(uint8_t a, uint8_t r, uint8_t g, uint8_t b) {
    return (a << 24) | (r << 16) | (g << 8) | b;
}

// Extract individual components
uint8_t get_alpha(uint32_t color) { return (color >> 24) & 0xFF; }
uint8_t get_red(uint32_t color)   { return (color >> 16) & 0xFF; }
uint8_t get_green(uint32_t color) { return (color >> 8)  & 0xFF; }
uint8_t get_blue(uint32_t color)  { return color & 0xFF; }

Performance and Optimization

Common Programming Patterns

// Define flags
#define FLAG_ACTIVE    0x01
#define FLAG_VISIBLE   0x02
#define FLAG_ENABLED   0x04
#define FLAG_SELECTED  0x08

// Set flags
flags |= FLAG_ACTIVE | FLAG_VISIBLE;

// Clear flags
flags &= ~(FLAG_ENABLED | FLAG_SELECTED);

// Test flags
if (flags & FLAG_ACTIVE) {
    // Handle active state
}

// Toggle flag
flags ^= FLAG_VISIBLE;

enum class Flags : uint32_t {
    Active   = 1 << 0,
    Visible  = 1 << 1,
    Enabled  = 1 << 2,
    Selected = 1 << 3
};

// Bitwise operators for enum class
constexpr Flags operator|(Flags a, Flags b) {
    return static_cast<Flags>(
        static_cast<uint32_t>(a) | 
        static_cast<uint32_t>(b)
    );
}

// Usage
auto flags = Flags::Active | Flags::Visible;

// Fast modulo for powers of 2
result = value & (power_of_2 - 1);

// Swap two variables without temp
a ^= b; b ^= a; a ^= b;

// Check if two numbers have opposite signs
bool opposite_signs = (a ^ b) < 0;

// Round up to next power of 2
uint32_t next_power_of_2(uint32_t n) {
    n--;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    return n + 1;
}

Learning Resources and Practice