How to make a variable volatile in main loop but not in IR handler

Ok so there are many things here which need improvement and apart from being slow, this looks like it have lots of race condition bugs all over it too.

• The ADC interrupt should not result in something that's immediately placed into some double complex mathematical model. Rather, the ISR should notify the ADC driver that a new value is available. Which is just a volatile uint32_t or similar, together with a volatile bool new_value.
• Only the ADC driver communicates with the ADC interrupt. You may have to temporarily disable the interrupt during variable reads to prevent race conditions, since atomic access isn't guaranteed in this case.
• Your application logic calls the ADC driver and asks for a new value. Then it gets a plain old uint32_t which is a copy of the last stored volatile value.
• Now your application logic can start chewing through all manner of slow math, complex numbers etc etc.

Unrelated to that need of complete re-design, making individual struct members const and/or volatile is often questionable and it should usually be the whole struct that got the const or volatile qualifier.

General good practice in embedded real-time systems is also not to hardcopy big chunks of data ever, but especially not from inside an ISR. So rather than passing around this big struct by value all over the place and making copies of it during run-time, you could use two or more pointers to struct and just swapped where they point at. So that the ISR works with one data set and the main program with another, aka double/triple buffering. This also minimizes the time where your race condition protection is up, since swapping pointers goes much faster than swapping whole chunks of memory.

What makes an access volatile is the qualifier on the lvalue, not in the original object definition. C 2024 5.2.2.4 says:

An access to an object through the use of an lvalue of volatile-qualified type is a volatile access.

Further, an unqualified object may be accessed through a qualified lvalue. So, you can define the object without volatile and use it in the interrupt routine:

unsigned foo;

void InterruptRoutine(/* ... */)
{
    // Use foo.
}

and use it with volatile elsewhere:

#define vfoo (* (volatile unsigned *) &foo)

void RegularRoutine(/*...*/)
{
    // Use vfoo.
}

One might even use foo for the macro name:

#define foo (* (volatile unsigned *) &foo)

That works since a macro name that appears in its own replacement list is not replaced again, and it helps guard against inadvertent use of foo in the regular routines.

(This answer only asserts those will work according to C standard. This answer does not speak to whether it is a good idea to do these things.)

The interrupt handler fragment you showed writes to a volatile variable and then immediately read back from it (and others) in order to compute a value to be written to yet another volatile.

// Writes to state.v_in.
state.v_in = new_x + new_y*I;
// Reads back from state.v_in (and others):
state.z_ratio = -state.v_sens / (state.v_in/z1 + state.v_ref/z2);

That's costly, of course, since the volatile qualifier requires the values be reloaded from memory every time.

Try computing all of the updated state values in non-volatile variables, and then write to the volatile ones just once at the of the handler:

double complex updated_v_in = new_x + new_y*I;
double complex updated_z_ratio =
    -updated_v_sens / (updated_v_in/z1 + updated_v_ref/z2);
// ...
state.v_in = updated_v_in;
state.z_ratio = updated_z_ratio;
// ...
return;

Another way to do this would be to define the State_s without the volatile qualifiers. Have the mainline code access the state through a volatile pointer

I see OP's approach as weak, unreliable and so suggest a larger change.

Consider an architecture shift

With "I oversample and average", all the ISR should do is get the ADC value, sum the results, get out.

Defer significant data processing to the main loop, especially any floating point math.

// Concept pseudo code

volatile struct sum_count {
  uint32_t sum;
  uint16_t count;
} adc;

// Get in, do little, get out
void ISR_ADC(void) {
  uint16_t sample = ADC_read();
  ADC_Setup_for_next_sample(); 
  adc.sum += sample;
  adc.count++;
}

// Called by the main loop.
sum_count ADC_GetSample(void) {
  sum_count sc;

  // Keep this quick.
  state = save_interrupt_state();
  disable_isr();  // Or disable just the ADC ISR.
  sc = adc;
  adc.sum = 0;
  adc.count = 0;
  restore_interrupt_state(state);

  // Now we can take our time.

  // Maybe do more complex data processing here and instead return another type.

  return sc;
}