outdoor I

[inka]

ich habe noch einmal getestet:

- der code für arduino mini bringt als ausdruck im seriellen monitor (beim druck auf eine taste auf dem smartphone) drei untereinander liegende zweistellige zahlen

- der code für mega2560 bringt als ausdruck 8 untereinander liegende nullen

- dies passiert auch bei einer änderung auf die 2te serielle schnittstelle, also TX2 /RX2

- ein tauschen der tx/rx anschlüsse hat zu folge, dass kein ausdruck erfolgt...

ich würde vermuten, dass der 2560 einen anderen datentyp braucht?

[Moppi]

Ich kann das nicht so recht verstehen, da steht nichts ungewöhnliches in loop().

Ich würde loop() mal ganz leer machen und dann einfach erst einmal so probieren,
was da überhaupt ankommt:

void loop(){
while (Serial1.available())Serial.write(Serial1.read());
}

Zwischen Serial.write() und Serial.print() sollte es geringfügige Unterschiede geben.
Arduino.cc sagt dazu:
Um Daten ohne Umwandlung in ihre Darstellung als Zeichen zu senden, verwende Serial.write().

Mit der kurzen Schleife oben siehst Du, welche Zeichen geschickt wurden,
wenn Du nichts siehst, dann wurden auch keine lesbaren Zeichen geschickt.
Kurz: write() gibt das aus, was geschickt wurde. Steuerzeichen, lesbare Zeichen oder was auch immer.

[inka]

danke Moppi,
aber da kommt einfach garnix an. Ich glaube ich lasse es und mache weiter mit der wifi fernbedienung...

[Moppi]

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

[inka]

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

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...

[Moppi]

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


Gruß

[inka]

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...

[inka]

ich habe mir mal die beiden versionen des codes angeschaut und verglichen...

deine

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


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


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

und die meine

//#include "Arduino.h"

//2019_12_21:

//bei linksdrehen ist das langsammere anfahren berücksichtigt / auskommentiert
//dauerbewegung beim einmal drücken (fernbedienung "quer" am smartphone) geht nicht

//uint8_t LED = 13;

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


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

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

bei meiner version habe ich die rekursiv - aufrufe in den einzelnen bewegungsfunktionen rausgenommen - und - das ist bei mir in ein wenig in vergessenheit geraten - die Stepper laufen mit mikrostepping, 1/8schritt, das bedeutet, dass ich die variable "StepsPerRevolution" auf 1600 anpassen muss. Dann laufen die Stepper je nach befehl vom smartphone genau eine umdrehung.

Bei Deiner version verstehe ich einiges nicht. Dass Du in den einzelnen "richtungs"funktionen die richtungsdefinition nur einmal ablaufen lässt verstehe ich, auch den sinn der "s-* variablen" (vor, rück usw) ist klar.
Bei einer änderung der zeile " StepsPerDirection = 200/4;" in 200 dreht der Stepper um 1/8 umdrehung, bei 200/4 war es 1/32 pro befehl vom smartphone. Wenn ich die zahl in 1600 ändere müsste doch der Stepper eine ganze umdrehung machen er dreht sich aber nur um einen 1/24stel. Wie kommt das?

[Moppi]

Bei einer änderung der zeile " StepsPerDirection = 200/4;" in 200 dreht der Stepper um 1/8 umdrehung, bei 200/4 war es 1/32 pro befehl vom smartphone. Wenn ich die zahl in 1600 ändere müsste doch der Stepper eine ganze umdrehung machen er dreht sich aber nur um einen 1/24stel. Wie kommt das?

Die 200 sind auf Full Steps bezogen. Daran hatte ich schon gedacht, dass Du mit Microstepping arbeiten möchtest. Ich dachte, Du kannst das umrechnen, wenn Du einen anderen Step-Mode wählst. Wenn das bei 1/16tel sechszehn mal mehr Schritte pro Umdrehung sind, muss man die 200 mit 16 multiplizieren: 200*16/4,. Bei 1/8 wären das dann 200*8/4 (also: StepsPerDirection = 200*8/4. Theoretisch wäre das also mit 1600 richtig. Dann wären 1600/4, wieder ein Viertel. Wie dann jetzt 1/24stel rauskommt, verstehe ich nicht an der Stelle. Ich hoffe natürlich, dass der Code so weit fehlerfrei war, das kann ich schlecht ausprobieren (das wäre immer meine Kontrolle hinterher). Aber ich will gerne noch mal schauen. Dann stell den Code hier noch mal rein, wie der bei Dir 1/24stel Umdrehung macht.

Habe gerade gesehen, oben steht der Code ...

Mal eine grundsätzliche Frage: funktionierte dass denn vom Prinzip, mit den Änderungen, die ich angebracht habe?

Dann entspräche dieser Code jetzt dem mit Mode 1/8 Step und das Rad müsste eine viertel Umdrehung machen, bis es steht:

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




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




        break;
      }








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




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




        break;




      }








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




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




        break;
      }








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




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




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

MfG





- - - Aktualisiert - - -

Außerdem kann man dann natrülich die "200*8" auch durch "StepsPerRevolution" ersetzen, wie hier, als Beispiel:

StepsPerDirection = StepsPerRevolution/4; //Nach 1/4 Radumdrehung Stillstand