Roboter an einem Auto entlang fahren lassen

[ga69jot]

was meinst du denn mit einem quasistationären regler?

[Geistesblitz]

Wo hab ich das denn bitte geschrieben?
Ich schrieb quasikontinuierlicher Regler, also ein Regler, der mit kontinuierlichen Werten arbeitet, nicht mit diskreten. Bei einer If-Verzweigung wird das Programm ja gucken, ob irgendwelche Werte über- oder unterschritten werden, wobei ein kontinuierlicher Regler direkt mit den Zahlenwerten vom Sensor arbeitet und daraus die neuen Stellgrößen für die Antriebe berechnet. Ich denk mal, du wirst nicht drum herum kommen, dir wenigstens ein paar Grundlagen zur Regelungstechnik anzulesen. Wenn du bei deinen if- und while-Schleifen bleiben willst, empfehle ich die Stichwörter Zweipunkt. bzw. Dreipunktregler.

[ga69jot]

Sorry habe mich verschrieben

Die Seite für Regelungstechnik habe ich schon gelesen
Ich weiß nur nicht, wie ich das mit dem arduino programmieren soll.
Vorallem habe ich ja zwei Sensoren, die messen und geben mir eine Entfernung in cm an. Dann gebe ich noch einen sollwert für die Entfernung an, und die Stellgrösse wird verändert (die Signale für servo-Motoren).

Ich komm aber nicht dahinter, wie die Stellgrössen je nach Entfernung gesetzt werden?! Wie programmiere ich das?

[Geistesblitz]

Wie sind denn die Sensoren angeordnet? Man könnte mittels der Differenz der Werte die Schrägstellung des Rollstuhls bestimmen und mitels Mittelwert ca. den Abstand. Man kann dann eine mittlere Geschwindigkeit für die Motoren vorgeben und je nachdem, wie groß jetzt die Werte für Schrägstellung und Abstand sind, wird bei einem Motor die Geschwindigkeit erhöht und bei dem anderen reduziert, damit der Rollstuhl beim fahren eine Kurve fährt. Wie sehr die Geschwindigkeitsänderung der Motoren aussieht kann man dann von den gemessenen Werten abhängig machen. Nehmen wir jetzt mal an, der Rollstuhl fährt an der linken Seite des Autos nach hinten, das Auto wäre also auf der linken Seite des Roboters. Nun lässt sich ja sagen, je mehr er nach links fährt (also Richtung Auto), soll sich das linke Rad schneller drehen und das rechte Rad langsamer. Für den Fall, dass er zu sehr nach rechts fährt, wärs dann umgekehrt. Mit dem Abstand wärs dann ähnlich, man legt einen Sollabstand fest und je mehr er davon in eine Richtung abweicht, desto mehr lenkt er die andere Richtung.
Um es mal in Form einer Formel darzustellen:
Motor_links = v_soll + a*Schrägungswinkel - b*(Istabstand-Sollabstand)
Motor_rechts = v_soll - a*Schrägungswinkel + b*(Istabstand-Sollabstand)
Wobei du jetzt nun noch herausfinden musst, wie du auf den Schrägungswinkel und den Istabstand kommst, sowie welche Werte am günstigsten für a und b sind. Das musst du wohl selber herausfinden, da braucht man dann die Daten vom Roboter, zB. wie die Sensoren angebracht sind, was sie für Werte liefern, Achsabstand der Räder usw. Am besten wäre es natürlich, wenn man das ganze schonmal in einem Programm simulieren könnte, bevor man anfängt, einen Prototypen nach dem anderen gegen ein Auto fahren zu lassen. Wenn man ganz genau gehen möchte, müsste man nämlich auch noch die Dynamik mit berücksichtigen, aber ich befürchte, dass du damit gerade überfordert wärst.

Nun möchte ich aber auch, dass du diese Gedanken dazu selber zuende führst. Ich hab eigentlich den Grundsatz, in Foren wie hier nur zu helfen, aber niemandem die eigentliche Arbeit abzunehmen.

[ga69jot]

Vielen Dank für die Antwort.

Erstmal, ich habe schon viele Gedanken darüber gemacht. Und genau das, was du beschrieben hast, habe ich schon versucht in ein Code zu schreiben.
Ich habe einen kleinen Rollstuhl, im maßstab 1:5 zum Original. Die Sensoren kommen auf die linke Seite vom Rollstuhl, einmal ganz vorne und einmal ganz hinten.
Für meinen Arduino habe ich schon 2 Sketches geschrieben. Einmal um den Rollstuhl parallel zu halten und einmal um Kurven fahren zu können.

Ich werde die Tage mal die beiden Sketches ausprobieren, inwieweit Sinn und Zweck erfüllt werden.
Bin mir leider nicht sicher ob meine Sketches funktionieren werden, auf Papier sieht alles gut aus

[ga69jot]

Hallo Community,

ich habe vorhin beide meiner Sketche am Rollstuhlmodell versucht.

Beim ersten Sketch versucht mein Rollstuhl sich parallel zur Wand zu halten, wenn parallel dann stoppt er.
Beim zweiten Sketch fährt er Kurven je nach Abstand.

Jetzt habe ich beide Sketches vereinigt, aber ich hab da ein Programmierproblem. Er versucht da auch nur parallel zu halten, Kurven fährt er nicht...

[Geistesblitz]

Wärst du dann auch so nett, uns den Code zu zeigen? Oder zumindest die Formeln, mit denen du die Stellgrößen berechnest, würden mich interessieren, ich bin leider nicht gut im Hellsehen

[ga69jot]

Mit Sicherheit. Der erste Code versucht das Ding parallel zu halten.

#include <Servo.h>

Servo servoRechts;
Servo servoLinks;
long Toleranzwert = 1;

const int TRIG_PIN1 = 12;
const int ECHO_PIN1 = 13;
const int ECHO_PIN2 = 8;
const int TRIG_PIN2 = 9;

void setup() {
  // initialize serial communication:
  Serial.begin(9600);

  pinMode(TRIG_PIN1,OUTPUT);
  pinMode(ECHO_PIN1,INPUT);
  pinMode(TRIG_PIN2, OUTPUT);
  pinMode(ECHO_PIN2, INPUT);
  servoRechts.attach(7);
  servoLinks.attach(6);

} 
void loop()
{
  long duration1, distanceCm1;
  long duration2, distanceCm2;
  long Differenz;

  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  digitalWrite(TRIG_PIN1, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN1, HIGH);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN1, LOW);
  duration1 = pulseIn(ECHO_PIN1,HIGH);

  digitalWrite(TRIG_PIN2, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN2, HIGH);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN2, LOW);
  duration2 = pulseIn(ECHO_PIN2,HIGH);

  // convert the time into a distance
  distanceCm1 = duration1 / 29.1 / 2 ;

  // convert the time into a distance
  distanceCm2 = duration2 / 29.1 / 2 ;


  if (distanceCm1 <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distanceCm1);
    Serial.print("cm");
    Serial.println();
  }

  if (distanceCm2 <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distanceCm2);
    Serial.print("cm");
    Serial.println();
  }


  delay(500);

  Differenz = abs(distanceCm2 - distanceCm1);
  if(Differenz > Toleranzwert){
    if(distanceCm2 > distanceCm1){
      servoLinks.write(92);
      servoRechts.write(90);
    }
    else{
      servoRechts.write(89);
      servoLinks.write(91);
    }
    Differenz = abs(distanceCm2 - distanceCm1);
  }
  else if (Differenz <= Toleranzwert){
    servoRechts.write(90);
    servoLinks.write(91);
    Differenz = abs(distanceCm2 - distanceCm1);

  }
}

Der zweite Code ist fürs Kurven fahren.

#include <Servo.h>

Servo servoRechts;
Servo servoLinks;
float Toleranzwert = 1;

const int TRIG_PIN1 = 12;
const int ECHO_PIN1 = 13;
const int ECHO_PIN2 = 8;
const int TRIG_PIN2 = 9;

void setup() {
  // initialize serial communication:
  Serial.begin(9600);

  pinMode(TRIG_PIN1,OUTPUT);
  pinMode(ECHO_PIN1,INPUT);
  pinMode(TRIG_PIN2, OUTPUT);
  pinMode(ECHO_PIN2, INPUT);
  servoRechts.attach(7);
  servoLinks.attach(6);

} 
void loop()
{
  long duration1, distanceCm1;
  long duration2, distanceCm2;
  long Differenz;

  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  digitalWrite(TRIG_PIN1, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN1, HIGH);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN1, LOW);
  duration1 = pulseIn(ECHO_PIN1,HIGH);

  digitalWrite(TRIG_PIN2, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN2, HIGH);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN2, LOW);
  duration2 = pulseIn(ECHO_PIN2,HIGH);

  // convert the time into a distance
  distanceCm1 = duration1 / 29.1 / 2 ;

  // convert the time into a distance
  distanceCm2 = duration2 / 29.1 / 2 ;


  if (distanceCm1 <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distanceCm1);
    Serial.print("cm");
    Serial.println();
  }

  if (distanceCm2 <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distanceCm2);
    Serial.print("cm");
    Serial.println();
  }


  delay(100);

  if( ( distanceCm1 + distanceCm2 ) / 2  > 52) {
    servoRechts.write(87);
    servoLinks.write(100);
  }
  else if( ( distanceCm1 + distanceCm2 ) / 2 < 48) {
    servoRechts.write(80);
    servoLinks.write(94);
  }
  else {
    servoRechts.write(80);
    servoLinks.write(100);
  }
}

Mir fehlt nur noch die Kombination. Ich hatte nicht viel Zeit und hab das parallel fahren einfach mal in die if-Schleifen kopiert und geguggt, was passiert...
Bei servoLinks.write(91) stoppt das linke Rad und bei servoRechts.write(90) stoppt das rechte Rad. Ein wert höher als 91 beim Linken dreht diesen nach vorne und ein Wert kleiner 90 dreht das rechte Rad vorwärts.

[Geistesblitz]

Das ist eine Info, die schon wesentlich früher gekommen sein müsste: Die Motoren können nur Vorwärts oder Stoppen, nix dazwischen und auch nicht rückwärts? Dann muss man es wirklich so angehen, wie du es begonnen hast. Mein Vorschlag würde in dem Fall folgendermaßen aussehen:

Wenn der Roboter zu nah am Auto steht oder zu weit nach links zeigt -> Rechtsdrehung
Wenn der Roboter zu weit vom Auto weg steht oder zu weit nach rechts zeigt -> Linksdrehung
Wenn der Roboter im richtigen Abstand zum Auto ist und auch parallel steht -> Geradeausfahrt

Dabei würde ich aber auch einen gewissen Toleranzbereich einplanen, zB. wenn die Differenz zwischen den Sensorwerten innerhalb gewisser Grenzen liegt, zählt es so, als wenn der Roboter parallel stünde. Ähnlich dann auch mit dem Mittelwert für die Abstandserkennung. Das macht das Ganze ein bisschen robuster, sonst würde der Bot die ganze Zeit nur hin und herzucken und dabei langsamer vorrankommen.

[ga69jot]

Doch doch, die Motoren können sich in beide Richtungen drehen
Also wenn man am Linken Motor einen Wert kleiner als 91 eingibt dann dreht er sich rückwärts und beim rechten Motor größer 90 dann rückwärts...

Der Sketch zum parallel halten funktioniert, er bleibt stehen wenn er parallel ist. Beim Kurven fahren geht es auch, also wenn er zu nah an der Wand ist fährt er nach rechts und wenn zu weit dann nach links...

Jetzt muss ich die beiden kombinieren, aber ich weiß nicht so recht wie ich das machen soll...

Toleranzwert für parallel stehen habe ich mit 1 bzw. 2cm versucht und für den Mittelwert habe ich ja einen Wert zwischen 48 und 52 cm ausgesucht...

Wie gesagt, einzeln funktionieren die beiden Sketches ja so wie ich es haben möchte aber wie kombiniere ich die nun?

EDIT:

Der Motor kann auch beschleunigt werden, zum Beispiel bei 90 stoppt er, zwischen 90 und 100 wird er beschleunigt und ab 100 ist auf v_max. Und in die andere Richtung dann 90-80 beschleunigen und kleiner 80 v_max.