How to Use Bit Fields for Register Access in Embedded C

In embedded C, use struct with unsigned int members and specify their bit widths to create bit fields that map to hardware register bits. This allows easy and readable access to individual bits or groups of bits within a register.

Syntax

Define a struct with unsigned int members followed by a colon and the number of bits they occupy. Each member represents a bit or group of bits in the register.

• unsigned int field_name : bit_width; declares a bit field.
• The total bits should match the register size (usually 8, 16, or 32 bits).
• Use volatile if the register can change outside program control.

c

typedef struct {
    volatile unsigned int bit0 : 1;
    volatile unsigned int bit1 : 1;
    volatile unsigned int bits2_3 : 2;
    volatile unsigned int reserved : 4;
} RegisterBits;

Example

This example shows how to define a register with bit fields and set or read individual bits easily.

c

#include <stdio.h>

// Simulate a hardware register as an 8-bit unsigned char
volatile unsigned char REG = 0;

// Define bit fields matching the register bits
typedef struct {
    unsigned char bit0 : 1;
    unsigned char bit1 : 1;
    unsigned char bits2_3 : 2;
    unsigned char reserved : 4;
} RegisterBits;

int main() {
    // Create a pointer to the register bits
    RegisterBits *regBits = (RegisterBits *)&REG;

    // Set bit0 and bits2_3
    regBits->bit0 = 1;
    regBits->bits2_3 = 3; // binary 11

    // Print the whole register value
    printf("Register value: 0x%02X\n", REG);

    // Read individual bits
    printf("bit0 = %u\n", regBits->bit0);
    printf("bit1 = %u\n", regBits->bit1);
    printf("bits2_3 = %u\n", regBits->bits2_3);

    return 0;
}

Output

Register value: 0x0D
bit0 = 1
bit1 = 0
bits2_3 = 3

Common Pitfalls

• Bit field order and packing: Bit field layout depends on compiler and platform, so it may not match hardware exactly.
• Use volatile keyword: Always mark hardware registers as volatile to prevent compiler optimizations that break access.
• Do not assume bit field size: The size of the underlying type can vary; use fixed-width types if possible.
• Accessing multi-bit fields: Be careful when assigning values to multi-bit fields to avoid overflow.

c

/* Wrong: Missing volatile and assuming bit order */
typedef struct {
    unsigned int bit0 : 1;
    unsigned int bit1 : 1;
} RegBitsWrong;

/* Correct: Use volatile and check compiler docs for bit order */
typedef struct {
    volatile unsigned int bit0 : 1;
    volatile unsigned int bit1 : 1;
} RegBitsCorrect;

Quick Reference

• Use struct with unsigned int and bit widths to map register bits.
• Mark registers volatile to avoid optimization issues.
• Check your compiler's bit field layout and packing rules.
• Use pointers to overlay bit fields on hardware register addresses.
• Test bit field access carefully on your target hardware.

Key Takeaways

Use struct with bit fields to access individual bits in hardware registers clearly.

Always declare hardware register bit fields as volatile to prevent unwanted compiler optimizations.

Bit field layout can vary by compiler; verify your compiler's behavior for correct mapping.

Overlay bit field structs on register addresses using pointers for direct bit manipulation.

Be cautious with multi-bit fields and ensure values fit within the specified bit width.