outdoor I

Da musst Du herausfinden, warum nichts ankommt. Nutzt nichts. Vielleicht ist auch die Platine kaputt.

Wenn du die Leitungen statt RX1 und TX1 mit RX2 und TX2 verbindest, kommt dann was an, auf Serial2 ?
Wenn ja, dann nochmal versuchen mit RX1 und TX1, kommt nichts an? Kabel vertauscht?



MfG
:Weihnacht

Zitat:

---

Zitat von Moppi

Da musst Du herausfinden, warum nichts ankommt. Nutzt nichts. Vielleicht ist auch die Platine kaputt.

---

einen anderen atmega 2560 und eine andere BT-platine genommen - das gleiche ergebnis

Zitat:

---

Zitat von Moppi

Wenn du die Leitungen statt RX1 und TX1 mit RX2 und TX2 verbindest, kommt dann was an, auf Serial2 ?
Wenn ja, dann nochmal versuchen mit RX1 und TX1, kommt nichts an? Kabel vertauscht?

---

das hatte ich ja schon weiter oben getestet, auch mit dem kabeltauschen. Also entweder mache ich irgendwo noch einen fehler, oder - was kanns noch sein? - egal, ich sagte ja schon, ich hab ja noch die wifi alternative...

Ich denke schon, dass Du irgendwo einen Fehler machst. Aber von Ferne kann man nicht beurteilen, wo das sein könnte.


Gruß
:Weihnacht

Zitat:

---

Zitat von Moppi

Ich denke schon, dass Du irgendwo einen Fehler machst. Aber von Ferne kann man nicht beurteilen, wo das sein könnte

---

man sollte sich nie zu sicher sein, so nach dem motto, das hast du doch schon hundertmal gemacht... Ja, das BT-modul war nicht 100%tig richtig programmiert :-( , jetzt geht alles...

Zitat:

---

man sollte sich nie zu sicher sein, so nach dem motto, das hast du doch schon hundertmal gemacht ..

---

Wie wahr. (M)Ein bemerkenswerter Fall: Projekt Jugend forscht, ich hatte gecoacht, P*** hatte von vier nachmittags bis acht abends an einer Platine mit einigen Sensoren gesessen - nix ging - ausser einem Hilferuf an mich. Um acht war ich da und wir hatten gemeinsam drei weitere Stunden gesucht - periphere Sensoren, (Mutter)Platine etc. Schließlich stellte ich fest, dass die PullUps fürs I²C fehlen. Mit den restlichen Arbeiten war P*** noch ne gute Stunde dran. Sooo lang für einen total blödsinnigen Fehler.

Hallo Inka,

kommst Du voran? Wie ist denn der Stand der Dinge?

MfG
:Weihnacht

weihnachten naht :-) -- wenig zeit weil gäste kommen...

aber in kleinen schritten gehts voran - momentan versuche ich einen "200 steps per buttonklick" in eine dauerbewegung bei gleichzeitiger ständiger abfrage des tastenfeldes der bluetooth FB in der app umzuwandeln - wenn du nicht dranbleiben kannst, machst du eigentlich immer wieder die gleichen fehler :-)

jetzt hänge ich's doch hier rein. Egal was ich mache, entweder es gibt nur kurze bewegungen (in der länge der definierten stepps per revolution), oder die erste angewählte richtung wird dauernd bedient und ich habe keine möglichkeit einzugreifen :-( --- Wer weiss rat warum das so ist?

danke...

Code:

---


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



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_FB_switch_bluetooth_1.ino");

  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()
{

  while (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    tasten_abfrage();
  }
}
/***********************************************************/

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)
{

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



  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);
  }
  tasten_abfrage();
}


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

void rueckwaerts(void)
{

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


  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);
  }
  tasten_abfrage();
}

/***********************************************************/
void rechts_drehen(void)
{

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



  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);
  }
  tasten_abfrage();
}


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

void links_drehen(void)
{

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


  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);
  }
  tasten_abfrage();
}

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

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

---

Zunächst mal, was mir zuerst, beim Überfliegen des Codes, auffällt und unvorhersehbar enden kann:

Du rufst in loop() die Funktion tasten_abfrage() auf.
In tasten_abfrage() rufst Du die Funktionen rechts_drehen(), links_drehen() usw. auf. In diesen Funktionen wiederum rufst du tasten_abfrage() erneut auf.
Es entsteht eine Rekursion, die zum Stapelüberlauf und damit zum Absturz führen kann.

Zuerst würde ich die Rekursion entfernen. Und dann den Code anders gestalten - dazu muss ich erst genauer schauen.



MfG
:Weihnacht

- - - Aktualisiert - - -

Dann mein Vorschlag zum weiteren Programmablauf:

zuerst vier Statusvariablen einführen, für die jeweiligen Richtungen:

Code:

---

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

---

Dann nur in loop() die Funktion tasten_abfrage() aufrufen.

Dann habe ich hier für das Beispiel "vorwärts" den Code geändert:

Code:

---

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


void weiter_vorwaerts(void)
{
    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);
}

---

Zuerst wird der Status für die Richtung "vorwärts" abgefragt. Ist der "0", dann müssen die Enable-Pins aktiviert werden und die Richtung bestimmt.
Dann wird der Status für die Richtung auf "1" gesetzt, die Vorbereitungen müssen nicht mehr ausgeführt werden, einmal genügt.
Außerdem werden die Statusvariablen der anderen Richtungen auf "0" gesetzt.

Dadurch, dass die Statusvariable für "Vorwärts" auf "1" gesetzt wurde, wird in jedem weiteren Durchlauf nur noch die Funktion weiter_vorwaerts() aufgerufen,
wo der Schrittmotor tatsächlich bewegt wird. Und zwar hier im Beispiel nur einen Schritt.

In allen anderen Funktionen für die Richtungen muss identisch verfahren werden.

Falls die Fernbedienung nicht schnell genug "feuert", läuft der Motor nur sehr langsam , weil immer nur ein Schritt pro Durchlauf gemacht wird.
Um das zu ändern, müssen in einem Durchlauf mehr Schritte gemacht werden (die Schleife habe ich jetzt raus genommen).

Der Code kann noch weiter geändert werden, dass es "besser" funktioniert. Das würde jetzt aber alles auf einmal wohl etwas überfordern. Deshalb erst einmal so weit.



MfG

- - - Aktualisiert - - -

Ich habe des gesamten Code überarbeitet, schau es Dir mal an, Du solltest es durchschauen, was ich gemacht habe.
Ob das jetzt fehlerfrei ist, weiß ich nicht. Ich hoffe dass Du den Code so kompilieren kannst und dass er funktioniert:

Code:

---

// 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;
uint8_t StepsPerDirection = 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_FB_switch_bluetooth_1.ino");


  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();
  }


  if ( StepsPerDirection > 0)
  {
        StepsPerDirection--;
        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
      {


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        rechts_drehen();


        break;
      }




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


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        links_drehen();


        break;


      }




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


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        vorwaerts();


        break;
      }




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


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        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);
}
/***********************************************************/


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

---

Zu viel des guten Moppi, danke...
Der Weihnachtsmann kommt ja erst morgen...
Frohe Weihnachten!