Nutzt Dir später nicht viel. Die müssen auch alle zur selben Zeit laufen können. Wenn das Teil mal was transportieren soll, arbeiten die sich richtig warm. Dafür brauchen die Motoren Energie.
MfG
Druckbare Version
Nutzt Dir später nicht viel. Die müssen auch alle zur selben Zeit laufen können. Wenn das Teil mal was transportieren soll, arbeiten die sich richtig warm. Dafür brauchen die Motoren Energie.
MfG
das hier entspricht in etwa den daten des akkus, auf den ich warte:
- Spannung: 12V
- Kapazität: 15Ah
- Energie: 180Wh
kann man daraus auf den strom schliessen den die stepper ziehen können?
Du sprichst von "laufen"... - ist der stromverbrauch beim laufen und an-laufen gleich?
Wenn die ausgelastet sind, können die ständig MAX-Strom benötigen, der wird ja vom Treiber begrenzt.
Daher kann der im Betrieb genau so hoch sein, wie beim ersten Step.
Du kannst den Max-Strom am Treiber mit dem Trimpoti einstellen.
Beim Anfahren dürfte der größte Strom fließen.
Müsste man mal messen, wenn das Fahrzeug fährt, was für ein Strom durchschnittlich insgesamt fließt (Strommessgerät).
Sind vielleicht auch maximal nur 6 bis 8A. Pro Treiber sind es max. 1.5 bis 2A, dann mit Kühlung, dass der Treiber nicht
wegschaltet, falls er thermisch überlastet wird.
MfG
eine andere frage:
ich bin mit der von mir realisierten befestigung der steppertreiberplatinen nicht sehr zufrieden, das erreichen des einstellpotis ist im eingebauten zustand so gut wie unmöglich, austausch schwierig. Jetzt begegnete mir das hier:
Anhang 34449
wäre das geeignet? Was bedeutet z.b. die bitte 9V zu verwenden? Ich habe auch keine anleitung gefunden, wie es zu verwenden ist...
Habe ich auch gesehen.
Da gibt es noch andere Boards, wo gleich 5 Treibermodule drauf passen. Die sind eigentlich für 3D-Drucker gedacht oder Fräsen.
Ich habe das hier nur nicht verlinkt, weil ich Dein Konzept nicht beeinflussen wollte.
Ich schau mal, wo die waren... melde mich dann wieder ...
MfG
- - - Aktualisiert - - -
Die Teile nennen sich RAMPS 1.4 Control Board
Da sind noch "Hochleistungsteile" verbaut (weiß nicht ganeu - FETs oder so) für die Druckdüse und das Heizbett am 3D-Drucker, darüber kann man auch andere Sachen steuern.
Es gibt auch sonst ganze Pakete, wie so was hier: https://www.amazon.de/perfk-Steuerpl...%2C164&sr=8-50
Für einen Roboter als Grundlage wäre so was natürlich ideal. Wer es nachbauen will, bestellt so ein Kit.
Es gibt auch fertige Fahrplattformen, die durchaus bis zu 10kg tragen können, mit Kettenantrieb z.B. für so ca. 100,- bis 180,-€.
- - - Aktualisiert - - -
Benutzen kann man das natürlich alles.
- - - Aktualisiert - - -
Falls Du mal mehr Leistung schalten wolltest, da gibt es auch so was hier: https://www.amazon.de/Quimat-MOSFET-...NsaWNrPXRydWU=
ich würde schon lieber 4 einzelne in der nähe der motoren einbauen (wie der einbauort jetzt ist). Ich wusste garnicht, dass es sowas auch gibt, aber es gibt nichts was es nicht gibt :-)
im umkehrschluss heisst es dann, "solange der akku dran ist" - stehen die treiberplatinen ständig unter spannung?Zitat:
Zitat von Klebwax
Na ja, zumindest bei meiner Anwendung dürfte nichts in den Akku zurückfließen, weil ich vom Akku über Diode die Schaltung versorge.
Nach Schaltbild hängt die Versorgung der Motoren, also in unserm Fall der Akku, direkt an der DMOS Full Bridge. Dort direkt dran hängen auch die Motorspulen.
MfG
Ja. Zumindest solange das Gerät eingeschaltet ist. Wenn die Treiber keinen Strom in den Motor liefern sollen (er ist dann frei drehbar) schaltet man ENABLE ab. Wenn man noch weniger Strom verbrauchen will, benutzt man SLEEP. Dabei muß man immer berücksichtigen, daß der Motor dabei die Schritt bzw die Mikroschrittposition verliert.Zitat:
Zitat von inka
Den praktischen Stromverbrauch eines Steppers mit Stromchopper zu bestimmen, ist nicht einfach. Der Chopper bildet zusammen mit der Induktivität der Motorspulen einen Schaltregler. Da reicht dann das Ohmsche Gesetz nicht mehr zur Beschreibung. Dazu kommt noch die Gegen-EMK, die von der Drehzahl abhängt. Insgesamt sind Schrittmotore nicht gerade für ihre Effizienz berühmt. Sie können dafür eine Sache gut: ohne externe Positionsmessung eine Position anfahren, Das hat sich aber relativiert. Sensoren sind so billig und die µC sind so schnell geworden, daß man selbst in billigen Druckern DC-Motore mit Getriebe und Sensor findet.
MfG Klebwax
der kleinere akku ist da, also kann ich weiter experimentieren. Bei diesem
für eine fernbedienung, die ich im code mit bounce entprellt habe, stellte ich fest, dass bei einer "Vorwärts - STOP - Rückwärts" befehlsfolge die abgebrochene vorwärtsbewegung beim betätigen der rückwärtstaste erstmal zu ende ausgeführt wird bevor es rückwärts geht...Code:
#include <AccelStepper.h>
#include <Wire.h>
#include <IRremoteInt.h>
#include <ir_Lego_PF_BitStreamEncoder.h>
#include <IRremote.h>
#include <Bounce2.h>
uint8_t RECV_PIN = 13; //13
uint8_t taste = 0;
uint8_t zaehler = 0;
uint8_t idx;
#define PIN2RESET 10
#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;
Bounce debouncer = Bounce();
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/mit_lib/infra_rot_pin_13/remote_vier_stepper_switch_1_enbl");
//pinMode(RECV_PIN, INPUT_PULLUP);
pinMode(PIN2RESET, INPUT);
debouncer.attach(RECV_PIN);
debouncer.interval(5); // interval in ms
irrecv.enableIRIn(); // Start the receiver
for (idx = stepper_VL; idx < stepper_MAX; idx++)
{
stepper[idx].setMaxSpeed(1000);
stepper[idx].setSpeed(800);
stepper[idx].setAcceleration(100);
}
digitalWrite(enbl_VL, HIGH);
digitalWrite(enbl_HL, HIGH);
digitalWrite(enbl_VR, HIGH);
digitalWrite(enbl_HR, HIGH);
digitalWrite(PIN2RESET, HIGH);
}
void loop()
{
// Update the Bounce instance :
debouncer.update();
// Get the updated value :
zaehler = debouncer.read();
if (zaehler == 1)
{
zaehler = 0;
if (irrecv.decode(&results))
{
taste = results.value;
Serial.println(taste);
// delay(1000);
irrecv.resume(); // Receive the next value
}
// taste = 0;
tasten_abfrage();
//vorwaerts();
fahrt_ausfuehren();
}
}
/***********************************************************/
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)
{
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);
reboot();
}
/***********************************************************/
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].runSpeed();
stepper[idx].move(-200);
}
for (idx = stepper_VR; idx < stepper_MAX; idx++)
{
stepper[idx].runSpeed();
stepper[idx].move(200);
}
}
/**********************************************************/
void rueckwaerts(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].runSpeed();
stepper[idx].move(200);
}
for (idx = stepper_VR; idx < stepper_MAX; idx++)
{
stepper[idx].runSpeed();
stepper[idx].move(-200);
}
}
/***********************************************************/
void rechts_drehen(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].runSpeed();
stepper[idx].move(-200);
}
for (idx = stepper_VR; idx < stepper_MAX; idx++)
{
stepper[idx].runSpeed();
stepper[idx].move(-200);
}
}
/**********************************************************/
void links_drehen(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].runSpeed();
stepper[idx].move(200);
}
for (idx = stepper_VR; idx < stepper_MAX; idx++)
{
stepper[idx].runSpeed();
stepper[idx].move(200);
}
}
/***********************************************************/
void reboot()
{
pinMode(PIN2RESET, OUTPUT);
digitalWrite(PIN2RESET, LOW);
delay(100);
}
/***********************************************************/
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 verstehe es nicht, weil ich den gleichen code bereits bei den anderen, kleinere steppern - ohne dieses phänomen - verwendet habe. Hier scheint es mir so zu sein, dass nach einem stop-befehl die variablen nicht in den zustand versetzt werden, der nach RESET bzw. neustart des codes vorhanden ist. Kann das an der motortreibern liegen?
Ich konnte mir zunächst damit helfen, dass ich den arduino im STOP befehl mit diesem
resette. Es funktioniert, ganz wohl ich mir aber nicht dabei...Code:#define PIN2RESET 10
void setup()
{
Serial.begin(115200);
Serial.println("code----//home/georg/Arduino/tools/reboot");
pinMode(PIN2RESET, INPUT);
delay(2000); //nur für test
}
void loop()
{
reboot();
// delay(2000); //nur für test
}
/***********************************************************/
void reboot()
{
pinMode(PIN2RESET, OUTPUT);
digitalWrite(PIN2RESET, LOW);
delay(100);
}