What is a good way to make static data in structs using C?

Question

I have these structs

typedef struct DeviceState_s {
    uint32_t Function_Type;
    uint8_t Left_Trigger;//byte [1]#9 left analog trigger
    uint8_t Right_Trigger;//byte [2]#10 right analog trigger
    uint8_t Buttons_1;//byte [3]#11 1----XY(1/Z) ..X and Y are the bits representing the buttons state (1 for unpress 0 for press) the last bit is z if the controller supports it.
    uint8_t Buttons_2;//byte [4]#12 PR PL PD PU start A B (1/C)  PR=pad right same for the rest and the bit marked as one is c if the controller supports it.
    uint8_t Analog_a1;//byte [5]#13 useless in original controller
    uint8_t Analog_a2;//byte [6]#14 useless in original controller
    uint8_t Analog_Y;//byte [7]#15 joystick Y axis movement
    uint8_t Analog_X;//byte [8]#16 joystick X axis movement

} DeviceState;

typedef struct DeviceStatus_s {
    uint32_t Function; 
    uint32_t DeviceID[3]; 
    uint8_t AreaCode; //1
    uint8_t ConnectorDirection; //1
    char ProductName[30];
    char ProductLicense[60];
    uint16_t StandbyPower; //2
    uint16_t MaxPower;  //2
} DeviceStatus;


typedef struct Status_FPacket_s {
    PacketHeader Header; //4
    DeviceStatus Status //112
} Status_FPacket;
static Status_FPacket Status_Packet; 

then I pulsate them later on. But There is no need to populate the Status each time, it's always the same. I thought maybe one was like so.

typedef struct Status_FPacket_s {
    PacketHeader Header; //4
    DeviceStatus Status //112
    = {
        .Function = FUNC_CONTROLLER,
        .DeviceID[0] = 0xffff06fe,
        .DeviceID[1] = 0x0000ffff,
        .DeviceID[2] = 0x00000000,
        .AreaCode = 0xff,
        .ConnectorDirection = 0,
        .ProductName =0,
        .ProductLicense  =0,
        .StandbyPower =  (430>>8) | (430<<8),
        .MaxPower =  (500>>8) | (500<<8),
    };

} Status_FPacket;

but that didn't work. Maybe I need to use my own type?

///////////adding AbeMonk's suggestion////////

typedef struct DeviceStatus_s {
    uint32_t Function; 
    uint32_t DeviceID[3]; 
    uint8_t AreaCode; //1
    uint8_t ConnectorDirection; //1
    char ProductName[30];
    char ProductLicense[60];
    uint16_t StandbyPower; //2
    uint16_t MaxPower;  //2
} DeviceStatus;

static DeviceStatus  controllerStatus =
{
    .Function=FUNC_CONTROLLER,
    .DeviceID[0]= 0xffff06fe,
    .DeviceID[1]= 0x0000ffff,
    .DeviceID[2] = 0x00000000,
    .AreaCode = 0xff,
    .ConnectorDirection = 0,
    .ProductName = "....";
    .ProductLicense "....";
    .StandbyPower =  (430>>8) | (430<<8),
    .MaxPower =  (500>>8) | (500<<8),
};

then just do this later

Status_Packet.Status = controllerStatus;

the things I use to set my strings are

strncpy(Status_Packet.Status.ProductName, "text here", sizeof(Status_Packet.Status.ProductName));

not sure how to do this without strncpy.

Answer 1

C is not an object oriented language. While structs in C can be used to group data, their functionality doesn't extend much beyond that - in other words, they don't provide nearly the level of functionality and abstraction that C++ classes, for instance, provide. However, this doesn't make it impossible to achieve - or at least get close to - a theoretical "static" struct member in C. Using pointers and global variables, it is possible to achieve something of the like:

First, you need to initialize a global variable:

DeviceStatus global_status
= {
    .Function = FUNC_CONTROLLER,
    .DeviceID[0] = 0xffff06fe,
    .DeviceID[1] = 0x0000ffff,
    .DeviceID[2] = 0x00000000,
    .AreaCode = 0xff,
    .ConnectorDirection = 0,
    .ProductName =0,
    .ProductLicense  =0,
    .StandbyPower =  (430>>8) | (430<<8),
    .MaxPower =  (500>>8) | (500<<8),
};

Then, in the struct implementation that will contain this "static" member, you would declare a pointer. This means that the global variable will not need to be copied across instances, and will change for all instances if modified by one:

typedef struct Status_FPacket_s {
   PacketHeader Header;
   DeviceStatus* Status; 
} Status_FPacket;

Of course, storing the address in the pointer will take up space (though significantly less than a copy by value). However, I cannot think of a way to avoid this (at least without the more obvious solution which is just to use the global variable directly in all situations where it is needed; however, I assume you would have already done this if it were adequate).

Now, all you need do is create a "constructor" (seeing as we're trying to emulate classes, in a sense) that will be called every time you initialize a Status_FPacket object:

Status_FPacket create_Status_FPacket() {
    Status_FPacket obj;
    obj.Status = &global_status;
    return obj;
}

Then when you want to initialize a Status_FPacket object:

Status_FPacket status_packet = create_Status_FPacket();

A slight possible modification

I'm aware that global variables are considered bad practice. There is one way around this, though there may be repurcussions I'm not aware of (I have tried it though, and it seems to work). You could create a static variable inside the "constructor" function like so:

Status_FPacket create_Status_FPacket() {
    static DeviceStatus global_status
    = {
       .Function = FUNC_CONTROLLER,
       .DeviceID[0] = 0xffff06fe,
       .DeviceID[1] = 0x0000ffff,
       .DeviceID[2] = 0x00000000,
       .AreaCode = 0xff,
       .ConnectorDirection = 0,
       .ProductName =0,
       .ProductLicense  =0,
       .StandbyPower =  (430>>8) | (430<<8),
       .MaxPower =  (500>>8) | (500<<8),
    };

    Status_FPacket obj;
    obj.Status = &global_status;
    return obj;
}

Static function variables in C are special - they retain their place in memory across all function calls and endure for the entire lifetime of the application. This means the static global_status variable will actually be the same instance every time the "constructor" is called.

Avoiding strcpy

As for your use of strcpy, this unnecessary overhead can be completely avoided. I assume you won't be internally modifying the values of productName and productLiscense once they are assigned one. In this case, you can declare them as constant char pointers instead of arrays, like so:

typedef struct DeviceStatus_s {
   uint32_t Function; 
   uint32_t DeviceID[3]; 
   uint8_t AreaCode; 
   uint8_t ConnectorDirection; 
   const char* ProductName;
   const char* ProductLicense;
   uint16_t StandbyPower; 
   uint16_t MaxPower; 
} DeviceStatus;

You will now be able to directly assign string literals to them using = since they are constant.