Motor Positionsregelung mit Encoder

[MechMac]

Hallo,

ich habe einen Modellbaumotor mit Regler, an dem ein Encoder (360 incremente) angeschlossen ist.
Das lesen der incremente klappt soweit, ich erfasse von beiden Spuren je steigende und fallende Flanke, so das ich je Umdrehung auf 1440 impulse komme.
Die werden entweder positiv oder negativ erfasst.

Ich habe eine einfache Routine erstellt, welche es ermöglicht eine bestimmte Strecke abzufahren. z.B. 400mm.
Wenn das erreicht ist, stoppt der Motor. Soweit klappt das.

Jetzt hätte ich gern, das wenn das Fahrzeug auf einer schrägen steht, oder von mir verschoben wird, die letzte Position versucht zu halten.

1. Geht das überhaupt mit einem gewöhnlichen Rc-Regler, oder ist der schon zu träge?
2. Ich bekomme keinen vernünftigen Code hin der das sauber schafft. Ich habe immer das Problem das sich der Regelkreis "aufschaukelt".
Das ist nur verständlich, da das Fahrzeug zum Reaktionszeitpunkt schon über das Ziel hinaus geschossen ist und dann immer heftiger gegensteuern muss um zum gewünschten Punkt zurückzukommen.

Wer kann mir da ein bisschen helfen?

Hier mal mein Haltemodus:
Ich habe es versucht halbwegs gut zu kommentieren.






if (holdmodus){
full_cycl=15000; //Zykluszeit verringern, um schneller zu reagieren
if (!proc){ //Wenn gerade KEIN PWM-Signal generiert wird

//Reaktion wenn das Fahrzeug sich außerhalb der Sollposition befindet
if (negativeDir){ //Wenn die Zielposition negativ ist
if (position_k>holdpos-50) switch_len--;
if (position_k<holdpos+50) switch_len++;
}
else //Wenn die Zielposition positiv istist
{
if (position_k>holdpos-50) switch_len++;
if (position_k<holdpos+50) switch_len--;
}

//Begrenzung der maximalen Geschwindigkeit beim regeln
//1500 ist neutral=kein Gas
if (switch_len>1550) switch_len=1550;
if (switch_len<1450) switch_len=1450;

//Reaktion wenn das Fahrzeug sich innerhalb eines zulässigen Fensters um die Sollposition herum befindet
if ((position_k>holdpos-50) && (position_k<holdpos+50)) { //wenn mitte erreicht

//WEnn ich in diesem Bereich das gas ganz wegnehme (switch_len=MV) , schaukelt er sich nicht auf,
//aber auf einer Schrägen fährt er dann immer ein stück runter und dann wieder hoch :-(

if (ticks_real==0){ //wenn eine bewegung stattfindet, dann gas langsam wegnehmen
//-> ticks_real wird bei feststellen einer bewegung auf 0 gesetzt, sonst zählt es hoch
//(Das hat nix mit den geberincrementen zu tun)
if (switch_len>MV) switch_len= switch_len-((abs(switch_len)-abs(MV))/2);
if (switch_len<MV) switch_len= switch_len+((abs(switch_len)-abs(MV))/2);
}

}
}
}


}

[Holomino]

Hast Du schon mal was von PID-Reglern gehört? Die sind relativ einfach in einem Controller umzusetzen.
Das hilft allerdings bei Deinem Schrägenproblem nur bedingt , weil:

"Ohne Abweichung keine Regelung!"

Vielleicht wäre für das Schrägenproblem denkbar, über einen 3-Ach-Accelerometer die Schräglage zu messen und damit einen zweiten PID-Regler zuzuschalten (Die Dinger kann man kaskadieren, also das Ergebnis mehrerer Regler je nach Anwendungsfall miteinander multiplizieren oder addieren.)

Mal ein Beispiel für eine PID-Implementierung

PID.h

#ifndef INCL_PID_H
#define INCL_PID_H

#include <avr/io.h>
#include <stdint.h>

#define PID_SIZEOFFSET 19 // Offset in uint8_t array for data start

typedef struct
{
uint8_t Depth; //0
double KP; //1
double KI; //5
double KD; //9
double Sum; //13
uint8_t Index; //17
double Buffer[];//18
}PID_t;


extern void InitPIDStruct(uint8_t arr[], uint16_t size);
extern void PIDCalculate(PID_t* pid, double diff, double* result);


#endif

So ein PID-Regler benötigt drei Konstanten, die an das System anzupassen sind: KP(roportional), KI(ntegral), und KD(ifferential).
Proportional: Je größer die aktuelle Abweichung, desto größer die Gegensteuerung
Integral: Je "stabiler" (länger anhaltend) die Abweichung, desto größer die Gegensteuerung
Differential: Je nach Trend (Änderung der Abweichung) ändert sich die Gegensteuerung.



PID.c


#include <stdint.h>
#include <math.h>
#include <string.h>
#include "PID.h"



//Init array: iRead/iWrite = 0, data elements = 0, Buffer length = array length -4
void InitPIDStruct(uint8_t arr[], uint16_t size)
{
memset( arr, 0, size);
arr[0] = (size-PID_SIZEOFFSET) / sizeof(double);
}

double p, i, d;

void PIDCalculate(PID_t* pid, double diff, double* result)
{
//Proportional
p = diff * pid->KP;

//Differential
double previous = pid->Buffer[pid->Index];
d = (diff - previous) * pid->KD;

//Integral
pid->Index = (pid->Index + 1) % pid->Depth; //Step up index
double oldVal = pid->Buffer[pid->Index];
pid->Buffer[pid->Index] = diff;
pid->Sum -= oldVal;
pid->Sum += diff;
i = (pid->Sum/ pid->Depth) * pid->KI;

*result = -1.0 * (p + i + d);
}

Um den integralen Anteil zu berechnen, verwende ich hier ein Array, dass die letzten 16 Werte hält. Allerdings berechne ich nicht die komplette Summe in jedem Durchlauf neu, sondern ziehe immer nur das älteste Element ab und füge das neu hinzugekommene Element hinzu.



Initialisierungsbeispiel:

static uint8_t arrDistance[16 * sizeof(double) + PID_SIZEOFFSET];
static PID_t* PIDDistance;

void Drive_Init()
{
InitPIDStruct(arrDistance, sizeof(arrDistance));
PIDDistance = (PID_t*) arrDistance;

PIDDistance->KP = 0.6;
PIDDistance->KI = 0.2;
PIDDistance->KD = 0.4;
}

Vielleicht wird's hier klar, warum ich zuerst ein Array anlege und anschließend auf den Strukturtyp caste. Ich kann dadurch die Größe des Integrationspuffers in der Arraydefinition anpassen (in InitPIDStruct wird entsprechend dann das "Depth" errechnet).


Ein Durchlauf in etwa so:

//calculate Distance regulation value
static double dregDistance;
PIDCalculate(PIDDistance, dDistance, &dregDistance);

//!!! Wenn Neutral = 15000, dann hier aufaddieren
int16_t newPWM = 15000 + (int16_t) dRegDistance;

Eingang ist die Regeldifferenz dDistance, also Sollwert-Istwert
Ausgang ist der Regelwert, hier als Beispiel mal die PWM.

Die drei Konstanten kP, kI und kD einzustellen, ist allerdings eine Kunst für sich. Es gibt sowohl mathematische Ansätze als auch den reinen Probieralgorithmus, in dem zuerst kP möglichst optimal eingestellt, danach kI dazugenommen und kD als optimierendes i-Tüpfelchen zum Schluss ausgetestet wird.

[i_make_it]

In der Industrie haben Motoren, die eine Position unter Last halten sollen, üblicherweise 3 Regler.
Drehzahl-Reglung, Positions-Reglung, Strom-Reglung.
Wobei dort neben Drehgebern auch Resolver zum Einsatz kommen.
Durch Abgleich des Reglers mit dem Resolver wird die Winkelstellung unter unterschiedlichsten Lasten gehalten.
Da der Regler bei dem CPC Encoder mindestens 2 Flankenwechsel (einen je Kanal) braucht, um die Drehrichtung zu erkennen, wird die Positionsreglung minimal um 4 Impulse schwanken.
Ohne PID Regler ist diese Regelgüte aber nicht erreichbar.

[Holomino]

...wobei Du bei Batteriebetrieb gleich 'nen vierten Regler zum Ausgleich der Versorgungsspannungsänderung einplanen kannst...

...sofern die Motorspannung nicht über 'nen Stabi vorher stabilisiert wird...

[MechMac]

Ich habe mit der PID-Regelung nun ein wenig herumgespielt. Vielleicht erwarte ich auch zuviel davon.
Im Grunde würde es mir ja schon reichen wenn das Fahrzeug auf einer geraden Strecke von A nach B fährt.
Ohne in diesen Regelkreis einzugreifen bekomme ich es nicht hin.
Damit meine ich: Ich muss mindestens die Regelung stoppen wenn das Ziel erreicht ist.
(Auf einer schiefen Ebene würde er dann gnadenlos herunter fahren)

Nur mal angenommen ich setze die Werte für KI und KD auf 0 und fange nun an KP hochzusetzen.
In meinem Fall fährt das Fahrzeug mit KP=0 quasi gar nicht, sondern zuckelt nur auf der Stelle.
Setze ich KP so hoch das das Fahrzeug fährt, schwingt er am Zielpunkt hin und her.
Es gibt keine Einstellung wo er nicht schwingt.
Ich weiß nicht ob das so sein soll???

Gruß, Andreas

[i_make_it]

ich habe einen Modellbaumotor mit Regler, an dem ein Encoder (360 incremente) angeschlossen ist.

Kann es sein, das Du versuchst den Regler zu Regeln und der daraus mit seinen Reglersettings wiederum was macht das er dem Motor gibt?
Oder ist der Quellcode der von eben diesem Regler?

Den PID Regelung an sich funktioniert, wie CNC Maschinen, Industrieroboter, Aufzüge, Eisenbahn, Segways etc. beweisen.
Also muß entweder die Implementierung fehlerhaft sein oder im Regelkreis befinden sich Störgrößen wie eben ein zweiter Regler der sein eigenes Ding macht.

Eventuell wären Daten zu Motor, Regler, Aufbau des Ganzen, hilfreich.

[MechMac]

Der Motor ist ein Brushless-Motor mit Sensoren. Er wird von einem gewöhnlichen Modellbau-Regler gesteuert.
Dieser Modellbau-Regler hat jedoch kein "Eigenleben". Er erwartet eine PWM im Bereich von etwa 1 - 2 Millisekunden.
Diese sagt ihm wie er den Motor ansteuern soll. 1,0=Rückwärts 1,5=Neutral 2,0=Vorwärts

Motor: LRP-Eraser
Regler: AI-Pro
Der Encoder sitzt hinter einem Planetengetriebe, da der Motor zu schnell dreht. (Ich weiß das der Encoder eigentlich auf den Motor gehört)

Das eine PID Regelung funktioniert glaube ich. Vielmehr denke ich das der Fehler bei meinem Aufbau bzw. der Umsetzung liegt.
Der Quelltext oben findet aktuell keine Verwendung mehr, da ich ja jetzt mit der PID-Regelung arbeite.

Vom Aufbau her ist es ein ehemals Allrad-Fahrzeug, welches auf Frontantrieb reduziert wurde.
Am zweiten Ausgang des Planetengetriebes sitzt jetzt der Encoder (da wo vorher die zweite Kardanwelle für das Heck dran war)
Die Einheit, welche den encoder ließt und die PWM für den Modellbau-Regler erzeugt ist ein Arduino Nano, dieser wird von einem Arduino Mega über I2C mit den Infos (z.B.Fahrbefehl, Halt, KP,KD und KI versorgt). Der Mega wiederum erhält via XBee seine Befehle von meinem Computer.
Somit kann ich sehr bequem mit den Werten spielen.

Gruß, Andreas

[i_make_it]

Wenn der Regler der "A.I. BRUSHLESS (PRO) REVERSE" ist, hat der eine eigene Regelung. Alleine schon wegen der EMK Bremse wird er sich nicht passiv verhalten.
Laut der Beschreibung die ich eben gelesen habe, kann man die Bremse wohl auch nicht abschalten.
Willst Du den Motor wirklich selbst regeln, wirst Du in dem Fall wohl drei Halbbrücken brauchen und selbst einen Motortreiber bauen müssen oder anstelle einem Regler nach einem reinen Motortreiber für BLDC suchen müssen.

[Unregistriert]

wenn es allerdings tatsächlich über normale H-Brücken geregelte Motoren sind (L293 o. L298 o.ä.) , wäre es vielleicht auch ein Tipp, die PID_v1 lib der Arduinos zu verwenden. Es gibt dafür sogar ein eigene Autotuning-Zusatzlib.
http://playground.arduino.cc/Code/PIDLibrary
http://playground.arduino.cc/Code/PIDLibaryBasicExample

[oberallgeier]

Hallo Andreas.
.. Wer kann mir da ein bisschen helfen? ..Vor längerer Zeit hatte ich mich in die Regelungstechnik (siehe hier (https://www.roboternetz.de/community/threads/37518-Linie-Folgen?p=357629&viewfull=1#post357629)) von Gleichstrommotoren (klicken) (https://www.roboternetz.de/community/threads/37518-Linie-Folgen?p=357569&viewfull=1#post357569) zur Geschwindigkeitsregelung eingearbeitet. Daraus wurde dann die Geschwindigkeitsregelung meiner Roboterantriebe. Die Vorgehensweise ist hier beschrieben (https://www.roboternetz.de/community/threads/37518-Linie-Folgen?p=357670&viewfull=1#post357670) und zeigt (m)ein Codebeispiel. Die Funktion ist ziemlich gut. Es ist ein sauberer Geradlauf bzw. Gleichlauf der beiden kleinen Motörchen in meinem MiniD0 möglich. Der saubere Gleichlauf erlaubt z.B. diese sauber-platztreue Pirouette im Video (https://www.youtube.com/watch?v=jgm9DhS7vS4).

Die Sprungantwort zur Dimensionierung der Reglerkennwerte ist sehr praktisch. Hatte ich später nicht am freilaufenden Motor bestimmt sondern im fertigen Target. Ne ähnliche Regelung hatte ich auch bei meinem Archie verwendet - die Dimensionierung der Reglerkennwerte erfolgte nach einiger Erfahrung mit früheren Auslegungen eher über den Daumen gepeilt.

Später hatte ich eine Stellungsregelung in ähnlicher Weise programmiert für nen "Servomotor" eigener Zusammenstellung am Handgelenk (https://www.roboternetz.de/community/threads/61379-Kopfsache-und-ein-m1284-etliche-Servos-viel-Alu?p=625271&viewfull=1#post625271) meines Archie. Dort ist, wegen der relativ einfachen Aufgabenstellung, nur ein PD-Regler (Software) eingebaut. Der I-Anteil konnte wegen geringer Lastvariation weggelassen werden. Die Vorgehensweise war wie oben beschrieben, der Code lehnte sich ebenfalls an diese erste Variante an.


Der Motor ist ein Brushless-Motor mit Sensoren .. Modellbau-Regler hat jedoch kein "Eigenleben" ..Ich hatte noch nie Brushless´ in der Hand :-/ . Meine Regelungen laufen üblicherweise über käufliche Motortreiber-ICs/Motor-Vollbrücken wie L293D oder VNH2SP30.

[Holomino]

Nur mal angenommen ich setze die Werte für KI und KD auf 0 und fange nun an KP hochzusetzen.
In meinem Fall fährt das Fahrzeug mit KP=0 quasi gar nicht, sondern zuckelt nur auf der Stelle.
Setze ich KP so hoch das das Fahrzeug fährt, schwingt er am Zielpunkt hin und her.
Es gibt keine Einstellung wo er nicht schwingt.
Ich weiß nicht ob das so sein soll???

Gruß, Andreas

Wahrscheinlich ist einfach die gewählte Strecke zu kurz, um alleine durch eine Proportionalregelung angesteuert werden zu können. Wenn Du die Strecke vergrößerst, muss doch das Ergebnis des P-Anteils auch wachsen und das Fahrzeug fährt los, idealerweise bis kurz vors Ziel. Die Strecke musst Du so wählen, dass der P-Anteil den PID-Regler bis in die Sättigung (also maximale Aussteuerung) treibt.

OK, wenn dem so ist, dann stell Dir vor, Du hast KP mit dem Zuckelwert für kurze Distanzen optimal eingestellt. Schwingen sollte es mit KP alleine auf keinen Fall, egal, bei welcher Strecke.

Dann nimm mal testweise etwas KI dazu, bis sich das Fahrzeug auch bei kurzen Distanzen bewegt. Auch der integrale Anteil sollte sich ja mit Annäherung ans Ziel verkleinern.

[oberallgeier]

.. stell Dir vor, Du hast KP mit dem Zuckelwert für kurze Distanzen optimal eingestellt ..Schöner Beitrag!

Von Bedeutung ist gerade bei der digitalen Regelung natürliche zusätzlich der Vergleich der Motorzeitkonstanten, der Abtastrate und der Encoder-Tickrate (digital!!!). Die sollten schon in gleichen Größenordnungen liegen; leider stecke ich nicht so tief in Regelungstechnik drin, dass ich dazu sinnvolle Richtwerte angeben könnte. Aber wenn ich z.B. zehn Mal pro Minute regle und der Motor in zehn Millisekunden an die 90 % hochfahren kann - dann siehts schon düster aus. Wenn der Motor in einem Regelzyklus den Encoder grad mal ein, zwei Digits weiterdreht ist´s auch sehr suboptimal. Mein Grundsatz ist halt die Regelung schon aus Zeitgründen integer zu rechnen, dafür in einem Zeitraster der Motorzeitkonstanten oder schneller und mit Encoderticks pro Zyklus zwischen knapp zwanzig und weit über hundert. Zu letzterem habe ich aber bei 1440 Ips wenig Sorge (Irrtum vorbehalten :-/m). Aktuell regle ich (der Motorcontroller) Archie, etwa sechs bis sieben Kilo Gewicht, und die mikroskopische Coladose mit hundert Hertz.

[MechMac]

Wenn der Regler der "A.I. BRUSHLESS (PRO) REVERSE" ist, hat der eine eigene Regelung. Alleine schon wegen der EMK Bremse wird er sich nicht passiv verhalten.
Laut der Beschreibung die ich eben gelesen habe, kann man die Bremse wohl auch nicht abschalten.
Willst Du den Motor wirklich selbst regeln, wirst Du in dem Fall wohl drei Halbbrücken brauchen und selbst einen Motortreiber bauen müssen oder anstelle einem Regler nach einem reinen Motortreiber für BLDC suchen müssen.

Selber regeln fällt flach.
A) dieses Fahrzeug ist nur ein Testfahrzeug zum Erfahrung sammeln. Es macht keinen Sinn hierfür irendetwas zu basteln.
Mein eigentliches Projekt weicht stark in allen Belangen ab.
B) Und die Sensoren? Ich denke nicht das es eine triviale Sache ist das ans Laufen zu bekommen.





wenn es allerdings tatsächlich über normale H-Brücken geregelte Motoren sind (L293 o. L298 o.ä.) , wäre es vielleicht auch ein Tipp, die PID_v1 lib der Arduinos zu verwenden. Es gibt dafür sogar ein eigene Autotuning-Zusatzlib.
http://playground.arduino.cc/Code/PIDLibrary
http://playground.arduino.cc/Code/PIDLibaryBasicExample

Die nutze ich. Trotzdem Danke für die Infos, diese Autotuning-Lib hatte ich übersehen ;-)




Hallo Andreas.Vor längerer Zeit hatte ich mich in die Regelungstechnik (siehe hier (https://www.roboternetz.de/community/threads/37518-Linie-Folgen?p=357629&viewfull=1#post357629)) von Gleichstrommotoren (klicken) (https://www.roboternetz.de/community/threads/37518-Linie-Folgen?p=357569&viewfull=1#post357569) zur Geschwindigkeitsregelung eingearbeitet. Daraus wurde dann die Geschwindigkeitsregelung meiner Roboterantriebe. Die Vorgehensweise ist hier beschrieben (https://www.roboternetz.de/community/threads/37518-Linie-Folgen?p=357670&viewfull=1#post357670) und zeigt (m)ein Codebeispiel. Die Funktion ist ziemlich gut. Es ist ein sauberer Geradlauf bzw. Gleichlauf der beiden kleinen Motörchen in meinem MiniD0 möglich. Der saubere Gleichlauf erlaubt z.B. diese sauber-platztreue Pirouette im Video (https://www.youtube.com/watch?v=jgm9DhS7vS4).

Die Sprungantwort zur Dimensionierung der Reglerkennwerte ist sehr praktisch. Hatte ich später nicht am freilaufenden Motor bestimmt sondern im fertigen Target. Ne ähnliche Regelung hatte ich auch bei meinem Archie verwendet - die Dimensionierung der Reglerkennwerte erfolgte nach einiger Erfahrung mit früheren Auslegungen eher über den Daumen gepeilt.

Später hatte ich eine Stellungsregelung in ähnlicher Weise programmiert für nen "Servomotor" eigener Zusammenstellung am Handgelenk (https://www.roboternetz.de/community/threads/61379-Kopfsache-und-ein-m1284-etliche-Servos-viel-Alu?p=625271&viewfull=1#post625271) meines Archie. Dort ist, wegen der relativ einfachen Aufgabenstellung, nur ein PD-Regler (Software) eingebaut. Der I-Anteil konnte wegen geringer Lastvariation weggelassen werden. Die Vorgehensweise war wie oben beschrieben, der Code lehnte sich ebenfalls an diese erste Variante an.

Ich hatte noch nie Brushless´ in der Hand :-/ . Meine Regelungen laufen üblicherweise über käufliche Motortreiber-ICs/Motor-Vollbrücken wie L293D oder VNH2SP30.

Dieser hier ist auch relativ "selten", die meisten BL-Motoren, sind sensorlos. Außerdem setze ich eher auf Außenläufer wegen der geringerer Drehzahl und dem besseren Anlaufverhalten.






Wahrscheinlich ist einfach die gewählte Strecke zu kurz, um alleine durch eine Proportionalregelung angesteuert werden zu können. Wenn Du die Strecke vergrößerst, muss doch das Ergebnis des P-Anteils auch wachsen und das Fahrzeug fährt los, idealerweise bis kurz vors Ziel. Die Strecke musst Du so wählen, dass der P-Anteil den PID-Regler bis in die Sättigung (also maximale Aussteuerung) treibt.

OK, wenn dem so ist, dann stell Dir vor, Du hast KP mit dem Zuckelwert für kurze Distanzen optimal eingestellt. Schwingen sollte es mit KP alleine auf keinen Fall, egal, bei welcher Strecke.

Dann nimm mal testweise etwas KI dazu, bis sich das Fahrzeug auch bei kurzen Distanzen bewegt. Auch der integrale Anteil sollte sich ja mit Annäherung ans Ziel verkleinern.

Die Strecke sollte passen. Das Fahrzeug ist etwa 4-5 sekunden unterwegs und die Motorleistung ist PID-seitig auf etwa 5% begrenzt.
Eigentlich ist es erst schlecht geworden als ich auch negativwerte für den Motor zugelassen habe. Wenn ich nur vorwärts fahre sieht es besser aus.
Bei den tests mit KI und KD hatte ich nicht den eindruck das diese Werte überhaupt vorteilhaft sind. Also besser wurde es damit definitiv nicht.
Allerdings muss ich sagen, das ich einmal eine Situation auf einer schiefen Ebene hatte, wo das Fahrzeug (wenn es denn etwa 3Kg mehr wiegen würde) gehalten worden wäre.


Im Grunde wird es darauf hinaus laufen, das ich die Regelung bei erreichen des Endpunktes abschalten werde.
Wie ich schon schrieb ist das hier aktuell nur ein Testfahrzeug. Das Fahrzeug um was es letztendlich geht hat u.a. eine mechanische Motorbremse.
Die könnte ich einfallen lassen.
Was ihr da so schreibt ließt sich alles sehr speziell. Ich nehme daraus mit, das diese Werte und das drum herum doch sehr an das Fahrzeug und die Situation angepasst werden müssen.
Somit macht es nicht soviel Sinn an dem Testfahrzeug die Werte weiter zu optimieren wenn das eigentliche Fahrzeug doch so viel anders ist.

[i_make_it]

Eigentlich ist es erst schlecht geworden als ich auch negativwerte für den Motor zugelassen habe. Wenn ich nur vorwärts fahre sieht es besser aus.
Bei den tests mit KI und KD hatte ich nicht den eindruck das diese Werte überhaupt vorteilhaft sind. Also besser wurde es damit definitiv nicht.
Allerdings muss ich sagen, das ich einmal eine Situation auf einer schiefen Ebene hatte, wo das Fahrzeug (wenn es denn etwa 3Kg mehr wiegen würde) gehalten worden wäre.


Das dürfte Daran liegen das der A.I. "BRUSHLESS (PRO) REVERSE" sich asymetrisch verhält.
1,5ms bis 2,0ms Vorwärts.
1,5ms bis z.B. 1,3ms EMK für vorwärts Drehung.
1,3ms bis 1,0ms Rückwärts.

Du könntest jetzt versuchen, mal das PWM vom Servo synchon mit dem DIR und PULS Signal das Du aus dem Enkoder generierst auszugeben (seriell Print).
Dann den den PID Regler bzw. die PWM Generierung so modifizieren das der EMK Bereich übersprungen wird.
Also 2,0 - 1,5ms Vorwärts und dann direkt von 1,5ms auf 1,3ms springen für 1,3 - 1,0ms für die Rückwärtsfahrt.
Den tatsächlichen Wert wo EMK aufhört und Rückwärts anfängt müsste man dann empirisch ermitteln.

[Holomino]

Wenn Du schreibst, Du begrenzt per PID den Leistungsbereich auf 5%, muss ich mal nachhaken: Setzt Du jetzt nur noch Steuersignale zwischen 1,475 und 1,525 ms an den Motorregler ab?

[i_make_it]

Da ich die letzten 10 Jahre fast nichts mehr mit RC gemacht habe, habe ich erst mal etwas auffrischen müssen.

Also im Extremfall verhält sich der "A.I. BRUSHLESS (PRO) REVERSE" Regler wie folgt.
Servosignal 2,0ms - 1,5ms proportional Vorwärts.
1,5ms - 1,25ms (50% des Bereichs) EMK, proportionale Bremswirkung der Vorwärtsdrehung.
1,5ms - 1,25ms bei Stillstand keine Funktion.
1,25ms - 1,0ms proportional Rückwärts.
Je nach Regelverhalten,
kann er noch die Drehung über die Hallsensoren oder EMK auswerten und Rückwärts erst freigeben wenn der Motor steht.
Das ist zumindest ein oft vorkommendes Setting für RC-Cars.
Da der "LRP-Eraser" von seiner Bauform eher wie die alten EF 76 DC Motoren aussieht, dürfte der primär für Schiff- und Automodelle gedacht sein.
Was mit dem Regelverhalten dann hinkäme.
Sprich dein PID muß wirklich die EMK ausblenden und dann erst kannst Du sehen ob nicht noch eine Stillstandserkennung im Regler steckt.
Falls ja, wirst Du mit dem "A.I. BRUSHLESS (PRO) REVERSE" nie einen Erfolg mit Deiner PID Regelung haben.

Dann bist Du auf sowas:
https://www.lxrobotics.com/produkte/arduino-shields/brushless-motorshield
angewiesen.
Dazu kommt dann noch die Auswertung der Hallsensoren, da es die für eine Positionsregelung (= niedrige Drehzahl) braucht.