Roboter Antrieb by DL1NOS

2.1 Einleitung

Für die Fortbewegung des Roboters kommen zwei Schrittmotoren zum Einsatz. Mit Schrittmotoren können sehr genaue Bewegungen durchgeführt werden. Jeder gefahrene Zentimeter lässt sich präzise messen. Außerdem besitzen Schrittmotoren ein hohes Drehmoment und sind somit wie geschaffen für unseren Roboter. Man unterscheidet Unipolare und Bipolare Schrittmotoren. Diese Steuerung kann beide Varianten betreiben. Im Bild 1 ist ein Unipolarer Schrittmotor abgebildet. Die beiden Mittenanzapfungen (schwarze und weisse Leitung) bleiben unbenutzt und werden nicht verlötet. Durch die Kombination der Schaltkreise L297 und L298 ist der sogenannte Chopper-Betrieb des Schrittmotors möglich. Nähere Informationen dazu sind auf der Seite http://www.strippenstrolch.de zu finden. Der abgebildete Schrittmotor benötigt pro Wicklung 5,0V und 0,8A . Werden, wie in diesem Fall zwei Spulen in Reihe geschaltet, verdoppelt sich die Spannung auf 10,0V. Für die Stromaufnahme ergibt sich folgende Rechnung (0,8A / (Wurzel 2)) = 0,565A im Chopperbetrieb der Schrittmotorsteuerung. Der Chopperbetrieb ist aktiv, sobald am Enable-Eingang +5V angelegt wird. Das bedeutet, dass mit dem Trim-Potentiometer bei 10,0V eine Stromaufnahme von 0,56A eingestellt werden muss. Bei dieser Gelegenheit zeigt sich ein weiterer Vorteil dieser Steuerung. Je nach Gewicht des Roboters kann die Stromaufnahme und damit das maximale Drehmoment stufenlos eingestellt werden. Soll der Akku länger halten oder fährt mein Roboter nur auf ebenen Flächen (Parkett), so kann der Strombedarf getrost heruntergeregelt werden. Fährt der Roboter auf Teppichen und über Teppichkanten, dann muss die Stromaufnahme so eingestellt werden, dass der Roboter diese Hindernisse bei maximaler Geschwindigkeit problemlos meistert.

 

Abbildung 1: Schrittmotorsteuerung für den Antrieb

Abbildung 1: Schrittmotorsteuerung für den Antrieb

 

2.1.1 Bestellliste

Es lohnt sich bei den Widerständen mindestens 10 Stück zu kaufen. Benötigt werden mindestens die in der Bestellliste angegebenen Bauteile. Das ergibt dann zwei Schrittmotorsteuerungsplatinen.

Nr. Bezugsquelle Best.-Nr. Was Anz. Einz.-Preis Ges.-Preis
1 ebay Schrittmotor 2 19,90 19,90
2 reichelt L 297 Motor-Driver, DIL-20 2 2,10 4,20
3 reichelt L 298 Driver, Multiwatt-15 = L 298N 2 1,90 3,80
4 reichelt PT 6-L 1,0K Einstellpotentiometer, 6mm, 1,0 K-Ohm 2 0,23 0,46
5 reichelt X7R-2,5 100N Vielschicht-Keramikkondensator 100N, 10% 8 0,04 0,32
6 reichelt KERKO 220P Keramik-Kondensator 220P 2 0,06 0,12
7 reichelt KERKO 3,3N Keramik-Kondensator 3,3N 2 0,06 0,12
8 reichelt 2W DRAHT 0,56 Draht-Widerstand 2W, 10% 0,56 Ohm 4 0,23 0,92
9 reichelt 1N 5822 Schottky Diode, DO201AD, 40V, 3A 16 0,21 3,36
10 reichelt WSL 10G Wannenstecker, 10-polig, gerade 2 0,08 0,16
11 reichelt RAD 1.000/25 Elektrolytkondensator, 12,5x20mm, RM 5,0 2 0,10 0,20
12 reichelt METALL 1,00K Metallschichtwiderstand 1,00 K-Ohm 2 0,082 0,164
13 reichelt METALL 2,70K Metallschichtwiderstand 2,70 K-Ohm 2 0,082 0,164
14 reichelt METALL 10,0K Metallschichtwiderstand 10,0 K-Ohm 4 0,082 0,328
15 reichelt METALL 22,0K Metallschichtwiderstand 22,0 K-Ohm 4 0,082 0,328
16 reichelt V 5640A Spezial-Kühlkörper, 33×25,4mm, 20K/W 1 0,39 0,39

 

2.2 Schaltpläne, Platinenlayouts

Die Schaltpläne und Platinenlayouts wurden mit dem Layoutprogramm Eagle erstellt und können beim Anklicken des Bildes heruntergeladen werden.

 

2.3 Berechnungen

2.3.1 Schritte pro Zentimeter

Normalerweise braucht ein Staubsauger-Roboter kein Gedächtnis, auf welchem Punkt der Fläche er sich befindet / befunden hat. Durch das Zufallsprinzip erreicht er früher oder später jede Ecke der Fläche. Das soll bei unserem Roboter anders werden. Unser Roboter soll genau wissen, wo er war, wo sich welche Hindernisse befinden und welche Ecken noch abgesucht werden müssen. Eine Genauigkeit im Zentimeterbereich sollte daher ausreichen. Wir benötigen also Kenntnis über die zurückgelegten Zentimeter bis zum Erreichen eines Hindernisses. Mit den Schrittmotoren geht das problemlos. Die verwendeten Schrittmotoren haben einen Winkel von 1,8° pro Vollschritt. Das bedeuted, wenn sich das Rad einmal vollständig um die eigene Achse drehen soll, dann müssen 200 Schritte gemacht werden (360° Vollkreis/1,8° pro Schritt = 200).

Frage: Wieviele Motor-Schritte müssen für einen Zentimeter gemacht werden?

Lösung: An den Schrittmotoren sind Räder mit einem Durchmesser von 5,5cm befestigt. Wir brauchen also den Umfang der Räder. Die Formel dafür lautet: Umfang=PI*Durchmesser. Eingesetzt in die Formel ergibt sich ein Umfang  von 17,27cm (3,14*5,5cm). Das heißt, bei einer vollen Umdrehung des Rades werden 17,27cm Weg gefahren. Wir wissen, dass 200 Schritte einer Umdrehung von 360° entsprechen. Deshalb stellen wir folgenden Dreisatz auf: 17,27cm entspricht 200 Schritte und 1cm entspricht x Schritte. Jetzt rechnen wir: 200*1cm/17,27cm. Ergibt 11,58 Schritte. Das heißt nach 12 Motor-Schritten hat sich unserer Roboter um 1cm bewegt.

Noch genauer  kann der Roboter bei Verwendung von Halbschritten gesteuert werden. In dem Fall beträgt der Winkel nur 0,9° pro Halbschritt. Es müssen dann 400 Schritte für eine Umdrehung von 360° erfolgen. Diese hohe Genauigkeit wird z.B. in Fräsmaschinen, Druckern oder Plottern benötigt. Für unsere Zwecke reicht die Vollschritt-Variante vollkommen aus.

 

2.3.2 Kurvenfahrt

Etwas Mathematik ist ebenfalls für eine Kurvenfahrt nötig. Es wäre prima, wenn man einer Funktion einen Winkel x übergeben kann und die Funktion dann selbständig errechnet, wieviele Schritte die Schrittmotoren ausführen müssen. Hierzu folgende Überlegung: Wenn der Roboter eine Kurvenfahrt vornimmt, zeichnet das angetriebene Rad einen Kreis. Das andere Antriebsrad steht im Mittelpunkt des Kreises still. Soll ein Roboter mit drei Rädern eine komplette Runde im Kreis drehen, so ist der Radstand, also der Abstand der beiden Antriebsräder zueinander, wichtig. Der Radstand definiert, wieviele Zentimeter sich ein Rad drehen muss, um den Roboter um einen Winkel x zu drehen (Abbildung 2).

Abbildung 2: Radstand Roboter Verdeutlichung am 360° Vollkreis

Abbildung 2: Radstand Roboter Verdeutlichung am 360° Vollkreis

Bei unserem Roboter beträgt der Radstand 21cm. Aber Achtung: der Radstand entspricht dem Radius eines Kreises. Wir brauchen also wieder den Umfang. Ähnlich, wie im vorherigen Kapitel, rechnen wir: Umfang = PI * Radius * 2. Eingesetzt in die Formel ergibt sich ein Umfang (3,14 * 21cm * 2) von 131,88cm also rund 132cm. Das heißt für eine volle Drehung von 360° muss ein Schrittmotor 132cm weit fahren. Wir haben im vorherigen Kapitel berechnet, dass ein Zentimeter ca. 12 Schritten entspricht. Jetzt können wir die 132cm in die Anzahl der Schritte umrechnen (132cm * 12 Schritte pro cm = 1584 Schritte), die ein Schrittmotor für eine Drehung des Roboters um die eigene Achse machen muss. Soweit so gut. Berechnen wir als Beispiel eine 90° Kurve. Wir stellen wieder einen Dreisatz auf: 360° entspricht 132cm, 90° entspricht x. Und wir rechnen: (90° * 132cm) / 360° ergibt 33cm. 33cm * 12 Schritte pro cm = 396 Schritte. Damit fährt unser Roboter einen ziemlich großen 90° Bogen. Aber halt, haben wir nicht zwei Schrittmotoren? Da könnte man doch das zweite Rad entgegengesetzt drehen, damit würde sich unser Roboter auf der Stelle drehen. Wir lassen also den linken Schrittmotor 198 Schritte im Uhrzeigersinn und den rechten Schrittmotor 198 Schritte im entgegengesetzten Uhrzeigersinn drehen (396 / 2 = 198). Jetzt dreht sich unserer Roboter auf der Stelle (Abbildung 3). Aber nur, wenn sich der Dreh- und Angelpunkt (Pivotpunkt) genau in der Mitte des Roboters befindet! Sind die Räder im Roboter weiter hinten angebracht, dann liegt der Pivotpunkt ebenfalls weiter hinten.

Abbildung 3: Roboter Drehung auf der Stelle

Abbildung 3: Roboter Drehung auf der Stelle

 

2.4 Funktionstest

Zum Testen der Schrittmotor-Endstufen stecken wir einen ATMega8 und eine Steckerleiste auf das Steckbrett und verbinden die Leitungen. Spätestens hier sollte die Frage kommen, wie die Steckerleiste vernünftig auf das Steckbrett gesteckt werden soll. Die zwei Reihen der Steckerleiste sind zu eng beieinander, deshalb kann die Steckerleiste nicht direkt auf das Steckbrett gesteckt werden. Wir brauchen eine Art Adapter. Entweder lötet man an die Steckerleiste Leitungen und biegt sie soweit auseinander, dass die Leitungen in das Steckbrett passt oder man nimmt sich ein Stück Streifenraster-Platine, lötet die Steckerleiste und jeweils etwas versetzt zwei 5-polige Pinleisten auf und trennt schlussendlich in der Mitte der Steckerleiste die Verbindung, damit keine Kurzschlüsse zwischen den zwei Reihen entstehen. Die Pinleisten müssen allerdings dann von der Lötseite angelötet werden, was sich als etwas knifflig herausstellt und nur mit einem sehr spitzen Lötkolben einigermaßen vernünftig verlötet werden kann. Ist die Steckerleiste auf dem Steckbrett, dann sollten alle Leitungen zum Mikrocontroller mit einem Multimeter durchgemessen werden. Als Nächstes wird ein 10-poliges Flachbandkabel vom ATMega8 zu den Schrittmotorplatinen abgemessen, abgeschnitten und an die passenden Stellen Pfostenbuchsen (Reichelt: PFL 10) gekrimpt. Beim Krimpen immer auf PIN1 achten! Anschließend prüfen, ob die Verdrahtung korrekt ist und keine Kurzschlüsse vorhanden sind, dann die Spannung mit einem Labornetzteil zuschalten.

Abbildung 4: Erste Testschaltung zum Prüfen der Schrittmotorplatinen

Abbildung 4: Erste Testschaltung zum Prüfen der Schrittmotorplatinen

Die beiden Schrittmotor-Platinen sind jeweils gegenüberliegend verdrahtet. Damit können beide Platinen und die daran angeschlossenen Schrittmotoren unabhängig voneinander angesteuert werden. Im Schaltplan entsprechen die Pins 3 (Enable), 5 (Halb/Vollschritt), 7 (Clock) und 9 (Uhrzeigersinn/entgegengesetzter Uhrzeigersinn) der rechten Platine und dem rechten Schrittmotor, die Pins 4 (Enable), 6 (Halb/Vollschritt), 8 (Clock) und 10 (Uhrzeigersinn/entgegengesetzter Uhrzeigersinn) der linken Platine und somit dem linken Schrittmotor. Natürlich können die beiden Platinen auch getauscht werden. Ich habe sie während der Montage nur zufällig so angeordnet (im Schaltplan steht mit Absicht „Rechts“ auf der linken Seite und umgekehrt – daher nicht wundern).

Im Quellcode definieren wir uns sämtliche Ausgänge entsprechend der Anschlussbelegung in Abbildung 4, wie folgt:

für den linken Schrittmotor:
#define STEPPER_LEFT_CW                    PORTC |= 0b00000100;
#define STEPPER_LEFT_CCW                 PORTC &= ~(0b00000100);
#define STEPPER_LEFT_CLOCK_HI       PORTC |= 0b00001000;
#define STEPPER_LEFT_CLOCK_LO      PORTC &= ~(0b00001000);
#define STEPPER_LEFT_FULL_STEP     PORTC &= ~(0b00010000);
#define STEPPER_LEFT_HALF_STEP     PORTC |= 0b00010000;
#define STEPPER_LEFT_ENABLE            PORTC |= 0b00100000;
#define STEPPER_LEFT_DISABLE           PORTC &= ~(0b00100000);

und für den rechten Schrittmotor:
#define STEPPER_RIGHT_CW                   PORTC |= 0b00000001;
#define STEPPER_RIGHT_CCW                PORTC &= ~(0b00000001);

Wir müssen beim Initialisieren die Datenrichtungsregister der Anschlüsse auf Ausgang einstellen:
DDRC = 0b11111111;
DDRD = 0b00011000;

und die entsprechenden Einstellungen zu den Schrittmotoren aufrufen:
STEPPER_LEFT_CW
STEPPER_LEFT_FULL_STEP
STEPPER_LEFT_ENABLE
STEPPER_RIGHT_CW
STEPPER_RIGHT_FULL_STEP
STEPPER_RIGHT_ENABLE

Jetzt geben wir in einer Endlosschleife die Impulse auf den Schrittmotor-Treiber. Das dürfen wir aber nicht zu schnell tun, sonst drehen sich unsere Schrittmotoren nicht mehr. Deshalb ist eine Verzögerung z.B. mit einer Delay-Funktion notwendig:
while(1)
{
STEPPER_LEFT_CLOCK_HI
STEPPER_RIGHT_CLOCK_HI

_delay_ms(200);
_delay_ms(200);
_delay_ms(200);

STEPPER_LEFT_CLOCK_LO
STEPPER_RIGHT_CLOCK_LO

_delay_ms(200);
_delay_ms(200);
_delay_ms(200);
}
Drehen sich beide Schrittmotoren nicht, dann muss die Verkabelung und die Schrittmotor-Treiber auf Fehler, Kurzschlüsse oder kalte Lötstellen überprüft werden. Wenn beide Schrittmotoren funktionieren, dann alle Kombinationen austesten, z.B. beide Schrittmotor im entgegengesetzten Uhrzeigersinn drehen lassen oder anstatt Vollschritte Halbschritte oder beide Schrittmotoren deaktivieren und prüfen, ob noch Strom verbraucht wird, usw…

 

2.5 Treiber

War der Test erfolgreich, ist es an der Zeit, einen Treiber zu programmieren und die Schrittmotorsteuerung in dafür vorgesehene Dateien zu kapseln. Die berechneten Werte tragen wir in defines ein:

//Raddurchmesser: 5,5cm
//Schrittwinkel: 1,8° Vollschritt
//(360°/1,8°)/(5,5cm * 3,1415926) = 11,5749049521 -> rund 12
#define NUM_STEPS_PER_CM        12

//für die Drehung um einen bestimmten Winkel:
//Radstand: 21cm
//Umfang: 21cm * 3,1415926 = 65,97cm -> rund 66
//Beispiel für 90°: 66cm entspricht 360°, x cm entspricht 90° -> x = 17cm -> (/2 = 8 beide Räder um 8 cm drehen) also 8*12 (NUM_STEPS_PER_CM) = 96 Schritte
#define PERIPHERY_OF_CIRCLE        66

Bei zeitkritischen Prozessen bieten sich Timer viel eher an, als Verzögerungsfunktionen im Hauptprogramm. Außerdem ermöglichen sie es, Programmabläufe zu parallelisieren. Wir werden Timer 0 benutzen. Unsere Initialisierungsfunktion ergibt sich wie folgt:

/** \brief Initialisiert die Ausgänge und den Timer für die angeschlossenen Schrittmotoren
*/
void init_stepper( void )
{
DDRC = 0b11111111;
DDRD = 0b00011000;

STEPPER_LEFT_DISABLE
STEPPER_RIGHT_DISABLE

TCCR0 = _BV(CS01)|_BV(CS00);
}

Weiterhin definieren wir uns zwei Aufrufe, zum Ein- und Ausschalten des Timers:

#define TIMER0_ON                TIMSK |= _BV(TOIE0);
#define TIMER0_OFF                TIMSK &= ~_BV(TOIE0);

Was macht der Timer? In den Variablen steps_left und steps_right stehen die Anzahl der benötigten Schritte, die der linke und der rechte Schrittmotor ausführen müssen. Der Timer wird so lange automatisch aufgerufen, wie noch Schritte gemacht werden müssen. Die Schritte werden durch die definierten Aufrufe STEPPER_LEFT/RIGHT_CLOCK_LO, bzw. STEPPER_LEFT/RIGHT_CLOCK_HI auf unsere Ausgänge gegeben. Wenn keine Schritte mehr notwendig sind, dann wird die Funktion stepper_stop(); aufgerufen.

/** \brief Timer Interrupt Funktion für die Schrittmotoren
*/
ISR(TIMER0_OVF_vect)
{
if(steps_left > 0)
{
steps_left–;
if(STEPPER_LEFT_CLOCK_IS_HIGH)    STEPPER_LEFT_CLOCK_LO
else                                                 STEPPER_LEFT_CLOCK_HI
}

if(steps_right > 0)
{
steps_right–;
if(STEPPER_RIGHT_CLOCK_IS_HIGH)    STEPPER_RIGHT_CLOCK_LO
else                                                   STEPPER_RIGHT_CLOCK_HI
}

if(steps_right == 0 && steps_left == 0)    stepper_stop();

TCNT0 = speed;             //erlaubt eine Änderung der Geschwindigkeit auch während der Fahrt
}

Die Variablen steps_left und steps_right müssen wir modul-global anlegen:

unsigned long steps_left;
unsigned long steps_right;

Wir definieren zwei weitere Aufrufe:

#define STEPPER_LEFT_CLOCK_IS_HIGH             (PORTC & 0b00001000)
#define STEPPER_RIGHT_CLOCK_IS_HIGH          (PORTC & 0b00000010)

Fehlt noch die Funktion stepper_stop():

/** \brief Stoppt die Schrittmotoren unverzüglich
*/
void stepper_stop( void )
{
TIMER0_OFF                                                            //schaltet den Timer aus
STEPPER_LEFT_DISABLE
STEPPER_RIGHT_DISABLE
}

Wenn der Roboter geradeaus fahren soll, dann brauchen wir dafür folgende Funktion:

/** \brief Lässt den Roboter geradeaus fahren

\param[in] steps_full_half 0 = Vollschritte; 1 = Halbschritte
\param[in] forth_back 0=vorwärts, 1= rückwärts
\param[in] spd Geschwindigkeit von 0 (langsamste) bis 255 (schnellste) regelbar
\param[in] cm Anzahl der Zentimeter die gefahren werden sollen (0 = unendlich)
*/
void go_straight_on(unsigned char steps_full_half, unsigned char forth_back, unsigned char spd, unsigned int cm)
{
if(steps_full_half == 0)     //Voll- oder Halbschritte
{
STEPPER_LEFT_FULL_STEP
STEPPER_RIGHT_FULL_STEP
}
else
{
STEPPER_LEFT_HALF_STEP
STEPPER_RIGHT_HALF_STEP
}

if(forth_back == 0)     //vorwärts oder zurück
{
STEPPER_LEFT_CW
STEPPER_RIGHT_CCW
}
else
{
STEPPER_LEFT_CCW
STEPPER_RIGHT_CW
}

STEPPER_LEFT_ENABLE
STEPPER_RIGHT_ENABLE

if(cm == 0)
{
steps_left  = 65535L;            //unendlich lässt sich schlecht abbilden, daher max. von (2 hoch 32)-1
steps_right = 65535L;
}
else
{
steps_left = cm*NUM_STEPS_PER_CM*2;          //Frage: Warum müssen für die korrekte Anzahl von 
steps_right = cm*NUM_STEPS_PER_CM*2;        //Schritten die Schritte mit zwei multipliziert
//werden? Antwort siehe unten.

}

if(steps_full_half == 1)
{
steps_left  *= 2;                    //bei Halbschritten müssen wir die Anzahl der Schritte mal zwei rechnen
steps_right *= 2;
}

speed = spd;                                            //Geschwindigkeit -> Nachladewert für Timer merken
TCNT0 = speed;

TIMER0_ON
}

Hier die Antwort: Am Clock Ausgang für den Schrittmotor (STEPPER_LEFT_CLOCK_LO, STEPPER_LEFT_CLOCK_HI, usw.) wird bei jedem Aufruf des Timers eine Statusänderung hervorgerufen, also ein Low->High-Übergang oder ein High->Low-Übergang. Statusübergänge akzeptiert der Schrittmotortreiber L297 nicht. Der Schrittomotortreiber erwartet einen vollständigen Zyklus. Es muss demnach zuerst ein Low->High-Übergang und danach ein High->Low-Übergang erfolgen. Erst dann veranlasst der Schrittmotortreiber L297 den Schrittmotor einen Schritt weiter zu drehen. Die Timer-Funktion muss also doppelt so oft aufgerufen werden. Konsequenz: Wir multiplizieren unsere steps_left und die steps_right-Variablen mit zwei. Diese Berechnung der Schritte sollten wir in eine Funktion packen, wir werden sie noch öfters benötigen:

unsigned long get_steps( unsigned int cm )
{
return (cm*NUM_STEPS_PER_CM)*2;
}
Natürlich müssen wir dann die Zuweisungen in der go_straight_on()-Funktion wie folgt abändern:

steps_left = get_steps(cm);
steps_right = get_steps(cm);

Folgende Funktion lässt den Roboter eine Kurve fahren:

/** \brief Berechnet die Parameter zum fahren einer Kurve
\param[in] steps_full_half 0 = Vollschritte; 1 = Halbschritte
\param[in] right_left 0=rechts herum, 1=links herum
\param[in] spd Geschwindigkeit von 0 (langsamste) bis 255 (schnellste) regelbar
\param[in] angle der Winkel, der gefahren werden soll: min. 0°, max. 360°
*/
void go_around_the_bend(unsigned char steps_full_half, unsigned char right_left, unsigned char spd, unsigned int angle)
{
unsigned long steps = get_steps(((angle * PERIPHERY_OF_CIRCLE)/360));

if(steps_full_half == 0)     //Voll- oder Halbschritte
{
STEPPER_LEFT_FULL_STEP
STEPPER_RIGHT_FULL_STEP
}
else
{
STEPPER_LEFT_HALF_STEP
STEPPER_RIGHT_HALF_STEP
}

if(right_left == 0)   //rechts herum
{
STEPPER_LEFT_CCW
STEPPER_RIGHT_CCW
}
else         //links herum
{
STEPPER_LEFT_CW
STEPPER_RIGHT_CW
}

STEPPER_LEFT_ENABLE
STEPPER_RIGHT_ENABLE

steps_left = steps;
steps_right = steps;

if(steps_full_half == 1)
{
steps_left  *= 2;                    //bei Halbschritten müssen wir die Anzahl der Schritte mal zwei rechnen
steps_right *= 2;
}

speed = spd;                                            //Geschwindigkeit -> Nachladewert für Timer merken
TCNT0 = speed;

TIMER0_ON
}

2.6 Probleme

Die beim Metallbaukasten mitgelieferten Gummireifen sind nicht fest mit der Plastik Felge verbunden. Das führt zwangsläufig dazu, dass der Roboter beim Gas geben oder abrupten Abbremsen „durchrutscht“. Weiterhin ist der Spalt zwischen Plastik-Felge und Gummi sehr groß. Eine mögliche Lösung ist das Auffüllen des Spaltes mit einer geeigneten Füllmasse und das anschließende verkleben des Gummis mit der Felge. Oder alternativ gänzlich andere Räder zu benutzen.

Die maximal noch halbwegs benutzbare Geschwindigkeit liegt im Test bei 200 als Nachladewert für den Timer und Vollschrittbetrieb. Versucht man, den Nachladewert mit noch größeren Werten zu laden, reicht das Drehmoment nicht mehr aus, die Leistung auf die Achse und die daran befestigten Reifen zu bringen.

 

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.