- MultiPlus Wechselrichter Insel und Nulleinspeisung Conrad         
Ergebnis 251 bis 260 von 566

Thema: outdoor I

Baum-Darstellung

Vorheriger Beitrag Vorheriger Beitrag   Nächster Beitrag Nächster Beitrag
  1. 05.01.2020, 11:23 #11
    inka
    inka ist offline
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    77
    Beiträge
    2.180
    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
    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 //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...
    Geändert von inka (05.01.2020 um 12:43 Uhr)
    gruß inka
    ZitierenZitieren
« Vorheriges Thema | Nächstes Thema »

Ähnliche Themen

  1. Abstandsmessung Outdoor bis 3m
    Von robo218 im Forum Sensoren / Sensorik
    Antworten: 4
    Letzter Beitrag: 14.12.2017, 06:56
  2. outdoor spy robot
    Von jancrombach im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 7
    Letzter Beitrag: 14.08.2010, 13:09
  3. Outdoor Roboter
    Von OsramLED im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 3
    Letzter Beitrag: 07.08.2006, 09:34
  4. Outdoor-Robo
    Von RobotrixerP im Forum Mechanik
    Antworten: 3
    Letzter Beitrag: 16.04.2006, 18:38
  5. [ERLEDIGT] Outdoor - Navigation
    Von Quaio im Forum Sensoren / Sensorik
    Antworten: 37
    Letzter Beitrag: 21.04.2005, 12:31

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

Foren-Regeln


Solar Speicher und Akkus Tests