-         
Seite 23 von 34 ErsteErste ... 13212223242533 ... LetzteLetzte
Ergebnis 221 bis 230 von 333

Thema: outdoor I

  1. #221
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.713
    Blog-Einträge
    9
    Anzeige

    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

  2. #222
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.677
    Zitat Zitat von Moppi Beitrag anzeigen
    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 Beitrag anzeigen
    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...
    gruß inka

  3. #223
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.713
    Blog-Einträge
    9
    Ich denke schon, dass Du irgendwo einen Fehler machst. Aber von Ferne kann man nicht beurteilen, wo das sein könnte.


    Gruß

  4. #224
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.677
    Zitat Zitat von Moppi Beitrag anzeigen
    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...
    gruß inka

  5. #225
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    8.101
    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.
    Ciao sagt der JoeamBerg

  6. #226
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.713
    Blog-Einträge
    9
    Hallo Inka,

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

    MfG

  7. #227
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.677
    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
    gruß inka

  8. #228
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.677
    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);
    }
    /***********************************************************/
    
    /************************************************************/
    gruß inka

  9. #229
    Erfahrener Benutzer Robotik Einstein Avatar von Moppi
    Registriert seit
    18.03.2018
    Beiträge
    1.713
    Blog-Einträge
    9
    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


    - - - 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);
    }
    /***********************************************************/
    
    
    /************************************************************/
    Geändert von Moppi (23.12.2019 um 21:07 Uhr)

  10. #230
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    72
    Beiträge
    1.677
    Zu viel des guten Moppi, danke...
    Der Weihnachtsmann kommt ja erst morgen...
    Frohe Weihnachten!
    gruß inka

Seite 23 von 34 ErsteErste ... 13212223242533 ... LetzteLetzte

Ähnliche Themen

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

Berechtigungen

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