Motorsteuerung über Sensorik

[i_make_it]

Dazu habe ich 3 Ultraschalsensoren Links ; Mitte ; Rechts

Du hast 3 Sensoren: nennen wir sie mal us1, us2, us3.

us1 - ist der Linke
us2 - vorne mittig
us3 - ist der rechte

"ein Hinderniss anzeigt" steht für "der Schwellwert wurde überschritten" (dies kann später noch mit mehreren Schwellwerten erweitert werden)

wenn us2 ein Hinderniss anzeigt, soll was passieren?
wenn us1 ein Hinderniss anzeigt soll solange nach rechts gedreht werden bis kein Hinderniss mehr angezeigt wird.
Wenn us1 und us2 ein Hinderniss anzeigen soll solange nach rechts gedreht werden, bis Beide kein Hinderniss mehr anzeigen.
wenn us3 ein Hinderniss anzeigt soll solange nach links gedreht werden bis kein Hinderniss mehr angezeigt wird.
Wenn us3 und us2 ein Hinderniss anzeigen soll solange nach links gedreht werden, bis Beide kein Hinderniss mehr anzeigen.
wenn us1, us2 und us3 ein Hinderniss anzeigen soll solange rückwärts gefahren werden, bis entweder us1 oder us2 kein Hinderniss mehr anzeigen und dann um mindestens 60° gedreht werden.
Wenn us1 und us3 ein Hinderniss anzeogen aber nicht us2, soll was passieren?

wir haben jetzt also 7 Fälle die eine Aktion benötigen.
und 3 Eingänge (us1, us2, us3) die zu verarbeiten sind.

Werten wir eine Detektion an us1 mit 1,
an us2 mit 2 und an us3 mit 4,

bekommen wir folgende Wahrheitstabelle

us3|us2|us1
---+---+---
 4 | 2 | 1
---+---+---
 0 | 0 | 0 = 0 kein Handlungsbedarf
---+---+---
 0 | 0 | 1 = 1 nach rechts drehen
---+---+---
 0 | 1 | 0 = 2 Was soll passieren?
---+---+---
 0 | 1 | 1 = 3 stark nach rechts drehen
---+---+---
 1 | 0 | 0 = 4 nach links drehen
---+---+---
 1 | 0 | 1 = 5 was soll passieren?
---+---+---
 1 | 1 | 0 = 6 stark nach links drehen
---+---+---
 1 | 1 | 1 = 7 Rückwärts fahren und dann um mindestens 60° drehen
---+---+---

Das könnte dann so in etwa implementiert werden

if us1 < 16 
then var1 = 1
else var1 = 0

if us2 < 16 
then var2 = 2
else var2 = 0

if us3 < 16 
then var2 = 4
else var2 = 0

var = var1 + var2 + var3

switch (var)
case 1
   rechts drehen
break
case 3
   rechts drehen
break
case 4
   links drehen
break
case 6
   links drehen
brake
case 7
   rückwärts
   merker7 = 1
default
   if merker7 == 1
   then rechts drehen 60°
   merker7 = 0
   else
   vorwärts

Das ist ein Denkanstoß und kein Code zum stur Abtippen, da ich mich an keine Sprachsyntax halte sondern einen Pseudocode nutze der nur das Konstrukt verdeutlichen soll.

Die hier nicht berücksichtigten case(es) kann man natürlich (besser, sollte man) auch noch füllen, da alle nicht behandelten Fälle im Default landen.

bei einem System mit 2 Schwellwerten könnte man das erweitern:

if us1 < 16 
then var1 = 8
else if us1 < 32 
then var1 = 1
else var1 = 0

if us2 < 16 
then var2 = 16
else if us2 < 32 
then var2 = 2
else var2 = 0

if us3 < 16 
then var3 = 32
else if us3 < 32 
then var3 = 4
else var3 = 0

Die entstehenden Fälle kannst Du problemlos in eine Tabelle eintragen und so wie ich es oben gezeigt habe den jeweiligen Zahlenwert errechnen.

So kann man z.B. bei einem etfernteren Hinderniss schon eine kleine Kurskorrektur beginnen ohne die Geschwindikeit zu verlangsamen.
Reicht das nicht, kommt man dem Hinderniss ja immer näher und irgendwann gilt die Bedingung für das nahe Hinderniss, wo man dann eventuell sogar stoppt und im Stillstand dreht.

Ist die Switch Case Anweisung nicht für beispielweise Tastatur eingaben ?

Kann man natürlich auch für Tastatur nehmen, aber Abfragen sei es nun IF-THEN oder SWITCH-CASE,
ist das eigentlich wurst welchen Variablentyp man abfragt.

Es ist eine Kontrollstruktur. Und die ist unabhängig von dem was man damit füttert.
Wenn ich ein Blech mit 4 Verschieden großen Löchern drin habe, ist dem das auch egal ob ich durch die Löcher Äpfel, Birnen oder Mandarinen fallen lasse.
Wenn ich vom kleinsten Loch zum größten gehe wird einfach alles nach Größe sortiert.

So ist es auch mit den Abfragen. Bedingung erfüllt? Ja/Nein, fertig.

Schau einfach mal hier:
http://www.arduino-tutorial.de/category/programmieren/

[zerebrator]

Super danke damit kann ich was anfangen. vor allem die Anweisungen.

Falls das nicht allzu viel ist hätte ich noch eine zusätzliche Frage

Kann ich das ganze auf einen Kompasssensor übertragen.?
Und zwar dieser gibt mir ebenso ständig die Position aus:

  /////////////////////////////////////////////////////////////
  //     Kompass Modul Abfrage und senden der Daten         ///
  ////////////////////////////////////////////////////////////
  
  byte byteHigh, byteLow; // byteHigh / byteLow für Bearing
  char pitch, roll;       // Pitch und Roll
  int bearing;            // Bearing

  Wire.beginTransmission(CMPS10Addr); // Kommunikation mit CMPS10
  Wire.write(2);                      // Start Register (2)
  Wire.endTransmission();
  Wire.requestFrom(CMPS10Addr , 4); // Abfrage von 4 Bytes vom CMPS10
  while (Wire.available() < 4); // Warten, bis 4 Bytes verfügbar
  byteHigh = Wire.read();       // High-Byte für Bearing speichern
  byteLow = Wire.read();        // Low-Byte für Bearing speichern
  pitch = Wire.read();          // Byte für Pitch speichern
  roll = Wire.read();           // Byte für Roll speichern
  bearing = ((byteHigh << 8) + byteLow) / 10; // Bearing berechnen
  
  sendData(bearing, pitch, roll);             // Daten versenden

void sendData(int bearing, int pitch, int roll) {
  String data = String(bearing) + ";" + String(pitch) + ";" + String(roll);
  
  lcd.setCursor(0,0);
    lcd.print("bear-pitch-roll");
    lcd.setCursor(0,1);
    lcd.print(data);
   
  
 // Serial.println(data);
delay (100);
}

Bearing ist für mich interessant.

Hier möchte ich unabhängig von Wert ( es kann ja im raum der Wert zwischen 0 und 360° vorliegen) bei finden eines Gegenstandes mit den vorher beschriebenen Sonar Sensor um 90° gedreht werden .

Wie wäre hier dein Ansatz ?

1000 dank nochmal  

[i_make_it]

Ein Kompaßsensor kann keine Position mitteilen sondern nur einen Winkel zwichen seiner Ausrichtung und der Nordweisung.
Von dem was ich sehe vermute ich mal Das du keinen Kompass sondern ein 3DOF Mems oder Magnetometer Gyroskop hast.
Da mußt Du Dich dann auch noch um Drift etc. kümmern, sonst wird es über die Laufzeit immer lustiger.

Erst mal mußt Du unterscheiden können ob Hinderniss oder Gegenstand (wenn du nur beim Finden eines Gegenstandes so reagieren willst und nicht bei jedem Hinderniss).

vom Rechnen her ist das einfach. Wenn du schon Winkelgrad hast, dann mußt Du ja nur 90° addieren oder subtrahieren (je nach dem ob du links oder rechts Drehen willst).
Ist das Ergebniss gößer 360° ziehst du 360° ab.
Ist das Ergebniss kleiner 0° addierst du 360°.
Dann ist das Ergebniss immer im gültigen Wertebereich.

Du nimmst also vor der Drehung dein Sensorwert, führts die Berechnung aus und übergibst das Ergebniss einer Variablen.
Dann kannst Du den aktuellen Sensorwert mit der Variablen vergleichen und beim Drehen z.B. bei einer Differenz kleiner 10° und kleiner 3° jeweils die Geschwindigkeit senken, damit daraus kein endloses Hinundherdrehen wird, weil er nie das Ergebniss trifft.
Geht dann auch wieder mit IF oder CASE.

[zerebrator]

Sorry habe mich natürlich falsch ausgedrückt . Du hast vollkommen Recht es geht hier um den Winkel der ausgegeben wird. Und der Sensor ist ein CPMS10 mit Magnetometer Tilt Compensated und Gyro modul usw.
Es ist auch absolut richtig was du weiterhin beschreibst das hin und herdrehen nervt und hier liegt mein Problem ...
Wie kann ich das Codetechnisch lösen ?

Habe absolut keine Idee wie ich das in einer if Anweisung lösen soll
Sprich uS1 sieht etwas bei 15 cm dann Lese bearing ein, drehe solange bis du + 90° ( + Toleranz) erreicht hast, dann weiter gerade aus ?

ich krieg das nicht hin  
Wie würdest du das Code technisch lösen ?

[i_make_it]

Sprich uS1 sieht etwas bei 15 cm dann Lese bearing ein, drehe solange bis du + 90° ( + Toleranz) erreicht hast, dann weiter gerade aus ?

Das wird gerinfügig komlizierter.

In dem von mir Skizzierten Konstrukt dreht er ja bis die Bedingung des us-Sensors nicht mehr erfüllt ist.
Jetzt hast Du ja us-Sensor Bedingung erfüllt, Entscheidung der Drehrichtung, Bedingung 90° Drehen setzen
Drehen bis 90° Bedingung erfüllt ist unabhängig davon ob us-Sensor Bedingung weiterhin erfüllt ist.

Der Case Abschnitt, darf also nicht mehr selbst das Dehen ausführen sondern muß variablen setzen, die den Systemzustand speichern und über die dann im nächsten Schritt verhindert wird das der us-Case Teil erneut angesprungen wird dafür aber ein 90° Case Teil.
dort wird dann gedreht bis der Winkel entsprechend klein wird und dann mit geringerer Geschwindigkeit weitergedreht bis der Winkel 0 ist.
Wenn die Bedingugn erfüllt dit, werden die Merker wieder gelöscht und der Teil verlassen.
Dann kann wider normal weitergearbeitet werden.
Das Ziel ist dabei halt so Geschickt die Logik aufzubauen, das man sich nicht in endlosen hin und her Springen verzettelt.

Deshalb macht es Sinn sich vor dem Programmierne zu überlegen wass will man denn alles machen und welche Bedingunge nmüssen erfüllt werden.
Asl zweites mauß man sich darüber im klaren sein, daß, damit Sensoren immer wieder eingelesen werdne können das Programm ständig weiterlaufen muß.
Also Endlosschleife.
Damit wird auch der Code wärend einer Aktion tausende male durchlaufen.
Also wo halte ich wie, welchen Systemzustand fest, und verhindere damit das Entscheidungsbäume während einer Aktion immer wieder durchlaufen werden und sich so Werte verschieben oder Aktionen vorzeitig Terminiert werden, weil Eingangsbedingungen mittleriweile nicht mehr erfüllt sind.

delay sollte im Code nirgendswo vorkommen, sondern durch Timer ersetzt werden. so kann der Code durchlaufen werden und während einer Aktion auch andere Eingaben und Ausgaben verarbeitet werden.
Wenn etwas wirklich genau sein soll, muß man über Interrupts nachdenken.

Unter Umständen kann es notwendig sein den gesammten bisher erstellten Code auf den Prüfstand zu stellen und mit dme auge des neu erworbenen wissens zu überlegen ob ein kompletter Neubau nicht sinnvoller ist um schwächen und ausuferndes Volumen auszubügeln.

Wenn das ganze erst mal zu komplex ist, kannst Du Dir auch Anleien bei UML holen und z.B. auf einem Sück Hartschaum mit kleinen Papierkarten die einzelnen Funkionsblöcke mit Stecknadeln feststecken sowie mit bunten Fäden die Abhängigkeiten (alternativ auch ein UML Programm am Computer) aufzeigen.
Nach und nach eränzt man auf den Karten dan ndie Variabeln und erkennt so ob ein vorrausgehendes Modul die auch liefert oder ob eine Variabel nach dem Setzen auch irgendwo wieder gelöscht wird. Oder als Zombie das System blockiert.

Das dann in Code zu bringen ist dann meist der einfachere Teil, da man da schon den meisten Denksport hinter sich hat und (fast) nur noch auf Syntax achten muß.

[zerebrator]

Hi

Also ich habe das versucht so zu lösen :

else if (taskTrigger==3) { //nach rechts 
   switch (taskStep) {
     case 0:
       digitalWrite(leftMtrDirPin1, LOW);
      digitalWrite(leftMtrDirPin2, LOW);  
      digitalWrite(rightMtrDirPin1, HIGH);
      digitalWrite(rightMtrDirPin2, LOW); 
      analogWrite(leftMtrSpdPin, 255);   //drive the motor
      analogWrite(rightMtrSpdPin, 255);
       
       currentPosition=bearing;
       taskStep++;
       break;
     case 1:
       if (currentPosition= newPosition+90) { 
         taskTrigger=0;
         taskStep=0;  
   
    analogWrite(leftMtrSpdPin, 0);   //stopp the motors
    analogWrite(rightMtrSpdPin, 0);      
       }
   }
 }

vorher kommt die Anweisung :

if (!taskTrigger && (uS2 < 15 & uS3 > 30 )) //abstand kleiner als 15cm und abstand links grösser als 30  
    taskTrigger=1;
    
else if (!taskTrigger && ( uS2 < 15 & uS1 > 30 )) //wenn abstand kleiner als 15 und links groesser als 30 dann rechts
    taskTrigger=2;

else if (!taskTrigger && (uS3 < 16)) //wenn abstand kleiner als 16 dann rechts drehen
    taskTrigger=3;

leider "pulsiert" der Antrieb nur
Es schert ihm nicht was die Werte des kompasmoduls machen.

Ich krieg das nicht hin ....
Warum wartet er nicht bis er um 90° gedreht hat ???

Hat jemand einen Vorschlag ?

Gruß
Chr.

[i_make_it]

if (currentPosition= newPosition+90) {

Syntaxfehler?
http://www.arduino-tutorial.de/category/programmieren/

Arithmetische Operatoren
= Zuweisung a=2*b Weist der linken Seite den Wert auf der Rechten Seite zu.

Vergleichsoperatoren
== Gleichheit a==b Prüft auf Gleichheit.


currentPosition=bearing;
wird bei jedem Durchlauf aktualisiert

und mit dem Inhalt von "newPosition+90" wieder überschrieben.
if (currentPosition= newPosition+90) {

Wo "newPosition" herkommt, wann es mit was gesetzt wird und was sicherstellt das es nur einmal am Anfang einer Drehung gesetzt wird kann ich nicht erkennen.