Softwarekonzept für autonomen Roboter

[oberallgeier]

.... Rad-Encoderimpuls wird genutzt, um einen Interrupt ... Umrechnung in zurückgelegte Wege ...

Langsam, langsam! Überleg mal, was Dein Interrupt bedeutet. Entweder zählst Du die Encoderimpulse in einem bestimmten Zeitraster oder Du misst die Zeit zwischen zwei Endoder-Interrupts.

So - was bedeutet ein Encoder-Interrupt? Dass seit dem letzten ein BESTIMMTER Weg zurückgelegt wurde ¹⁾. Also brauchst Du (hatte ich) da nicht extra Wege berechnen, wenn Du beim Regelungsansatz statt "Meter" das Längenmass "Abstand zwischen zwei Encoder-Interrupts" zu Grunde legst. Ist nur ne andere Einheit, aber keine andere Größe!

Und wenn Du diese Einheit nimmst, dann hast Du beim "Entweder" die - abgeleitete - Einheit Wege pro Zeit(raster) und beim "oder" die Dimension Zeit pro Weg (und das ist eine inverse Geschwindigkeit - die kann die Regelung bei entsprechendem Ansatz auch verarbeiten).

Etwas überlegen hilft manchmal aufwendige(re) Be-/Rechnungen zu vereinfachen.

¹⁾ Das gilt natürlich nur theoretisch - da gäbs noch nen eher unbekannten Schlupf und solche Unartigkeiten. Der Alptraum jedes Odometrie-Fuzzies.

[pemiso]

nach meinem Verständnis muss der Prozessor doch angestossen werden, um überhaupt einen Impuls zählen zu können, oder ein extra Zählerbaustein zählt sie und wird bei Abfrage im festen Zeitraster wieder genullt???

[oberallgeier]

nach meinem Verständnis muss der Prozessor doch angestossen werden, um ... zählen zu können ...

Ohhh - mein Prozessor läuft, wenn ich im Saft gebe, die Fuses ok sind usw. mehr Anstoß braucht der nicht. Aber Du meinst vermutlich, dass Du dem Prozessor irgendwie Dein Encodersignal "mitteilen" musst. Oder nicht?

Das Geheimnis heißt z.B. externer Interrupt, dann natürlich auch "Timer/Counter" (lies dazu mal das Datenblatt Deines Prozessors durch, da gibts mehrere Timer/Counter die verwendbar sind um a) Timer zu spielen - also ne Zeit zu messen oder einen Zeittakt zu bewirken oder b) um Counter zu spielen, d.h. z.B. Encoder-Signal-Flanken zu zählen . . . und da kann man sogar meist zwischen steigender, fallender oder irgendeiner Flanke auswählen.

... Für die Motoransteuerung ... habe ich ... Routinen entwickelt, die ... Korrektur ... bewirken ...

Das know how müsstest Du ja schon hier angewandt haben ! ? ! ?

[pemiso]

Hallo oberallgeier - ja danke, dass Ihr mir alle so auf die Spur helft!!!
Bei der timer-Doku des Prozessors bin ich auch gelandet, muss ich mir aber erstmal richtig reinziehen! Bei der Motoransteuerung habe ich bis dato noch gaaaanz primitiv gearbeitet - aller Anfang ist schwer ... s.u.

Der nächste Schritt ist die Erweiterung um die Nutzung der timer-Möglichkeiten ...

// sketch to test motor M1 with Pololu mc33926 carrier
/* Pin map
M1D1, M2D1 jumpered to LOW onbord
M1D2, M2D2 jumpered to HIGH onboard
EN jumpered to HIGH onboard
SLEW connected to arduino GND
*/
int M1G = 0; // Geschwindigkeit M1, M2
int M2G = 0;
int M1R = 1; // Richtung M1, M2 vorwärts
int M2R = 1;
int M1RG = M1R * M1G; // gerichtete Gecschwindigkeit M1, M2
int M2RG = M2R * M2G;


int M1IN1 = 4; // M1 IN1
int M1IN2 = 5; // M1 IN2
int INV = 6; // digital pin direction invert for both motor channelsint M1R = 1; // Richtung M1 vorwärts
int M2IN1 = 8; // M2 IN1
int M2IN2 = 9; // M2 IN2

int M1GND = M1IN1; // aktiver digitaler PWM-Pin M1, M2 default für Vorwärtsfahrt
int M2GND = M2IN1;
int M1PWM = M1IN2; // aktiver digitaler GND-Pin M1, M2 default für Vorwärtsfahrt
int M2PWM = M2IN2;

int pause = 1500;
int motordelay = 2;
// --------------------------


void setup () {
pinMode(INV, OUTPUT);
pinMode(M1IN1, OUTPUT);
pinMode(M2IN1, OUTPUT);
pinMode(M1IN2, OUTPUT);
pinMode(M2IN2, OUTPUT);
Serial.begin(9600);


Serial.println("Test M1 on Dual MC33926 Motor Carrier");
// Motorinitialisierung
digitalWrite(INV, LOW); // direction invert default value for both motor channels
digitalWrite(M1GND,LOW); // Motorlaufrichtung auf default
digitalWrite(M2GND,LOW);
analogWrite(M1PWM,0); // Motordrehzahl auf 0
analogWrite(M2PWM,0);
}


// --------------------------
void loop () {
Serial.println(""); Serial.println(""); Serial.println(""); Serial.println("");
M1RGW (1,155); M2RGW (1,155);
M1RGW (1,250); M1RGW (1,250);
M1RGW (-1,316); M2RGW (-1,316);
M1RGW(1,455); M2RGW(1,455);
M1RGW(-1,400); M2RGW(-1,400);
M1RGW(1,0); M2RGW(1,0);
delay(10000);


/*
// Serial.print("M1GND / M1PWM: "); Serial.print(M1GND); Serial.print(" / "); Serial.println(M1PWM);
M2RGW(1,0);
//delay(10000);
// Serial.print("M2GND / M2PWM: "); Serial.print(M2GND); Serial.print(" / "); Serial.println(M2PWM);
// Serial.println(""); Serial.println(""); Serial.println(""); Serial.println("");
// Serial.print("M1GND / M1PWM: "); Serial.print(M1GND); Serial.print(" / "); Serial.println(M1PWM);
M1RGW (1,155);
//delay(pause);
// Serial.print("M2GND / M2PWM: "); Serial.print(M2GND); Serial.print(" / "); Serial.println(M2PWM);
M2RGW (1,155);
//delay(pause);
// Serial.print("M1GND / M1PWM: "); Serial.print(M1GND); Serial.print(" / "); Serial.println(M1PWM);
M1RGW (1,250);
//delay(pause);
M1RGW (-1,316);
//delay(pause);
// Serial.print("M2GND / M2PWM: "); Serial.print(M2GND); Serial.print(" / "); Serial.println(M2PWM);
M2RGW(1,455);
//delay(pause);
M2RGW(-1,400);
//delay(pause);
M1RGW(1,0);
//delay(10000);
// Serial.print("M1GND / M1PWM: "); Serial.print(M1GND); Serial.print(" / "); Serial.println(M1PWM);
M2RGW(1,0);
*/
}


// --------------------------
void M1A(int G1, int G2) {
// abbremsen
// Serial.print("bremse von "); Serial.print(G1); Serial.print(" auf "); Serial.print(G2); Serial.print(": ");
int G = 0; for (G = G1; G >= G2; G--) {
analogWrite(M1PWM, G * 51 / 80); // reskalieren auf 255
delay(motordelay);
// Serial.print(" "); Serial.print(G); Serial.print(" ");
}
// Serial.println("");
M1G = G2;
// Serial.print(" M1G ");Serial.println(M1G);
}


// --------------------------
void M1B(int G1, int G2) {
// beschleunigen
// Serial.print("beschleunige von "); Serial.print(G1); Serial.print(" auf "); Serial.print(G2); Serial.print(": ");
int G = 0;
for (G = G1; G <= G2; G++) {
analogWrite(M1PWM, G * 51 / 80); // reskalieren auf 255
delay(motordelay);
// Serial.print(" "); Serial.print(G); Serial.print(" ");
}
// Serial.println("");
M1G = G2;
// Serial.print(" M1G ");Serial.println(M1G);
}


// --------------------------
void M2A(int G1, int G2) {
// abbremsen
// Serial.print("bremse M2 von "); Serial.print(G1); Serial.print(" auf "); Serial.print(G2); Serial.print(": ");
int G = 0; for (G = G1; G >= G2; G--) {
analogWrite(M2PWM, G * 51 / 80); // reskalieren auf 255
delay(motordelay);
// Serial.print(" "); Serial.print(G); Serial.print(" ");
}
// Serial.println("");
M2G = G2;
// Serial.print(" M2G ");Serial.println(M2G);
}


// --------------------------
void M2B(int G1, int G2) {
// beschleunigen
// Serial.print("beschleunige M2 von "); Serial.print(G1); Serial.print(" auf "); Serial.print(G2); Serial.print(": ");
int G = 0;
for (G = G1; G <= G2; G++) {
analogWrite(M2PWM, G * 51 / 80); // reskalieren auf 255
delay(motordelay);
// Serial.print(" "); Serial.print(G); Serial.print(" ");
}
// Serial.println("");
M2G = G2;
// Serial.print(" M2G ");Serial.println(M2G);
}


// --------------------------
void M1RW (int M1RN) {
M1R = M1RN; // Richtungswechsel
// Serial.print("R wechselt auf ");Serial.println(M1R);
if (M1GND == M1IN1) {
M1GND = M1IN2;
M1PWM = M1IN1;
}
else {
M1GND = M1IN1;
M1PWM = M1IN2;
}
digitalWrite(M1GND, LOW);
analogWrite(M1PWM, 0); // Stop nach Richtungswechsel
// Serial.print("M1GND / M1PWM: "); Serial.print(M1GND); Serial.print(" / "); Serial.println(M1PWM);
}


// --------------------------
void M2RW (int M2RN) {
M2R = M2RN; // Richtungswechsel
// Serial.print("R wechselt auf ");Serial.println(M1R);
if (M2GND == M2IN1) {
M2GND = M2IN2;
M2PWM = M2IN1;
}
else {
M2GND = M2IN1;
M2PWM = M2IN2;
}
digitalWrite(M2GND, LOW);
analogWrite(M2PWM, 0); // Stop nach Richtungswechsel
// Serial.print("M2GND / M2PWM: "); Serial.print(M2GND); Serial.print(" / "); Serial.println(M2PWM);
}


// --------------------------
void M1RGW (int M1RN, int M1GN) { // M1-Richtungs-Geschindigkeits-Wechsel auf M1-Rchtungs-Geschwindigkeit-Neu
int M1RGN = 0; // Richtungs-Geschwindigkeit M1 Neu
// Serial.println("");
// Serial.print(" fahre auf "); Serial.print(M1RN); Serial.print(" / "); Serial.println(M1GN);
M1RG = M1R * M1G; // aktuelle gerichtete Geschwindigkeit
M1RGN = M1RN * M1GN; // neue ...

if (M1RGN == M1RG) {
// keine Änderung nötig
// Serial.print("### unverändert: RGalt / neu "); Serial.print(M1RG);Serial.print(" / ");Serial.println(M1RGN);
}
else {
if (M1GN > 400) {
M1GN = 400; // Limitieren auf 400
M1RGN = M1RN * M1GN;
// Serial.println(" Limitiert auf 400");
}

// Richtung * Geschwindigkeit alt / neu sind unterschiedlich


if (M1RN != M1R) {
// Richtungen alt / neu ungleich
// Serial.print("### R alt / neu sind unterschiedlich: "); Serial.print(M1R);Serial.print(" / ");Serial.println(M1RN);
M1A(M1G, 0); // Abbremsen von M1G auf 0
M1RW (M1RN); // Richtungswechsel
M1B(0, M1GN); // Beschleunigen auf Geschwindigkeit-Neu
}
else {
if (M1GN > M1G) {
M1B(M1G, M1GN); // Beschleunigen auf Geschwindigkeit-Neu
}
else {
M1A(M1G, M1GN); // Abbremsen auf Geschwindigkeit-Neu
}
}
}
}


// --------------------------
void M2RGW (int M2RN, int M2GN) { // M1-Richtungs-Geschindigkeits-Wechsel auf M1-Rchtungs-Geschwindigkeit-Neu
int M2RGN = 0; // Richtungs-Geschwindigkeit M1 Neu
// Serial.println("");
// Serial.print(" fahre auf "); Serial.print(M2RN); Serial.print(" / "); Serial.println(M2GN);
M2RG = M2R * M2G; // aktuelle gerichtete Geschwindigkeit
M2RGN = M2RN * M2GN; // neue ...

if (M2RGN == M2RG) {
// keine Änderung nötig
// Serial.print("### unverändert: M2 RGalt / neu "); Serial.print(M2RG);Serial.print(" / ");Serial.println(M2RGN);
}
else {
if (M2GN > 400) {
M2GN = 400; // Limitieren auf 400
M2RGN = M2RN * M2GN;
// Serial.println(" Limitiert auf 400");
}

// Richtung * Geschwindigkeit alt / neu sind unterschiedlich


if (M2RN != M2R) {
// Richtungen alt / neu ungleich
// Serial.print("### M2 R alt / neu sind unterschiedlich: "); Serial.print(M2R);Serial.print(" / ");Serial.println(M2RN);
M2A(M2G, 0); // Abbremsen von M2G auf 0
M2RW (M2RN); // Richtungswechsel
M2B(0, M2GN); // Beschleunigen auf Geschwindigkeit-Neu
}
else {
if (M2GN > M2G) {
M2B(M2G, M2GN); // Beschleunigen auf Geschwindigkeit-Neu
}
else {
M2A(M2G, M2GN); // Abbremsen auf Geschwindigkeit-Neu
}
}
}
}

- - - Aktualisiert - - -

Ergänzung: das Codebeispiel läuft in der Arduino Entwicklungsumgebung auf Mega2560 mit dem Pololu MC99326 Dual Motor Controller Carrier (nicht Shield!!!).