Zwei Ultraschallsensoren auslesen lassen und mithilfe des gemessenen Abstands einen Motor nach vorne bzw. hinten laufen lassen

Hallo Leute,

ich bin mittlerweile mit meinem Schulprojekt fertig und es ist relativ gut gelaufen. Dafür danke ich euch vielmals für eure Hilfe. Zu Hause bin ich aber noch sehr an dem Projekt interessiert.
(Wer es nicht mitbekommen hat, wir mussten ein Schulprojekt erstellen, in dem ein Auto nach vorne fährt und, wenn es, mithilfe eines Ultraschallsensors, einen gewissen Abstand zur Wand erkennt, soll es nach hinten fahren können.)
Zu Hause möchte ich das Projekt für mich selber weiterentwickeln. Das heißt ich möchte zwei Ultraschallsensoren benutzen und einen Piezo der einen Piepston von sich gibt, wenn er nach hinten fährt. Ich habe es hinbekommen, dass die beiden Ultraschallsensoren "gleichzeitig" einen Wert ausgeben und dieser im Seriellen Monitor angezeigt wird.
Mein Problem liegt jetzt daran, dass der 12V Gleichstrommotor sich nicht nach hinten drehen will, wenn der vordere Sensor einen kleineren Abstand als 15cm erkennt; genauso andersherum. Ebenfalls habe ich es nicht geschafft, dass der Piezo während dem nach hinten Fahren einen Piepston von sich gibt. Bzw. weiß ich nicht wie ich mit dem Code anfangen soll, welchen ich auch jetzt im unteren eingeblendeten Code nicht mit reingeschrieben habe.
Es wäre sehr nett, wenn Ihr mir weiterhelfen könntet und ich hätte sehr Lust dieses private Projekt umzusetzten. Ich danke euch schonmal vielmals im Voraus.
(Falls dieses Thema im englisch-sprachigen Bereich gelandet sein sollte, tut es mir sehr leid. Ich weiß noch nicht wie das alles hier funktioniert, da ich relativ neu hier bin. Sowas ähnliches kam nämlich schonmal bei mir vor, wobei sich Leute beschwert haben. Also Entschuldigung schon im Voraus, falls dies der Fall sein sollte.)
(PS: Ich hab die Kommentare bzw die Erklärungen noch nicht an diesem neuen Code angepasst, also bitte nicht wundern :wink: )

Mit freundlichen Grüßen :wink:

Code:
|
|
|

int trigger = 7;               //erstellt eine Variable mit dem Namen "trigger", welcher den Wert 7 erhält (= 7 steht für den Pin an dem der Trigger des Ultraschallsensors angeschlossen wird)
int trigger2 = 8;
int echo = 6;                  //erstellt eine Variable mit dem Namen "echo", welcher den Wert 6 erhält (= 6 steht für den Pin an dem das Echo des Ultraschallsensors angeschlossen wird)
int echo2 = 9;
unsigned long entfernung = 0;  //erstellt eine Ganzzahl-Variable mit dem Namen "entfernung" und dem Anfangswert 0
unsigned long entfernung2 = 0;
unsigned long dauer = 0;       //erstellt eine Ganzzahl-Variable mit dem Namen "dauer" und dem Anfangswert 0
unsigned long dauer2 = 0;

int piezo = 5;  //erstellt eine Variable mit dem Namen "piezo", welcher den Wert 5 erhält (= 5 steht für den Pin an dem der Piezo angeschlossen wird)
int led = 4;    //erstellt eine Variable mit dem Namen "led", welcher den Wert 4 erhält (= 4 steht für den Pin an dem die LED angeschlossen wird)

int motorPin1 = 10;                 //erstellt eine Variable mit dem Namen "motorPin1", welcher den Wert 10 erhält (= 10 steht für den Pin an dem der Minuspol des Motors angeschlossen wird)
int motorPin2 = 11;                 //erstellt eine Variable mit dem Namen "motorPin2", welcher den Wert 11 erhält (= 11 steht für den Pin an dem der Pluspol des Motors angeschlossen wird)
const byte geschwindigkeit1 = 175;  //erstellt eine Konstante (= der Wert kann nicht mehr innerhalb des Codes verändert werden) mit dem Namen "geschwindigkeit1", welcher den Wert 175 erhält (= 175 steht für die Geschwindkeit mit dem der Motor nach vorne läuft)
const byte geschwindigkeit2 = 140;  //erstellt eine Konstante (= der Wert kann nicht mehr innerhalb des Codes verändert werden) mit dem Namen "geschwindigkeit2", welcher den Wert 140 erhält (= 140 steht für die Geschwindkeit mit dem der Motor nach hinten läuft)

void piepen() {        //mithilfe eines weiteren void-Befehls wird ein neuer Befehl mit dem Namen "piepen" erstellt
    tone(piezo, 988);  //der Piezo soll den Ton h'' (988 = h'') abspielen
    delay(400);        //dieser Ton soll 0,4 Sekunden abgespielt werden
    noTone(piezo);     //nach der Verzögerung soll der Piezo keinen Ton mehr ausgeben
    delay(800);        //es soll für 0,8 Sekunden kein Ton mehr ausgegeben werden
}

void motorStop(){             //mithilfe eines weiteren void-Befehls wird ein neuer Befehl mit dem Namen "motorStop" erstellt: ↓
  analogWrite(motorPin1, 0);  //dabei soll der "motorPin1" stoppen und nicht weiterlaufen 
  analogWrite(motorPin2, 0);  //ebenfalls soll der "motorPin2" stoppen und nicht weiterlaufen 
}

void ultra1(){
  digitalWrite(trigger, LOW);        //Der pin "trigger" wird Low geschaltet (= gibt kein Signal von sich aus) 
  delayMicroseconds(10);             //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger, HIGH);       //Der Pin "trigger" wird auf High geschaltet (= gibt ein Signal von sich aus) 
  delayMicroseconds(10);             //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger, LOW);        //Der pin "trigger" wird Low geschaltet (= gibt kein Signal von sich aus)
  dauer = pulseIn(echo, HIGH);       //Der Ganzzahl-Variable "dauer" wird festgelegt, was sie "tun" soll. Sie misst die Zeit am Pin "echo" seit Start des Codes, da dieser lediglich die Zeit zwischen dem Aussenden und der Rückkehr der Schallwelle des Ultraschallsensors misst 
  entfernung = (dauer/2) * 0.03432;  //Der Ganzzahl-Variable "entfernung" wird festgelegt, was sie "tun" soll. Die "dauer" soll durch zwei geteilt werden, da man nur einer der zurückgelegten Strecken herausfinden möchte, und multipliziert sie mit der Geschwindigkeit des Schalls (= 343,2 m/s)
  Serial.print(entfernung);        //Im Seriellen-Monitor soll dann die "entfernung" ausgegeben werden
  Serial.println("cm  Sensor 1");
}

void ultra2(){
  digitalWrite(trigger2, LOW);        //Der pin "trigger" wird Low geschaltet (= gibt kein Signal von sich aus) 
  delayMicroseconds(10);             //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger2, HIGH);       //Der Pin "trigger" wird auf High geschaltet (= gibt ein Signal von sich aus) 
  delayMicroseconds(10);             //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger2, LOW);        //Der pin "trigger" wird Low geschaltet (= gibt kein Signal von sich aus)
  dauer2 = pulseIn(echo2, HIGH);       //Der Ganzzahl-Variable "dauer" wird festgelegt, was sie "tun" soll. Sie misst die Zeit am Pin "echo" seit Start des Codes, da dieser lediglich die Zeit zwischen dem Aussenden und der Rückkehr der Schallwelle des Ultraschallsensors misst 
  entfernung2 = (dauer2/2) * 0.03432;  //Der Ganzzahl-Variable "entfernung" wird festgelegt, was sie "tun" soll. Die "dauer" soll durch zwei geteilt werden, da man nur einer der zurückgelegten Strecken herausfinden möchte, und multipliziert sie mit der Geschwindigkeit des Schalls (= 343,2 m/s)
  Serial.print(entfernung2);        //Im Seriellen-Monitor soll dann die "entfernung" ausgegeben werden
  Serial.println("cm  Sensor 2");
}

void setup() {                 //Das "void setup()" verläuft im ganzen Code nur einmal am Anfang 
  pinMode(trigger, OUTPUT);    //Der Pin "trigger" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output (= gibt elektrische Signale aus) von sich geben 
  pinMode(trigger2, OUTPUT);
  pinMode(echo, INPUT);        //Der Pin "echo" (der Pin wurde beim Erstellen der Variablen angegeben) interagiert hier als Input (= nimmt elektrische Signale auf)
  pinMode(echo2, INPUT);
  pinMode(piezo, OUTPUT);      //Der Pin "piezo" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output (= gibt elektrische Signale aus) von sich geben 
  pinMode(motorPin1, OUTPUT);  //Der Pin "motorPin1" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output (= gibt elektrische Signale aus) von sich geben 
  pinMode(motorPin2, OUTPUT);  //Der Pin "motorPin2" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output (= gibt elektrische Signale aus) von sich geben 
  pinMode(led, OUTPUT);        //Der Pin "led" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output (= gibt elektrische Signale aus) von sich geben 
  digitalWrite(led, HIGH);     //Die LED soll ganz Anfang des Codes auf High geschaltet werden. Somit leuchtet die LED, solange der Programmcode aktiv ist
  Serial.begin(9600);          //Der Serielle-Monitor wird angesteuert
}

void loop() {                        //Der Code im "void loop()" wird ständig wiederholt, solange alle Befehle durchlaufen sind 

  ultra1();
  ultra2();
  

  if (entfernung <= 15) {                      //falls die "entfernung" größer als 50cm ist, soll das passieren: ↓
    analogWrite(motorPin1, geschwindigkeit2);  //Der Pin "motorpin1" wird auf Low geschaltet (= gibt kein elektrisches Signal von sich aus) 
    analogWrite(motorPin2, 0);                 //Der Pin "motorPin2" soll mit der Signalstärke "geschwndigkeit1" (= 175) laufen
  }                                            //Der Schulbus fährt nach vorne 

  if (entfernung <= 15) {                      //falls die "entfernung" größer als 50cm ist, soll das passieren: ↓
    analogWrite(motorPin1, 0);                 //Der Pin "motorpin1" wird auf Low geschaltet (= gibt kein elektrisches Signal von sich aus) 
    analogWrite(motorPin2, geschwindigkeit1);  //Der Pin "motorPin2" soll mit der Signalstärke "geschwndigkeit1" (= 175) laufen
  }        
  
}

Nochmal drüber schaun.

Wirklich, das habe ich schon so oft gemacht bevor ich diesen Artikel hier reingestellt habe. Ich habe alles mögliche ausprobiert. Ich weiß einfach nicht was ich im Code verändern bzw. hinzufügen muss.
Natürlich weiß ich, dass das Problem in diesem Bereich liegt, aber genau deshalb frage ich auch nach.
Danke dir aber trotzdem für deine Rückmeldung

GRÖSSER > und KLEINER < noch einmal verinnerlichen.
Kommentare sollen immer das enthalten, was BESCHRIEBEN wird. (Da hilft auch nachträgliches Sorry nicht.)

Neuer Versuch?

if (entfernung <= 15) 
...
if (entfernung <= 15) 

Hmmm.
Es gibt auch noch eine entfernung2 - die ist global definiert und wird in ultra2() sogar beschrieben.

Ich empfehle, grundsätzlich wirklich sprechende Namen zu verwenden - also z.B. entfernungVorn und entfernungHinten. Bei den Namen mit Nummern kommt es immer (wirklich immer!) zu Problemen durch kopieren, einfügen und unvollständiges Ändern.
motorPinX und geschwindigkeitX sind auch so Kandidaten.

Yep, dazu rate ich auch.

erste Frage:
was bedeutet

<=

??
.
.
.
.

zweite Frage:
was bedeutet

<=

??

erste Frage:
auf was fragst du ab mit der if-bedingung

if (entfernung <= 15)

.
.
.
.
zweite Frage
auf was fragst du ab mit der if-bedingung

if (entfernung <= 15)

Vergleiche den orangefarbenen code mit dem grünen code

Was fällt dir auf?

vgs

Ich bin da wohl der falsche Adressat.

Oh ja da hast du recht, das ist mir bis jetzt überhaupt nicht aufgefallen. Vielen Dank, ich verändere auf jeden Fall die Namen der Variablen und beachte natürlich den Fehler, dass nicht nur "entfernung" mit drin steht. Danke dir

Danke dir auch, das habe ich echt überhaupt nicht bemerkt. Ich werde es gleich ausprobieren.
Das Symbol "<=" bedeutet beispielsweise: wenn die "entfernung" kleiner als der Wert 15, bzw der Wert 15 miteinbezogen, enthält, passiert das...

Jetzt bin ihc mir aus deiner antwort nicht sicher ob du verstanden hast auf was es ankommt.

if (entfernung <= 15) {                      //falls die "entfernung" größer als 50cm ist, soll das passieren: ↓
    analogWrite(motorPin1, geschwindigkeit2);  //Der Pin "motorpin1" wird auf Low geschaltet (= gibt kein elektrisches Signal von sich aus) 
    analogWrite(motorPin2, 0);                 //Der Pin "motorPin2" soll mit der Signalstärke "geschwndigkeit1" (= 175) laufen
  }                                            //Der Schulbus fährt nach vorne 

  if (entfernung >= 15) {                      //falls die "entfernung" größer als 50cm ist, soll das passieren: ↓
    analogWrite(motorPin1, 0);                 //Der Pin "motorpin1" wird auf Low geschaltet (= gibt kein elektrisches Signal von sich aus) 
    analogWrite(motorPin2, geschwindigkeit1);  //nach HINTEN HINTEN Der Schulbus fährt nach HINTEN
  }  

du hast in beiden If-bedingungen genau das gleiche stehen.
if (entfernung <= 15)
wenn Entfernung kleiner gleich 15 schalte aus Vorwärtsfahrt.
und gleich anschließen benutzt du die
genau gleiche Bedingung

if (entfernung <= 15)
wenn Entfernung kleiner gleich 15 schalte aus Rückwärtsfahrt.
und gleich anschließen benutzt du die genau gleiche Bedingung

Das macht keinen Sinn.

vgs

Beim zweiten Befehl steht jetzt „entfernung2“ (ich stelle meinen neuen Coden später nochmal rein), da ich ja zwei Ultraschallsensoren benutze. Wenn also der vordere Ultraschallsensor einen kleineren Wert als 15cm erkennt soll das Auto nach hinten fahren und wenn der hintere Sensor während dem nach hinten Fahren einen neuen kleineren zweiten Wert als 15cm erkennt, soll das Auto wieder nach vorne fahren. Also denke ich nicht, dass der zweite Ultraschallsensor einen größeren Wert als 15cm erkennen soll, da ja beide einen kleineren Wert als 15cm auslesen sollen und damit agieren sollen.

Und was passiert wenn vorn und hinten ein Hindernis ist?

Endlosschleife bis zur Explosion :wink:

Gruß Tommy

Hallo Leute,

dank eurer Hilfe habe ich es geschafft den Motor nach meinen Wünschen zum Laufen zu bringen. Vielen Dank für eure Hilfe.
Soweit so gut, ich möchte aber noch einen Piezo einbauen, der während dem nach hinten Fahren einen wiederholenden Piepston von sich gibt. Das heißt, er gibt so lange einen Piepston von sich, solange er nach hinten fährt. Wenn der Motor wieder vorwärts läuft, soll der Piezo keinen Ton mehr von sich geben. Den Befehl dafür habe ich schon erstellt und dementsprechend an die Stelle gepackt, an dem der Piepston später ausgeführt werden soll (Befehl nennt sich: piepen() ). Ich habe schon vieles versucht und ausprobiert, auch sowas wie mit der "while-Schleife", es piepste zwar, dennoch lief der Motor nicht.
Könnte mir dabei vielleicht noch bitte jemand weiterhelfen. Danke :slight_smile:

Hier ist der "neue" Code:
|
|
|

int trigger = 7;                     //erstellt eine Variable mit dem Namen "trigger", welcher den Wert 7 erhält (= 7 steht für den Pin an dem der Trigger des Ultraschallsensors angeschlossen wird)
int trigger2 = 8;                    //erstellt eine Variable mit dem Namen "trigger2", welcher den Wert 8 erhält (= 8 steht für den Pin an dem der Trigger des Ultraschallsensors angeschlossen wird)
int echo = 6;                        //erstellt eine Variable mit dem Namen "echo", welcher den Wert 6 erhält (= 6 steht für den Pin an dem das Echo des Ultraschallsensors angeschlossen wird)
int echo2 = 9;                       //erstellt eine Variable mit dem Namen "echo2", welcher den Wert 9 erhält (= 9 steht für den Pin an dem das Echo des Ultraschallsensors angeschlossen wird)

unsigned long entfernungVorne = 0;   //erstellt eine Ganzzahl-Variable mit dem Namen "entfernungVorne" und dem Anfangswert 0
unsigned long entfernungHinten = 0;  //erstellt eine Ganzzahl-Variable mit dem Namen "entfernungHinten" und dem Anfangswert 0

unsigned long dauerUltra1 = 0;       //erstellt eine Ganzzahl-Variable mit dem Namen "dauerUltra1" und dem Anfangswert 0
unsigned long dauerUltra2 = 0;       //erstellt eine Ganzzahl-Variable mit dem Namen "dauerUltra2" und dem Anfangswert 0

int piezo = 5;  //erstellt eine Variable mit dem Namen "piezo", welcher den Wert 5 erhält (= 5 steht für den Pin an dem der Piezo angeschlossen wird)
int led = 4;    //erstellt eine Variable mit dem Namen "led", welcher den Wert 4 erhält (= 4 steht für den Pin an dem die LED angeschlossen wird)

int motorPinHintenFahren = 10;  //erstellt eine Variable mit dem Namen "motorPinHintenFahren", welcher den Wert 10 erhält (= 10 steht für den Pin an dem der Minuspol des Motors angeschlossen wird)
int motorPinVorneFahren = 11;   //erstellt eine Variable mit dem Namen "motorPinVorneFahren", welcher den Wert 11 erhält (= 11 steht für den Pin an dem der Pluspol des Motors angeschlossen wird)

int geschwindigkeitVorneFahren = 175;   //erstellt eine Variable mit dem Namen "geschwindigkeitVorneFahren", welcher den Wert 175 erhält (= 175 steht für die Geschwindkeit mit dem der Motor nach vorne läuft (keine km/h!!!))
int geschwindigkeitHintenFahren = 140;  //erstellt eine Variable mit dem Namen "geschwindigkeitHintenFahren", welcher den Wert 140 erhält (= 140 steht für die Geschwindkeit mit dem der Motor nach hinten läuft(keine km/h!!!))

void piepen() {        //mithilfe eines weiteren void-Befehls wird ein neuer Befehl mit dem Namen "piepen" erstellt
    tone(piezo, 988);  //der Piezo soll den Ton h'' (988 = h'') abspielen
    delay(500);        //dieser Ton soll 0,5 Sekunden abgespielt werden
    noTone(piezo);     //nach der Verzögerung soll der Piezo keinen Ton mehr ausgeben
    delay(500);        //es soll für 0,5 Sekunden kein Ton mehr ausgegeben werden
}

void motorStop(){                        //mithilfe eines weiteren void-Befehls wird ein neuer Befehl mit dem Namen "motorStop()" erstellt: ↓
  analogWrite(motorPinHintenFahren, 0);  //dabei soll der "motorPinHintenFahren" stoppen und nicht weiterlaufen 
  analogWrite(motorPinVorneFahren, 0);   //ebenfalls soll der "motorPinVorneFahren" stoppen und nicht weiterlaufen 
}

void ultra1(){                                  //mithilfe eines weiteren void-Befehls wird ein neuer Befehl mit dem Namen "ultra1()" erstellt: ↓
  digitalWrite(trigger, LOW);                   //Der Pin "trigger" wird LOW geschaltet 
  delayMicroseconds(10);                        //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger, HIGH);                  //Der Pin "trigger" wird auf HIGH geschaltet 
  delayMicroseconds(10);                        //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger, LOW);                   //Der Pin "trigger" wird LOW geschaltet 
  dauerUltra1 = pulseIn(echo, HIGH);            //Der Variable "dauerUltra1" wird festgelegt, was sie "tun" soll. Sie misst die Zeit am Pin "echo" seit Start des Codes, da dieser lediglich die Zeit zwischen dem Aussenden und der Rückkehr der Schallwelle des Ultraschallsensors misst 
  entfernungVorne = (dauerUltra1/2) * 0.03432;  //Der Variable "entfernungVorne" wird festgelegt, was sie "tun" soll. Die "dauerUltra1" soll durch zwei geteilt werden, da man nur einer der zurückgelegten Strecken herausfinden möchte, und multipliziert sie mit der Geschwindigkeit des Schalls (= 343,2 m/s)
  Serial.print(entfernungVorne);                //Im Seriellen-Monitor soll dann die "entfernungVorne" ausgegeben werden
  Serial.println("cm Sensor 1");                //Hinter der ausgegebenen Entfernung im Seriellen-Monitor wird "cm Sensor 1" dazugeschrieben
}

void ultra2(){
  digitalWrite(trigger2, LOW);                   //Der Pin "trigger2" wird LOW geschaltet 
  delayMicroseconds(10);                         //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger2, HIGH);                  //Der Pin "trigger2" wird auf HIGH geschaltet 
  delayMicroseconds(10);                         //Danach gibt es eine Verzögerung von 10 Millisekunden 
  digitalWrite(trigger2, LOW);                   //Der Pin "trigger" wird LOW geschaltet 
  dauerUltra2 = pulseIn(echo2, HIGH);            //Der Variable "dauerUltra2" wird festgelegt, was sie "tun" soll. Sie misst die Zeit am Pin "echo2" seit Start des Codes, da dieser lediglich die Zeit zwischen dem Aussenden und der Rückkehr der Schallwelle des Ultraschallsensors misst 
  entfernungHinten = (dauerUltra2/2) * 0.03432;  //Der Variable "entfernungHinten" wird festgelegt, was sie "tun" soll. Die "dauerUltra2" soll durch zwei geteilt werden, da man nur einer der zurückgelegten Strecken herausfinden möchte, und multipliziert sie mit der Geschwindigkeit des Schalls (= 343,2 m/s)
  Serial.print(entfernungHinten);                //Im Seriellen-Monitor soll dann die "entfernungHinten" ausgegeben werden
  Serial.println("cm  Sensor 2");                //Hinter der ausgegebenen Entfernung im Seriellen-Monitor wird "cm Sensor 2" dazugeschrieben
}

void setup() {                            //Das "void setup()" verläuft im ganzen Code nur einmal am Anfang 
  pinMode(trigger, OUTPUT);               //Der Pin "trigger" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output von sich geben 
  pinMode(trigger2, OUTPUT);              //Der Pin "trigger2" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output von sich geben 
  pinMode(echo, INPUT);                   //Der Pin "echo" (der Pin wurde beim Erstellen der Variablen angegeben) interagiert hier als Input
  pinMode(echo2, INPUT);                  //Der Pin "echo2" (der Pin wurde beim Erstellen der Variablen angegeben) interagiert hier als Input
  pinMode(piezo, OUTPUT);                 //Der Pin "piezo" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output von sich geben 
  pinMode(motorPinHintenFahren, OUTPUT);  //Der Pin "motorPinHintenFahren" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output von sich geben 
  pinMode(motorPinVorneFahren, OUTPUT);   //Der Pin "motorPinVorneFahren" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output von sich geben 
  pinMode(led, OUTPUT);                   //Der Pin "led" (der Pin wurde beim Erstellen der Variablen angegeben) soll ein Output von sich geben 
  digitalWrite(led, HIGH);                //Die "led" soll ganz Anfang des Codes auf High geschaltet werden. Somit leuchtet die "led", solange der Programmcode aktiv ist (= Steht dafür, dass wenn die "led" leuchtet, dass der Van an ist.)
  Serial.begin(9600);                     //Der Serielle-Monitor wird angesteuert
}

void loop() {  //Der Code im "void loop()" wird ständig wiederholt, solange alle Befehle durchlaufen sind 

  ultra1();  //Der Befehl "ultra1" wird ausgeführt
  ultra2();  //Der Befehl "ultra2" wird ausgeführt

  if (entfernungVorne <= 15) {                                       //falls die "entfernungVorne" kleiner als 15cm beträgt, soll das passieren: ↓
    analogWrite(motorPinHintenFahren, geschwindigkeitHintenFahren);  //Der Pin "motorpinHintenFahren" soll mit der Signalstärke "geschwindigkeitHintenFahren" (= 140) laufen
    analogWrite(motorPinVorneFahren, LOW);                           //Der Pin "motorPinVorneFahren" wird auf LOW geschaltet
  }                                                                  //Der Van fährt nach hinten 

  if (entfernungHinten <= 15) {                                    //falls die "entfernungHinten" kleiner als 15cm beträgt, soll das passieren: ↓
    analogWrite(motorPinHintenFahren, LOW);                        //Der Pin "motorpinVorneFahren" wird auf LOW geschaltet 
    analogWrite(motorPinVorneFahren, geschwindigkeitVorneFahren);  //Der Pin "motorPinHintenFahren" soll mit der Signalstärke "geschwndigkeitVorneFahren" (= 175) laufen
    piepen();
  }                                                                //Der Van fährt nach vorne
  delay(1000);                                                     //Danach gibt es eine Verzögerung von einer Sekunde
}

Du hast festgestellt, das Du blockierend programmiert hast.
Das bedeutet: Eine Funktion blockiert die andere.

Denn: Während Du piepst

vergehen 2x 500 ms in denen Du Nichts anderes machen kannst.

DATEI - BEISPIELE - 02. Digital - Blink Without Delay.
Das Beispiel zeigt Dir, wie Du ohne delay() auskommst.

@my_xy_projekt war schneller; aber jetzt habe ich meinen Sermon auch fertig.

@DemirAhmetspahic
Du machst Fortschritte - die Namen sind deutlich besser! (Das ist auch Geschmackssache, muss jeder seinen eigenen Stil finden) Hoffe, dass Du Dich jetzt auch besser in Deinem Programm zurecht findest.

Zum Piepen:

  • Grundsätzlich macht Dich Deine Funktion piepen() für eine Sekunde "blind" - keine Sensorüberprüfung wegen der delay()
  • Der Aufruf steht an welcher Stelle?
    Tipp: //falls die "entfernungHinten" kleiner als 15cm beträgt, soll das passieren: ↓

Also nochmal überlegen, was die Bedingungen für das Aktivieren und das Abschalten des Piepers sind - und dann an den entsprechenden Stellen eine bool-Variable passend setzen.
Das Piepen selbst in Abhängigkeit von dieser Variablen in der Funktion loop() aufrufen - und dann mit millis() organisieren.


Hier noch etwas für die Zukunft.

Es gibt übrigens noch erheblichen Verbesserungsbedarf bei den Variablen (z.B. const byte statt int für die Pins), den Kommentaren (die eben nicht die Anweisung in möglichst vielen Worten wiederkäuen sollen) und bei Deinem Verständnis, was eine Funktion ist:

//mithilfe eines weiteren void-Befehls wird ein neuer Befehl mit dem Namen "ultra1()" erstellt
//Der Befehl "ultra1" wird ausgeführt

Nein, das ist kein Befehl, sondern eine Funktion namens ultra1(), die keine Parameter hat und nichts (void) zurückgibt. Die wird deklariert, implementiert und später aufgerufen.
Da hast Du übrigens immer noch das nameX-Problem. Was macht die Funktion? Entfernung messen - dann darf sie auch so oder ähnlich heißen.

1 Like

:joy:

Ich nehme meinen Vorteil gerne wahr :wink:

Da wären wir also mal wieder beim Programmieren von mache zwei Dinge parallel:

  1. Abstand messen
    und
  2. intervall-piepen.

Das erfordert nicht blockierendes timing.
delay() blockiert.
Solange der Microcontroller mit "delay()" beschäftigt ist kann er nichts anderes machen.
Solange der Microcontroller in einer while-Schleife drin ist macht er nur das was innerhalb der while-Schleife programmiert ist.

Jetzt gibt es eine umständliche Möglichkeit und eine elegante Möglichkeit

  1. Abstand messen
    und
  2. intervall-piepen.
    zu machen.

Die umständliche Möglichkeit ist:
das Abstand messen und all den anderen Kram ein zweites mal innerhalb der piepen-while-Schleife zu programmieren

oder viel eleganter
nicht-blockierendes Timing zu erlernen.

Nicht blockierendes Timing funktioniert wie
Ein Beispiel aus dem menschlichen Alltag

Stelle dir jemanden vor der gerade Essen zubereitet.
Es soll Pizza mit Gurkensalat geben.
Die Pizza ist schon im Ofen und backt vor sich hin
gleichzeitig wird die Gurke geschnitten.
Ca. alle 30 Sekunden schaut man auf die Uhr wie viel (Back)Zeit ist schon vergangen?
Das bedeutet: die ganze Zeit werden Gurkenscheiben geschnitten und zwischen zwei Schnitten wird auf die Uhr geschaut.
Und das wiederholt sich die ganze Zeit
als Programm auf das allerwesentlichste reduziert

loop() {
  EineScheibeAbschneiden();
  AufDieUhrSchauen();
}

Das ist das Grundprinzip:
die einzige Schleife die es gibt ist loop()

Null for-schleifen, Null-while-schleifen
Dadurch wird erreicht dass man mehrere Dinge "gleichzeitig" oder "nebenher" machen kann.

loop() {
  AbstandMessen();
  TasterAbfragen();
  LED_Blinken();
  SummerPiepsen();
  DatenAufSD_KarteSchreiben();
  usw();
  usf();
}

Dabei müssen ausnahmslos alle functions nach dem Jump_in____Jump_out-prinzip arbeiten
Das heißt ein kleines schnell durchzuführendes Detail erledigen und dann sofort wieder raus

Dadurch erreicht man das die verschiedenen Funktionen ganz schnell hintereinander ausgeführt werden und es dadurch "parallel" erscheint.

Abstand messen ist eine Code-Zeile
das Piepen wird durch loop() immer wieder neu aufgerufen
aaaber
das Timing muss nicht-blockierend porgrammiert werden

Das aus/einschalten des Piezos ist auch jeweils nur eine Code-Zeile
Das muss in gewissen Zeitabständen gemacht werden
Piezo einschalten
wenn 500 millisekunden vergangen sind ausschalten
wenn 500 millisekunden vergangen sind einschalten
wenn 500 millisekunden vergangen sind ausschalten
usw.

hier ein kleines Tutorial das das erklärt

vgs

Oh wow, das sind echt sehr viele Informationen, die mir sehr weiterhelfen werden. Ich werde morgen so viel wie möglich ausprobieren.
Vielen Dank für eure Hilfe und eure schnellen Rückmeldung. Ihr seid alle echt mega.
:pray:

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.