在结构中使用union的目的是什么？

Question

I'm currently struggling with uart snippet codes from embedded UART program.

Then I came across what I can't undersatnd when I analysing code.

Q1. In case of using "union" in "struct". what is the benefit and what purpose to use like this?

#define     __IO    volatile   

typedef struct {
  union {
  __IO  uint32_t RR;
  __IO  uint32_t TR;
  __IO  uint32_t DL;
  __IO  uint32_t RR_TR_DL;
  };
  union {
  __IO  uint32_t DH;
  __IO  uint32_t IR;  
  __IO  uint32_t DH_IER;
  };
} UART_TypeDef;

Q2. In case of using "union" in "struct" in "struct". what is the benefit and what purpose to use like this?

typedef struct {
  union {
  struct{
    __IO   uint32_t CTRLR0; 
    __IO   uint32_t SSI_COMP_VERSION;  
    union {
    __IO   uint32_t DR;              
    __IO   uint32_t DR0;            
    };
    __IO   uint32_t DR1;            
    __IO   uint32_t RSVD_2;       
  };
  uint8_t RESERVED[0x1000];     
  };
} SSI_TypeDef;

Answer 1

The first case is basically "aliasing" of the field names. The UART_TypeDef type consists of two uint32_t fields, the first which can be referred to as any of RR , TR , DL or RR_TR_DL . Ditto for the second field, which can be DH , IR or DH_IER .

The second case, SSI_TypeDef , is similar in respect to the inner unions, consisting of three uint32_t fields, CTRLR0/SSI_COMP_VERSION , DR/DR0 and DR1/RSVD_2 (in all cases, either name can be used for the fields).

But the structure as a whole is sized at 4K, due to the unioning with uint8_t RESERVED[0x1000] .

---

The aliasing is useful if, for example, the same underlying field can be accessed as either RR or TR , depending on context. For example, a device may have different behaviour depending on whether you read or write the location.

Say, for example, that you write to a given address (a memory mapped I/O operation) to indicate to the other end that you are read-ready (able to receive data). Further assume that reading that exact same location will let you know whether you're able to transmit.

First, let's set up said memory mapped I/O address (say it's at 0xf000 ):

UART_TypeDef *utd = (UART_TypeDef *)0xf000; // very shifty :-)

Now both these statement refer to the same memory address:

int transmitReady = utd->TR; // Can I transmit?
utd->RR = 1;                 // Tell other end it can send.

Being able to use distinct names for the same underlying thing can aid readability.