Ggtcf

I am implementing PID control using the standard libraries of the Teensy Atmega32u4. My control variable is PWM signal. My process variable is the current angular position of a DC motor that is interfaced with a 10kohm potentiometer with code that reads position ADC input on a scale of 0 to 270 degrees. The set point is a laser cut joystick whose handle is also attached to a 10kohm potentiometer that reads angular position in the same manner as the process variable.

My question is how to implement the integral portion of the control scheme. The integral term is given by:

Error = Set Point – Process Variable

Integral = Integral + Error

Control Variable = (Kp * Error) + (Ki * Integral)

But I am unsure as to how to calculate the integral portion. Do we need to account for the amount of time that has passed between samples or just the accumulated error and initialize the integral portion to zero, such that it is truly discretized? Since I'm using C, the Integral term can just be a global variable?

Am I on the right track?

Since Sample time (time after which PID is calculated) is always the same it does not matter whether u divide the integral term with sample time as this sample time will just act as a Ki constant but it is better to divide the integral term by sample time so that if u change the sample time the PID change with the sample time but it is not compulsory.

Here is the PID_Calc function I wrote for my Drone Robotics competition in python. Ignore "[index]" that was an array made by me to make my code generic.

def pid_calculator(self, index):

 #calculate current residual error, the drone will reach the desired point when this become zero
 self.Current_error[index] = self.setpoint[index] - self.drone_position[index] 

 #calculating values req for finding P,I,D terms. looptime is the time Sample_Time(dt).
 self.errors_sum[index] = self.errors_sum[index] + self.Current_error[index] * self.loop_time 
 self.errDiff = (self.Current_error[index] - self.previous_error[index]) / self.loop_time

 #calculating individual controller terms - P, I, D.
 self.Proportional_term = self.Kp[index] * self.Current_error[index]
 self.Derivative_term = self.Kd[index] * self.errDiff
 self.Intergral_term = self.Ki[index] * self.errors_sum[index] 

 #computing pid by adding all indiviual terms
 self.Computed_pid = self.Proportional_term + self.Derivative_term + self.Intergral_term 

 #storing current error in previous error after calculation so that it become previous error next time
 self.previous_error[index] = self.Current_error[index]

 #returning Computed pid
 return self.Computed_pid

Here if the link to my whole PID script in git hub.
See if that help u.
Press the up button ig=f u like the answer and do star my Github repository i u like the script in github.
Thank you.

To add to previous answer, also consider the case of integral wind up in your code. There should be some mechanism to reset the integral term, if a windup occurs. Also select the largest available datatype to keep the integram(sum) term, to avoid integral overflow (typically long long). Also take care of integral overflow.

If you are selecting a sufficiently high sampling frequency, division can be avoided to reduce the computation involved. However, if you want to experiment with the sampling time, keep the sampling time in multiples of powers of two, so that the division can be accomplished through shift operations. For example, assume the sampling times selected be 100ms, 50ms, 25ms, 12.5ms. Then the dividing factors can be 1, 1<<1, 1<<2, 1<<4.

It is convenient to keep all the associated variables of the PID controller in a single struct, and then use this struct as parameters in functions operating on that PID. This way, the code will be modular, and many PID loops can simultaneously operate on the microcontroller, using the same code and just different instances of the struct. This approach is especially useful in large robotics projects, where you have many loops to control using a single CPU.