🔧 Bitwise Essentials for Firmware: Macros, Flags, and Bit Spreading

Clean bit-twiddling is a reliability feature. Small helpers + predictable patterns beat ad-hoc shifts every time. Here are three tight patterns you’ll reuse everywhere.

🧷 Maintainable Bit Macros + Ordered Ops (Set 2&7, Clear 3, Toggle 5)

Goal: modify an 8-bit register with readable, testable macros.

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

#define BIT(b)            (1u << (b))
#define SET_BIT8(r,b)     ((r) = (uint8_t)((r) |  (uint8_t)BIT(b)))
#define CLEAR_BIT8(r,b)   ((r) = (uint8_t)((r) & (uint8_t)~BIT(b)))
#define TOGGLE_BIT8(r,b)  ((r) = (uint8_t)((r) ^  (uint8_t)BIT(b)))

static inline uint8_t modify_register(uint8_t reg) {
    SET_BIT8(reg, 2);     // set 2
    SET_BIT8(reg, 7);     // set 7
    CLEAR_BIT8(reg, 3);   // clear 3
    TOGGLE_BIT8(reg, 5);  // toggle 5
    return reg;
}

int main(void) {
    uint8_t reg;
    scanf("%hhu", &reg);
    printf("%u", modify_register(reg));
    return 0;
}

Notes: BIT(b) is unsigned; casts clamp to 8-bit. For dynamic positions, ensure b < 8.

🏷️ Decode Status Register → Human-Readable Flags (LSB→MSB)

Goal: map bits to names and print only enabled ones.

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

static const char * const flag_names[8] = {
    "Power On","Error","Tx Ready","Rx Ready",
    "Overheat","Undervoltage","Timeout","Reserved"
};

static void decode_status(uint8_t status_reg) {
    for (int i = 0; i < 8; ++i)
        if ((status_reg >> i) & 1u)
            printf("%s\n", flag_names[i]);
}

int main(void) {
    uint8_t reg;
    scanf("%hhu", &reg);
    decode_status(reg);
    return 0;
}

Why this style: LUT keeps meanings centralized; LSB→MSB aligns with datasheets.

🧩 Bit Spreading (Interleave Zeros): 8→16 with Even-Bit Placement

Goal: place each input bit at even positions (0,2,4,…) with zeros in odd positions.

Fast “dilate bits” version (branchless)

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

static inline uint16_t spread_bits(uint8_t x) {
    uint16_t v = x;
    v = (v | (v << 4)) & 0x0F0F;
    v = (v | (v << 2)) & 0x3333;
    v = (v | (v << 1)) & 0x5555;
    return v;
}

int main(void) {
    uint8_t val;
    scanf("%hhu", &val);
    printf("%u", spread_bits(val));
    return 0;
}

Why it’s useful: display pipelines, Morton/Z-order, IO packing, DSP simulators.

🧊 Myth vs Truth

• Myth: “Bit hacks are unreadable.”

• Truth: Small, named helpers + LUTs are clearer and safer than ad-hoc shifts.

• 
  

🔌 Embedded Relevance

• Stable macros reduce register bugs.

• Flag decoding documents behavior (that won’t rot).

• Bit spreading appears in protocols, graphics, and indexing.

• 
  

✅ Conclusion

Treat bit ops like APIs: clear names, tight scopes, and deterministic patterns. You’ll get safer register code, self-documenting status handling, and reusable transforms that scale.

Written By: Musaab Taha

This article was improved with the assistance of AI.