outdoor I

[Moppi]

Zur ersten if-Abfrage:
Du bist in der Funktion/Methode loop() innerhalb einer Schleife. Deshalb habe ich das ursprüngliche while von Dir entfernt und durch if ersetzt.

Die zweite if-Abfrage sorgt dafür, dass die Stepper so lange in die angeforderte Richtung gedreht werden, wie dies in StepsPerDirection vorgegeben ist. Hier habe ich gedacht, dass eine viertel Umdrehung ein guter Wert wäre. Denn wenn Du die Fernbedienung drückst, "feuert" die ja nicht 200mal pro Sekunde (oder wie lange eine Radumdrehung dauert), sondern weniger. Hier muss man dann passende Werte finden, dass die Handhabung angenehm wird. Wenn für Dich 1 Radumdrehung pro Tastendruck angenehm ist, kannst Du natürlich aus der viertel Umdrehung eine Ganze machen (also: StepsPerDirection = StepsPerRevolution).

Wenn Du 11 Mal Drücken musst, um eine Umdrehung zu erhalten, könnte man versuchsweise schreiben: StepsPerDirection = StepsPerRevolution*11;
Allerdings verstehe ich das mit den 11 Malen nicht, ich sehe darin keine Logik.


MfG

[inka]

Zur ersten if-Abfrage:
Du bist in der Funktion/Methode loop() innerhalb einer Schleife. Deshalb habe ich das ursprüngliche while von Dir entfernt und durch if ersetzt.

ok, die loop wird ja immer wieder durchlaufen, ist es aber nicht so, dass "if" nur einmal abgefragt wird und "while" so lange, bis ein bestimmtes ereignis eintrifft? Damit wollte ich erreichen, dass weitere anweisungen in der loop erst nach diesem ereignis ausgeführt werden...

Du die Fernbedienung drückst, "feuert" die ja nicht 200mal pro Sekunde (oder wie lange eine Radumdrehung dauert), sondern weniger. Hier muss man dann passende Werte finden, dass die Handhabung angenehm wird.

Das eigentliche ziel war (und ist) einmal auf "vor" zu drücken und der roboter fährt so lange vorwärts, bis er einen andern befehl bekommt, oder halt ein anderer sensor meldet sich...

Wenn Du 11 Mal Drücken musst, um eine Umdrehung zu erhalten, könnte man versuchsweise schreiben:

StepsPerDirection = StepsPerRevolution*11; Allerdings verstehe ich das mit den 11 Malen nicht, ich sehe darin keine Logik.

ich auch nicht...

[Moppi]

ist es aber nicht so, dass "if" nur einmal abgefragt wird und "while" so lange, bis ein bestimmtes ereignis eintrifft

Ja, wenn die Abfrage so formuliert ist.
"if" wird auch immer wieder geprüft (weil ja in "loop()"). Wenn dann ein Ereignis eingetreten ist, weil auf "Serial1" etwas "available" ist, wird das Ereignis abgearbeitet.

Damit wollte ich erreichen, dass weitere anweisungen in der loop erst nach diesem ereignis ausgeführt werden...

Passiert hier mit dem "if" genau so. Wenn keine Taste gedrückt wurde und also kein Ereignis vorhanden ist, bewegt sich auch kein Motor, es sei denn, die viertel oder ganze Umdrehung ist noch nicht fertig. Und wenn sich die Motoren in eine Richtung drehen, kannst Du eine andere Taste drücken und die Motoren bewegen sich praktisch sofort in die andere Richtung.

Also eigentlich sollte das Programm dann das tun, was Du beabsichtigt hast. Und wie gesagt, das "while" erübrigt sich, weil Du in "loop()" bist und dieser Code darin immer wieder abgearbeitet wird.

Daher macht

while(Serial1.available()){
...
}

im Grunde dasselbe, wie

loop(){
    if(Serial1.available()){
    ...
    }
}

Beides wird immer wieder abgearbeitet, wenn die Bedingungsprüfung für "Serial1.available()" positiv ausfällt.
Wenn diese Prüfung negativ ausfällt, stoppt "while" nicht den Programmablauf in "loop()", bis ein Ereignis eintritt, sondern nur, solange eines da ist.
Mit "if" passiert dasselbe. Nur dass es den Programmablauf nicht aufhält, solang Ereignisse vorhanden sind, sondern nur so lange, wie ein Ereignis abgearbeitet wird. Wenn beim nächsten Durchlauf in "loop()" festgestellt wird, dass immer noch oder wieder ein Ereignis vorhanden ist, wird das wieder abgearbeitet. Das geht dann so lange, bis kein Ereignis (also Zeichen auf Serial1) mehr vorhanden ist.


MfG

[inka]

Passiert hier mit dem "if" genau so. Wenn keine Taste gedrückt wurde und also kein Ereignis vorhanden ist, bewegt sich auch kein Motor, es sei denn, die viertel oder ganze Umdrehung ist noch nicht fertig. Und wenn sich die Motoren in eine Richtung drehen, kannst Du eine andere Taste drücken und die Motoren bewegen sich praktisch sofort in die andere Richtung.
Also eigentlich sollte das Programm dann das tun, was Du beabsichtigt hast. Und wie gesagt, das "while" erübrigt sich, weil Du in "loop()" bist und dieser Code darin immer wieder abgearbeitet wird.

das ist es ja - eben nicht. ich habe deine version von vorwärtes etwas geändert, von:

void vorwaerts(void)
{
  if(s_vor == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);


      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);


      s_vor = 1;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}

in:

void vorwaerts(void)
{
  if (s_vor == 0)
  {
    // enable pins aktivieren:
    digitalWrite(enbl_VL, HIGH);
    digitalWrite(enbl_HL, HIGH);
    digitalWrite(enbl_VR, HIGH);
    digitalWrite(enbl_HR, HIGH);

    //richtung bestimmen
    digitalWrite(dirPin_VL, LOW);
    digitalWrite(dirPin_HL, LOW);
    digitalWrite(dirPin_VR, HIGH);
    digitalWrite(dirPin_HR, HIGH);

    s_vor = 1;
    s_rueck = 0;
    s_links = 0;
    s_rechts = 0;

    for (int i = 0; i < stepsPerRevolution; i++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
    }
  }
  else

    for (int i = 0; i < stepsPerRevolution; i++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
    }
}

so macht sie eine umdrehung pro signal vom smartphone, wie meine ursprüngliche auch
allerdings muss ich am ende der umdrehung für die nächste wieder drücken...

[Moppi]

Du kannst es natürlich machen, wie Du es für richtig hältst. Ich verstehe Deine Intention, das sequentiell abarbeiten zu wollen. Das ist tendenziell für Beginner einfacher. Allerdings wirst Du später eventuell auf eine parallele Abarbeitung hinaus wollen oder müssen. Sequentielle Abarbeitung blockiert immer ein Programm und wird unübersichtlich, wenn man dies zu ändern versucht (indem man immer wieder kreuz und quer Funktionsaufrufe einstreut). Parallele Abarbeitung verfolgt dagegen den Ansatz, mehrere Aufgaben nebeneinander abzuarbeiten, übersichtlich und kontrolliert.

Ich schlage (leider hier nicht zum ersten Mal) vor, einen Programmablaufplan zu erstellen. Gerade, wenn man nicht so den Überblick hat, ist das eine tolle Sache! Den dafür sind die sogenannten PAPs da: optisch einen Überblick über den Programmablauf zu verschaffen. Da erkennt man auch Probleme in der Programmabarbeitung.

Ein Problem will ich noch bildhaft beschreiben, wenn Du die Programmierung in diesen Schleifen (for (int i = 0; i < stepsPerRevolution; i++)...) so aufrecht erhalten willst:

Sollte der Roboter eine dreiviertel Umdrehung am Abgrund stehen und er fährt vorwärts, kannst Du ihn mit keiner Taste stoppen. Weil er erst den Abgrund hinunterstürzt, bevor er auf eine weitere Taste reagiert.



MfG

[inka]

Lieber Moppi,
wir schreiben aneinander vorbei , es geht nicht um parallel oder seriell, auch das mit der einer Umdrehung pro Smartphonesignal ist doch nur eine Hausnummer, die jederzeit geändert werden kann...
Es geht um die Dauerbewegung nach nur einem Klick am Smartphone, das weiss ich nicht wie ich da hinkomme...
morgen geht's weiter...

[Moppi]

Dauerbewegung nach nur einem Klick

Wenn Du willst, dass das Teil immer vorwärts oder rückwärts ... fährt, dann geht das z.B. so:

// DIR und STEP pins definieren
#define dirPin_VL 6 //2
#define stepPin_VL 7 //3
#define dirPin_HL 8 //4
#define stepPin_HL 9 //5
#define dirPin_VR 2 //6
#define stepPin_VR 3 //7
#define dirPin_HR 4 //8
#define stepPin_HR 5 //9








//enable pins definieren
#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43








//resett pin definieren
#define PIN2RESET 10
















//steps pro umdrehung definieren:
#define stepsPerRevolution 200
















uint8_t taste_neu = 1;
uint8_t taste_alt = 8;
uint8_t taste = 0;








uint8_t s_vor = 0;
uint8_t s_rueck = 0;
uint8_t s_links = 0;
uint8_t s_rechts = 0;


void setup()
{
  //  pinMode(LED, OUTPUT);








  //pins als output:








  pinMode(dirPin_VL, OUTPUT);
  pinMode(stepPin_VL, OUTPUT);
  pinMode(enbl_VL, OUTPUT);
  pinMode(dirPin_HL, OUTPUT);
  pinMode(stepPin_HL, OUTPUT);
  pinMode(enbl_HL, OUTPUT);
  pinMode(dirPin_VR, OUTPUT);
  pinMode(stepPin_VR, OUTPUT);
  pinMode(enbl_VR, OUTPUT);
  pinMode(dirPin_HR, OUTPUT);
  pinMode(stepPin_HR, OUTPUT);
  pinMode(enbl_HR, OUTPUT);
















  //resett pin zustand definieren
  pinMode(PIN2RESET, INPUT);








  Serial.begin(115200);
  Serial1.begin(115200);
  Serial.println("code----- /home/georg/Arduino/outdoor_robo/smartphone_steuerung/outdoor_moppi_FB_switch_bluetooth_1");








  Serial.println("bluetooth übertragung!");
















  //enable pins deaktivieren:
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);








  //resett pin aktivieren
  digitalWrite(PIN2RESET, HIGH);
}








void loop()
{
  if (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    tasten_abfrage();
  }


  richtung_abfrage();
}








/***********************************************************/
void richtung_abfrage(void)
{
  if (s_rechts == 1) rechts_drehen();
  if (s_links == 1) links_drehen();
  if (s_vor == 1) vorwaerts();
  if (s_rueck == 1) rueckwaerts();
}








/***********************************************************/
void tasten_abfrage(void)
{








  switch (taste)
  {








    case 100:// rotate rechts - FB quer smartphone
      {








        rechts_drehen();








        break;
      }
















    case 97:// rotate links - FB quer smartphone
      {








        links_drehen();








        break;








      }
















    case 116:// fahre vor - FB quer smartphone
      {








        vorwaerts();








        break;
      }
















    case 115:// fahre rückwärts - FB quer smartphone
      {








        rueckwaerts();








        break;
      }
  }
















}








/***********************************************************/
void alle_stepper_stop(void)
{
  //enable pins deaktivieren
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);
  reboot();
}








/***********************************************************/
void vorwaerts(void)
{
  if(s_vor == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);








      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);








      s_vor = 1;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}








/**********************************************************/








void rueckwaerts(void)
{
  if(s_rueck == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);








      //richtung bestimmen
      digitalWrite(dirPin_VL, HIGH);
      digitalWrite(dirPin_HL, HIGH);
      digitalWrite(dirPin_VR, LOW);
      digitalWrite(dirPin_HR, LOW);








      s_vor = 0;
      s_rueck = 1;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}




/***********************************************************/
void rechts_drehen(void)
{
  if(s_rechts == 0)
  {
      // enable pins aktivieren
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);








      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, LOW);
      digitalWrite(dirPin_HR, LOW);








      s_vor = 0;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 1;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}
















/**********************************************************/








void links_drehen(void)
{
  if(s_links == 0)
  {
      //enable pins aktivieren
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);








      //richtung bestimmen
      digitalWrite(dirPin_VL, HIGH);
      digitalWrite(dirPin_HL, HIGH);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);








      s_vor = 0;
      s_rueck = 0;
      s_links = 1;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}








/*
  void links_drehen(void) //mit beschleunigung und sound
  {








  //enable pins aktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);








  //richtung bestimmen
  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);








  //"j = 2000": der Anfangswert für das Delay in Microsekunden








  for (int i = 0, j = 2000; i < stepsPerRevolution; i++)
  {








    //"j > 500": der Endwert für das Delay in Microsekunden - bestimmt auch die Endgeschwindigkeit (mindestens 250 bis 300)








    if (j > 300) j--;
    //"z < 3": wieviele Schritte mit dem eingstellten Delay "j" gemacht werden sollen, bevor es reduziert wird








    for (int z = 0; z < 3 && i < stepsPerRevolution; z++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(j);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(j);
      i++;
    }
  }
  }
*/
/***********************************************************/
void reboot()
{
  pinMode(PIN2RESET, OUTPUT);
  digitalWrite(PIN2RESET, LOW);
  delay(100);
}
/***********************************************************/








/************************************************************/

Du hast da aber keinen Stop-Code drinnen, auf den Du reagieren kannst. Wenn der dann fährt, bleibt er nicht mehr stehen.
Allerdings ist der Code so angelegt, dass Du die Chance hast, eine Taste zu drücken, wenn er fährt, also auch eine Stop-Taste.
Die musst Du aber noch abfragen, weil noch nicht vorhanden!


MfG

- - - Aktualisiert - - -

Eine Funktion zum Anhalten des Fahrzeugs, auf den obigen Code zugeschnitten. Sollte aufgerufen werden, wenn eine Stop-Taste gedrückt wird.

/***********************************************************/
void anhalten(void)
{
  //enable pins deaktivieren
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);
  s_vor = 0;
  s_rueck = 0;
  s_links = 0;
  s_rechts = 0;
}

[inka]

ich habe jetzt mal eine frage betreffend microstepping und wollte wissen, was ihr so drüber denkt...

Die extenderplatine für den steppertreiber hat ja einen 3poligen schiebeschalter on board, mit dem man - ohne strippen ziehen zu müssen - zwischen den verschiedenen microstep-modi umschalten kann. Allerdings ist sowas eher für den stationären betrieb gedacht, beim fahrenden roboter eher nicht gut machbar.
Die frage:
wäre es sinnvoll die schaltung von der extenderplatine zum arduino zu führen um dann vom smartphone auch "unterwegs" mal umschalten zu können? Alle motoren auf einmal, oder einzeln?

[Moppi]

Im Datenblatt steht, übersetzt mit goggle:

Beim Ändern der Stufe
Modus Die Änderung wird erst mit dem nächsten Schritt wirksam
Kante.
Wenn der Schrittmodus ohne Zurücksetzen des Übersetzers geändert wird, und absolut
Position muss beibehalten werden, es ist wichtig, die zu ändern
Schrittmodus an einer Schrittposition, die beiden Schrittmodi in gemeinsam ist
um fehlende Schritte zu vermeiden.

Die MAx-Geschwindigkeit, wie ich schon mal erwähnt habe, erreichst Du glaub ich nur im Full-Step-Mode.
Den Step-Mode musst Du dann bei allen Motoren gleichzeitig ändern. Sonst drehen die ja unterschiedlich schnell.

MfG

[inka]

bei der erweiterung der funktionen der smartphone fernbedienung musste ich langwierig testen, was das smartphone sendet und was der arduino im switch / case nun in der lage ist zu empfangen:

                               
zeichen abfrage switch case /
zeichen gesendet smartphone




49
1

51
3

52
4

53
5

54
6

55
7

56
8

57
9

97
a

100
d

109
m

110
n

111
o

112
p

113
q

114
r

115
s

116
t

117
u

118
v

119
w

120
x

kennt jemand solch eine zuordnung? Oder ist es einfach von dem app-entwickler willkürlich so festgelegt worden?