PID Regler + Getriebmotor + Encoder

Hallo,
ich möchte gerne einen DC Motor mittels einem PID-Regler auf eine gewünschte Drehzahl regeln. Die Drehzahl wird über Rotary Encoder gemessen.

Ich glaube, habe ich einen Fehler im Code beim Messen der Drehzahl.

Ich wäre dankbar, wenn jemand mir weiterhelfen könnte.

#include <PID_v3.h>      //https://github.com/ZHomeSlice/Arduino_PID_Library_v3

// Adjust these variables:
int PulsesPerRevolution = 100;// From encoder How Many Pulses Pur Revolution
int SampleDuration = 30; // in Milliseconds -- How often do you want to trigger the PID Lower the number the more detailed control but the more the arduino processor time is used up
double consKp = 1, consKi = 0.01, consKd = 1;
double Setpoint = 100;// RPM 
#define PWMpin  12
#define interruptPin 2
#define  motordrive_dir pinMode(10, OUTPUT);digitalWrite(10, LOW); 
//Define Variables we'll be connecting to

double Input, Output;

//Specify the links and initial tuning parameters
PID myPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, DIRECT);

// Varables used for Calculations 
volatile unsigned long timeX = 1;
unsigned long StallTimer = SampleDuration *3;
volatile int Counts = 1;
double PulsesPerMinute;
volatile unsigned long LastTime;
volatile int PulseCtrX;
int PulseCtr;
unsigned long Counter;
unsigned long Time;

void setup() {
  Serial.begin(115200);
  Serial.println("Test Tachometer");
  PulsesPerMinute = (60 * 1000000) / (PulsesPerRevolution / Counts);// initialize
  pinMode(interruptPin, INPUT_PULLUP);
  pinMode(PWMpin, OUTPUT);
  motordrive_dir;
  attachInterrupt(digitalPinToInterrupt(interruptPin), sensorInterrupt, FALLING);
  myPID.SetSampleTime(1);
  myPID.SetOutputLimits(0, 255); // Standard PWM Range
  myPID.SetMode(AUTOMATIC);
}

void loop() {
  readRpm();

}

// New version of sensorInterrupt
void sensorInterrupt()
{
  static int Ctr;
  unsigned long Time;
  Ctr++;
  if (Ctr >= Counts) { // so we are taking an average of "Counts" readings to use in our calculations
    Time = micros();
    timeX += (Time - LastTime); // this time is accumulative ovrer those "Counts" readings
    LastTime = Time;
    PulseCtrX ++; // will usually be 1 unless something else delays the sample
    Ctr = 0;
  }
}

void readRpm()
{
  static unsigned long STime;
  if (!PulseCtrX) {
    if ((unsigned long)(millis() - STime) >= StallTimer) {
      Time = micros();
      timeX += (Time - LastTime); // this time is accumulative ovrer those "Counts" readings
      LastTime = Time;
      PulseCtrX ++; // will usually be 1 unless something else delays the sample
      Serial.print(" Stall \t");
      //Setpoint +=100;
    } else return; // << Added lets not stop interrupts unless we know we are ready (keep other code happy).
  }
  cli ();         // clear interrupts flag
  Time = timeX;   // Make a copy so if an interrupt occurs timeX can be altered and not affect the results.
  timeX = 0;
  PulseCtr = PulseCtrX ;
  PulseCtrX = 0;
  sei ();         // set interrupts flag
  if (PulseCtr > 0) {
    Input =  (double) (PulsesPerMinute /  (double)(( (unsigned long)Time ) *  (unsigned long)PulseCtr)); // double has more percision
    //   PulseCtr = 0; // set pulse Ctr to zero
    AverageCapture(Input);
    debug();
    myPID.Compute();
    analogWrite(PWMpin, Output);
    long DSDur = ((long) Time *  (long)PulseCtr) - ((long) SampleDuration * 1000L);
    Counts -= DSDur * .015;
    Counts = max(Counts, max(1, PulsesPerRevolution * .25));
    Time = 0; // set time to zero to wait for the next rpm trigger.
    Counter += PulseCtr;
    PulseCtr = 0; // set pulse Ctr to zero
    PulsesPerMinute = (60.0 * 1000000.0) / (double)((double)PulsesPerRevolution / (double)Counts);
    STime = millis();
  }
}
float AvgArray[100];
int Readings = 0;
void AverageCapture(float in) {
  static int Position = 0;
  AvgArray[Position] = in;
  Position++;
  Readings++;
  Readings = min (100, Readings); // 100 readings 0-99;
  if (Position >= 100)Position = 0;//99 spots
}
float AverageValue() {
  float Total = 0;
  float Average;
  if (!Readings)return (0.0);
  for (int Position = 0; Position < Readings; Position++) {
    Total += AvgArray[Position];
  }
  Average = Total / Readings;
  return (Average);
}

void debug(){
  char S[20];
  for (static long QTimer = millis(); (long)( millis() - QTimer ) >= 100; QTimer = millis() ) {  // one line Spam Delay at 100 miliseconds
    Serial.print("Counts: "); Serial.print(Counts );
    //    Serial.print(" Target RPM: ");Serial.print(RPM );
    //    Serial.print(" Counts: "); Serial.print(Counts );
    //    Serial.print(" time: "); Serial.print(Time );
    //    Serial.print(" DeltaT: "); Serial.print(Time *  PulseCtr);
       Serial.print(" PulseCtr: "); Serial.print(PulseCtr );
    //    Serial.print(" PulsesPerMinute: "); Serial.print(dtostrf(PulsesPerMinute, 6, 1, S));
    Serial.print("\t Average: "); Serial.print(dtostrf(AverageValue(), 6, 1, S));
    //    Serial.print(" Setpoint: "); Serial.print(dtostrf(Setpoint, 6, 1, S) );
        Serial.print(" Calculated RPM: "); Serial.print(dtostrf(Input, 6, 1, S));
       Serial.print(" Output: "); Serial.print(dtostrf(Output, 6, 2, S));
    Serial.print("\t "); 
        Serial.println();

  }
}

DC Motor und Encoder sind wie so verbinden
22794326c8d6c264a521fd0b059857ce26bf7d2e_1

Schau welchen Gültigkeitsbereich eine Variable hat.
Und Deine ISR ist zu lang!
Das ganze if-Konstrukt gehört da raus.

soll ich so schreiben?

void sensorInterrupt()
{
  static int Ctr;
  unsigned long Time;
  Ctr++;
  Time = micros();
  timeX += (Time - LastTime); // this time is accumulative ovrer those "Counts" readings
  LastTime = Time;
  PulseCtrX ++;
}

Nein!
Du definierst Time vor dem setup() global und hier nur lokal. Wenn Du die ISR verlässt, ist Time verloren.
Mit dem Neueinstieg ist Time irgendwas.

Stelle ein:
DATEI - VOREINSTELLUNGEN - Ausführliche Ausgabe während [x] Kompilierung und darunter Compiler-Warnungen: ALLE
Dann kannst Du schon die Warnungen sehen...

Und dann Deine ISR auflösen:

void loop()
{
  readRpm();
  ctrAndCounts()
}

// New version of sensorInterrupt
void sensorInterrupt()
{
  Ctr++;
}

void ctrAndCounts()
{
  if (Ctr >= Counts)   // so we are taking an average of "Counts" readings to use in our calculations
  {
    Time = micros();
    timeX += (Time - LastTime); // this time is accumulative ovrer those "Counts" readings
    LastTime = Time;
    PulseCtrX ++; // will usually be 1 unless something else delays the sample
    Ctr = 0;
    // Ctr -= Counts;  
  }
}

Wobei mir noch nicht klar ist, was Deine ganzen Variablen machen.
Nu kann ich kein englisch, aber erklär mal beschreibend in Deutsch, was Deine variablen machen -> als Kommentar im Sketch.
Wenn Counts nicht verloren gehen dürfen, gehört die von mir als letzte Zeile auskommentierte Variante anstelle von Ctr=0;

eigentlich das ist nicht mein Code, habe ich im Internet gefunden, das macht gleiche was ich brauche. Leider bei mir klappt nicht

Ich finde auch immer wieder mal was - auf der Straße.
Manchmal auch im Garten. Oder im Keller.

Wenn es macht, was Du brauchst, verändere es nicht und benutze es.
Wenn es nicht macht, was Du brauchst, dann nimm wenigstens Ratschläge an.
Du musst nicht - ich auch nicht.

Hallo,
wie kommst Du darauf ?
ich denke dann solltest Du erst mal die Messung der Drehzahl ohne den PID Regler im reinen Stellbetrieb testen. ich habe Deinen Sketch nicht ganz verstanden. Die ISR macht ja anscheinend eine Periodenmessung über mehrere Perioden. Dabei ist die Anzahl der zu messenden Perioden mittels Counts erst mal auf 1 eingestellt. Ergebnis ist dann die Zeit timeX. Auf der anderen Seite gibt es noch die Variable pulseCtrX die aufsummiert wird, und ebenfalls die Anzahl der gemessenen Perioden sein soll.
ich hab jetzt nicht die Stelle gefunden wo Du das nachvollziehbar in eine Drehzahl umrechnest. Es gibt zwar die Zeile wo Du Counts mit pusesPerRev berechnest und etwas später PulsePerMinute berechnest.

Also erst mal sauber die Drehzahl messen und berechnen. Dazu gibt es auch fertige Libs. Und Dann den Regelkreis dazu nehmen.
Tipp : Du willst eine Frequenz messen, das kannst Du auch mit Tone und einer Drahtbrücke testen.
Heinz

vielen dank für die Tipps!

ich habe einen neue Code geschrieben, kannst du mir bitte sagen, was noch fehlt?

//Encoder pin
const int encoderPinA = 2;

// MD30C PWM connected to pin 12
#define PWM 12
// MD30C DIR connected to pin 10 
#define DIR 10

//Encoder variables
volatile unsigned long encoder_Position;
unsigned long newposition_encoder;
unsigned long oldposition_encoder = 0;

//Time variables
unsigned long newtime = 0;
unsigned long oldtime = 0;

float encoder_rpm;
float Input;
float Output= 250;
int PPR = 100;// From encoder How Many Pulses Pur Revolution
const int interval = 1000; //choose interval is 1 second (1000 milliseconds)

void setup() {
  // DC motor
  pinMode(PWM, OUTPUT);
  pinMode(DIR, OUTPUT);

  pinMode (encoderPinA, INPUT_PULLUP);
 
  attachInterrupt (digitalPinToInterrupt (encoderPinA), doEncoderA, FALLING);
  Serial.begin (115200);
}

float read_speed(void)
{
  if(millis() - newtime > interval)
  {
  newposition_encoder = encoder_Position;
  newtime = millis();
  encoder_rpm = ((newposition_encoder - oldposition_encoder)*60 * 1000) /PPR/(newtime-oldtime);
  oldposition_encoder = newposition_encoder;
  oldtime = newtime;
}
  return encoder_rpm;
}

void doEncoderA()
{
    encoder_Position++;
}

void loop() {
  Input = read_speed();
  analogWrite(PWM, Output);
  digitalWrite(DIR, LOW);

   Serial.print(" Input = ");
  Serial.print(Input);
  Serial.print("  Output = ");
  Serial.print(Output);
  Serial.println();
  
}

Was erwartest Du hier?

Drehzahl

Wenn Du

erwartest: beachte! Jeder Rechenschritt auf der rechten Seite wird int gemacht, wenn nicht ausdrücklich wenigstens ein Wert größer festgelegt.

Es könnte funktionieren, aber ohne Garantie:
encoder_rpm = ((newposition_encoder - oldposition_encoder)*60 * 1000UL) /PPR/(newtime-oldtime);

Du verwendest einfache Zahlen, ohne jegliche Deklaration und ohne das irgendwer - nicht mal der Compiler - weiß, was Du da vor hast.... :slight_smile:
Nachtrag: Brauchst Du wirklich Nachkommastellen für die rpm?
@a.az Nachtrag2 nur für die Funktion...
Ich hab das mal umgebaut... geht? Geht nicht? Was kommt?

float read_speed(void)
{
  newtime = millis();
  newposition_encoder = encoder_Position;
  if (newtime - oldtime >= interval)
  {
    encoder_rpm = ((newposition_encoder - oldposition_encoder) * 60 * 1000UL) / PPR / (newtime - oldtime);
    oldposition_encoder = newposition_encoder;
    oldtime = newtime;
  }
  return encoder_rpm;
}

eigentlich nein

leider nicht...das was kommt raus

 Input = 65.00  Output = 250.00
 Input = 65.00  Output = 250.00
 Input = 65.00  Output = 250.00
 Input = 65.00  Output = 250.00
 Input = 65.00  Output = 250.00

Ich erwarte möglicherweise hier ~250 wie Output

Ich glaube, habe ich nur den PWM-Wert bestimmt. Und jetzt soll ich den PWM-Wert in die RPM umrechnen oder?

Und ich hätte mich gefreut gewusst zu haben, das Du vor einer Woche das schon mal angefragt hast!

ja genau habe ich dort angefragt, leider bis jetzt habe ich noch nicht gelöst

Das habe ich gelesen, aber ich werde aus Deinem Vorhaben auch nicht schlau.
Du benutzt einen Encoder, bestimmst aber die Richtung nicht, sondern willst nur zählen?

Dann zähle erstmal einfach mit einer Torzeit um überhaupt zu sehen, was da an Zahlen tatsächlich kommt.

const byte encoderPin = 2;
const byte pwmPin = 12;
const byte dirPin = 10;

const uint32_t interval = 1000;
uint32_t lastMillis;

volatile uint32_t encoderValue;
uint32_t lastEncoderValue;

uint16_t pwmValue = 50;
uint16_t umlauf;
void setup()
{
  delay(300);
  Serial.begin(115200);
  Serial.println(F("Start..."));
  pinMode (encoderPin, INPUT_PULLUP);
  pinMode(pwmPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  attachInterrupt (digitalPinToInterrupt (encoderPin), encoderAdd, FALLING);
  digitalWrite(dirPin, LOW);
  analogWrite(pwmPin, pwmValue);
}

void encoderAdd()
{
  encoderValue++;
}

void loop()
{
  uint32_t myMillis = millis();
  if (myMillis - lastMillis >= interval)
  {
    cli();
    uint32_t myValue = encoderValue;
    sei();
    Serial.print(F("Interval: ")); Serial.print(myMillis - lastMillis);
    Serial.print(F("\tPWM: ")); Serial.print(pwmValue);
    Serial.print(F("   \tInput: ")); Serial.println(myValue - lastEncoderValue);
    umlauf++;
    if (umlauf % 5 == 0) {pwmValue += 50; Serial.println();}
    if (pwmValue > 250) {analogWrite(pwmPin, 0); while (1);}
    lastEncoderValue = myValue;
    lastMillis += interval;
    analogWrite(pwmPin, pwmValue);
  }
}

sieht bei mir z.B. so aus:

14:00:29.666 -> Start...
14:00:30.362 -> Interval: 1000	PWM: 50   	Input: 348
14:00:31.356 -> Interval: 1000	PWM: 50   	Input: 393
14:00:32.350 -> Interval: 1000	PWM: 50   	Input: 392
14:00:33.344 -> Interval: 1000	PWM: 50   	Input: 392
14:00:34.371 -> Interval: 1000	PWM: 50   	Input: 391
14:00:34.371 -> 
14:00:35.365 -> Interval: 1000	PWM: 100   	Input: 792
14:00:36.360 -> Interval: 1000	PWM: 100   	Input: 791
14:00:37.353 -> Interval: 1000	PWM: 100   	Input: 792
14:00:38.348 -> Interval: 1000	PWM: 100   	Input: 792
14:00:39.375 -> Interval: 1000	PWM: 100   	Input: 792
14:00:39.375 -> 
14:00:40.370 -> Interval: 1000	PWM: 150   	Input: 1180
14:00:41.364 -> Interval: 1000	PWM: 150   	Input: 1180
14:00:42.358 -> Interval: 1000	PWM: 150   	Input: 1181
14:00:43.352 -> Interval: 1000	PWM: 150   	Input: 1180
14:00:44.346 -> Interval: 1000	PWM: 150   	Input: 1182
14:00:44.379 -> 
14:00:45.373 -> Interval: 1000	PWM: 200   	Input: 1561
14:00:46.367 -> Interval: 1000	PWM: 200   	Input: 1565
14:00:47.362 -> Interval: 1000	PWM: 200   	Input: 1566
14:00:48.356 -> Interval: 1000	PWM: 200   	Input: 1563
14:00:49.350 -> Interval: 1000	PWM: 200   	Input: 1566
14:00:49.383 -> 
14:00:50.377 -> Interval: 1000	PWM: 250   	Input: 1945
14:00:51.371 -> Interval: 1000	PWM: 250   	Input: 1949
14:00:52.365 -> Interval: 1000	PWM: 250   	Input: 1947
14:00:53.360 -> Interval: 1000	PWM: 250   	Input: 1947
14:00:54.386 -> Interval: 1000	PWM: 250   	Input: 1949
14:00:54.386 -> 

Und wenn Du die Umdrehungen hast, wird daraus etwas auf was Du vergleichen kannst.

so sieht bei mir aus.
motor dreht bei PWM=50 und 100 nicht. Und bei PWM=150 , 200 und 250 dreht fast mit gleiche Umdrehung.

15:18:35.535 -> Start...
15:18:36.238 -> Interval: 1000	PWM: 50   	Input: 0
15:18:37.269 -> Interval: 1000	PWM: 50   	Input: 0
15:18:38.253 -> Interval: 1000	PWM: 50   	Input: 0
15:18:39.237 -> Interval: 1000	PWM: 50   	Input: 0
15:18:40.265 -> Interval: 1000	PWM: 50   	Input: 0
15:18:40.265 -> 
15:18:41.249 -> Interval: 1000	PWM: 100   	Input: 0
15:18:42.233 -> Interval: 1000	PWM: 100   	Input: 0
15:18:43.264 -> Interval: 1000	PWM: 100   	Input: 0
15:18:44.249 -> Interval: 1000	PWM: 100   	Input: 0
15:18:45.233 -> Interval: 1000	PWM: 100   	Input: 0
15:18:45.233 -> 
15:18:46.263 -> Interval: 1000	PWM: 150   	Input: 77
15:18:47.263 -> Interval: 1000	PWM: 150   	Input: 77
15:18:48.247 -> Interval: 1000	PWM: 150   	Input: 71
15:18:49.231 -> Interval: 1000	PWM: 150   	Input: 74
15:18:50.262 -> Interval: 1000	PWM: 150   	Input: 72
15:18:50.262 -> 
15:18:51.247 -> Interval: 1000	PWM: 200   	Input: 73
15:18:52.231 -> Interval: 1000	PWM: 200   	Input: 70
15:18:53.262 -> Interval: 1000	PWM: 200   	Input: 73
15:18:54.246 -> Interval: 1000	PWM: 200   	Input: 71
15:18:55.230 -> Interval: 1000	PWM: 200   	Input: 69
15:18:55.230 -> 
15:18:56.261 -> Interval: 1000	PWM: 250   	Input: 74
15:18:57.245 -> Interval: 1000	PWM: 250   	Input: 72
15:18:58.229 -> Interval: 1000	PWM: 250   	Input: 69
15:18:59.260 -> Interval: 1000	PWM: 250   	Input: 74
15:19:00.244 -> Interval: 1000	PWM: 250   	Input: 74
15:19:00.244 -> 

Na dann haben wir einige Probleme.
Ich hab grad gesehen... DC24V40RPM - das Ding ist doch ein Getriebemotor und der macht tatsächlich nur 40 Umdrehungen pro Minute - Hast Du das Getriebe abgerissen?

Wenn Du alle 13ms einen Impuls bekommst, brauchst das Interruptgedödel nicht zwingend. Das kannste auch manuell zaehlen :wink:

Der PWM-Treiber ist dieser?

Hast Du den mal manuell ausgelöst?
Jumper 6 auf intern PWM und Jumper 4 auf extern Pot und dann am ExternSpeed-Anschluss ne Brücke von 1 nach 2 bzw. wenns nicht dreht von 2 nach 3.
Dann müsste er Fullspeed machen.

Wenn da tatsächlich nicht mehr raus kommt, schaun wa mal...

leider habe ich auch darüber nicht gedacht

nein habe ich nicht abgerissen

ja genau

ich habe so JP6 : EXT PWM und JP4: INT POT verbunden

was soll ich da machen?

mit Getriebemotor kann man mittels einem PID Regler und Encoder auf eine gewünschte Umdrehung regeln. oder?

Hallo,
hast du einen Arduino Uno dran , da ist der Pin 12 kein Pwm Ausgang nimm Mal pin11
Heinz