Drehzahlregelung in c

[Dirk D. (sureai)]

Hallo!

Ich versuche momentan eine Drehzahlregelung zu implementieren und leider 
komme ich nicht zu zufriedenstellenden Ergebnissen.

Ich würde mich freuen, wenn ihr mir sagen könnt, ob dass was ich vorhabe 
mit meinem Hardware Setup nicht möglich ist und wenn ja, was ich 
upgraden sollte oder ob in meiner kurzen aber schlechten Software ein 
gravierender Fehler ist.

Mein System:
Eine rotierende Scheibe mit vier Magneten in gleichem Abstand und einem 
Hall-Sensor der viertel Umdrehungen erfasst. Einem Timer, der die Zeit 
zwischen zwei Abständen misst und einem 12V Gleichstrommotor, der die 
Scheibe antreibt.

Mein Problem:
Erst nach ca. 160 Viertelumdrehungen oder 40 Umdrehungen schafft es mein 
P-Regler zum Sollwert +-10%, das ist für meine Anforderung viel zu 
langsam und zu ungenau. Bisher habe ich nur einen P-Regler, weil alle 
anderen erst im Feintuning angegangen werden sollen.

Mein Code:

#include <stdint.h>
#include <avr/io.h>
#include "seriel.h"
#include <stdio.h>
#include <avr/interrupt.h>
static int uart_putchar(char c, FILE *stream);
static int uart_getchar(FILE *stream);
static FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL,_FDEV_SETUP_WRITE);
static FILE mystdin = FDEV_SETUP_STREAM(NULL, uart_getchar,_FDEV_SETUP_READ);

//Interrupts:
volatile unsigned int counterUmdrehung = 0;
volatile unsigned int umdrehungProSekunde = 0;
volatile uint8_t flagUmdrehung = 0;
volatile uint8_t flagUmdrehung2 = 0;
//volatile unsigned int counterMillisekunden = 0;

ISR(INT0_vect){
  counterUmdrehung ++; //Eine Umdrehung wurde registriert
  flagUmdrehung2 = 1;
}

int ms2int(int regelgroesse){
  //Momentan nicht verwendet
  float m = -5.0495;
  float b = 324.53;
  float result = regelgroesse * m + b;// g(x) = m*x+b m=-2.164, b=414
  if (result > 255.0) {
    result = 255.0;
  }
  if (result < 0.0) {
    result = 0.0;
  }
  return (int)result;
}


volatile uint8_t flagUmdrehung3 = 0;
volatile unsigned int counterUmdrehung3 = 0;
ISR(INT1_vect){
  //Externer Interrupt 2
    counterUmdrehung3 ++; //Eine Umdrehung wurde registriert
    flagUmdrehung3 = 1;
}

int timerStarten(){
  // Timer0 konfigurieren
  TIMSK |= (1<<TOIE0);  // den Overflow Interrupt des Timers freigeben
  TCNT0 = 40;    //40 bei Prescaler = 8 und swTeiler = 8
  TCCR0 = (1<<CS01);// Vorteiler 8, jetzt zählt der Timer bereits
  return 0;  
}

//Überlauf Timer0 8-Bit
volatile unsigned int counterUeberlaeufe = 0;
volatile unsigned int millisekunden = 0;
volatile unsigned int sekunden = 0;
volatile unsigned int counterMillisekunden = 0;

ISR( TIMER0_OVF_vect )       // Overflow Interrupt Vector Timer0
{
  static uint8_t swTeiler = 0;
  
  swTeiler++;
  if( swTeiler == 8 ) { 
    swTeiler = 0;
    millisekunden++;
    counterMillisekunden++;
    if (millisekunden == 1000){
      counterUeberlaeufe++;
      millisekunden = 0;
      sekunden++;
    } 
  }
}

//Überlauf Timer2 8-Bit
volatile unsigned int counterUeberlaeufe2 = 0;
volatile unsigned int millisekunden2 = 0;
volatile unsigned int sekunden2 = 0;
volatile unsigned int counterMillisekunden2 = 0;
ISR( TIMER2_OVF_vect ) {    // Overflow Interrupt Vector Timer2

  static uint8_t swTeiler2 = 0;
  
  swTeiler2++;
  if( swTeiler2 == 8 ) {
    swTeiler2 = 0;
    millisekunden2++;
    counterMillisekunden2++;
    if (millisekunden2 == 1000){
      counterUeberlaeufe2++;
      millisekunden2 = 0;
      sekunden2++;
    }
  }
}


void ADC_init(void){
  ADCSRA |= (1<<ADEN);//ADC aktivieren
  ADCSRA |= (1<<ADPS2);//Teilungsfaktor auf 64 stellen
  ADCSRA |= (1<<ADPS1);
}

uint16_t ADC_read(uint8_t kanal){
  ADMUX = kanal;//Kanal des Multiplexers wählen
  ADCSRA |= (1<<ADSC);//Messung starten
  while(bit_is_set(ADCSRA,ADSC));
  return ADCW;
}


int main(void){
   
  da();
    int i ,j,a=0;
    int sollwert;
  int messsignal;
  int regelgroesse;
  int Te;
  int Kr;
  int Tn;
  int Tv;
  int error;

  USART_Init(16);

  stdout = &mystdout;
  stdin  = &mystdin;                     // Anschluss der low-level Routinen????

  printf("P-Regler gestartet");
  TCCR1B |= (1<<CS12);
  TCCR1A |= (1<<WGM10);
  TCCR1B |= (1<<WGM12);
  TCCR1A |= (1<<COM1A1) | (1<<COM1B1);
  OCR1A =  0;
  DDRD |= (1<<PD4) | (1<< PD5);
  #define MotorLinks OCR1A
  //MotorLinks = 255;
  counterMillisekunden = 0;
  counterUmdrehung = 0;
  int zeit = 0;
  DDRD &= ~(1<<2); //PD2 als Eingang
  PORTD|= (1<<2); //Pullup aktivieren
  GICR|=(1<<INT0); //INT0 (INTNULL) enable im General Interupt Control Register
  MCUCR|=(1<<ISC01)|(1<<ISC00); //Steigende Flanke löst aus
  sei();
  sollwert = 30;
  //sollwert = ms2int(15);
  //if (MotorLinks == 0 && sollwert > 0) {
  //  MotorLinks = ms2int(sollwert);
  //}
  MotorLinks = 255/5; //Motor benötigt Initialgeschwindigkeit um Istgeschwindigkeit messen zu können
  int ealt = 0;
  while(1){
    if (flagUmdrehung2 == 1) {
      flagUmdrehung2 = 0;
      TIMSK |= (1<<TOIE0);  
      TCNT0 = 40;    
      TCCR0 = (1<<CS01);
      messsignal =counterMillisekunden;
      printf("%d\n",counterMillisekunden);
      counterMillisekunden = 0;
      MotorLinks = MotorLinks + messsignal - sollwert;
    }
    
  }
}

    static int uart_putchar(char c, FILE *stream)
    {

      if (c == '\n')
        uart_putchar('\r', stream);
      loop_until_bit_is_set(UCSRA, UDRE);
      UDR = c;
      return 0;
    }

static int uart_getchar(FILE *stream)

{
   char c;
   loop_until_bit_is_set(UCSRA, RXC);
    c = UDR;
    uart_putchar(c, stdout);
   
 if (c == '\r')
    return '\n';

    return(c);
}

Meine Überlegungen:
-Eine schnelle Regelung sollte auch mit einem einfachem P-Regler 
erreicht werden können. Der P wert von 1 gibt auch das bis jetzt beste 
(Ergebnis siehe Bild). Eine Optimierung der Regelparameter könnte das 
Problem verbessern aber nicht drastisch.
-Vier Messpunkte pro Umdrehung sind nicht genau genug: wahrscheinlich 
sind mehr immer besser, allerdings gebe ich im Code eine 
Sollgeschwindigkeit vor und ändere den Sollwert (noch) nicht innerhalb 
kürzester Zeit, also sollten die vier Magneten erstmal reichen
-Der Motor verhält sich nicht linear zur Spannung. Bei niedrigen 
Spannungen von 0 bis ca. 1V reagiert der Motor so gut wie gar nicht mit 
einer Umdrehung. Ein besserer Motor oder die Zwischenschaltung eines 
Getriebes könnte das Problem verbessern.
-Der Code ist mies :D


Ich hoffe ihr könnt mir ein paar Tips geben, was ich verbessern kann. 
Wenn ich mein Ziel zufriedenstellend erreichen sollte würde ich auch 
etwas zurück geben und meine komplette Dokumentation als Anleitung 
wieder zur Verfügung stellen.

Gruß Sureai

[Kai S. (kai1986)]

Hallo,

deine bleibende Regelabweichung kommt vom reinen P-Anteil, dieser kann 
die nämlich nicht kompensieren. Regelabweichung kompensieren benötigst 
du einen I-Anteil. Damit kommst du recht weit, wenn du dann noch 
schneller werden willst kannst du noch einen D-Anteil hinzunhemen.

Gruß Kai

[Dirk D. (sureai)]

Hey,
danke für deine Antwort. Die bleibende Regelabweichung und ihr Ursache 
ist mir bewusst. Nur Braucht der Motor von Stand auf Maximale 
Geschwindigkeit eine Umdrehung. Deswegen verstehe ich nicht, wieso ich 
erst nach 40 Umdrehungen auf Sollwert +- Regelabweichung lande.
Ich wollte eine Einschwingzeit von ungefähr einer Umdrehung erreichen.
Aber dann probiere ich doch mal einen PID Regler um das zu 
beschleunigen.
Gruß Sureai

[lol (Gast)]

Ich bin mir nicht sicher, ob man soo genaue Werte in C überhaupt 
auswerten kann. Wäre reiner Assembler da nicht geeigneter?

[Frank (Gast)]

Mach mal mehr Magnete drauf.
Du musst definitiv die Auflösung deines Gebers erhöhen bzw die Totzeit 
verringern.
Dann bekommst du auch das Einschwingen schneller runter.
Bzw. Gerade bei langsamen Umdrehungen oder wenigen Strichen solltest du 
eher die Zeit zwischen zwei Flanken auswerten und nicht die Anzahl pro 
Zeit!

Ein Freilaufender Zähler. In den Interrupts der IOs speicherst Du die 
Timestamps ab und setzt ein flag.
Danach kannst du auch sauber die Zeitdifferenz berechnen!

[Dirk D. (sureai)]

Hallo Frank,
ich bin mir gerade nicht ganz sicher, ob ich dich richtig verstehe. Ich 
werte doch die Zeit zwischen zwei Flanken aus, oder nicht? Wenn eine 
auslösende Flanke registriert wird, wird die if-Bedingung der main loop 
ausgelöst.
Verringert sich die Totzeit auch mit mehr Magneten? Ich dachte die um 
die Totzeit zu "regeln" verwendet man einen Smith-Prediktor. Ich dachte 
mein System hat eine relativ geringe Totzeit von einstelligen ms.
Ich werde die doppelte Anzahl an Magneten testen und überprüfen ob sich 
die Einschwingzeit reduziert.
Gruß Sureai

[Bastian W. (jackfrost)]

Dirk D. schrieb:
> MotorLinks = MotorLinks + messsignal - sollwert;

Der Code oben ist kein P Regler. Du ziehst deinen Sollwert ( 30 von 
deinem Startwert 255/5) ab und addierst das Messsignal, wenn dies bei 
dem ersten Durchlauf noch 0 ist dann startet der Motor mit 20.

Ein P-Regler arbeite mit der Regelabweichung ( Soll - Ist ) und 
multipliziert dies mit dem Proportionalwert. Das Ergebnis ist dann der 
Stellgrad 0 - 100 % bzw. bei dir 0 - 255.



Dirk D. schrieb:
> y,
> danke für deine Antwort. Die bleibende Regelabweichung und ihr Ursache
> ist mir bewusst. Nur Braucht der Motor von Stand auf Maximale
> Geschwindigkeit eine Umdrehung. Deswegen verstehe ich nicht, wieso ich
> erst nach 40 Umdrehungen auf Sollwert +- Regelabweichung lande.
> Ich wollte eine Einschwingzeit von ungefähr einer Umdrehung erreichen.
> Aber dann probiere ich doch mal einen PID Regler um das zu
> beschleunigen.
> Gruß Sureai

Wenn du das brauchst , dann wird dir das kaum ein Regler schaffen. Du 
musst dann schon mit der Frequenz den Motor anfahren den er direkt 
braucht. Ein Regler schafft das nicht aus dem Stand ( 0 % ) das 
anzufahren.
Allein von der Massenträgkeit wird das schon schwer das der Motor das 
mit der ersten Umdrehung schaffen soll.

Der Nadelimpuls für einen D-Anteil wird nicht einfach. Versuch erstmal 
einen PI Regler. Die Dämpfung über den D-Anteil kannst du dann immer 
noch rein bauen das das System Schwinungsämer wird. Mach dir vorallem 
Gedanken um das Anti-Windup für den I-Anteil. So das dieser nicht weiter 
integriert
wenn der Istwert nicht steigt.

Für den I-Anteil brauchst du nen zweiten Timer. Einfach mal ins blaue 
geschossen:

$$\Delta y = (x - w)*\frac{{{t_{abtast}}}}{{{t_{nachstell}}}}$$

t_abtast ist die Durchlaufzeit deines Timers nach der jedesmal die 
Stellgradänderung berechnet wird.

Ist den Istwert zu niedrig wird das Ergebnis addiert, wenn nicht dann 
abgezogen. Zum Stellgrad vom I-Anteil noch den P-Anteil addieren und die 
Summe gibt dann den Stellgrad für den Ausgang. Den Stellgrad für den 
I-Anteil bis zur Summe der beiden Anteile musst du getrennt vom P-Anteil 
führen. Du brauchst also zwei Variablen. Und im I-Zweig muss bereits das 
Anti-Windup drinnen sein ( Begrenzung auf 0 und 255 )

Gruss JackFrost

[Frank (Gast)]

Dirk D. schrieb:
> ich bin mir gerade nicht ganz sicher, ob ich dich richtig verstehe. Ich
> werte doch die Zeit zwischen zwei Flanken aus, oder nicht?

Schon, aber warum machst Du diese eine (zeitkritische) Subtraktion nicht 
in der ISR? Du hast definitiv Fehler in der Zeitmessung sobald noch ein 
Interrupt dazwischen kommt.
Ich würde einfach einen Zähler frei laufen lassen. Relativ schnell. Im 
externen Interrupt machst Du dann nur noch sowas ind er Art:

ISR(INT0_vect)
{
 timeOld = timeNew; //Alten Wert sichern
 //Aktueller 32Bit Zeitstempel aus Overflow + aktuellem 16Bit Counter
 timeNew = (((uint32)OverflowCounterTimer <<16 )+ aktueller Timerwert);
 timeDiff = timeNew - timeOld;
}

Dirk D. schrieb:
> Verringert sich die Totzeit auch mit mehr Magneten?

Bei gleicher Drehzahl zumindest die Aktualisierungsrate Deiner 
Geschwindigkeit. Du kannst ja nur mit RPM/4 Geschwindigkeiten rechnen 
(es sei denn Du fängst noch mit Prädiktoren an).

Wenn Du 4 Mal mehr Magnete hast, bekommst Du 4 Mal so oft eine aktuelle 
Geschwindigkeit. Wenn Du darüber wieder einen Filter legst (z.B. 
gleitenden Mittelwert über 4 Werte) hast Du genauso oft wie vorher einen 
neuen Wert, aber mit deutlich weniger Drehzahlrauschen. Was Deiner 
Regelung mit Sicherheit wieder zugute kommt.

Grüße
Frank