Druckbare Version
Solange ein Akku dran ist, lädt es ihn auf. Da muß schon eine Menge passieren, bis da die Spannung zu hoch wird. Bei einem Netzteil kann das schon mal anders sein. Da fließt rückwärts kein Strom rein, die Spannung kann also steigen. Es ist aber auch ein Kondensator drin. Wieviel der hilft, hängt nun wiederum von der Leitungslänge und von anderen Schaltungsteilen, die auch an dieser Versorgung angeschlossen sind ab.Zitat:
Zitat von Moppi
MfG Klebwax
also ich hab schon an den rädern von hand gedreht (wer würde es nicht tun, wenn alles so gut passt :-) ), ohne zu wissen dass man es tunlichst vermeiden sollte :-(
auf den bildern die ich kenne, sind die kühlkörper direkt auf dem chip angebracht, die durchkontaktierung würdfe ich nur auf dem original von pololu vermuten...
Bin mal gespannt, wenn die bei Dir laufen, wie es sein soll, welche Last sich damit bewegen läßt.
Dauert ja noch was, bis die neuen Teile bei Dir sind, deshalb hier noch etwas zum Lesen, bis dahin: https://www.filamentpreis.de/alles-u...motor-treiber/
Interessant finde ich dort die Beschreibung zu den Trinamic-Treibern, die auch Schrittverluste erkennen sollen.
Sieht auf den Bildern besser aus, unten gibts da möglicherweise mechanische Probleme mit den Steckerleisten. Aber es ist doch ganz klar, daß der Kunstoff des Gehäuses die Wärme viel schlechter leitet als das Metall des Pads auf der Unterseite. Die Photos hat sicher auch ein Verkäufer und nicht ein Entwickler gemacht.Zitat:
Zitat von inka
Warum? Achso sind ja Chinesen. Und was ist original? Das ist die Schaltung aus dem Datenblatt von Allegro. Und wie das zu Layouten ist, steht da auch. Wenn es ein Original gibt, findet man es da. Alle malen da nur ab.Zitat:
die durchkontaktierung würdfe ich nur auf dem original von pololu vermuten...
Ich hab nur welche mit dem DRV8825. Da kann man die Thermal Vias von der Rückseite gut sehen, Und die ganze Fläche ist auch beim Lötstoplack ausgespart. Auch an Leiterbahnen, die die Ströme leiten müssen, sind da mehrfach Vias gesetzt. Besser gehts auf der kleinen Fläche kaum.
Wenn du dir die Bilder bei Pololu mal ansiehst und sie mit der "Black Edition" vergleichst kannst du sehen, daß auch die nochmal nachgebessert haben.
MfG Klebwax
ich hab ja nix gegen die chinesen, kaufe doch das meiste material was ich brauche dort :-) , könnte mir das garnicht leisten das hier zu kaufen... naja, bis auf die lieferzeiten...
habe mir noch einmal die geschrotteten stepsticks angeschaut: also unten, auf der seite, wo die stiftkontakte rausschauen ist wirklich keine fläche zu sehen, vier durchkontaktierungen, mal mit mal ohne lötstopplack...
Ich habe auch nochmal nachgeschaut. Es gibt viele Boards, wo die Treibermodule draufgesteckt werden können, eins neben dem andern. Da wärs nicht möglich, den Kühlkörper unten anzubringen. Also kommt der oben auf den IC drauf.
Bei den Pololu 4988 haben die extra große Kupferflächen, um viel Wärme abzuleiten. Dennoch sind die dann mit Lack überzogen. Die Wärme, die über die Kupferflächen abgeführt wird, gelangt über die Pins direkt vom Chip an die CU-Flächen. Dennoch kommt aber auch Wärme an der IC-Gehäuseoberfläche selber an. Wenn die Oberfläche sehr heiß wird, spräche nichts dagegen dort auch einen Kühlkörper direkt aufzukleben. Die überschüssige Wärme von dem Gehäuse wird nach unten auf die Platine abgestrahlt und gelangt so auf die Außenseite. Das ist sicher nicht effektiver, als ein Kühlkörper direkt auf dem IC-Gehäuse aufgebracht, wenn man mal davon ausgeht, dass der Chip im Gehäuse vertikal genau mittig plaziert ist.
MfG
Daß SMD-Bausteine ihre Wärme über die Pads in die Platine bringen ist üblich, der Einsatz von Thermal Vias als Hilfe dabei auch. Natürlich kann man einen Kühlkörper auf ein Kunststoffgehäuse kleben, man darf sich nur nicht zuviel davon versprechen.
Hier mal ein Bild
Anhang 34424
Da sind bei einem Treiber die Steckerleisten rückwärts eingelötet. So passt dann ein Kühlkörper gut rauf und die warme Luft kann gut abfließen. Am Ende gehts aber nur darum, daß der Stepper nicht mitten im Lauf wegen Übertemperatur anhält. Kaputt geht er davon nicht.
MfG Klebwax
Ich kann mir vorstellen, dass der ein oder andere gleich eine Lenkung einsetzen würde. Wobei Du verschiedene Möglichkeiten hast: nur die vorderen Zwei gemeinsam zu lenken, nur die vorderen Zwei einzeln zu lenken oder eventuell sogar alle Vier einzeln zu lenken.Zitat:
Zitat von inka
Als Alternative sind die Mecanum-Räder hier schon öfter erwähnt worden. Davon gibt es mittlerweile eine größere Auswahl, hier mal ein Link.
Vielleicht solltest Du von Anfang eine Variante mit einplanen(?).
MfG
- - - Aktualisiert - - -
Jetzt kam mir gerade nochmal die Frage zum Gewicht, dass die Plattform bewegen könnte., deshalb mache jetzt mal hier explizit einen Frageabsatz draus:
Diese NEMA17 haben ca. 40ncm Max.-Drehmoment; wenn das so richtig ist und ich Pi mal Daumen drüber nachdenke - mit Radgröße, dürften etwa max. 1.5kg pro Motor rauskommen; die Plattform jetzt könnte - geschätzt - etwa 1.5kg auf die Waage bringen; da kommt noch der Akku dazu der einiges an Gewicht mit bringt; die spätere Nutzlast könnte bei 3 bis 4kg liegen? Inka was hattest Du so für eine Vorstellung?
ich dachte hier wirklich nur an eine alternative als "notlösung", wenn es ohne nicht geht, weil ja die notwendige mechanik das ganze komplizierter und störungsanfälliger macht. Und die möglichkeiten des 3D-drucks sind ja auch begrenzt...Zitat:
Zitat von Moppi
ich habe schon die kombination aus 3 rädern durchmesser ca. 50mmZitat:
Zitat von Moppi
Anhang 34425
und vier rädern mit einem durchmesser von ca. 70mm
Anhang 34426
ausprobiert. In innenräumen ok, draussen nur begrenzt, weil sie doch recht schnell und gründlich verdrecken :-(
Abgesehen vom preis, bei 100 mm durchmesser sind es sicher 30€ pro rad...
entspricht in etwa Deiner schätzung, die platform wiegt schon ohne den akku fast 2kg, die nutzlast schätze ich auf maximal 4-5kg...Zitat:
Zitat von Moppi
also, die treiber sind mit einem C (100µF, 63V) an den versorgungspinns der stepper versehen, sie laufen, das fliegensterben ist wohl gestoppt. Gleich eine frage: Die stepper sind beim einschalten betromt, d.h. sie sind fest in der einschaltposition fixiert.
- Macht es den steppern oder treibern etwas aus?
- Sollten sie nicht besser stromlos sein beim einschalten des roboters? Da werden sie ja noch nicht gebraucht, erst beim befehl zum fahren.
- ist es nur über den enable-pin möglich?
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
stromlos geschaltet, nach Deinen ausführungen hätte ich eigentlich das gegenteil erwartet, nämlich "LOW"...Code:digitalWrite(enbl_VL, HIGH);
digitalWrite(enbl_HL, HIGH);
digitalWrite(enbl_VR, HIGH);
digitalWrite(enbl_HR, HIGH)
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:
So ist es dann richtig.Zitat:
This input turns on or off all of the
FET outputs. When set to a logic high, the outputs are disabled.
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.
ich hab aber auch beispiele gefunden, wo die einfach frei sind:Zitat:
Zitat von Moppi
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 :-)
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?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);
}
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?
An der Ansteuerung des Treibers, der bekommt Step-Signale etc. :)
Du hast es doch im lopp() so geschrieben!?
Verstehe jetzt nicht, was Du meinst! Was stört Dich jetzt daran, dass er links und rechts herum dreht, wenn das im Programm so steht? Ich stehe wohl etwas auf'm Schlauch, hilf mir mal!
MfG
Jetzt weiß ich was Du meinst. Aber ich kenne das nicht. Ich habe das zu keiner Zeit. Allerdings steuere ich meine Treiber auch über den Sleep-Pin und kann da mit dem Enable-Pin nicht so mitreden, der ist bei mir dauerhaft auf GND geschaltet.
MfG
habe mir Dein codebeispiel noch einmal angeschaut:
- definiert (und verdrahtet?) hat du SLEEP und STEP
- den stepper schaltest du an- und aus- per SLEEP
- ENABLE hast Du nicht verdrahtet
- bewegt wird er per STEP
bedeutet also, dass du den jumper zwischen SLEEP und RESET, wie er in vielen anleitungen beschriben wird, nicht hast?
Anhang 34444
Ich habe meine Zeichnung zum Aufbauen meiner Schaltungen verwendet, habe die Zeichnungen hinterher noch entsprechend geändert. Daher betreibe ich es so, wie es dort abgebildet ist.
Ursprünglich schaltete ich nur den Sleep, weil ich die Akkus schonen will. Dann, weil das nicht ausreichte, habe ich die Logikspannung gleich mitgeschaltet, so dass die Elektronik komplett abgeschaltet ist - mehr Sleep geht wohl nicht. Hat aber denselben Effekt auf den Motor, wie wenn ich nur den Sleep geschaltet habe. ENABLE liegt auf GND. D.h wenn der Treiber unter Logik-Spannung steht, wird der wach und ich steuer direkt den Motor per Step etc., ist die Position errreicht, dann geht es bei mir wieder in den Sleep - Modus (heißt bei mir auch, Logikspannung abschalten).
Steht bei mir im Blog unter: Schaltung neu
Das ist allerdings nicht ganz aktuell. Da müsste noch die endgültige Schaltung rein. Die habe ich aber weggelassen, weil ich nicht mehr Verwirrung stiften wollte. So, wie es dort abgebildet ist, funktionierte es ja auch und so war auch der Quellcode dafür geschrieben. Und auch damit hatte ich keine Probleme, nur dass der Stromverbrauch im Sleep-Mode evtl. höher war.
Deshalb hier gerne nochmal meine endgültiger Plan:
Zitat:
bedeutet also, dass du den jumper zwischen SLEEP und RESET, wie er in vielen anleitungen beschriben wird, nicht hast?
Wenn ich den RESET nicht benötige (extra steuern möchte), verbinde ich den mit VDD. Natürlich nicht mit SLEEP, wenn ich SLEEP alleine schalten möchte.
In andern Schaltungen wird SLEEP nicht gesteuert und daher mit RESET verbunden.
MfG
Das ist ziemlich schlecht, wenn das schon bei unbelastetem Motor auftritt. Mach mal ein Rad ran, und sieh wie es sich entwickelt.Zitat:
Zitat von inka
Die Logik-Signale an den Anschlüssen sind doch nun wirklich nicht kompliziert:
ENABLE (erlauben/einschalten) hat einen Überstrich, ist also active Low. Ein Low schaltet den Chip also an. SLEEP hat auch einen Überstrich, bei Low legt sich der Chip schlafen und schaltet sich auch intern das meisste ab. RESET ist ebenfalls active Low, muß also auf High damit der Chip nicht im Reset hängt.
Also muß also ENABLE auf Low und SLEEP und RESET auf High, dann arbeitet der Chip. Und im ersten Schritt legt man die Abschlüsse mit Pull-Ups oder Pull-Downs fest auf den richtigen Pegel. Ein Pulse an Step lässt dann den Motor einen Schritt machen. Wenn erstmal alles funktioniert, kann man sich ums Stromsparen oder andere Sachen kümmern.
Zum Testen würde ich einen Taster an den Prozessor schalten und ein kleines kleines Programm schreiben: Taster entprellen und für jeden Druck einen Puls ausgeben. Je nach dem Pegel von DIR muß der Motor einen Schritt nach links oder rechts machen.
MfG Klebwax
nochmal zum Überbrücken SLEEP und RESET:
Der SLEEP - Eingang am Treiber kann von außerhalb unbeschaltet bleiben, weil der mit einem 5k-Widerstand gegen VDD verbunden sein soll. Wenn man Sleep also nicht braucht, muss der nicht zusätzlich beschaltet werden. Wird RESET auch nicht benötigt, wird der gerne einfach mit dem SLEEP verbunden, somit liegt der RESET dann auch über 5kOhm an VDD.
MfG
es rattert weniger, weil eine grössere masse bewegt werden muss...Zitat:
Zitat von Klebwax
stimmt. Ich habe auch inzwischen keine probleme mit dem eigentlichen code. Das problem liegt im einschalten. Seltsamer weise ratterts nur wenn vier stepper gleichzeitig eingeschaltet werden, beim einzelnen passiert es nicht...Zitat:
Zitat von Klebwax
Das letztere war ein Gedanke, den ich auch schon hatte.
Prüfe mal, ob beim Einschalten, aller 4 Motoren gleichzeitig, die Spannung einbricht! Bei Batterien geht nur runter, sinkt evtl. auf 5V ab oder was ähnliches. Beim Netzteil könnte es sein, dass die Spannung bei Überlast kurzzeitig ganz abgeschaltet wird und dann zu diesen Aussetzern führt. Wenn ich es richtig gelesen habe, brauchen die Stepper-Treiber am Eingang wenigstens 8V.
Da ist es: Load Supply Voltage Range VBB Operating 8 – 35 V
Kannst ja mal an allen Treibern das Trimpoti (frühere Strombegrenzung = weniger Strom für die Motorspulen) verstellen, dass die Stepper noch anlaufen und nicht stehen bleiben. Bei jedem einzeln einstellen (nicht alle zusammen an der Spannungsquelle hängen lassen). Dann noch mal alle zusammen ausprobieren. Funktioniert es dann, liefert Deine Spannungsquelle nicht ausreichend Strom, bei wenigstens 8V.
MfG
habe ich jetzt gemessen, allerdings ist beim ausgeschalteten steckernetzteil ja alles stromlos. Beim einschalten habe ich erstmal (ganz kurz nur) so um 3.5V gemessen, bevor es auf 12V ging...
Ich muss jetzt wirklich auf den akku warten, die chinesen zieren sich aber irgendwie. Zwei verkäufer haben schon einen rückzieher gemacht, die kapazität von 10.000 mAh beim preis von ca. 15€ scheint nicht so ganz easy zu liefern zu sein...
Habe jetzt ein akku über amazon bestellt, natürlich mehr als doppelt so teuer. Mal sehen ob und wann er kommt. Und ob er dann auch in die knie geht...
vielleicht die motoren mit einer kleinen verzögerung schalten?
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);
}