Why would one create a volatile pointer? And suppose I want a volatile pointer which points to a volatile variable, which of the following declarations would accomplish this:
volatile int *pData;
or
volatile int * volatile pData;
Why would one create a volatile pointer?
Example: To access data whose pointer is updated by a background process.
Stuff * volatile VideoFrame;
for (;;) {
Block_Changes();
Stuff MyCopy = *VideoFrame;
Allow_Changes();
Use(&MyCopy);
}
I want a volatile pointer which points to a volatile variable, which of the following declarations would accomplish this:
The 2nd meets the goal. volatile int * volatile pData; is a:
pData as volatile pointer to volatile int
The 1st volatile int *pData; is a non-volatile pointer to volatile data:
pData as pointer to volatile int
The volitle keyword is most often used in this context. # Eugene Sh.
One reason to use the modifier `volatile' is so the compiler does not optimize the variable out of existence.
Another reason to use the modifier 'volatile' is so when ever the code references that variable, it accesses the actual variable and not the value left in some register.
Another reason to use the modifier 'volatile' is when the variable value can change outside the control of the current program. For instance a hardware register or when an 'interrupt' updates the variable that your application is reading.
Related
Clarification about terminology used:
For static array I mean array statically memory allocated like: int x[10].
The problem
I need to declare a static array with volatile elements.
If I well understood how volatile qualifier works, it should be:
volatile uint8_t *x; // x is a pointer to volatile uint8_t
uint8_t *volatile x; // x is a volatile pointer to uint8_t
volatile uint8_t *volatile x; // x is a volatile pointer to volatile uint8_t
Ok, but now I need to do the same thing with a static array.
I tried with:
volatile uint8_t x[10]; // Only the pointer is decleared as volatile
uint8_t volatile x[10]; // Same as above
volatile uint8_t *x3[10]; // Casting problems and errors when I do ...
*x3[0] = 1; // ... something like this. Moreover, I do not know if this...
// ... statement declares the uint8_t element as volatile
Thanks!
UPDATE
Ok, as highlighted in the comments I should use:
volatile uint8_t x[10]
As I could understand, the problem is not in the declaration but in the usage of this variable in my code. I pass this element to a function whose prototype is:
static void functionName(uint8_t *buffer, uint32_t size);
I call the function in this way:
functionName(x, 10);
The compiler reports: passing argument 1 of 'functionName' discards 'volatile' qualifier from pointer target type
I can't change the function prototype, how can I solve the problem?
What you have to do to declare a static array of 10 volatile elements of type uint8_tis just:
volatile uint8_t x[10];
Be aware that this is a declaration of an array, which has nothing to see with pointers at this step.
Note: Later in your code, if you use x, it may decay to a pointer to the first volatile element, but in this case this pointer will have a constant value, given at the linking step. The pointed value is obviously volatile.
Stumbled across the problem myself today.
A variable CAN be 'sometimes' volatile.
Being volatile means, that its value can changed outside the program flow. By a parallel thread or an ISR.
Now if the ISR is what changes the value 'unexpectedly', it won't change unexpectedly inside the ISR itself. So for the ISR, the variable is not volatile and disabling compiler optimizations for it is counterproductive.
If I call a function from inside the ISR (and only from there), then the variable is not volatile and I don't want to pass a pointer to volatile, as it would produce inefficient code.
For this case, the solution I found was to have two declarations:
int a[x] = {};
volatile int * b = a;
Now the outside world uses b (globally declared in the header file) and treats the values pointed to by b as volatile, while the ISR (locally) defines both and uses a, treating the values as being not volatile.
Well, this is a very special case. In general, a function only sees the function parameter declaration. Which is either volatile or not, so the funciton will treat a parameter either always as being volatile or always as being not. It cannot automatically switch between two maybe completely differently compiled code blocks depending on the original volatile qualifier state of the passed parameter. Hence the warning.
I'm writing simple code in C for STM32F0 discovery board. I'm generating different waveforms, according to external analog signal.
Declared global arrays with waveforms:
const uint32_t sinus[WAVELENGHTS] = {128,131,134,137,141,...}
const uint32_t square[WAVELENGHTS] = {0,0,0,0,0,0,0,0,0,0,...}
and pointer to array
const uint32_t (*currentWave)[WAVELENGHTS];
That pointer is used in timer irq to generate chosen waveform:
void TIM14_IRQHandler()
{
...
TIM2->CCR1 = (*currentWave)[(mainSynth.DDSAccumulator)>>24];
TIM14->SR &= ~(TIM_SR_CC1IF);
}
According to external value, in main loop I choose one of waveforms:
while(1) {
...
if(ADC_values[2] < 2048)
currentWave = &sinus;
else
currentWave = □
...
}
Without optimizations, currentWave value changes according to ADC_values[2] change (exactly: to TIM2->CCR1 are written values from good waveform, sinus or square), but enabling any optimization makes code working bad, it means assignment
currentWave = &sinus;
or
currentWave = □
never executes, currentWave always have initial value.
I also tried to declare both pointer and arrays as volatile, with no effect.
I need optimization for size to fit code in my device.
Any ideas?
I'm going to make a wild guess: you tried the volatile this way and it didn't work:
const volatile uint32_t (*currentWave)[WAVELENGHTS];
And that is to be expected, because this declaration makes volatile the uint32_t values of the array, not the pointer. And the pointer is what changes asynchronously.
Try instead:
const uint32_t (* volatile currentWave)[WAVELENGHTS];
And see what happens.
Note: if you find the syntax awkward, try with typedefs:
typedef const uint32_t waveform_t[WAVELENGHTS];
waveform_t *volatile currentWave;
You could even do:
typedef waveform_t *waveform_ptr;
volatile waveform_ptr currentWave;
but I find it excessive.
I guess you could try make the pointer volatile. Be sure not to just declare it a pointer to volatile uint32_t values, but to declare the pointer itself as volatile. My guess is that the compiler ignores it if the pointer itself is not volatile.
const volatile uint32_t *currentWave; <- "pointer" to "const volatile memory"
const uint32_t * volatile currentWave; <- "volatile pointer" to "const memory"
Also, I think there is no need for that extra indirection, you can just use a pointer, and assiging it like:
currentWave = sinus;
is perfectly valid, just as indexing it like
currentWave[(mainSynth.DDSAccumulator)>>24]
is valid C code.
How does one create an array of volatile structs? Each struct contains 3 function pointers.
i.e. is it
State_t * volatile states[10];
or
volatile State_t * states[10];
??
Also, should the struct properties be defined as volatile as well?
This is to ensure function pointers are not cleared by compiler. Code works fine when compiled with GCC. However, the second entry in the array returns rubbish compiled with the ARM compiler for Cortex-M3.
State_t *volatile states[10];
The above means states is an array of 10 volatile pointers to objects of type State_t. The volatile keyword here qualifies the pointers, not the value pointed to.
State_t volatile *states[10];
The above means states is an array of 10 pointers to objects of type volatile State_t. Here, the volatile keyword qualifies not the the pointer, but the value pointed to. The above can also be written as
volatile State_t *states[10];
To answer the latter part of your question, if you qualify a structure variable as volatile, then all its members are volatile. However, the volatile qualification is not part of the structure definition.
volatile struct states {
// stuff
} state_a;
struct states state_b;
Here, state_a is volatile qualified but state_b is not. Therefore, you need to qualify each states instance explicitly as volatile unless you create states instances in the same statement as the structure definition.
I vaguely remember that the order of the volatile keyword has influence on wether you want the pointer to the array to be volatile or the contents itself. If I want the content to be volatile, do I need to write:
volatile short Array[];
or
short volatile Array[3];
Either will do. It is the difference between
short volatile * ptr; /* pointer to volatile short */
and
short * volatile ptr; /* volatile pointer to short */
that matters.
const behaves the same way.
Both of them will work fine. Order of specifiers doesn't matter.
Read this answer for more detailed explanation.
volatile void * ptr;
Whether ptr is volatile or it points to the volatile location.
So the actual doubt is :
Is the same thing applied to the above declaration as it applied with const qualifier ?
Little explanation will help me a lot.
It's a pointer to volatile data. If the pointer itself should be volatile but not the data it points at, you'd use:
void * volatile ptr;
So yes, it works the same way as the const modifier.
A Microsoft explanation:
The volatile keyword specifies that the value associated with the name that follows can be modified by actions other than those in the user application.
The volatile keyword is useful for declaring objects in shared memory that can be accessed by multiple processes.
Both const and volatile are type qualifiers (they're the only type qualifiers in C, in fact). The syntax for using them is identical.