2017-07-06 2 views
0
#The recipe gives simple implementation of a Discrete Proportional-Integral-Derivative (PID) controller. PID controller gives output value for error between desired reference input and measurement feedback to minimize error value. 
#More information: http://en.wikipedia.org/wiki/PID_controller 
# 
#[email protected] 
# 
####### Example ######### 
# 
#p=PID(3.0,0.4,1.2) 
#p.setPoint(5.0) 
#while True: 
#  pid = p.update(measurement_value) 
# 
# 


class PID: 
    """ 
    Discrete PID control 
    """ 

    def __init__(self, P=2.0, I=0.0, D=1.0, Derivator=0, Integrator=0, Integrator_max=500, Integrator_min=-500): 

     self.Kp=P 
     self.Ki=I 
     self.Kd=D 
     self.Derivator=Derivator 
     self.Integrator=Integrator 
     self.Integrator_max=Integrator_max 
     self.Integrator_min=Integrator_min 

     self.set_point=0.0 
     self.error=0.0 

    def update(self,current_value): 
     """ 
     Calculate PID output value for given reference input and feedback 
     """ 

     self.error = self.set_point - current_value 

     self.P_value = self.Kp * self.error 
     self.D_value = self.Kd * (self.error - self.Derivator) 
     self.Derivator = self.error 

     self.Integrator = self.Integrator + self.error 

     if self.Integrator > self.Integrator_max: 
      self.Integrator = self.Integrator_max 
     elif self.Integrator < self.Integrator_min: 
      self.Integrator = self.Integrator_min 

     self.I_value = self.Integrator * self.Ki 

     PID = self.P_value + self.I_value + self.D_value 

     return PID 

    def setPoint(self,set_point): 
     """ 
     Initilize the setpoint of PID 
     """ 
     self.set_point = set_point 
     self.Integrator=0 
     self.Derivator=0 

    def setIntegrator(self, Integrator): 
     self.Integrator = Integrator 

    def setDerivator(self, Derivator): 
     self.Derivator = Derivator 

    def setKp(self,P): 
     self.Kp=P 

    def setKi(self,I): 
     self.Ki=I 

    def setKd(self,D): 
     self.Kd=D 

    def getPoint(self): 
     return self.set_point 

    def getError(self): 
     return self.error 

    def getIntegrator(self): 
     return self.Integrator 

    def getDerivator(self): 
     return self.Derivator 

Je souhaite utiliser ce code pour contrôler la température du réservoir avec de l'eau chaude. L'entrée est la température réelle de l'eau et la sortie doit être juste une information pour que le réchaud à gaz chauffe ou ne fasse rien (1 ou 0). Mais en exécutant ce fichier, je reçois la valeur pid. Par exemple, le point de consigne est de 20 degrés et la mesure de 15 degrés donne la réponse de 23 degrés. Maintenant, comment dois-je interpréter l'asnwer. Juste chauffer? jusqu'à la prochaine mesure? obviolsuly quand la température atteindra 20 degrés et au-dessus de la valeur de pid sera au-dessous de 0 i.e = -5. et obvolusly cela signifie arrêter le chauffage. Mais le résultat de sortie me donne-t-il quelque chose de plus que si 0 chaleur, si = < 0 ne chauffe pas.PID sur Rpi - interprétation du résultat

Répondre

0

Cela dépend vraiment de la façon dont vous voulez contrôler votre vanne de gaz? Certains utilisent des PID pour contrôler la proportion d'un cycle de service. Si votre réservoir est grand et lent à chauffer, vous pourriez vouloir quelque chose comme un feu de feu de 10 minutes/pas de feu avec le temps de feu limité entre 10 secondes et une combustion continue de 600 secondes, et ajusté par le PID.

Si vous le contrôliez à la main, à quelle vitesse voudriez-vous faire fonctionner la flamme en allumant et en éteignant la flamme? Et à quelle distance de la température cible commenceriez-vous à diminuer? Par exemple, si à pleine combustion, le réservoir augmente à 0.5C/minute et prend 10 minutes pour se stabiliser après l'avoir éteint, vous pouvez échantillonner/mettre à jour le PID toutes les 60 secondes et commencer à diminuer de 20 à 10 point de consigne. Pour cela, je prélèverais un échantillon lent (60 secondes?) Et j'utiliserais le PID pour prendre la décision du nombre de secondes d'allumage du feu pendant le cycle de combustion. Par exemple: dt = 60sec, kP = 60sec/10degC = 6s/degC_erreur, kI = 0,6 secondes/integrated_degC_error, kD = 0.