outdoor I

**Moppi** · 26.12.2019, 16:43

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:

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_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:

Code:

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

Thema: outdoor I

Themen-Optionen

Thema durchsuchen

Anzeige

Baum-Darstellung

Ähnliche Themen

Abstandsmessung Outdoor bis 3m

outdoor spy robot

Outdoor Roboter

Outdoor-Robo

Outdoor - Navigation

Lesezeichen

Lesezeichen

Berechtigungen