PI negative controller output to unsigned duty cycle

Question

I am trying to implement a PI controller in C that outputs / controls a PWM's duty cycle on a microcontroller. The duty cycle that I can write to the certain PWM control register is limited to 10bit (values 0 - 1023 correspond to 0% - 100% duty cycle). My controllers output "Stell", that should correspond to a duty cycle, exceeds this bit limit due to calculations of the controlled values. Here is a simplified version of my controller function that is called regularely with a base clock:

void controller(void)
{
    int32_t stell_1, stell_2, stell; 
    int32_t Integral; 
    int16_t delta_e; 
    uint32_t DZSoll, DZIst; 
    uint16_t duty_cycle; 
    int32_t temp_duty_cycle; 
     
    //Error = Setpoint - actual_value
    delta_e = DZSoll - DZIst; 

    //PI controller
    stell_1 = delta_e * Kp; 
    Integral += delta_e; 
    stell_2 = Ki * Integral; 
    stell = stell_1 + stell_2; 

    //Max values 
    Max_S1 = Max_delta_e * Kp; 
    Max_S2 = (Max_delta_e + Integral) * Ki; 
    Max_Stell = Max_S1 + Max_S2; 

    //Scaling of the controller output to a 10bit duty cycle 
    temp_duty_cycle = stell<<10; //*1023
    duty_cycle = temp_duty_cycle / Max_Stell; 
    PWMUpdate(duty_cycle); 

    //...
}

Now, I thought that I would need to scale the controller output "Stell" to the desired 10bit "duty cycle" by setting them into a relation: duty_cycle/2^10 = Stell/Max_Stell (basically to receive the scaling factor). Nevertheless, this only works for positive values of "stell" as my duty cycle by definition has to be a positive value (uint16_t). In the case that my actual value "DZIst" is bigger that the setpoint "DZSoll" (for instance on a overshoot of the integral part of the PI controller), this results in a negative "Stell" which is then incorrectly calculated into a duty cycle. This is especially a problem on lower setpoints as the Integral value cannot compensate the negative control error.

So, my question is: Am I scaling "Stell" correctly to the 10bit duty cycle? Could I compensate the negative "Stell" values with an offset (and how?)? I would appreciate every help a lot, thank you in advance!

Answer 1

In the comments you've mentioned that the value ranges would be between 0 - 3500 for set point as well as for the Max_Stell, fix me if I got it wrong.
Anyhow, what you want to do can be achived by using linear interpolation since;

it is used to calculate data points within the range of a discrete set of known data points.

Let's say you wanna interpolate a range from -3500 to 3500 and the range of 10 bit value which is from 0 to 1023. Here is a graph from wiki to visualize the interpolation between 2 range of values: x0 - x1 and y0 - y1.

Well, it will make more sense when we assign values for Xs and Ys which would be as following:

y0 = -3500
y1 = 3500

x0 = 0
x1 = 1023

Let's assume that you calculated the Max_Stell as -1750 which corresponds the y point in the graph and we need to interpolate it to the 0 - 1023 range. Here we will calculate for x point value in order to find the corresponding value in the 0 - 1023 scale, so the formula is as following:
x = x0 + (y - y0) * (x1 - x0) / (y1 - y0)

Let's put the values and calculate what the corresponding value would be for -1750...

x = 0 + (-1750 - (-3500)) * (1023 - 0) / (3500 - (-3500))
x = 1750 * 1023 / 7000
x = 1,790,250 / 7000
x = 255.75

Now let's calculate it for the max value of y which is 3500 to see if it will correspond to max x value...

x = 0 + (3500 - (-3500)) * (1023 - 0) / (3500 - (-3500))
x = 7000 * 1023 / 7000
x = 7,161,000 / 7000
x = 1023 // Here we have it!

As you can see, you can convert any range of data points to another range using the handy interpolation. You can also interpolate vice versa using the following formula:
y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

Let's do it for the max value of duty cycle to prove it. x is 1023 in this case and we calculate for the corresponding y value...

y = -3500 + (1023 - 0) * (3500 - (-3500)) / (1023 - 0)
y = -3500 + 1023 * 7000 / 1023
y = -3500 + 7,161,000 / 1023
y = -3500 + 7000
y = 3500

Now that you have the idea on how to convert any range of values, you can translate it to the language of your specific microcontroller. But I wanna warn you about something:
If you will interpolate very frequently, this calculations will consume too many CPU cycles especially if you use an 8 bit PIC16 micro which has neither hardware multiplier nor hardware divider.

You should also choose between precision and speed when you implement the interpolator function. If you choose precision you need to calculate values with float type variables and trade-off the speed or vice versa.