Motoren Geschwindigkeit/ Leistungskontrolle

By | 13. Juli 2014

Durchmesser, Radius und Umfang

Radius, Durchmesser und Umdrehung. Diese drei Faktoren sind sehr wichtig in der Robotik. Soll ein Roboter besonders schnell fahren oder soll er eine Strecke mit Hindernissen (Unebenheiten auf dem Boden) meistern, ist es ein Fahrzeug für draußen (Off-Road)?

Als Radius (von lat. radius; „Strahl“) (deutsch: Halbmesser) bezeichnet man in der Geometrie den Abstand zwischen dem Mittelpunkt M eines Kreises und der Kreislinie.

Der Radius r entspricht dem halben Durchmesser d. Zum Kreisumfang U verhält sich der Radius wie folgt: .

Bei dem NXT Rad ist das: radius

Der Durchmesser (griech. Diameter) ist die Entfernung zwischen den Schnittpunkten eines Kreises mit einer Geraden, die dessen Mittelpunkt schneidet.

Der Umfang ist  die Strecke, die das Rad bei einer Umdrehung zurücklegt.  Den Umfang errechnet man mit der Formel:

// Der Durchmesser x Pi = der Umfang

Pi (π) ist eine mathematische Konstante, eine Kreiszahl mit dem unendlichen Wert:

3,14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59230 78164 06286 20899 86280 34825 34211 70679 …

 

Der Umfang des Rades bzw. Reifen bedeutet abgewickelt auf die Straße den zurückgelegten Weg.

Bsp.:  Ein Legorad mit einem Durchmesser von 3,18 cm hat einen Umfang von 9,99 cm.rad

Nach einer Umdrehung hat das Rad also 9,99 cm zurückgelegt. Jetzt ein paar Aufgaben zum Üben. Die richtige Radgrößenwahl kann manchmal einen Wettbewerb entscheiden!

 

Aufgaben:

1. Du hast diesen Roboter:Der Durchmesser des Rades beträgt 5,5 cm.Wie weit ist der Roboter gefahren, wenn sich das Rad 8-mal gedreht hat? 

­­­­­­­________________________ cm

 nxtrad

 

2. Du bereitest dich auf einen Wettkampf vor. Die Aufgabe lautet: Der Roboter soll eine Strecke von 10 m so schnell es geht fahren. Du hast 4 Räder mit folgenden Durchmessern zur Auswahl:

2,86 cm  , 3,18 cm , 5,5 cm und 7,94 cm.

Wie viele Umdrehungen muss dein gewähltes Rad machen?

 

Erstelle eine Tabelle in der du die Umdrehungen vergleichen kannst.

Durchmesser Formel Umdrehungen
2,86 cm __________ . π = __________________
3,18 cm
5,5 cm
7,94 cm

Wenn der Roboter eine bestimmte Streckenlänge fahren soll, er das aber nicht exakt so macht, kann es verschiedene Gründe dafür geben. Manchmal hängt es vom Antrieb deines Roboters, dem Ladezustand der Batterien oder des Akku und von der Art der Oberfläche ab, auf welcher der Roboter läuft.

Hier hilft es den Durchschnitt zu errechnen.

 

Aufgabe:

1. Nimm deinen Roboter und lasse ihn 3 Mal drei Sekunden vorwärts fahren.

Markiere mit Kreide einen Punkt auf den Reifen und zähle die exakten Umdrehungen.Was stellst du fest?Berechne nun den Durchschnitt.Ergebnis 1 + Ergebnis 2 + Ergebnis 3

3

 d= 5,5 cmnxtrad2

Der Roboter legt in 3 Sekunden im Durchschnitt  eine Strecke von ____________ cm zurück.

 

Motoren Geschwindigkeit/ Leistungskontrolle

Wer eine Strecke genau fahren möchte, benötigt eine exakte Kontrolle der Motoren. In den Lego-NXT-Motoren ist ein Umdrehungsmesser, ein so genannter Encoder, integriert. Der Encoder zählt 360 Schritte für eine Umdrehung.

Hier zeigen sich die Vorzüge von z.B. RobotC. Alle notwendigen Funktionen sind in der Software vorhanden, werden aber von der grafischen Oberfläche (NXT-G) nicht genutzt. Für die Steuerung der Motoren gibt es sehr viele unterschiedliche Funktionen.

Für Leistung ist eine Zahl zwischen -100 und 100 anzugeben. Negative Werte bedeuten dabei eine Umkehr der Drehrichtung.

 

Für Versatz wird ebenfalls eine Zahl zwischen -100 und 100 verlangt. Dabei werden für 0 beide Motoren synchronisiert (geeignet z.B. für gerade Fahrt), bei 100 sowie -100 genau entgegengesetzt gedreht (jeweils andere Richtung, z.B. zum Drehen auf der Stelle).  Vorsicht: Bei Werten knapp unterhalb von +50 bewegt sich nur einer der beiden Motoren, der andere bleibt nahezu regungslos.

 

Sensoren – Umdrehungssensor

In jedem Motor ist ein Rotationssensor eingebaut. Das Rotationssignal beinhaltet zwei Werte:

1. die Drehrichtung des Motors

2. die Anzahl der Drehimpulse.

Der NXT-Baustein erhält 360 Drehimpulse. Das entspricht 3600 für eine Umdrehung.

 

Mit nMotorEncoder[] wird der Umdrehungsmesser im Motor angesprochen.  Um den Motor bis zu einer bestimmten Umdrehungsanzahl laufen zu lassen, schreibt man (warten bis die Anzahl erreicht ist):

while (nMotorEncoder[motorA] < 1000)    //siehe Seite 39
{
Motor[motorX] = 100;  // hier werden den Motoren (dem Motor) die Leistung zugewiesen
}

 

Für Fortgeschrittene:

Die Winkelstellung eines Motors am Anschluss Port kann jederzeit, also auch während der Drehung, mit nMotorEncoder[motor]abgefragt und mit nMotorEncoder[motorA]=0;  auf 0 zurückgesetzt werden.

nMotorEncoder[] ist eine 16-bit Variable. Der Maximale Wert beträgt 32,767 welcher 95 Umdrehungen entspricht.

 

 

nMotorEncoder[motorA]=0;  zurücksetzen  Motor an Ausgang A

 

 

Man kann einem Motor eine bestimmte Anzahl von Umdrehungen zuordnen. Dieses geschieht mit der Anweisung nMotorEncoderTarget[]. Der Umdrehungsmesser zählt dann die Umdrehungen. Mit dieser Anweisung hat der Motor aber noch keine Leistung. Dazu braucht man die Anweisung der Leistungszuordnung für den Motor.

 

nMotorEncoderTarget[motorA] = 500; // zählt 500 Drehimpulse und stoppt
motor[motorA] = 50;                  // Bewegung mit 50% Leistung

 

Die Motoren drehen sich also solange, bis sie einen bestimmten Drehwinkel erreicht haben. Der nächste Befehl erlaubt es die Motoren zu synchronisieren, er bietet sich für normale gerade Fahrtstrecken an:

nSyncedMotors = synchType;

 

Bei:

nSyncedMotors = synchNone;  // werden die Motoren nicht synchronisiert

 

und bei:

 

nSyncedMotors = synchAC;    // Motor ‘C’ wird mit Motor  ‘A’ synchronisiert. Motor C ist dabei “Slave” und Motor A ist der “Master”.

Um die Leistung beider Motoren synchron anzugeben verwendet man die Variable  nSyncedTurnRatio.  Auch hier gibt man die Werte an von -100% bis +100%.

 

nSyncedMotors = synchAC;    // Motor C ist Slave von Motor A
//
// ………..
//
nSyncedTurnRatio = +100;
nMotorEncoder[motorA] = 0;
nMotorEncoderTarget[motorA] = -1000;
motor[motorA] = 100;

 

while (nMotorEncoder[motorA] < 1000)  // warte so lange, bis die Impulse  erreicht sind
{}
//
// ……….
//
nSyncedTurnRatio = -100;
nMotorEncoderTarget[motorA] = 200;
motor[motorA] = 50;

Die Motor-Befehle im ersten Teil setzen die Motoren nur in Gang, das Abschalten der Motoren erfolgt dann in Abhängigkeit von Sensor-Werten, oder der Zeit. Bei den folgenden Motor-Befehlen wird ein Drehwinkel vorgegeben, Dieses Verhalten ist z.B. dann nützlich, wenn man eine genau festgelegte Strecke zurücklegen möchte, oder der Roboter seine Richtung um einen bestimmten Winkel ändern soll.

Aufgabe:       

  1. Schreibt das obere Programm ab, kompiliert es und übertragt es auf den NXT bzw. euren Roboter. (Speichern nicht vergessen) – Was passiert?
  2. An welcher Stelle dreht der Roboter? Tragt es in den Quellcode ein.

 

Brake und Coast/Float Modus

Die Motorengeschwindigkeit wird durch die Pulsweitenmodulation (PWM) geregelt.  Die Pulsweitenmodulation (PWM) (auch Unterschwingungsverfahren) ist eine Modulationsart, bei der eine technische Größe (z. B. elektrischer Strom) zwischen zwei Werten wechselt. Dabei wird das Tastverhältnis bei konstanter Frequenz moduliert. Ein anschauliches Beispiel für diese Modulationsart ist ein Schalter, mit dem man eine Heizung ständig ein- und ausschaltet. Je länger die Einschaltzeit gegenüber der Ausschaltzeit ist, umso höher die mittlere Heizleistung. Die Temperatur der Heizung kann nur vergleichsweise langsam dem Ein- und Ausschaltvorgang folgen und ergibt so das notwendige Tiefpassverhalten zur Demodulation. (aus wikipedia.de)

Während der “Off”-Zeit wird die Leistung nicht auf die Motoren übertragen. Während der Off-Zeit der Motoren kann die Leistung entweder “freilaufend” oder “kurzgeschlossen” sein.    „Kurzschluss“ führt zu einer Bremsung/Blockung. RobotC hat eine kontrollierende Variable die unterscheidet, welcher Modus verwendet wird.

 

bFloatDuringInactiveMotorPWM = false; // bremsen, wenn die Motoren inaktiv sind

 

bFloatDuringInactiveMotorPWM = true;  // freilaufen, wenn die Motoren inaktiv sind

 

Der “Brake-Modus” ist der Bessere für den NXT und gleichzeitig der Standard-Modus.

 

Aufgabe:         1. Schreibe ein kleines Programm, wobei der Roboter mit einer Leistung von 75% 2 Sekunden vorwärts, bremsen, 5 Sekunden warten und dann 2 Sekunden rückwärtsfahren soll. Nun soll der Roboter stoppen aber nicht bremsen. Mache eine Markierung, von wo du gestartet bist. Was stellst du fest? Beschreibe dein Ergebnis und erkläre den Unterschied von bFloatDuringInactiveMotorPWM “false” und “true”.

2. Schreibe ein Programm mit synchronisierten. Lasse deiner Fantasie freien Lauf.

Beobachte den Roboter und verändere die Werte.

 

Die Leistung der Motoren hängt z.T. von den Batterien oder der Oberfläche ab. Mit nagelneuen Batterien kann ein Motor sich mit fast 1.000 Impulsen (Encoder) pro Sekunde bewegen. Aber mit einem teilweise entladenen Motor und einem Motor, der irgendeine Abnutzung  (Alter…) hat, kann sich die Höchstgeschwindigkeit auf 750 Zählimpulsen verringern. Dieses hat eine Auswirkung auf Geschwindigkeitsregelung. Mit völlig belasteten Batterien kann sich eine durchschnittliche Leistung von 75%  ergeben, für die Motoren eine regulierte Geschwindigkeit von 750 Zählimpulsen pro Sekunde. Aber mit neuen Batterien kann 100% Energie genutzt werden!

 

Damit die Geschwindigkeitsregelung richtig funktioniert, muss dort „Raum“ sein. nMotorPIDSpeedCtrl[].

 

nMotorPIDSpeedCtrl[motorA] = mtrNoReg;    // sperrt die Motordrehzahlregelung

nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg; // ermöglicht die konstante Motordrehzahlregelung

Beispiel:

nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg; //PID Motor A an

nMotorPIDSpeedCtrl[motorC] = mtrSpeedReg; //PID Motor C an

motor[motorA] = 50; // Motor A hält die Drehbeschleunigung mit   50% Leistung … auch wenn Reibung/Batteriezustand variieren

motor[motorC] = 50; // Motor C hält die Drehbeschleunigung mit   50% Leistung … auch wenn Reibung/Batteriezustand variieren

wait1Msec(5000);

Wenn die Batterien teilweise entladen werden, sollte man nicht versuchen, eine regulierte Geschwindigkeit über 750 Zählimpulsen pro Sekunde zu erzielen. Dies heißt, dass, wenn man gleich bleibende Geschwindigkeiten über Batterieniveau erzielen möchte, man entweder die  Geschwindigkeiten über dem 75% Niveau nicht spezifizieren oder das Höchstgeschwindigkeitniveau verringern muss. Letzteres  kann mit der folgenden Variablen eingestellt werden:

nMaxRegulatedSpeed = 750;

 

„Gespiegelte“ Motoren – Leistung umdrehen

Wenn man einmal einen Legoroboter baut, wo die Motoren aus baulichen Gründen anders herum eingebaut werden müssen, also wenn die Motoren sich vorwärts drehen der Roboter aber rückwärtsfährt, kann man die Drehrichtung spiegeln mit:

bMotorReflected[motorA] = true;

Um einen Wert umzudrehen gibt es auch den Modus bMotorFlippedMode[].  Es gibt zwei Einstellungen:  0; ist normal und 1; ist rückwärts.

Bsp.:

motor[motorA]= 100;  // Motor A – volle Kraft vorwärts
motor[motorC]= 100;  // Motor C – volle Kraft vorwärts

 

bMotorFlippedMode[motorA]= 1;  // „umdrehen“
motor[motorA]= 100;  // Motor A – volle Kraft rückwärts
motor[motorC]= 100;  // Motor C – volle Kraft vorwärts

 

Hier eine Liste der Anweisungen in der Übersicht :

motor[]

Setzt die Geschwindigkeit  (-100 bis +100) für einen Motor.

 

nMotorPIDSpeedCtrl[]

Ermöglicht oder sperrt die Geschwindigkeitsregelung auf einem Motor. Die Regelung stellt eine exakte Steuerung über die Motordrehzahl unter Verwendung des Rückgabewertes von dem Encoder zur Verfügung.

 

nSyncedMotors

Synchronisiert  Paare der Motoren, um die Bewegung eines „Slave“-Motors mit dem Primärmotor zu synchronisieren. Der `’slaved Motor folgt der Geschwindigkeit und der Bewegung des `primary Motors.

 

nSyncedTurnRatio

Bestimmt die Bewegung für den Slave-Motor für das Paar der synchronisierten  Motoren.

 

nMotorEncoder[]

Lese/Schreibe die aktuelle Position des Umdrehungsmessers.

 

nMotorEncoderTarget[]

Setzt den Rahmen für die Bewegung eines Motors mit Hilfe des Umdrehungsmessers (Encoders). Bsp.: der Motor soll 8 Umdrehungen machen: 8MotorEncoderTarget[motorA].

Das Ziel (target) soll sein: 8 Motorumdrehungen.

 

nMotorRunState[]

Enthält den Zustand (der Leerlauf, Fahrt nach vorn oder zurück, Encoder-Position  während die Motoren gestoppt werden), eines Motors. Diese Variable liefert eine einfache Methode der Prüfung, wann ein Motor einen gezielten Kodiererzählimpuls erreicht hat – der Bewegungszustand sich ändert z.B. „zum Leerlauf“ oder wenn eine Position erreicht wird und Motor gestoppt worden ist.