I need the variables in a struct to be volatile because they're being used in interrupts.
Right now I have:
struct signalDataGroup {
volatile short voltage;
volatile float current;
};
signalDataGroup currSignalData = {0, 0.0};
But if I did this instead:
struct signalDataGroup {
short voltage;
float current;
};
volatile signalDataGroup currSignalData = {0, 0.0};
would it make all parts of currSignaldata volatile?
Which way would you recommend?
If you declare the struct volatile, all members are volatile, which may or not be what you want. In some instances, you may wish only certain elements to be volatile, allowing the compiler to optimize the unused elements, in which case you can declare members volatile separately.
Case 1) volatile struct A{}
struct A will be volatile
Case 2) struct B{}
struct B some_variable will not be volatile
volatile struct B some_other_variable will be volatile
Case 3) struct C{
int D;
volatile int E;
}
.D is not volatile
.E is volatile
In the first example, 2 members of the struct are volatile for EVERY instance of the struct. As there are no other members, it would be the same as putting the keyword in the first line
volatile struct signalDataGroup {
In the second example, you can have instances of signalDataGroup that can be optimized, but the instance currSignalData cannot be. Just remember you are qualifying the TYPE and not the variable. Also, since you have variables that are larger than 8 bits, you will want to turn off global interrupts when accessing them outside of the interrupt where they are updated, to avoid any rollover bugs should an interrupt occur between reading the Hbyte of voltage and the Lbyte, for example.