Trường bit cho thanh ghi

#include <stdint.h>

typedef union {
    uint32_t raw;                     /* truy cập cả thanh ghi */

    struct {
        uint32_t enable    : 1;       /* bit 0 */
        uint32_t mode      : 3;       /* bit [3:1] */
        uint32_t reserved0 : 4;       /* bit [7:4] */
        uint32_t prescaler : 8;       /* bit [15:8] */
        uint32_t           : 16;      /* trường vô danh, phần còn lại */
    } bits;
} CtrlReg;

static volatile CtrlReg *TIM_CR = (volatile CtrlReg *)0x40000000UL;

/* Dùng: */
TIM_CR->bits.enable    = 1u;
TIM_CR->bits.mode      = 3u;
TIM_CR->bits.prescaler = 72u;

uint32_t ca_thanh_ghi = TIM_CR->raw;

typedef union {
    volatile uint32_t raw;

    struct {
        uint32_t a : 8;
        uint32_t b : 8;
        uint32_t c : 8;
        uint32_t d : 8;
    } bits;
} Reg;

static volatile Reg *R = (volatile Reg *)0x40000000UL;

void dat_b(void)
{
    R->bits.b = 0x5Au;
}

/* Cách 1: đọc cả thanh ghi vào biến TẠM không volatile,
   sửa trường bit trên biến tạm, rồi ghi cả thanh ghi. */
void dat_b_an_toan(void)
{
    Reg tam;

    tam.raw = R->raw;              /* một lệnh đọc 32 bit */
    tam.bits.b = 0x5Au;            /* sửa trên RAM, không phải thanh ghi */
    R->raw = tam.raw;              /* một lệnh ghi 32 bit */
}

/* Cách 2: bỏ hẳn trường bit, dùng mặt nạ như Bài 48.1. */
void dat_b_mat_na(void)
{
    uint32_t r = R->raw;

    r &= ~(0xFFu << 8);
    r |=  (0x5Au << 8);

    R->raw = r;
}

/* Trường bit rất hợp cho cấu trúc dữ liệu NỘI BỘ của bạn,
   nơi bố cục không cần khớp với thứ gì bên ngoài. */
typedef struct {
    uint16_t nhiet_do;                /* nhân 10, tức 253 là 25.3 độ */

    unsigned int  co_loi        : 1;
    unsigned int  dang_do       : 1;
    unsigned int  che_do        : 2;
    unsigned int  so_lan_thu    : 3;
    unsigned int                : 1;  /* đệm cho tròn byte */
} TrangThaiCamBien;

/* sizeof là 4 byte thay vì 8 nếu dùng năm biến uint8_t riêng.
   Trên chip 4 KB RAM với một trăm cảm biến, đó là 400 byte tiết kiệm. */

#include <stdint.h>

/* Giữ được sự tiện lợi của trường bit mà không có rủi ro:
   một struct THƯỜNG không volatile để tính toán,
   cộng hai hàm chuyển đổi qua lại với giá trị thô. */

typedef struct {
    uint8_t enable;
    uint8_t mode;
    uint8_t prescaler;
} TimCauHinh;

static inline uint32_t tim_dong_goi(const TimCauHinh *c)
{
    return ((uint32_t)(c->enable    & 0x01u) << 0)
         | ((uint32_t)(c->mode      & 0x07u) << 1)
         | ((uint32_t)(c->prescaler & 0xFFu) << 8);
}

static inline TimCauHinh tim_thao_goi(uint32_t raw)
{
    TimCauHinh c;

    c.enable    = (uint8_t)((raw >> 0) & 0x01u);
    c.mode      = (uint8_t)((raw >> 1) & 0x07u);
    c.prescaler = (uint8_t)((raw >> 8) & 0xFFu);

    return c;
}

/* Dùng: */
TimCauHinh c = tim_thao_goi(TIM3->CR1);

c.prescaler = 72u;
c.enable    = 1u;

TIM3->CR1 = tim_dong_goi(&c);      /* MỘT lệnh ghi 32 bit */