INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
SR-04 + UNO + 4WD Roboter, Abstandsfehler
19.09.2014, 18:59
Beitrag #1
SR-04 + UNO + 4WD Roboter, Abstandsfehler
Hey Leute Smile

Ich habe ein kleines Problem bei meinem Roboter:

Hardware:

L293D Motorshield
SainSmart 4WD
Arduino Uno R3
Mini Servo
SR-04 Ultraschallsensor.

1.) Das Problem ist das ich einfach nicht draufauf komme wieso der Roboter für links und rechts immer den selben Abstand misst, auch wenn dieser zb. rechts ein Hindernis hat?

Hier mein code:

Code:
// HOMECONTROL ROBOTER 1
// Version 1.2 BETA

// ################################################################################​################################################################################​###############################################################


#include <AFMotor.h>
#include <Servo.h>


#include <Ultrasonic.h>

#define TRIGGER_PIN  14
#define ECHO_PIN     15

Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN);

  



Servo PingServo;
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);




int minSafeDist = 11 ;                                                            // Minimale Distanz festlegen.
int centerDist, leftDist, rightDist, backDist;                                    // Variablen für die unterschiedlichen Distanzen.



// ################################################################################​################################################################################​###############################################################

void setup() {
  
  
PingServo.attach(10);                                                             // Servo am Pin 10 ( Motor Shield ).

PingServo.write(90);                                                              // Ping Sensor in Mittelstellung bringen ( 90 Grad ).

motor1.setSpeed(215);                                                             // Motor 1 Geschwindigkeit festlegen.
motor2.setSpeed(215);                                                             // Motor 2 Geschwindigkeit festlegen.
motor3.setSpeed(215);                                                             // Motor 3 Geschwindigkeit festlegen.
motor4.setSpeed(215);                                                             // Motor 4 Geschwindigkeit festlegen.


Serial.begin(9600);                                                               // Serielle Schnittstelle instalisieren.
Serial.println("Version 1.2 BETA start...");                                                   // Serielle Ausgabe. ( Text ).

}


// ################################################################################​################################################################################​###############################################################

void AllStop() {
  
motor1.run(RELEASE);                                                              // Motor 1 AUS
motor2.run(RELEASE);                                                              // Motor 2 AUS
motor3.run(RELEASE);                                                              // Motor 3 AUS
motor4.run(RELEASE);                                                              // Motor 4 AUS

}

void AllForward() {                                                               //  forwärts

motor1.run(FORWARD);                                                              // Motor 1 forwärts
motor2.run(FORWARD);                                                              // Motor 2 forwärts
motor3.run(FORWARD);                                                              // Motor 3 forwärts
motor4.run(FORWARD);                                                              // Motor 4 forwärts


Serial.println("forwaerts");                                                       // Serielle Ausgabe.

}


void turnRight() {                                                                // rechts abbiegen

motor2.run(FORWARD);                                                              // Motor 1 forwärts
motor1.run(FORWARD);                                                              // Motor 2 forwärts
motor3.run(BACKWARD);                                                             // Motor 3 rückwärts
motor4.run(BACKWARD);                                                             // Motor 4 rückwärts

delay(1600);                                                                      // Zeit lassen um zu wenden ( 1.6 Sekunden ).

Serial.println("rechts abbiegen");                                                // Serielle Ausgabe.
}


void GoBack() {                                                                   // zurück fahren

motor1.run(BACKWARD);                                                             // Motor 1 rückwärts
motor2.run(BACKWARD);                                                             // Motor 2 rückwärts
motor3.run(BACKWARD);                                                             // Motor 3 rückwärts
motor4.run(BACKWARD);                                                             // Motor 4 rückwärts

delay(1600);                                                                      // Zeit lassen um rückwärts zu fahren ( 1.6 Sekunden ).

Serial.println("rueckwaerts");                                                      // Serielle Ausgabe
}


void turnLeft() {                                                                 // links abbiegen

motor1.run(BACKWARD);                                                             // Motor 1 rückwärts
motor2.run(BACKWARD);                                                             // Motor 2 rückwärts
motor3.run(FORWARD);                                                              // Motor 3 vorwärts
motor4.run(FORWARD);                                                              // Motor 4 vorwärts

delay(1600);                                                                      // Zeit lassen um links abzubiegen ( 1.6 Sekunden ).

Serial.println("links");                                              // Serielle Ausgabe
}


// ################################################################################​################################################################################​###############################################################

  void loop () {
    
    
  float cmMsec, inMsec;
  long microsec = ultrasonic.timing();

  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
  
    
LookAhead();
    
// Serial.print(cmMsec);                                                          // DEBUG

if ((cmMsec) >= minSafeDist) {                                                    // Distanz prüfen.

  
AllForward();                                                                     // forwärts

delay(110);                                                                       // Warte 0,11 Sekunden

} else {
  
AllStop();                                                                        // Alle Motoren stoppen

LookAround();                                                                     // alle Richtungen messen

if (rightDist > leftDist) {
turnRight();

} else if (leftDist > rightDist) {                                                // Vergleich

turnLeft();

} else if (leftDist&&rightDist<minSafeDist)  {                                    // Vergleich

GoBack();

      }
     }
   }
    
    







// ################################################################################​################################################################################​###############################################################


void LookAhead() {
  
PingServo.write(90);                                                               // geradeaus schauen

delay(175);                                                                        

}

void LookAround() {
  
  float cmMsec, inMsec;
  long microsec = ultrasonic.timing();

  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
  
  
PingServo.write(0);                                                                // rechts schauen 0° Grad

delay(320);

rightDist = cmMsec;                                                                

PingServo.write(180);                                                              // links schauen 180° Grad

delay(620);

leftDist = cmMsec;

PingServo.write(90);                                                               // nach vorne schauen 90° Grad

delay(275);

Serial.println("RightDist: ");
Serial.println(rightDist);
Serial.println("LeftDist: ");
Serial.println(leftDist);
Serial.println("CenterDist: ");
Serial.println(centerDist);

}

// ################################################################################​################################################################################​###############################################################


Wär cool wenn mir jemand einen Tipp geben könnte

Gruß Marc

Shy
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.09.2014, 19:53
Beitrag #2
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
Hi,

Du darfst cmMsec in LookAround jeweils erst dann ermitteln, wenn Du das Servo in die richtige Richtung gedreht hast. Momentan ermittelst Du den Abstand nur einmal am Anfang. Dann hat cmMsec seinen Wert. Warum sollte der sich ändern?

Außerdem:
Code:
} else if (leftDist&&rightDist<minSafeDist)  {
Das ist nicht, was Du willst. Wahrscheinlich willst Du das:
Code:
} else if (leftDist<minSafeDist && rightDist<minSafeDist)  {

Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.09.2014, 20:37
Beitrag #3
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
Hey Smile danke für deine schnelle Antwort Wink

Ich versteh es nicht ganz? Ich fahre doch den Sensor vorher auf die Position? Oder hab ich da nen denkfehler? Smile


PingServo.write(0); // hier fahr ich nach rechts

delay(320); // warte bis position erreicht

rightDist = cmMsec; // hier wert für rechts abfragen und speichern?!

PingServo.write(180); // hier nach rechts fahren

delay(620); // warte bis position erreicht

leftDist = cmMsec; // hier wert für rechts abfragen und speichern?!


//////

Oder läuft da was falsch?
Ps. Was mich eh wundert das ich in jedem unterprogramm das einsetzen muss warum reicht das nich einmal in der loop oder void setup? :

long microsec = ultrasonic.timing();

cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);


Gruß Marc Smile

Shy
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.09.2014, 21:34
Beitrag #4
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
(19.09.2014 20:37)Marc2014 schrieb:  long microsec = ultrasonic.timing();
Dieser Befehl macht die Messung. Das musst Du natürlich immer dann machen, wenn Du eine Messung machen willst. Also erst dann, wenn Du in die richtige Richtung schaust. Danach das Ergebnis (microsec) noch in die Zentimeter wandeln.
cmMsec ist ja nur eine dumme Variable, die weiß nicht, dass sich der Kopf gedreht hat. Variablen behalten ihren Wert, bis man einen anderen zuweist.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.09.2014, 21:51
Beitrag #5
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
Danke dir Smile

Achso ok das wusste ich nicht das ich so keine Messung mache.

Dann müsste es so aussehen oder ?

Code:
void LookAround() {
  

  
PingServo.write(0);                                                                // sensor schaut nach rechts

delay(320);

  long microsec = ultrasonic.timing();

  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  
rightDist = cmMsec;                                                                

PingServo.write(180);                                                              // sensor schaut nach links

delay(620);

  long microsec = ultrasonic.timing();

  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  

leftDist = cmMsec;

PingServo.write(90);                                                               // nach vorne schauen 90° Grad

delay(275);

Serial.println("RightDist: ");
Serial.println(rightDist);
Serial.println("LeftDist: ");
Serial.println(leftDist);
Serial.println("CenterDist: ");
Serial.println(centerDist);

}




Da bin ich mir auch unsicher was von den beiden Versionen richtig und was falsch ist?

Hier:

Code:
if ((cmMsec) >= minSafeDist) {                                                    // Distanz prüfen.

oder

if (cmMsec >= minSafeDist) {                                                      // Distanz prüfen.

Shy
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
20.09.2014, 09:30
Beitrag #6
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
(19.09.2014 21:51)Marc2014 schrieb:  Dann müsste es so aussehen oder ?

Code:
void LookAround() {
  

  
PingServo.write(0);                                                                // sensor schaut nach rechts

delay(320);

  long microsec = ultrasonic.timing();

  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  
rightDist = cmMsec;                                                                

PingServo.write(180);                                                              // sensor schaut nach links

delay(620);

  long microsec = ultrasonic.timing();

  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  

leftDist = cmMsec;

PingServo.write(90);                                                               // nach vorne schauen 90° Grad

delay(275);

Serial.println("RightDist: ");
Serial.println(rightDist);
Serial.println("LeftDist: ");
Serial.println(leftDist);
Serial.println("CenterDist: ");
Serial.println(centerDist);

}
Ja, so in etwa. Oder etwas kompakter:
Code:
void LookAround() {
  
  PingServo.write(0);           // sensor schaut nach rechts
  delay(320);
  rightDist = ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM);
  
  PingServo.write(180);       // sensor schaut nach links
  delay(620);
  leftDist = ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM);

  PingServo.write(90);           // nach vorne   schauen 90° Grad
  delay(275);

  Serial.println("RightDist: ");
  Serial.println(rightDist);
  Serial.println("LeftDist: ");
  Serial.println(leftDist);
  Serial.println("CenterDist: ");
  Serial.println(centerDist);
}

Zitat:Da bin ich mir auch unsicher was von den beiden Versionen richtig und was falsch ist?
Hier:
Code:
if ((cmMsec) >= minSafeDist) {                                                    // Distanz prüfen.

oder

if (cmMsec >= minSafeDist) {                                                      // Distanz prüfen.
Da gibt es keinen Unterschied. Die Klammern um das cmMsec schaden nicht, sind aber überflüssig.
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
20.09.2014, 17:37
Beitrag #7
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
Danke nochmal das funktioniert super jetzt Wink

Ich habe jetzt heute den ganzen Tag versucht eine Lösung für das nächste Problem zu finden aber ich komm einfach nicht drauf bestimmt wieder eine Kleinigkeit.

Geradeausfahren klappt aber sobald er rechts oder links oder zurück fahren soll zuckt er nur einmal in die jeweilige Richtung.

Ich denke das liegt daran das ich ja nur ganz kurz im jeweiligen Unterprogramm bin und dann wieder in die loop gehe.

Es muss doch eine Möglichkeit geben in die jeweilige Richtung zb. für 2 Sekunden zu fahren und dann erst in den loop zurück zu gehen.

Ich hab alles mögliche versucht aber komme zu keinem brauchbaren Ergebnis.

Hier der aktuelle Code :

Code:
// HOMECONTROL ROBOTER 1
// Version 1.7 BETA

// ################################################################################​################################################################################​###############################################################


#include <AFMotor.h>
#include <Servo.h>


#include <Ultrasonic.h>

#define TRIGGER_PIN  14
#define ECHO_PIN     15

Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN);

  



Servo PingServo;
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);




int minSafeDist = 18 ;                                                            // Minimale Distanz festlegen.
int centerDist, leftDist, rightDist, backDist;                                    // Variablen für die unterschiedlichen Distanzen.



// ################################################################################​################################################################################​###############################################################

void setup() {
  
  
PingServo.attach(10);                                                             // Servo am Pin 10 ( Motor Shield ).

PingServo.write(90);                                                              // Ping Sensor in Mittelstellung bringen ( 90 Grad ).

motor1.setSpeed(120);                                                             // Motor 1 Geschwindigkeit festlegen.
motor2.setSpeed(120);                                                             // Motor 2 Geschwindigkeit festlegen.
motor3.setSpeed(120);                                                             // Motor 3 Geschwindigkeit festlegen.
motor4.setSpeed(120);                                                             // Motor 4 Geschwindigkeit festlegen.


Serial.begin(9600);                                                               // Serielle Schnittstelle instalisieren.
Serial.println("Version 1.2 BETA start...");                                                   // Serielle Ausgabe. ( Text ).

}


// ################################################################################​################################################################################​###############################################################

void AllStop() {
  
Serial.println("stop");                                                           // Serielle Ausgabe.

  
motor1.run(RELEASE);                                                              // Motor 1 AUS
motor2.run(RELEASE);                                                              // Motor 2 AUS
motor3.run(RELEASE);                                                              // Motor 3 AUS
motor4.run(RELEASE);                                                              // Motor 4 AUS

// delay(1500);

}

void AllForward() {                                                               //  forwärts

Serial.println("forwaerts");                                                       // Serielle Ausgabe.


motor1.run(FORWARD);                                                              // Motor 1 forwärts
motor2.run(FORWARD);                                                              // Motor 2 forwärts
motor3.run(FORWARD);                                                              // Motor 3 forwärts
motor4.run(FORWARD);                                                              // Motor 4 forwärts



}


void turnRight() {                                                                // rechts abbiegen

Serial.println("rechts abbiegen");                                                // Serielle Ausgabe.


motor1.run(FORWARD);                                                              // Motor 1 forwärts
motor2.run(FORWARD);                                                              // Motor 2 forwärts
motor3.run(BACKWARD);                                                             // Motor 3 rückwärts
motor4.run(BACKWARD);                                                             // Motor 4 rückwärts

// delay(5000);                                                                      // Zeit lassen um zu wenden ( 2.5 Sekunden ).

}


void GoBack() {                                                                   // zurück fahren

Serial.println("rueckwaerts");                                                      // Serielle Ausgabe


motor1.run(BACKWARD);                                                             // Motor 1 rückwärts
motor2.run(BACKWARD);                                                             // Motor 2 rückwärts
motor3.run(BACKWARD);                                                             // Motor 3 rückwärts
motor4.run(BACKWARD);                                                             // Motor 4 rückwärts

// delay(5000);                                                                      // Zeit lassen um rückwärts zu fahren ( 2.5 Sekunden ).

Serial.println("rueckwaerts");                                                    // Serielle Ausgabe
}


void turnLeft() {                                                                 // links abbiegen

Serial.println("links");                                                          // Serielle Ausgabe


motor1.run(BACKWARD);                                                             // Motor 1 rückwärts
motor2.run(BACKWARD);                                                             // Motor 2 rückwärts
motor3.run(FORWARD);                                                              // Motor 3 vorwärts
motor4.run(FORWARD);                                                              // Motor 4 vorwärts

// delay(5000);                                                                      // Zeit lassen um links abzubiegen ( 1.6 Sekunden ).

}


// ################################################################################​################################################################################​###############################################################

  void loop () {
    
    
  float cmMsec, inMsec;

  long microsec = ultrasonic.timing();

  
    
LookAhead();

   centerDist = ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM);


   if (centerDist > minSafeDist) {


   AllForward();
  
   }
  
   else {
    
    AllStop();
    
    LookAround();
    
   if (rightDist > leftDist) {
  

     turnRight();


    } else if (leftDist > rightDist) {                                                // Vergleich

    turnLeft();

    
     }
   }    
}





// ################################################################################​################################################################################​###############################################################


void LookAhead() {
  
PingServo.write(90);                                                               // Sensor auf Position 90 Grad ( geradeaus ) fahren.

// delay(250);                                                                        

}


void LookAround() {
  
  PingServo.write(0);                                                               // Sensor auf Position 0 Grad ( rechts ) fahren.
  delay(500);
  rightDist = ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM);
  
  PingServo.write(180);                                                             // Sensor auf Position 180 Grad ( links ) fahren.
  delay(650);
  leftDist = ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM);

  PingServo.write(90);                                                              // Sensor auf Position 90 Grad ( geradeaus ) fahren.
  delay(500);
  
  centerDist = ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM);


  Serial.println("RightDist: ");
  Serial.println(rightDist);
  Serial.println("LeftDist: ");
  Serial.println(leftDist);
  Serial.println("CenterDist: ");
  Serial.println(centerDist);
}



// ################################################################################​################################################################################​###############################################################

Danke nochmal an Thorsten Wink jetzt erkennt der Roboter beide Richtungen.

Gruß Marc

Shy
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
20.09.2014, 17:47
Beitrag #8
RE: SR-04 + UNO + 4WD Roboter, Abstandsfehler
(20.09.2014 17:37)Marc2014 schrieb:  Es muss doch eine Möglichkeit geben in die jeweilige Richtung zb. für 2 Sekunden zu fahren und dann erst in den loop zurück zu gehen.
Das geht mit den delay(), die Du rausgeschmissen hast.
Prinzipiell gibt es da auch elegantere Möglichkeiten, aber da müsstest Du eine Rückmeldung vom Motor haben, wie weit er sich schon gedreht hat.
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  kleiner Roboter blichi 24 792 27.07.2016 14:02
Letzter Beitrag: torsten_156
  Roboter-Bau Probleme blebbens 8 382 12.07.2016 07:35
Letzter Beitrag: Binatone
  Selbstfahrender Roboter Programm änderung hilfe ? arekklone 11 550 06.07.2016 14:59
Letzter Beitrag: Binatone
  Neo's Roboter Neoneo23 74 5.922 11.11.2015 21:18
Letzter Beitrag: Neoneo23
  Roboter J4Ng0 2 1.531 21.07.2013 15:49
Letzter Beitrag: Snake8811

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste