outdoor I

Zitat:

---

Mit den akkus beschäftige ich mich anschliessend, die machen eigentlich einen guten eindruck, das was man halt sehen kann.

---

Wenn, sehe ich auch eher das Problem, dass der Akku die Leistung nicht bringt. Da steht zwar 5000mA Dauerstrom, aber ich glaube das nicht. Wenn die Spannung auf 50% einbricht, wie Du gemessen hast. Und die Stepper ziehen doch nicht so viel Strom beim Einschalten, oder? Ich rechne da mal mit 250mA pro Motor. Das sind bei 4 Motoren 1A. Gut, lass es 1.5A, beim Einschalten, sein. Aber dass dort die Spannung schon so weit einbricht? Dann müssten die Akkus sehr schlechte Qualität haben bzw. mit max. 1A belastbar sein. Das sagt mein Bauch, da dies nicht meine Hauptbeschäftigung ist, kann der sich auch gewaltig irren. Eine Gegen-EMK von 4 bis 6V? Kann ich mir auch nicht so recht vorstellen. Aber rein theoretisch ergeben +12V vom Akku und -6V Gegen-EMK evtl. eben +6V zu dem Zeitpunkt, wo beides aufeinandertrifft, dann fällt die Elektronik aus und alles beginnt von vorn, bis sich das innerhalb 1sec aufgeschaukelt hat, dass es endlich stabil ist?

Du kannst natürlich die mA auch mal messen, die dort beim Einschalten vorhanden sind.

Zitat:

---

wird der Stepper HL aktiviert, alle 2 sec macht der jeweils eine sequenz in CW richtung, es rattert nicht, es scheint zu funktionieren. Jetzt muss ich die verdrahtung etwas ordentlicher machen und alle vier Stepper anschliessen. Vielleicht auch in umgekehrter reihenfolge....

---

was bedeutet "alle 2 sec macht der jeweils eine sequenz in CW richtung"?
und das " und alle vier Stepper anschliessen. Vielleicht auch in umgekehrter reihenfolge...." verstehe ich auch nicht, Du schon, Du kennst Deine Technik und hast sie vor Dir.




MfG

- - - Aktualisiert - - -

was bedeutet "alle 2 sec macht der jeweils eine sequenz in CW richtung"?

Ok, habe mir den Code angesehen, das ist also Normalzustand. - Ist ja schon mal gut.

- - - Aktualisiert - - -

Andersum fährt das Teil auch mit den Akkus, ohne auszufallen. Wenn das Oszi funktioniert, kannst Du mal damit messen, Du musst rausfinden, was auf den Leitungen los ist, um späteren Problemen vorzubeugen.

Zitat:

---

Zitat von Moppi

was bedeutet "alle 2 sec macht der jeweils eine sequenz in CW richtung"?
und das " und alle vier Stepper anschliessen. Vielleicht auch in umgekehrter reihenfolge...." verstehe ich auch nicht, Du schon, Du kennst Deine Technik und hast sie vor Dir.

---

das erste ist nun klar - nach 2sec delay macht er ein paar steps - usw... das zweite bedeutet, erstmal vielleicht quick&dirty alle stepper verdrahten und erst dann aufräumen :.-)

EDIT:
quick&dirty verdrahtung fertig und es läuft!!!!!! :-) :-)

danke noch einmal für die letzte idee, so wie es jetzt ist soll es sein :-)

Was mich jetzt vor allem interessiert, ist - natürlich - wie schnell hintereinander die A4988 zugeschaltet werden können, ohne, dass es Probleme gibt.
Wäre nett, wenn Du das noch ausprobieren/mitteilen könntest!

Später musst Du dran denken, wenn Du die Spannung der A4988 abschaltest, weil die anhalten sollen, dass dann das Haltedrehmoment weg ist. Die Treiber müssen immer aktiviert bleiben.

Zitat:

---

danke noch einmal für die letzte idee, so wie es jetzt ist soll es sein Bild hier  

---

War ganz schön anstrengend ;)

Und natürlich würden uns alle auch Messergebnisse der Leitungen interessieren, was die Störpegel angeht. Klebwax hatte doch geschrieben, wie Du mit Deinem Gerät messen kannst.

MfG

Zitat:

---

Zitat von Moppi

Was mich jetzt vor allem interessiert, ist - natürlich - wie schnell hintereinander die A4988 zugeschaltet werden können, ohne, dass es Probleme gibt.

---

momentan schalte ich die motortreiber (alle auf einmal - zumindest in einem anweisungsblock "nacheinander" an) erst mit dem anschalten / auswählen der bewegung mit der FB ein. Aber auch wenn ich sie im setup() aktiviere, gibt es keinerlei probleme. Es macht kurz einmal klack und sie sind an.

Code:

---


//libraries
#include <IRremoteInt.h>
#include <ir_Lego_PF_BitStreamEncoder.h>
#include <IRremote.h>
#include <Bounce2.h>


uint8_t RECV_PIN = 13;
uint8_t taste = 0;
uint8_t zaehler = 1;

//resett pin definieren
#define PIN2RESET 10


// DIR und STEP pins definieren
#define dirPin_VL 2
#define stepPin_VL 3
#define dirPin_HL 4
#define stepPin_HL 5
#define dirPin_VR 6
#define stepPin_VR 7
#define dirPin_HR 8
#define stepPin_HR 9

//enable pins definieren
#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43

//steps pro umdrehung definieren:
#define stepsPerRevolution 200

//IR pin definieren
IRrecv irrecv(RECV_PIN);

decode_results results;

// debouncer instanz definieren
Bounce debouncer = Bounce();


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


  Serial.begin(115200);

  Serial.println("code----/home/georg/Arduino/outdoor_robo/stepper/test_vier_stepper/ohne_lib/remote_vier_stepper_switch_1_enbl_bounce");

  //resett pin zustand definieren
  pinMode(PIN2RESET, INPUT);

  // IR empfänger pin mit bounce verbinden
  debouncer.attach(RECV_PIN);

  // debounce interval in ms
  debouncer.interval(5);

  // starte IR receiver
  irrecv.enableIRIn();

/*
  //enable pins aktivieren:
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);
*/


  //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()
{
/*
  // aktiviere enable pins:
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);
*/

  // bounce instance updaten:
  debouncer.update();

  // neuen bounce wert holen :
  zaehler = debouncer.read();

  if (zaehler == 1)
  {
    zaehler = 0;
    //    taste = 0;
    if (irrecv.decode(&results))
    {
      taste = results.value;
      Serial.println(taste);
      //      delay(1000);
      // nächsten IR-wert empfangen
      irrecv.resume();
    }

  }
  tasten_abfrage();

}


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

void tasten_abfrage(void)
{
  switch (taste)
  {

    case 151 ://taste 1 große FB
      {
        if (taste == 151 )
        {
          Serial.println("szenario_1");
          Serial1.println("szenario_1");

          //fahre szenario_1

          delay (1000);

          break;
        }
      }

    case 103://taste 2 große FB
      {
        if (taste == 103)
        {
          Serial.println("szenario_2");
          Serial1.println("szenario_2");

          //fahre szenario_2

          delay (1000);

          break;
        }
      }

    case 79://taste 3 große FB
      {
        if (taste == 79)
        {
          Serial.println("szenario_3");
          Serial1.println("szenario_3");

          //fahre szenario_3

          delay (1000);

          break;
        }
      }


    case 207://taste 4 große FB
      {
        if (taste == 207)
        {
          Serial.println("szenario_4");
          Serial1.println("szenario_4");

          //fahre szenario_4

          delay (1000);

          break;
        }
      }


    case 253://OK taste, motor stop
      {
        if (taste == 253)
        {
          alle_stepper_stop();

          break;
        }
      }


    case 61:// rotate rechts große FB
      {
        if (taste == 61)
        {
          rechts_drehen();

          break;
        }
      }


    case 221:// rotate links große FB
      {
        if (taste == 221)
        {
          links_drehen();

          break;
        }

      }


    case 157:// fahre vor große FB
      {
        if (taste == 157)
        {
          vorwaerts();

          break;
        }
      }


    case 87:// fahre rückwärts große FB
      {
        if (taste == 87)
        {
          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(250);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(250);
  }
}


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

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

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

}


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

}

/***********************************************************/
void reboot()
{
  pinMode(PIN2RESET, OUTPUT);
  digitalWrite(PIN2RESET, LOW);
  delay(100);
}
/***********************************************************/

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

---

Zitat:

---

Zitat von Moppi

Später musst Du dran denken, wenn Du die Spannung der A4988 abschaltest, weil die anhalten sollen, dass dann das Haltedrehmoment weg ist. Die Treiber müssen immer aktiviert bleiben.

---

warum? damit der roboter nicht wegrollt?

Zitat:

---

Zitat von Moppi

Und natürlich würden uns alle auch Messergebnisse der Leitungen interessieren, was die Störpegel angeht. Klebwax hatte doch geschrieben, wie Du mit Deinem Gerät messen kannst.

---

wird gemacht, allerdings wird in der verdrahtung erstmal aufgeräumt. :-)

Zitat:

---

warum? damit der roboter nicht wegrollt?

---

Ja. Obwohl der so einfach nicht wegrollt, bei Schrittmotoren. Aber das wirst Du dann sehen. Nur dass Du Bescheid weißt.

Zitat:

---

momentan schalte ich die motortreiber (alle auf einmal - zumindest in einem anweisungsblock "nacheinander" an) erst mit dem anschalten / auswählen der bewegung mit der FB ein. Aber auch wenn ich sie im setup() aktiviere, gibt es keinerlei probleme. Es macht kurz einmal klack und sie sind an.

---

Gut. Dann war's wohl vor allem wichtig, dass der Arduino vor den Treibern "an" ist. Welche Wechselspiele die auch immer miteinander ausgefochten haben.
Dann könntest Du von vier benötigten Arduino-Ausgängen auf einen reduzieren. Kannst einen MOSFET nachschalten, weil ich beim andern Thema gerade dabei war. Ich weiß aber nicht, ob ein MOSFET so schnell schaltet, nicht dass es dadurch wieder zu Problemen kommt. Deshalb würde ich, weil ich weiß, dass das funktioniert, einen BC547B nehmen. Am Arduino-Ausgang einen 2.2k-Widerstand anschließen (oder 1k, oder 4.7k), an das andere Ende des Widerstands die Basis des Transistor anschließen, Emitter des Transistor an GND verbinden und den Kollektor mit GND der Logikspannung der vier A4988. Vdd der Logikspannung, der A4988, dann mit +5V verbinden.



MfG

Zitat:

---

Zitat von Moppi

Dann könntest Du von vier benötigten Arduino-Ausgängen auf einen reduzieren.

---

Ja, das geht so. Ein Logikausgang kann viele Logikeingänge treiben. Vier Eingänge an einem Ausgang sind kein Problem. Bei CMOS Bausteinen, die quasi keinen Eingangsstrom brauchen (beim A4988 typ. weniger als 1µA) können das auch 10 oder mehr sein. Alles andere bringt nur Probleme, die man nicht braucht.

MfG Klebwax

Hallo inka,

für Deinen Code hätte ich einen Vorschlag, um den Ruck beim Anfahren zu reduzieren.

Der Codeteil, den ich meine:

Code:

---

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

}

---

könnte so geändert werden:

Code:

---

/**********************************************************/
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, j = 2000; i < stepsPerRevolution; i++)  //"j = 2000": der Anfangswert für das Delay in Microsekunden
  {
    if (j > 500) j--;                                      //"j > 500": der Endwert für das Delay in Microsekunden - bestimmt auch die Endgeschwindigkeit (mindestens 250 bis 300)
    for (int z = 0; z < 3 && i < stepsPerRevolution; z++)  //"z < 3": wieviele Schritte mit dem eingstellten Delay "j" gemacht werden sollen, bevor es reduziert wird
    {
      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++;
    }
  }


}

---

Ist übertragbar auf die anderen Richtungen.

danke für den vorschlag für die anfahrt-rampe....
ich habe inzwischen den akku gequält ...

steigung ca. 10°, strecke, die gefahren wurde ca. 70cm in ca. 2sec, akku mit 8000mAh. Masse des roboters ca. 3kg.

Nach ca. 45 minuten haben die stepper angefangen etwas lauter zu "singen", nach ca. 55 minuten war schluss. Die motoren wurden zu keiner zeit mehr als handwarm.
gefahrener stil: 2sec pause / 2sec rauf / 2sec pause / 2sec (motor gebremst) runter. Daraus habe ich eine gefahrene strecke von 472,5m errechnet, also ca. 500m. Ich weiss nicht, wie das allgemein gesehen wird, ich habe, nachdem den akkus hier relativ wenig zugetraut wurde, nicht mit so viel gerechnet, bin also mit der kombination akku / stepper / ansteuerung zufrieden...

jetzt muss ich mich um die verdrahtung kümmern, habe dazu eine stiftleiste an die stepper-extention-platinen angebracht, um (eigentlich auch für später) die 5V, GND und evtl. auch die 12V an mehreren stellen zur verfügung zu haben...
Anhang 34532
bedauerlich, dass es nur in ausnahmefällen so eine frei bestückbare zone auf den modulen gibt....

- - - Aktualisiert - - -
zu der stepperansteuerung:

Zitat:

---

Zitat von Moppi

Dann könntest Du von vier benötigten Arduino-Ausgängen auf einen reduzieren.

---

macht das wirklich sinn? Bitte nicht als kritik auffassen, aber der mega hat do fast schon zu viele ausgänge, und ist es nicht eher von vorteil die motoren auch einzeln ansteuern zu können? Abgesehen davon, dass mir die phantasie fehlt wo ich die dazu erforderliche schaltung unterbringen sollte? Wieder ein platinchen mit notwendiger befestigung, dann doch lieber die flexible art mit vier letungen und vier arduino-ausgängen, oder?

Zitat:

---

macht das wirklich sinn? Bitte nicht als kritik auffassen, aber der mega hat do fast schon zu viele ausgänge, und ist es nicht eher von vorteil die motoren auch einzeln ansteuern zu können?

---

Wenn Du zu viele Ausgänge hast und die belegen musst, dann lass es so, wie es ist. :) Ich achte nur, wenn später mal mehr und mehr dazu kommt, dass man I/O-Ports brauchen kann.
Die Dazu erforderliche Schaltung wäre ca. 1cm² groß, wenn überhaupt. Ich würde mir zutrauen, das längs zu verlöten, dass ein Schrumpfschlauch drüber passt, an das Ganze werden dann 3 Drähte angelötet und Schrumpfschlauch drüber. Aber man könnte auch ein Minigehäuse mit dem 3D-Drucker drucken, wo der Widerstand und der Transistor reinpassen, dazu noch schöne kleine Kabelführungen mit hineindrucken. Widerstand an Transistor löten, Kabel anlöten und alles ins Gehäuse einlegen, mit Klebstoff Deckel drauf kleben. Schönes Miniaturprojekt :) Kann man dann immer wieder so bauen und gebrauchen, wenn mal ein paar Milliampere fehlen.


MfG

Zitat:

---

Zitat von Moppi

Wenn Du zu viele Ausgänge hast und die belegen musst, dann lass es so, wie es ist. :) Ich achte nur, wenn später mal mehr und mehr dazu kommt, dass man I/O-Ports brauchen kann.

---

naja, zu viele könne es nie sein :-) aber ich dachte eher an die flexibilität bei der motoransteurung, ob man die wirklich braucht mal dahingestellt...

Zitat:

---

Zitat von Moppi

Die Dazu erforderliche Schaltung wäre ca. 1cm² groß, wenn überhaupt. Ich würde mir zutrauen, das längs zu verlöten, dass ein Schrumpfschlauch drüber passt, an das Ganze werden dann 3 Drähte angelötet und Schrumpfschlauch drüber. Aber man könnte auch ein Minigehäuse mit dem 3D-Drucker drucken, wo der Widerstand und der Transistor reinpassen, dazu noch schöne kleine Kabelführungen mit hineindrucken. Widerstand an Transistor löten, Kabel anlöten und alles ins Gehäuse einlegen, mit Klebstoff Deckel drauf kleben. Schönes Miniaturprojekt :) Kann man dann immer wieder so bauen und gebrauchen, wenn mal ein paar Milliampere fehlen.

---

hast recht, wäre schon was als druckprojekt - eigentlich eine sache für so ein 3D-drucker-unterforum... :-)

Was hälst Du von dem stepper / akku test?