BASCOM AVR PID-Regler

[Franz Vida (Gast)]

Hallo,
hat jemand Erfahrung mit PID-Regler unter BASCOM AVR? Kann mir jemand
einen Tip geben, wo ich suche soll oder gar ein Programmbespiel?
Habe bis jetzt nur das Buch Büttner, digitale Regelungen gefunden

[HansHans (Gast)]

www.mcselec.com/an_109.htm

Aber nicht von mir getestet
Gruß HH

[Leszek Cielecki (Gast)]

I am looking for some exampl of software for PID regulator on 
microcntroller AVR  for motor or temperatur.

[déjà vu (Gast)]

"AVR221: Discrete PID controller"
http://atmel.com/dyn/products/app_notes.asp?family_id=607

http://www.roboternetz.de/wissen/index.php/Regelungstechnik

[M.A.N (Gast)]

$regfile = "m8535.dat"

' -----[ Program Description 
]--------------------------------------------------
'
' This program implements an PID algorithm in BASCOM
'
' This File is partialy based on a program from ?????? and
' I do not intent to touch any of his rights !!!
' So for correct use of his copyrights please inform as marked below!
' ?????????
'
'
' -----[ Disclaimer 
]-----------------------------------------------------------
'
' This example is offered on an "AS IS" basis, no warranty expressed or 
implied.
' The programers disclaim liability of any damages associated with the 
use of
' the hardware or software described herein. You use it on your own 
risk.
' I'm not able to provide any free support.
'
' Copyright (c) 2001 Mike Eitel all rights reserved
'
' -----[ Revision History 
]-----------------------------------------------------
'
' 060529 - Version AVRPID Ver .95    Basic PID functionality   Mike 
Eitel
'
' -----[ Aliases 
]--------------------------------------------------------------
$sim                                                        ' Helps 
testing in a simulation
' -----[ Constant 
]-------------------------------------------------------------

' -----[ Variables 
]------------------------------------------------------------
   Dim Auto_mode As Bit                                     ' Regulator 
on ?
   Dim Manual_value As Single                               ' Output if 
not regulating

   Dim Sp As Single                                         ' Setpoint
   Dim Pv As Single                                         ' Process 
Value
   Dim Cv As Single                                         ' PID output

   Dim First_execution As Byte                              ' First 
start recognition
   Dim Initial_error As Single                              ' Startup 
difference

   Dim A As Byte                                            ' Tmp for 
random
   Dim B As Single                                          ' Tmp for 
random


' -----[ Start of program 
]-----------------------------------------------------
' -----[ Start of program 
]-----------------------------------------------------
' -----[ Start of program 
]-----------------------------------------------------

   Auto_mode = 1                                            ' Permanent 
running choosen
   First_execution = 0                                      ' Set 
permanent running algorithm
   Manual_value = 40                                        ' Output if 
not regulating = on
   Sp = 37                                                  ' Value to 
aim to

Cyclic:
' -----[ Start of endless running program 
]-------------------------------------
   Waitms 50                                                ' PID must 
run deterministic
                                                  ' time slices
   Gosub Regulator                                          ' Call the 
PID allgorithm
   Gosub Object                                             ' Call the 
simulated outer loop
Goto Cyclic

   ' -----[ End of endless running program 
]------------------------------------
   ' -----[ End of endless running program 
]------------------------------------
   ' -----[ End of endless running program 
]------------------------------------


   ' 
------------------------------------------------------------------------ 
---
   ' -----------------------------[ Subroutines 
]-------------------------------
   ' 
------------------------------------------------------------------------ 
---
Object:
   ' -----[ Start of simulated regulation loop 
]--------------------------------
    Pv = Pv + Cv                                            ' linear 
function used

    If Pv = Sp Then                                         ' When PV=SP 
then make a
       A = Rnd(100)                                         ' random SP 
jump
       Sp = 1 * A
    End If
Return

Regulator:
   ' -----[ Start of PID 
Regulator]---------------------------------------------
   ' -----[ Constant 
]----------------------------------------------------------
   Const Kp = .85                                           ' 
Proportional factor
   Const Ki = .67                                           ' 
Integration factor
   Const Kd = .15                                           ' Derivation 
factor
   ' -----[ Variables 
]---------------------------------------------------------
   'Dim Sp As Single                               ' Setpoint
   'Dim Pv As Single                               ' Process Value
   'Dim Cv As Single                               ' PID output
   '
   'Dim First_execution As Byte                    ' First start 
recognition
   'Dim Initial_error As Single                    ' Startup difference
   Dim Last_pv As Single                                    ' Last PV
   Dim Last_sp As Single                                    ' Last SP
   Dim Sum_error As Single                                  ' Summed 
error value
   Dim D_pv As Single                                       ' Derrivated 
delta PV

   Dim Error As Single                                      ' Difference 
between SP and PV
   Dim Pterm As Single                                      ' 
Proportional calculated part
   Dim Iterm As Single                                      ' Integrated 
calculated part
   Dim Dterm As Single                                      ' Derivated 
calculated part
   ' -----[ Code 
]--------------------------------------------------------------

   If Auto_mode = 1 Then
      ' -------- Regulating modus
      Error = Sp - Pv
      Sum_error = Sum_error + Error
      Iterm = Ki * Sum_error                                ' Integrated 
CV part

      ' -------- First time startup
      If First_execution < 2 Then
         If First_execution = 0 Then
            Sum_error = Manual_value / Ki
            First_execution = 1
            Initial_error = Error
         End If
         Pterm = 0
         Dterm = 0
         If Initial_error > 0 And Error < 0 Then
            First_execution = 2
            Last_pv = Pv
         End If
         If Initial_error < 0 And Error > 0 Then
            First_execution = 2
            Last_pv = Pv
         End If
         Last_sp = Sp

      ' -------- Normal calculation loop
      Else
         D_pv = Last_pv - Pv
         Last_pv = Pv
         Dterm = Kd * D_pv                                  ' Derivated 
CV part
         If Sp = Last_sp Then
            ' -------- Normal loop when setpoint not changed
            Pterm = Kp * Error                              ' 
Proportional CV part
            ' -------- Loop when setpoint changed
            Else
            Pterm = 0
            Dterm = 0
            If Sp > Last_sp And Pv > Sp Then
               Last_sp = Sp
               Last_pv = Pv
            End If
            If Sp < Last_sp And Pv < Sp Then
               Last_sp = Sp
               Last_pv = Pv
            End If
         End If                                             ' Enf of SP 
change seperation                                   '
      End If                                                ' Enf of 
first time running seperation                                  '

      Cv = Pterm + Iterm                                    ' Summing of 
the tree
      Cv = Cv + Dterm                                       ' calculated 
terms

   ' -------- Forced modus
   Else                                                     ' When 
running in non regulationg modus
      Cv = Manual_value                                     ' Set output 
to predefined value
      First_execution = 0                                   ' restart 
bumpless
   End If
Return

[MARIO (Gast)]

Ich hab vor Kurzem einen PID Regler mit Atmega8 + L293 aufgebaut. Ich 
wollte damit einen DC-Motor mit selbst gebastelten Encoder regeln.
Der Encoder besteht aus einer auf Overheadfolie bedruckten Codescheibe 
und einer Gabellichtschranke. Das Programm funktionier bisher ganz gut. 
Ich kann die Parameter Kp, Ki, und Kd verstellen und mir die Drehzahl 
via Uart/RS232 anzeigen lassen. Die Impulse werden mittels Interrupt an 
INT0 gezählt. Die Regelung erfolgt in 40ms Abstand mittels 
Timerinterrupt.

Dummerweise habe ich nun aber keine Idee, wie der Regler abgeändert 
werden muss um eine Positionsregelung zu erhalten. Ich möchte sagen, 
dass sich der Motor z.B. 20 Umdrehungen nach rechts drehen und dort 
stoppen soll. Ich möchte gerne eine Linearführung damit antreiben bzw. 
so etwas wie eine Servomotorsteuerung aufbauen. Ich hab zwar immer 
wieder etwas mit Kaskadenregelung gelesen, aber wie das nun in Bascom 
gehen soll, ist mir noch nocht ganz klar. Wenn ich recht verstanden habe 
brauche ich quasi noch einen äußeren Regelkreis, der mir aus den 
Umdrehungen pro Sekunde noch irgendwie eine Position verrät und diese 
dann Regelt.
Vielleicht hätte da jemand den Einen oder Anderen Codebrocken für mich?

Mein PID Drehzahlregler:

'------------------------------------------------------------------------------
'name                     : PID Drehzahlregelung
'copyright                : (c) 2009 by Türk Mario
'purpose                  : Drehzahlregelung von DC-Motoren
'
'micro                    : Mega8
'------------------------------------------------------------------------------
$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 32
$swstack = 8
$framesize = 24
$baud = 38400

Config Pinb.0 = Output                                      'LED
Config Pinb.3 = Output                                      'PWM
Config Pinc.0 = Output                                      'Richtung
Config Pinc.1 = Output                                      'Richtung
Config Pind.2 = Input
Portd.2 = 1                                                 'Pullup einschalten
Config Portd.0 = Input                                      'Uart Eingang
Portd.0 = 1

Dim E As Single
Dim Esum As Single
Dim Ealt As Single
Dim Kp As Single
Dim Ki As Single
Dim Kd As Single
Dim Ta As Single
Dim Proportionalteil As Single
Dim Integralteil As Single
Dim Differentialteil As Single
Dim Cv As Single
Dim Gv As Single

Dim Flanken As Integer                                      'Gezählte Flanken
Dim Flankenperturn As Integer                               'Anzahl der Flanken pro Umdrehung
Dim Umdrehungen As Single
Dim Solldrehzahl As Single
Dim Maxdrehzahl As Single

Dim Befehl As String * 9
Dim Bcount As Integer
Dim Ar(5) As String * 5

Kp = 30
Ki = 8
Kd = 0.2
Ta = 0.04
Solldrehzahl = 20
Maxdrehzahl = 80
Flankenperturn = 30

E = 0
Esum = 0
Ealt = 0

Config Int0 = Falling                                       'Fallende Flanke löst den Interupt aus
Enable Interrupts
Enable Int0
On Int0 Encoder_zaehlen                                     'Encoder_zaehlen wird im Falle des Interrupts ausgelöst


Config Timer1 = Timer , Prescale = 256                      'Timer1 führt alle 40ms die Regelung durch
On Timer1 Regler
Timer1 = 64285                                              ' 65535 - (8000000/256/Ta)   Ta = 25
Enable Timer1
Start Timer1
                                                             'Timer 2 ist für die Motor PWM zuständig
Config Timer2 = Pwm , Compare Pwm = Clear Up , Pwm = On , Prescale = 64
   Ocr2 = 30
   'Richtung Vorgeben:
   Portc.0 = 1
   Portc.1 = 0
   'Motor PWM Starten
   Enable Timer2
   Start Timer2
$sim

Do                                                          'Hauptprogramm

Input "" , Befehl
Bcount = Split(befehl , Ar(1) , ": ")
   If Ar(1) = "Kp" Then                                     'Einstell- und Infomöglichkeiten
          Kp = Val(ar(2))
   End If
    If Ar(1) = "Ki" Then
          Ki = Val(ar(2))
   End If
    If Ar(1) = "Kd" Then
          Kd = Val(ar(2) )
   End If
   If Ar(1) = "soll" Then
   Solldrehzahl = Val(ar(2))
   End If
    If Ar(1) = "max" Then
   Maxdrehzahl = Val(ar(2))
   End If
   If Ar(1) = "rps" Then
        Print Umdrehungen
   End If
    If Ar(1) = "pid" Then
        Print "Kp=" ; Kp
        Print "Ki=" ; Ki
        Print "Kd=" ; Kd
   End If
    If Ar(1) = "pwm" Then
        Print Ocr2
    End If
Loop

Encoder_zaehlen:                                            'Hier werden alle Flanken gezählt
Incr Flanken
Return



Regler:                                                     'Der PID Regler Algorithmus
Timer1 = 64285
Umdrehungen = Flanken / Ta                                  'Ermittlung der Umdrehungen pro Sekunde
Umdrehungen = Umdrehungen / Flankenperturn
Flanken = 0                                                 'Flankenzähler auf null setzen

E = Solldrehzahl - Umdrehungen                              'Regelabweichung berechnen
Esum = Esum + E                                             'Fehler aufsummieren

Proportionalteil = Kp * E                                   'Proportionalglied berechnen

Integralteil = Ki * Ta                                      'Integralglied berechnen
Integralteil = Integralteil * Esum

Differentialteil = E - Ealt                                 'Differentialglied berechnen
Differentialteil = Differentialteil / Ta
Differentialteil = Differentialteil * Kd

Cv = Proportionalteil + Integralteil                        'Alle Gliede zusammenfassen
Cv = Cv + Differentialteil

Gv = Maxdrehzahl / 255                                      'Übertragen auf PWM Duty Cycle
Gv = Gv * Cv

If Gv < 0 Then Gv = 0
If Gv > 255 Then Gv = 255
Ocr2 = Gv                                    'Motor PWM wird entsprechend angepasst



Ealt = E                                                    'Regelfehler merken für den nächsten Durchlauf


Return