outdoor I

[Moppi]

Guten Morgen!

Ich will nochmals einen Vorschlag vertiefen.

Es ist tatsächlich die beste Lösung, zunächst einen Ablaufplan zu erstellen.
Noch ist so viel nicht im Programmcode drin. Jedenfalls nicht in diesem hier, wie eben besprochen.

Ein einfach zu handhabendes Programm, um PAPs zu erstellen, findet man hier zum Download: https://www.heise.de/download/product/papdesigner-51889
Bilder sagen mehr als Worte. Beispiel 1 und Beispiel 2 des Programms verdeutlichen, was ein PAp ist.

1. Zuerst muss ein neues Projekt angelegt werden (Projekt -> neues Projekt erstellen).
2. Daraufhin wird Start und Ende des PAP bereits vorgegeben.
3. Auf der rechten Seite hat man einige Symbole zur Auswahl. Diese genügen, um einen PAP zu erstellen.
4. Statt "Hauptprogramm 1" schreibt man z.B. "void loop()". Indem man den Schriftzug anklickt, öffnet man ein Menü, wo man den Text ändern kann.
5. Um zu verdeutlichen, dass es sich bei "loop()" um eine Funktion/Methode handelt, die immer wieder aufgerufen wird - also in einer Schleife abgearbeitet wird, kann man das Symbol für "Schleife" rechts anklicken und es anschließend mit der Maus zwischen "Start" und "Ende" platzieren.
6. Als Schleifenbedingung kann einfach "void loop()" eingetragen werden, damit klar ist, worum es sich bei der Schleife handelt.
7. Zwischen den Symbolen für Schleifenanfang und das Schleifenende können nun weitere Symbole platziert und beschriftet werden. Es gibt fünf weitere Symbole, mit denen ein kompletter Programmablauf beschrieben werden kann, indem die Symbole angeklickt, dann platziert und beschriftet werden. Außerdem kann man dann Verbindungen zwischen den Symbolen herstellen, wo auch Pfeile angetragen werden, so dass die Flußrichtung zu erkennen ist.
8. Um eine Verbindungslinie (Flußlinie) zwischen zwei Symbolen zu erstellen, klickt man zuerst das Symbol für "Verbindungspunkt bzw. Endpunkt einfügen" an. Danach klickt man ein Mal auf das Zielsymbol, dann bewegt man den Mauszeiger zum Symbol, von dem aus die Verbindung starten soll. Es erscheinen so kleine Vierecke mit Richtungsweisern in Grün, wenn man über ein Symbol fährt. Auf diese grünen Vierecke klickt man einmal drauf und es wird dann eine Verbindung in der gewünschten Richtung, zwischen den Symbolen gezogen. Man kann die Verbindungslinien noch beschriften, das ist z.B. bei Verzweigungen üblich, wo dann an jede Flußrichtung "ja" oder "nein" angetragen wird oder auch "wahr" oder "falsch", da eine Verzweigung durch eine Bedingungsprüfung erreicht wird (wie: "ist A > B ?").

Mit diesen wenigen Handgriffen kann man sich nun ziemlich schnell und einfach seinen PAP erstellen.

Welche Vorteile haben PAPs:

- beim Erstellen, muss der Programmablauf (Logik) reflektiert werden, was zu einem besseren Verständnis des Programms schon während des Zeichnens führt
- durch einfache und immer wiederkehrende Symbole wird eine Übersichtlichkeit und sehr gute Lesbarkeit erzeugt
- anhand des Diagrammflusses (Linien/Verbindungen zwischen den Symbolen) kann leicht nachvollzogen werden, was das Programm tut, es fallen Fehler auf und Fehlverhalten in der Programmlogik kann leicht erkannt werden
- einen PAP kann ein Programmierer in einen Programmcode übersetzen, wie C++
- bei einem gut angelegten PAP, der dann auch aus mehreren Teil-PAPs besteht, werden auch große oder "kompliziertere" Projekte übersichtlich und die Programmlogik im Einzelnen gut nachvollziehbar
- Fragen, wie: was tut dieser oder jener Programmteil (if .. while ..) können anhand eines PAP besser nachvollzogen werden, als man dies in Worten erklären kann.

Hält man sich beim Programmieren dann an den PAP, kann so gut wie nichts mehr schief gehen.




MfG

[inka]

da ich linux (ubuntu) verwende, kommt leider der pap-designer für mich nicht in frage, habe aber yEd installiert, mal sehen, wie ich damit zurechtkomme...
Ansonsten ist mir das mit den PAP's ja nicht neu, ist auch sinnvoll, klar...

[Moppi]

Schau mal hier, Wine ist ein Emulator. Ich habe vor Jahren mal gehört, das soll unter Linux gut funktionieren.


MfG

[inka]

wine kenne ich, seit jahren schon ein mehr oder weniger schlechter ersatz für echtes windows. Es ist bei linux so, entweder es gibt was vergleichbares an software, oder halt nicht und damit kann man leben (seit 12 jahren schon), es kostet aber nix...

[Moppi]

Als ich in den 90ern Linux installiert hatte, gab es nicht mal Treiber für Hardware, die ich brauchte. Deswegen bin ich dann bei Windows geblieben.
Ist aber jetzt ab vom Thema.

MfG

[Searcher]

Ein einfach zu handhabendes Programm, um PAPs zu erstellen, findet man hier zum Download: https://www.heise.de/download/product/papdesigner-51889

@Moppi: Danke. Super! DAS ist ja mal ein Tipp. Habe schon öfter versucht ein PAP mit Zeichenprogrammen zu erstellen. Auch mal mit Visio. Immer abgebrochen weil mir das dann zu umständlich war. Dieses Programm hab ich mir mal runtergeladen und kurz ausprobiert. Läuft sogar noch auf WINXP, kommt mir praktisch und auch wirklich einfach vor. Damit sollte ich diesmal vielleicht doch endlich mehr/bessere Dokumentation zu meinen Programmen schaffen.

@Inka: Ich mag zu sehen, was andere so basteln und lese eifrig mit.

Gruß
Searcher

[inka]

ich habe die verdrahtung so geändert, dass die microstepp-pins der steppertreiber über den arduino auch später erreichbar sind - wer weiss wofür man das noch braucht

der

// 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 //1600

#define microstep_pin_S1 34
#define microstep_pin_S2 36
#define microstep_pin_S3 38

uint8_t taste = 0;

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


void setup()
{

  //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/stepper/test_vier_stepper/ohne_lib/outdoor_FB_switch_richtung_stop_full_half_quarter_step_delay_bl");

  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();
  if (s_stop == 1) alle_stepper_stop();
  if (s_parken ==1) parken();
}

/***********************************************************/
void tasten_abfrage(void)
{
  switch (taste)
  {

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

        vorwaerts();
        break;
      }

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

        rueckwaerts();
        break;
      }

    case 100:// rotate rechts - FB quer smartphone
      {
        rechts_drehen();
        break;
      }

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

        links_drehen();
        break;
      }

      case 49: //alle Stepper stop - FB quer smartphone
      {

        alle_stepper_stop();
        break;
      }

      case 51: //parken - FB quer smartphone
      {

        parken();
        break;
      }

    case 52: //full step - FB quer smartphone
      {

        full_step();
        break;
      }

    case 53: //half step - FB quer smartphone
      {

        half_step();
        break;
      }

    case 118: //quarter step - FB quer smartphone
      {

        quarter_step();
        break;
      }

    case 98: //eight step - FB quer smartphone
      {

        eight_step();
        break;
      }
      
  }

}


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

void full_step (void)
{
  digitalWrite (microstep_pin_S1, LOW);
  digitalWrite (microstep_pin_S2, LOW);
  digitalWrite (microstep_pin_S3, LOW);
}

void half_step (void)
{
  digitalWrite (microstep_pin_S1, HIGH);
  digitalWrite (microstep_pin_S2, LOW);
  digitalWrite (microstep_pin_S3, LOW);
}

void quarter_step (void)
{
  digitalWrite (microstep_pin_S1, LOW);
  digitalWrite (microstep_pin_S2, HIGH);
  digitalWrite (microstep_pin_S3, LOW);
}

void eight_step (void)
{
  digitalWrite (microstep_pin_S1, HIGH);
  digitalWrite (microstep_pin_S2, HIGH);
  digitalWrite (microstep_pin_S3, LOW);
}

void sixteen_step (void)
{
  digitalWrite (microstep_pin_S1, HIGH);
  digitalWrite (microstep_pin_S2, HIGH);
  digitalWrite (microstep_pin_S3, HIGH);
}


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

void parken(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;
      s_stop = 0;
      s_parken = 1;
}
      
void alle_stepper_stop(void)
{
  //enable pins deaktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

      s_vor = 0;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 0;
      s_stop = 1;
      s_parken = 0;
  
//  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;
      s_stop = 0;
      s_parken = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(1000);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(1000);
  }
}
/**********************************************************/
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;
      s_stop = 0;
      s_parken = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(1000);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(1000);
  }
}

/***********************************************************/
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;
      s_stop = 0;
      s_parken = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(1000);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(1000);
  }
}
/**********************************************************/

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;
      s_stop = 0;
      s_parken = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(1000);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(1000);
  }
}

/*
  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);
}
/***********************************************************/

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

ist dafür gedacht, für mich den zusammenhang zwischen drehmoment, geschwindigkeit, den drei microstepps - modi und den delays beim steppercode zu testen. Für die microstepps habe ich die digitalen arduino pins 34, 36 und 38 verwendet. Da sind alle vier Stepper zusammengeschaltet. Ein getrenntes schalten jedes einzelnen steppers schien nicht angebracht...

Gleich zu anfang ein "seltsames" verhalten:

bei 4 motoren ein komisches "stottern" bei der verwendung der microstepping pins. Bei entfernen eines der vier Stepper (egal welches) ist das stottern weg. Hängt das mit den 5V an den digitalen pins zusammen? Liefern die pinns nicht genug spannung, bzw. strom?

EDIT:
ich habe die microstep-pins aufgeteilt auf links und rechts - das war's noch nicht, es lag daran dass diese pins nicht als output definiert waren...
jetzt kann ich weiter testen...