outdoor I

Da gibt es den Enable- und den Sleep- Pin.

Weiß nicht, ob Dir das hilft: Ich habe den Enable mit GND verbunden und mit einem 47k gegen +5V. Ich steuer das EIN/AUS nur über den Sleep und die Logikspannung. Den Pin für die Logikspannung habe ich dazu mit dem Sleep-Pin verbunden. D.h., wenn ich den schlafen schicke, dann ist die Logikspannung auch abgeschaltet.

Wenn der nicht schläft - oder wie bei mir dann abgeschaltet ist - kann man das auch über Enable steuern. Enable = Off sollte den Motor stromlos machen. Bei Sleep passiert aber dasselbe.

Wenn die Position sicher gehalten werden soll, muss der Motor aktiv sein.

Nachtrag
-------------------------------------
Sleep-Mode deaktiviert + Enable aktiviert = Motor unter Strom
Sleep-Mode deaktiviert + Enable deaktiviert = Motor nicht unter Strom
Sleep-Mode aktiviert + Enable deaktiviert = Motor nicht unter Strom
Sleep-Mode aktiviert + Enable aktiviert = Motor nicht unter Strom


MfG

mit diesem code kann ich den roboter (zunächst einmal) per IR fernbedienung steuern, hier erstmal die befehle "vorwärts" und "stopp". Die schrittmotoren werden mit

Code:

---

  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH)

---

stromlos geschaltet, nach Deinen ausführungen hätte ich eigentlich das gegenteil erwartet, nämlich "LOW"...

Code:

---

#include <AccelStepper.h>
//#include <LCD.h>
//#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <IRremoteInt.h>
#include <ir_Lego_PF_BitStreamEncoder.h>
#include <IRremote.h>
//#include <stepper_standard.h>

//LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

uint8_t RECV_PIN = 13;
uint8_t taste = 0;

uint8_t idx;
uint8_t zitter;
uint8_t anzahl;


#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

#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43

IRrecv irrecv(RECV_PIN);

decode_results results;

enum stepper_e
{ stepper_VL, stepper_HL, stepper_VR, stepper_HR, stepper_MAX };


AccelStepper stepper[stepper_MAX]
{
  AccelStepper(1, stepPin_VL, dirPin_VL),
  AccelStepper(1, stepPin_HL, dirPin_HL),
  AccelStepper(1, stepPin_VR, dirPin_VR),
  AccelStepper(1, stepPin_HR, dirPin_HR)
};




void setup()
{
  Serial1.begin(115200);
  Serial.begin(115200);

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


  irrecv.enableIRIn(); // Start the receiver
/* 
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.setBacklight(HIGH);
  lcd.print("remot FB schwarz");
  lcd.setCursor(0, 1);
  lcd.print("switch 1");
  delay(2000);
  lcd.clear();
  lcd.setBacklight(LOW);
*/
  for (idx = stepper_VL; idx < stepper_MAX; idx++)
  {
    stepper[idx].setMaxSpeed(1000);
    stepper[idx].setSpeed(800);
    stepper[idx].setAcceleration(30);
    //    stepper[idx].disableOutputs();
    //        stepper[idx].setDirection(CCW);
    //    stepper[idx].rotate(1);

  }

  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

}

void loop()
{

  if (irrecv.decode(&results))
  {
    taste = results.value;
    Serial.println(taste);
    irrecv.resume(); // Receive the next value
  }
  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");
/*
          lcd.setCursor(0, 0);
          lcd.setBacklight(HIGH);
          lcd.print("szenario_1");
          delay(1000);
          lcd.clear();
          lcd.setBacklight(LOW);
*/
          //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();
          fahrt_ausfuehren();

          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)
        {
/*
          digitalWrite(enbl_VL, HIGH);
          digitalWrite(enbl_HL, HIGH);
          digitalWrite(enbl_VR, HIGH);
          digitalWrite(enbl_HR, HIGH);
*/
          vorwaerts();
          fahrt_ausfuehren();
          break;
        }
      }


    case 87:// fahre rückwärts große FB
      {
        if (taste == 87)
        {

          //          rueckwaerts();

          break;
        }
      }
  }


}


/***********************************************************/
void alle_stepper_stop(void)
{
  for (idx = stepper_VL; idx < stepper_MAX; idx++)
  {

    stepper[idx].stop();

  }

  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);
}

/***********************************************************/
void vorwaerts(void)
{

  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);

  for (idx = stepper_VL; idx < stepper_VR; idx++)
  {
    //    stepper[idx].moveTo(600);
    stepper[idx].runSpeed();
    stepper[idx].move(-100);
    //    stepper[idx].run();
    //    stepper[idx].rotate(1);
  }

  for (idx = stepper_VR; idx < stepper_MAX; idx++)
  {
    //    stepper[idx].moveTo(600);
    stepper[idx].runSpeed();
    stepper[idx].move(100);
    //    stepper[idx].setDirection(CW);
    //    stepper[idx].rotate(1);
  }
}


/***********************************************************/
void rotate_right_deg(void)
{

}

/**********************************************************/
void rotate_left_deg(void)
{

}

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

boolean fahrt_fertig()
{

  return        stepper[stepper_VL].isRunning() && stepper[stepper_HL].isRunning() && stepper[stepper_VR].isRunning()
                && stepper[stepper_HR].isRunning();

}

/************************************************************/
void fahrt_ausfuehren()
{
  while ( ! fahrt_fertig() )
  {
    for (idx = stepper_VL; idx < stepper_MAX; idx++)
    {
      stepper[idx].run();
      // delay(1);
    }
  }
}

---

Ich schau nochmal nach ...

Ich habe mich mit dem 47k vertan, der hat nichts mit dem Enable zu tun, sondern gehört bei mir zu einem Spannungsteiler. Enable liegt bei mir ständig auf LOW (auch wenn der 47k von dort nach +5V verbunden ist) und aktiviert also die Ausgänge.
Laut Datenblatt von Pololu soll der Enable-Pin ein invertierender Eingang sein.

Pololu schreibt dazu:

Zitat:

---

This input turns on or off all of the
FET outputs. When set to a logic high, the outputs are disabled.

---

So ist es dann richtig.

Auf welchem Pegel hast Du denn die Steuereingänge MS1 bis MS3 vom 4988?



MfG

wenn mich nicht alles täuscht - hab jetzt nicht nachgeschaut - sind die garnicht belegt?

Wenn die offen / nicht belegt sind, müsste der Motor im Full-Step-Modus laufen (200 Steps / Umdrehung). Laut Datenblatt haben die Eingänge 100 bzw. 50kOhm-Pull-Down-Widerstände. Step-Mode geht von Full bis 1/16tel.
Vorsichtshalber könnten die MS1 bis MS3 zusammengeschaltet und auf GND gelegt werden. Im Datenblatt sind die Eingänge per Beispiel nicht unbeschaltet.

Zitat:

---

Zitat von Moppi

Vorsichtshalber könnten die MS1 bis MS3 zusammengeschaltet und auf GND gelegt werden. Im Datenblatt sind die Eingänge per Beispiel nicht unbeschaltet.

---

ich hab aber auch beispiele gefunden, wo die einfach frei sind:
Anhang 34428

ich werde mich mit den MS-pinns beschäftigen müssen...
Hat die schrittweite (also full- bis 1/16) einfluss auf z.b. anzahl verlorener schritte oder die kraft des steppers, oder ist es nur für ein genaueres positionieren wichtig?

Was mir noch aufgefallen ist - ich betreibe das ganze immer noch mit dem netzteil, weil der akku immer noch nicht da ist - wenn ich einschalte, rattern alle stepper ca. eine sekunde lang als würden sie irgendwas suchen. Dabei sollen sie beim einschalten stromlos sein - code siehe weiter oben...

Der Step-Mode hat unmittelbaren Einfluss auf das Drehmoment. Kommt drauf an, wie man damit umgeht. Ich habe Mode 4 gewählt, wäre dann 1/16tel , wegen der Laufruhe. Bei mir hatte sich das auch auf die Geschwindigkeit ausgewirkt (drehte etwas schneller), wie dieser Zusammenhang besteht, ist mir aber bislang unklar. Aber die Kraft ist im 16tel-Step nicht so hoch. Anstatt sprunghaft auf 1/200 Umdrehung zu fahren, fährt der Motor bei meiner Anwendung in 16 Schritten auf 1/200 Umdrehung, das ist für so eine Rollosteuerung im Wohnumfeld sehr angenehm, da der Motor nur vor sich hinsurrt. Bei Full Step ist er schon richtig laut; weil der Motor dabei in einem Plastikgehäuse sitzt. Bei einem Fahrzeug, als Antrieb, würde ich wohl auch bei Full Step bleiben, dort sollte der Motor das höchste Drehmoment erreichen.

Ja, es gibt Schaltungen, wo die Eingänge offen gelassen sind. Aber es würde - evtl. zur Störsicherheit - nicht schaden, die gemeinsam auf GND zu legen.

Was das Rattern beim Einschalten angeht: das habe ich nicht. Beim Einschalten des Treibers fährt der Motor in eine Art Ausgangsposition, der bewegt sich ein klein wenig in eine Richtung (Millimeterbruchteil und hält dann die Position). Ein kleines bißchen unruhig ist er dabei auch, soll heißen, dass er bei 1/16tel Step minimal summt (wenn ich mit dem Ohr dran gehe hör ich es etwas). Bei Full Step kann das lauter sein und dauert so lange an, bis der Motor über den Treiber abgeschaltet wird. Vielleicht liegts an der Bibliothek, die Du verwendest, was immer darin passiert. Aber bedenke, dass Du MS1 bis MS3 unbeschaltet hast, vielleicht kommts auch daher, dass der Motor rattert. Wahrscheinlich nutzt Du auch den Sleep Mode nicht. Du müsstest mal messen, was am Enable-Pin für eine Spannung anliegt, nachdem Du gerade eingeschaltet hast. Ohne Sleep Mode liegt das dann nur an dem Pin. Dann weißt Du, was passiert. Lege MS1 bis MS3 versuchsweise auf GND und schaue, ob das was ändert. Ohnehin kann es passieren, dass die Motoren im Stillstand, wenn sie die Position auch nur halten, etwas summen oder brummen. Mit dem Netzteil wirst Du auch keine richtige Gleichspannung erhalten, da wird bestimmt noch ein Wechselspannungsanteil dabei sein, das könnte auch das Brummen/Summen verstärken.


MfG

ich hab mir jetzt noch einmal die beispiele ohne lib angeschaut, schwierig ist es wirklich nicht. Zumindest der anfang :-)

Code:

---

// Define stepper motor connections and steps per revolution:

#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

#define stepsPerRevolution 200


#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43


void setup()
{
  // deklariere pins als output:
  pinMode(dirPin_VL, OUTPUT);
  pinMode(stepPin_VL, OUTPUT);
  pinMode(dirPin_HL, OUTPUT);
  pinMode(stepPin_HL, OUTPUT);
  pinMode(dirPin_VR, OUTPUT);
  pinMode(stepPin_VR, OUTPUT);
  pinMode(dirPin_HR, OUTPUT);
  pinMode(stepPin_HR, OUTPUT);


  Serial.begin(115200);
// mache enaable pins stromlos:
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

  Serial.print("code---- /home/georg/Arduino/outdoor_robo/stepper/test_vier_stepper/ohne_lib/vier_stepper_ohne_lib_basic_example_idx_enbl_1");
}
void loop()
{

  // bestrome enable pins:
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);



  // drehe alle vier stepper langsam vorwaerts einmal herum:

    //set dir pinns vorwarts

  digitalWrite(dirPin_VL, LOW);
  digitalWrite(dirPin_HL, LOW);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);
 
  for (int i = 0; i < stepsPerRevolution; i++)
  {
    // These four lines result in 1 step:
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(2000);
  }
  delay(1000);

    // drehe alle vier stepper schnell rueckwaerts einmal herum:

    //set dir pinns rueckwaerts

  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, LOW);
  digitalWrite(dirPin_HR, LOW);
 
  for (int i = 0; i < stepsPerRevolution; i++)
  {
    // These four lines result in 1 step:
    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);
  }
  delay(1000);


    // drehe alle vier stepper langsam vorwaerts fünf mal herum:

    //set dir pinns vorwarts

  digitalWrite(dirPin_VL, LOW);
  digitalWrite(dirPin_HL, LOW);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);
 
  for (int i = 0; i < 5* stepsPerRevolution; i++)
  {
    // These four lines result in 1 step:
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(2000);
  }
  delay(1000);

      // drehe alle vier stepper schnell rueckwaerts fünf mal herum:

    //set dir pinns rueckwaerts

  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, LOW);
  digitalWrite(dirPin_HR, LOW);
 
  for (int i = 0; i < 5* stepsPerRevolution; i++)
  {
    // These four lines result in 1 step:
    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);
  }
  delay(1000);
 
}

---

der code funktioniert soweit, was mich noch ein bischen stört, sieht und hört man in dem video hier . Wenn zusätzlich zur stromversorgung (immer noch ein steckernetzteil) der atmega 2560 an der USB verbindung zum PC hängt passiert es nicht. Das kenne ich von den steppern 28BYJ_48 und ULN2003 treibern so nicht, da stand der stepper beim einschalten.... Ob sich das bei akkuversorgung ändert?

Ich gebe noch mal den Tip. ein paar Varta-Batterien zu holen "D", hatte ich irgendwo schon mal genauer geschrieben. Einfach um sicher zu gehen und diese Frage zu beantworten.
Das ist jetzt mehr so ein Rätselraten, als für mich jedenfalls. Vielleicht weiß jemand anders mehr.
Nach dem Einschalten des Treibers kann sich der Stepper nicht bwegen, es sei denn, der Treiber bekommt die entsprechenden Signale.


MfG

gesagt, getan, ich hab ja (fast) alles zuhause :-)

video

und nun? Woran kann das nun liegen?