Union and struct usage in embedded C

Union and struct usage in embedded C

Union

O uniune este un tip de date special disponibil în C care permite stocarea diferitelor tipuri de date în aceeași locație de memorie. Puteți defini o uniune cu mai mulți membri, dar un singur membru poate conține o valoare la un moment dat. Union oferă un mod eficient de a utiliza aceeași locație de memorie în mai multe scopuri.

Pentru a defini o uniune, trebuie să utilizați declarația de uniune în același mod ca atunci când ați definit o structură. Declarația Union definește un nou tip de date cu mai mulți membri pentru programul dvs. Formatul declarației union este după cum urmează:  

 union UnionDefinition {      
   int Age;
   float Height;
   char Name[20];
  } union_tag;

Struct-ul

O structură este un tip de date definit de utilizator, disponibil în C, care permite combinarea elementelor de date de diferite tipuri. Structurile sunt folosite pentru a reprezenta o înregistrare.

Pentru a defini o structură, trebuie să utilizați instrucțiunea struct. Instrucțiunea struct definește un nou tip de date, cu mai mult sau egal cu un membru. Formatul instrucțiunii struct este după cum urmează: 

 struct StructDefinition {      
   int Age;
   float Height;
   char Name[20];
  } str_tag;

Avantajele structurii

• Structurile adună mai multe date despre același subiect împreună în același loc.
• Este util atunci când doriți să adunați date de tipuri de date și parametri similari, cum ar fi pentru o persoană numele, prenumele, vârsta etc.
• Este foarte ușor de întreținut, deoarece putem reprezenta întreaga înregistrare folosind un singur nume.
• În structură, putem trece un set complet de înregistrări către orice funcție folosind un singur parametru.
• Puteți utiliza o serie de structuri pentru a stoca mai multe înregistrări cu tipuri similare.

Avantajele union

• Ocupă mai puțină memorie în comparație cu structura.
• Când utilizați uniunea, numai ultima variabilă poate fi accesată direct.
• Uniunea este utilizată atunci când trebuie să utilizați aceeași locație de memorie pentru doi sau mai mulți membri ai datelor.
• Vă permite să păstrați datele unui singur membru de date.
• Spațiul alocat este egal cu dimensiunea maximă a membrului de date.

Dezavantaje ale structurii

• Dacă complexitatea proiectului IT depășește limita, devine greu de gestionat.
• Schimbarea unei structuri de date într-un cod necesită schimbări în multe alte locuri. Prin urmare, modificările devin greu de urmărit.
• Structura este mai lentă, deoarece necesită spațiu de stocare pentru toate datele.
• Puteți recupera orice membru la un moment dat în structură, în timp ce puteți accesa un membru la un moment dat în uniune.
• Struct-ul ocupă spațiu pentru fiecare membru scris în parametri interiori, în timp ce union-ul ocupă spațiu pentru un membru care are cea mai mare dimensiune scrisă în parametri interiori.
• Struct-ul suportă matrice flexibilă. Union-ul nu acceptă o matrice flexibilă.

Dezavantajele union

• Puteți folosi un singur membru al union odată.
• Toate variabilele din union nu pot fi inițializate sau utilizate cu valori diferite la un moment dat.
• Union atribuie un spațiu de stocare comun pentru toți membrii săi. 

 Documentatie: 

• https://www.geeksforgeeks.org
• https://www.guru99.com/difference-structure-union-c.html
  

Cod de test:

#include "stdio.h"
#include "stdlib.h"

typedef unsigned int uint32;
typedef unsigned short uint16;
typedef unsigned char uint8;

typedef union Register32bits /* uC configuration Register */
{
  uint32 R;
  struct
  {
    uint32 B0:1;
    uint32 B1:1;
    uint32 B2:1;
    uint32 B3:1;

    uint32 B4:1;
    uint32 B5:1;
    uint32 B6:1;
    uint32 B7:1;

    uint32 B8:1;
    uint32 B9:1;
    uint32 B10:1;
    uint32 B11:1;

    uint32 B12:1;
    uint32 B13:1;
    uint32 B14:1;
    uint32 B15:1;

    uint32 B16:1;
    uint32 B17:1;
    uint32 B18:1;
    uint32 B19:1;

    uint32 B20:1;
    uint32 B21:1;
    uint32 B22:1;
    uint32 B23:1;

    uint32 B24:1;
    uint32 B25:1;
    uint32 B26:1;
    uint32 B27:1;

    uint32 B28:1;
    uint32 B29:1;
    uint32 B30:1;
    uint32 B31:1;
  } B;
} Register32bits_tag;

typedef union RegisterCFG /* uC configuration Register */
{
  uint16 R;
  struct
  {
    uint16 B0:1;
    uint16 B1:1;
    uint16 B2:1;
    uint16 B3:1;

    uint16 B4:1;
    uint16 B5:1;
    uint16 B6:1;
    uint16 B7:1;

    uint16 B8:1;
    uint16 B9:1;
    uint16 B10:1;
    uint16 B11:1;

    uint16 B12:1;
    uint16 B13:1;
    uint16 B14:1;
    uint16 B15:1;
  } B;
} RegisterCFG_tag;

typedef union WorkRegister /* uC work Register */
{
  uint8 R;
  struct
  {
    uint8 B0:1;
    uint8 B1:1;
    uint8 B2:1;
    uint8 B3:1;

    uint8 B4:1;
    uint8 B5:1;
    uint8 B6:1;
    uint8 B7:1;
  } B;
} WorkRegister_tag;

Register32bits_tag Reg32; /* 32 bits register */
RegisterCFG_tag MCR;   /* Main Configuration Register - 16 bits  */
WorkRegister_tag WRKR; /* 8 bits work register*/

int main()
{
  uint16 register_MCR = 0U;
  uint8 register_MCR_Bit0=0U;

  WRKR.B.B0 =1;
  WRKR.B.B1 =1;

  printf("\nSizeof union WorkRegister_tag : %d\n", sizeof(WRKR));
  printf("\n WRKR.R : %d\n", WRKR.R);

  MCR.B.B0 =1;
  MCR.B.B14 =1;
  MCR.B.B15 =1;
  register_MCR= MCR.R;
  printf("\nSizeof union RegisterCFG_tag: %d\n", sizeof(MCR));
  printf("\n MCR.R : %d\n", MCR.R);

  Reg32.B.B3=1;
  printf("\nSizeof union Register32bits_tag: %d\n", sizeof(Reg32));
  printf("\n Reg32.R : %d\n", Reg32.R);

  return 0;
}

Progămelul de mai sus returnează:

  Sizeof union WorkRegister_tag : 1

 WRKR.R : 3

Sizeof union RegisterCFG_tag: 2

 MCR.R : 49153

Sizeof union Register32bits_tag: 4

 Reg32.R : 8
  
  

Pentru întrebari și/sau consultanță tehnică vă stau la dispozitie pe blog sau pe email simedruflorin@automatic-house.ro. O seară/zi plăcută tuturor !