moin Moppi,Zitat:
Zitat von Moppi
nein, habe ich noch nicht, der R grinst mich noch ganz schön frech an :-) - > passt es überhaupt noch mit dem "R2" am ENABLE pin?
Druckbare Version
moin Moppi,Zitat:
Zitat von Moppi
nein, habe ich noch nicht, der R grinst mich noch ganz schön frech an :-) - > passt es überhaupt noch mit dem "R2" am ENABLE pin?
Das mit dem Pull-Up von Holomino habe ich noch nicht verstanden, wo soll der hin - der Widerstand? :)
Warum nicht? Wenn ENABLE dauernd auf HIGH liegt dürfte sich nix mehr drehen.Zitat:
passt es überhaupt noch mit dem "R2" am ENABLE pin?
Dann mit dem Arduino nach dem Starten im Setup 2s Gedenkpause einlegen (s. Holominos Beitrag) und dann erst mit dem Programm fortfahren.
- - - Aktualisiert - - -
@inka
um Dich zu ärgern: bei meinem Versuchsaufbau funktioniert alles einwandfrei, obwohl ich keine Strippe gelötet habe, alles nur gesteckt. ;)
vier stepper? Oder von welchem aufbau sprichst Du? Bei mir ist ja auch alles gesteckt... Und ärgern? Ich freue mich für Dich :-)Zitat:
Zitat von Moppi
nachmittags will ich es probieren:
- - - Aktualisiert - - -
ENABLE VL pin eines der stepstick's ist bei mir mit pin 40 des arduino verbunden, diese widerstand zwischen enable und VDD (ist mit Vin bezeichnet) kommt zusätzlich dazu, oder? Ich will es bei einem Stepper probieren, denn wenns funktioniert, dreht der halt nicht mit...Zitat:
Zitat von Moppi
40 Stepper ... glaubst Du mir?
:)
Nein - einer! Reicht aus zum Ausprobieren.
- - - Aktualisiert - - -
Wenn Du die 12V nimmst, dann hängen dort die Motoren dran und geben vermutlich Störungen auf die Versorgungsspannung drauf, das gelangt dann zum Arduino.Zitat:
wahrscheinlich zielführend, aber etwas kompliziert. Ich habe noch eine beobachtung gemacht: Das rattern kommt nicht vor, wenn der arduino am USB programmierkabel hängt, und er somit mit unabhängigen 5V versorgt wird.
Klar kannst Du den Arduino extra mit Akku betreiben.
- - - Aktualisiert - - -
Du kannst aber auch was anderes noch versuchen, in diesem Fall. Nimm die 12V vom Akku , die auch an den Arduino gehen, verbinde die +12V mit einer Gleichrichterdiode und das andere Ende der Diode verbindest Du mit den Motoren. Also eine Diode in die Versorgungsspannung zu den Motoren. Vielleicht hilfts schon.
- - - Aktualisiert - - -
Sag mal, der Akku ist nicht vielleicht zu schwach, dass die Spannung einbricht, beim Einschalten des Gerätes?
kann der dann auch dauend an- und an den 5V und GND pins dranbleiben? Er hat ja nur 3.7V? Es ging ja auch nicht direkt darum den arduino damit zu betreiben, sondern zusätzlich zu der 12v versorgung quasi eine art "starthilfe" zu geben...Zitat:
Zitat von Moppi
probiere ich auch noch...Zitat:
Zitat von Moppi
und wie stelle ich das fest? Ich hab nur die spannungsangabe von 10,6 - 12V und die 8AhZitat:
Zitat von Moppi
dieser 5kOhm widerstand von ENABLE an VDD: zusätzlich zu der verbindung zum arduino pin (hier, einer von vier, die nr. 40) oder als ersatz? Wenn zusätzlich, könnte ich den widerstand auch auf der treiberplatine auflöten...
Ja, könntest Du.Zitat:
Wenn zusätzlich, könnte ich den widerstand auch auf der treiberplatine auflöten...
Was die Spannung angeht. Kannst Du doch messen. Du sagst doch, das dauert etwa eine Sekunde. Messgerät dran und dann Einschalten und beobachten.
Normal müsstest Du mir einem Oszilloskop messen, dann kannst Du genau sehen, was los ist. Wie hoch die Spannung ist und ob Störungen drauf sind.
Du kannst auch noch eine Diode zwischen "+" und "-" hängen, als Freilaufdiode, soll zwar nicht notwendig sein...
Ich würde mal die einfachste Möglichkeit versuchen und eine Gleichrichterdiode in die Plusleitung zu den Motoren reinhängen. Wenn das nichts nützt, eine zweite, gleiche Diode als Freilaufdiode.
Das Problem könnten auch Einschaltspitzen sein. Ich habe keine Ahnung, wieviel Strom kurzfristig gezogen wird, bei 4 Steppern. Theor., wenn ich an die bis 4A Spitze denke, die als Störung auftreten können, 4*4 sind 16A. Zwar sollen die Elkos hier gegensteuern, aber wer weiß. Und wenn es auch nur 2A sind, dann bist Du schon bei 8A. Wenn das beim Einschalten kurz passiert, bricht die Spannung am Akku ein. Wenn das sehr große Sprünge sind, kann es sein, dass der Spannungsregler vom Arduino das nicht hinbekommt. Dann hast Du so ein Phänomen. Oder, wenn die Störspitzen auf die Versorgung zurück gelangen, könnte auch das auch dazu führen. Noch schlimmer wird es in dem Fall, wenn die Störungen aller 4 Motoren zusammen kommen, das kann ganz heftig werden. Fest steht: beim Einschalten der Versorgungsspannung können die Stepper kurzfristig unter Strom stehen, das habe ich bei meinem Versuchsaufbau nämlich auch so.
Mehr fällt mir auch nicht ein.
MfG
wahrscheinlich ein erfolgserlebnis, kann es noch nicht so beurteilen :-) der stepper an dem ich den widerstand aufgelötet habe rattert beim einschalten nicht, bewegt sich (natürlich?) aber auch nachher nicht, wenn die FB benutzt wird...Zitat:
Zitat von Moppi
Mal eine Bitte: guck mal hier!
So ein 12V LiPo kostet 12 EUR. Ein Ladegerät hst Du doch. Der bringt bis 50A. Damit kannst Du deinen Roboter testen. Um auszuschließen, dass die Spannung einbricht.
Dann mach aus den 5K , mal 10KOhm. Normalerweise sollte das funktionieren. Nimm mal bitte ein Messgerät, lege den ENABLE-Pin auf Masse (GND) - den Widerstand zwischen dem Pin und +5V drin lassen, und messe mal, an dem Pin die Spannung (nicht vergessen dabei den Ausgang des Arduino abzuklemmen). Dort müssen dann 0V anliegen. Ebenfalls, wenn der Arduino-Ausgang den Pin auf LOW (das sind beim Arduino 0V) schaltet. Ob der Arduino 0V schaltet, kann auch überprüft werden. Mein UNO machte das jedenfalls so, also der 328P.Zitat:
aber auch nachher nicht, wenn die FB benutzt wird...
MfG
- - - Aktualisiert - - -
Und natürlich auch schauen, dass nach Änderungen immer alles richtig verdrahtet ist. Nicht das Verbindungen vom Arduino zum Treiberboard vergessen wurde.
- - - Aktualisiert - - -
Jedenfalls war der Gedanke richtig.Zitat:
wahrscheinlich ein erfolgserlebnis
Aber besser wärs, die Spannung vom Akku zu stabilisieren und zu entstören und genügend Strom zur Verfügung zu haben, beim Einschalten.
muss ich das verstehen?Zitat:
Zitat von Moppi
das war's, danke :-)Zitat:
Zitat von Moppi
das war das mit der diode von +12V zu den motoren, bzw. motortreibern. In der richtung muss sie ja auch leitend sein, denke ich... tut's eine schottky 1N5817? Und reicht eine? Die 12V leitung splittet sich erst später in 4 auf...Zitat:
Zitat von Moppi
Ist ein Akku mit 12V und liefert bis 50A Strom. Muss ja nicht lange durchhalten, zum Probieren reicht es aus.Zitat:
muss ich das verstehen?
Oder hast Du was dagegen? - Weiß ja nicht! :)
weiß ich nicht, da bin ich zu wenig experte, ich nehme immer Gleichrichterdioden (sowas: https://www.reichelt.de/gleichrichte...?&trstct=pos_6) gibt es auch etwas kleiner, glaub ich. - Aber ja, nimm die. Habe gerade nachgeschaut, was Schottky ist. Diese Dinger nehme ich sonst auch.Zitat:
tut's eine schottky 1N5817
Funktioniert damit?Zitat:
Dann mach aus den 5K , mal 10KOhm. Normalerweise sollte das funktionieren.
-------------------------------
das war's, danke :-)
Zitat:
das war das mit der diode von +12V zu den motoren, bzw. motortreibern. In der richtung muss sie ja auch leitend sein, denke ich
So ist es.
MfG
ich meine den link?Zitat:
ja, ein kleiner vermutstropfen - der stepper, bei dem ich es mit dem 10K widerstand versuchsweise gemacht habe, steht dauernd unter spannung. Egal was im sketch für den enable-pin angegeben ist, also unabhängig ob HIGH oder LOW. Wie gesagt, wesentlich weniger schlimm, als das rattern...Zitat:
Dann mach aus den 5K , mal 10KOhm. Normalerweise sollte das funktionieren.
-------------------------------
das war's, danke :-) Funktioniert damit?
Muss jetzt alle vier treiberplatinen mit dem widerstand nachrüsten - melde mich wieder :-)
Ach! Ich habe einen Link von Conrad gehabt!Zitat:
ich meine den link?
Hier noch einer: kostet dort 14 EUR bei Conrad zurzeit 12 EUR.
Wenn das mit dem Widerstand am ENABLE nicht funktioniert, dann lass den weg. Hat keinen Sinn dann.
naja teilweise hats ja funktioniert, das nervende rattern war zumindest weg. Ich hab dann den fliegenden aufbau durch was solideres ersetzt:
Anhang 34525
und ab dem moment hat's wieder gerattert!
Also, ich werde jetzt den kleinen "vorglüh-akku" einsetzen:
Anhang 34526
vorgehen beim starten:
- taste drücken, damit wird eine schaltung aktiviert, die von dem akku aus ein RC-glied lädt
- wenn geladen geht eine LED an
- hauptschalter an
- arduino schaltet kleinen akku ab (RC-glied ladeerkennung)
mal sehen ob das geht... :-)
und bis dahin ist der kleine akku dran und es rattert nicht :-)
Ich probiere das jetzt mit dem ENABLE aus. Ich hab ja den Aufbau vor mir liegen. Verstehe nicht, warum das nicht funktionieren soll, es sei denn, es gibt intern eine Beschaltung. Davon habe ich aber nichts gelesen.
MfG
- - - Aktualisiert - - -
Also mit 5k bzw. 4.7kOhm am ENABLE-Pin des A4988 funktioniert es, wie erwartet. Ohne Widerstand liegen dort vom Arduino her 5V oder 0V an. Mit Widerstand zwischen ENABLE und Vdd des A4988 liegen 5V oder 0.02V an und der Arduino kann diesen ENABLE-Pin auch steuern. Nur, wenn der Arduino-Ausgang noch nicht initialisiert ist, liegen am ENABLE-Pin (wie erwartet) auch keine 5V an, was normal ist und daran liegt, dass die Ausgänge des Arduino nach Neustart zunächst im hochohmigen Zustand sind. Somit bringt der 4.7k / 5k-Widerstand genau das, was er soll, nämlich für einen definierten Pegel sorgen, wenn der Arduino-Ausgang noch hochohmig ist.
Allerdings ändert dieser Widerstand am ENABLE nichts daran, dass der Motor beim Anschalten der Versorgungsspannung des Treibers kurzzeitig in Bewegung ist, also Strom fließt. Aber vermutlich liegt das Ganze ja sowieso an der Spannungsversorgung.
- - - Aktualisiert - - -
Du solltest unbedingt einen Schaltplan zeichnen, mit Arduino, A4988, div. Widerständen drin, Mäuseklavier etc. Sonst kann man wirklich nicht sagen, warum was bei Dir an der Schaltung nicht funktioniert.
- - - Aktualisiert - - -
Motor Geschwindigkeit steigern
Um den Motor auf Maximalgeschwindigkeit zu bringen, lasse ich im FULL-STEP-Modus diese Testschleife laufen:
Sollte jetzt selbsterklärend für Dich sein, inka.Code:int j=2000;
//-----------------------------------------------------------------------------
void loop() {
if(j>280)j--;
for(int i=0;i<3;i++){
digitalWrite(Step, LOW);
delayMicroseconds(j);
digitalWrite(Step, HIGH);
delayMicroseconds(j);
}
}
MfG
- - - Aktualisiert - - -
Zitat:
vorgehen beim starten:
- taste drücken, damit wird eine schaltung aktiviert, die von dem akku aus ein RC-glied lädt
- wenn geladen geht eine LED an
- hauptschalter an
- arduino schaltet kleinen akku ab (RC-glied ladeerkennung)
Dann kannst Du auch die Logikspannung der Platinen mit dem Arduino bereitstellen. Falls Du Angst hast, die vier A4988-Platinen würden zu viel Strom benötigen, kann man einen BC547B mit dem Arduino-Ausgang ansteuern. Dann nimmt man den BC547B in Open-Collector-Schaltung, verbindet VDD, des A4988, mit 5V und GND, des A4988, schaltet man über den Transistor. Das Schöne dabei: man kann auch einfach 2 BC547B parallel schalten, um auf insgesamt 200mA Max-Strom zu kommen, das reicht für die vier A4988 allemal aus (eigentlich sollten 100mA ausreichen). Der Effekt: Solange der Arduino hochohmige Ausgänge hat, schaltet der Transistor nicht durch und die A4988 bekommen keinen Strom. Wenn die ohne Logikspannung sind, bewegt sich der Motor nicht. So kann man auch immer die Logikspannung der Treiber mit dem Arduino abschalten und anschalten. - Das wäre mein Joker :) Zur Not wäre so auch jeder Treiber einzeln zuschaltbar, bloß bräuchte es dann vier Arduino-Ausgänge, allerdings kann dann der BC547B gespart werden, weil so viel Strom, wie ein A4988 benötigt, kann ein Arduino-Ausgang bereitstellen.
ich hab jetzt sogar den arduino ausgetauscht, es rattert. Ich weiss langsam, welchen fehler ich gemacht habe, aber in den kleinen verhältnissen war das gar nicht anders möglich. Ich hab ja quasi ein kabelbaum, der läuft an den wänden entlang, schön aufgeräumt, um nicht noch mehr strippen und durcheinander in der kiste zu haben. So weit so gut, nur laufen dort die 12V leitungen (versorgung der motoren), die 5V leitungen (versorgung motortreiber, arduino...) und fast alle signalleitungen mit ihren paar mA alle schön parallel. Hätte es eigentlich wissen müssen , diese problematik war von 30 jahren mein täglich brot... Da helfen keine paar widerstände am leitungsende...Zitat:
Zitat von Moppi
Ich muss es mit dem hilfsakku machen, sonst sehe ich kein land...
hier verstehe ich auch, was Du da machst und misst, mit einem unterschied, Du hast alles schön frei auf dem tisch vor Dir liegen, bei mir ist alles etwas schwerer zugänglich :-( und dort auch schwer zu messen...Zitat:
Zitat von Moppi
ist es auch, klar...Zitat:
Zitat von Moppi
Schirmung ist die eine Sache, die Du nachholen könntest und das Trennen der Leitungen, wo Leistung drüber fließt und derer, wo Signale drüber laufen.
Aber trotzdem: ich glaube nicht so recht, dass dies die Probleme verursacht. Wenn Du die Spannung aus dem DC/DC-Konverter und alle Signale, sowie alle leistungsführenden Kabel alle schön gerade zusammengebunden über 30cm Länge nebeneinander her führst, kann es natürlich sein, dass Du Dir Störungen auf den Signalleitungen fabrizierst. Aber für mich sieht dies Problem genau nach dem aus, dass ich beim Hexapod auch habe/hatte und kenne, dass eben die Leistung des Akkus/Netzteils nicht ausreichend ist, mit einer 2000mAh Powerbank wird es dann ganz verrückt, dann treten solche Sachen während stärkerer Belastungen auf, dass eben die Elektronik verrückt spielt und die Motoren dann infolge am Zappeln sind. Du wirst wahrscheinlich die Verkabelung ändern müssen, wenn Du zukünftig von Problemen verschont bleiben willst. :(
Ist eben die Frage, ob Dir eine Bastelei ausreichend ist oder ob Du ein solides Projekt haben möchtest.
Mal generell zum Aufbau:
- Versorgungsstrippen kurz (und dick), Motorleitungen lang (und ausreichend)
- Versorgung sternförmig von der Quelle weg
- Wenn was über eine Diode abgeblockt werden muss, dann tunlichst mit einem Kondensator dahinter. Damit Der nicht unendlich groß wird, empfielt es sich, den Zweig mit der geringsten Stromaufnahme abzublocken (wahrscheinlich also die wenigen mA vom Controller). Treiberbausteine über Dioden in der Versorgung abzublocken ist eher kontraproduktiv. Über die Freilaufdioden in den Treibern müssen Überspannungsimpulse der Motorinduktivitäten frei auf die Versorgung rückgekoppelt werden können.
Vielleicht macht es also Sinn, die ganze Elektronik in eine Ecke zu packen und nur die Motorleitungen über einen Kabelbaum zu verteilen.
Wegen der /Enabled-Leitung: Hast Du mal den Durchgang zwischen Eingang am Shield und Pin auf dem Treiberboard geprüft? Was ist denn noch auf diesem Shield? Ist da noch ein Regler drauf? Gibts dazu nen Schaltplan?
Freilaufdioden schalten Gegen-EMK gegen Masse kurz, das ist doch gegeben. Selbst wenn die Plusleitung über eine Diode geführt wird.Zitat:
Über die Freilaufdioden in den Treibern müssen Überspannungsimpulse der Motorinduktivitäten frei auf die Versorgung rückgekoppelt werden können.
Deshalb würden mich die Hintergründe dazu genauer interessieren, warum Überspannungsimpulse auf bspw. ein Netzteil rückgekoppelt werden müssen.
NUr so am Rande: wir hatten so was mal, dass Überspannung ins Stromnetz rückgekoppelt wurde, bei einem Fernseher (defekter Zeilentrafo oder was auch immer). Dabei ist die Sicherung des DVD-Players durchgegangen und die Stereoanlage hat gebrannt. Zum Glück war ich zu dem Zeitpunkt im Raum, weil ich fern gesehen habe.
MfG
das ist der letzter stand des aufbaus:Zitat:
Zitat von Holomino
Anhang 34527
die verbindungen basieren an den dupont litzen, also AWG30 schätze ich mal...
meinst Du ob der A4988 kontakt zum extenderboard hat? Hat er...Zitat:
Zitat von Holomino
das ist das einzige was an "unterlagen" zu finden war:
Anhang 34528 Anhang 34529
kennst Du die 20/80 regel?Zitat:
@Moppi:
Ist eben die Frage, ob Dir eine Bastelei ausreichend ist oder ob Du ein solides Projekt haben möchtest.
Gehört: kann sein, kennen: neinZitat:
kennst Du die 20/80 regel?
Das sehe ich auch so. Dazu nur mal ein paar Daumenwerte: Bei CMOS-Logik liegen die Schaltschwellen bei etwa 1/3 und 2/3 der Versorgung. Bei 5V bedeutet das, alles unter 1,6V ist eine 0, alles über 3,4V ist eine 1. Ein Signal von 1V mit einem Ripple von 100mV ist eine glatte 0. Selbst bei 200mV Ripple gilt das noch. Die oben erwänten 0,02V sind einfach 0. Am Ende zählt aber die Spannung, die am Modul anliegt und nicht der Wert, den die SW ausgibt. Daher sollte man sich alle Signale auf dem Scope anschauen. Bei mir läuft bei solchen Entwicklungen das Scope immer mit.Zitat:
Zitat von Moppi
Und bevor man anfängt, eine Sache umzubauen, die eigentlich funktionieren sollte, ist es sinnvoll den wirklichen Fehler zu finden. Sonst macht man ihn beim Umbau noch einmal. Dazu einen Schaltplan erstellen und den Plan der Treibermodule mit einbeziehen. Der ist bei Pollolu zu finden. Nicht jeden Pullup/Pulldown muß man selbst setzen, an SLEEP z.B. ist schon einer drauf. Die Pullup/Pulldown sind keine analogen Teile, sie können Werte zwischen 0Ω (Achtung, Gefahr eines Kurzschluß beim Abrutschen mit dem Tastkopf) und 50kΩ haben. Sollte sich ein unterschiedliches Verhalten bei unterschiedlichen Werten ergeben, liegt ein anderer Fehler vor. Da die Pullup/Pulldown auf den Treiber wirken sollen, sollten sie auch nahe bei ihm sein. Das macht es schnellen (µs) Störungen schwerer an den Treiber zu kommen.
In einem der vorigen Posts war von 9V und 1A die Rede. Kleiner als 9V (eigentlich 8V nach Datenblatt) sollte die Versorgung nicht sein. Der Chip schaltet sich sonst wegen Unterspannung ab. Die Maximalspannung des Chips, und mehr ist auf dem Board ja nicht drauf, beträgt 35V. Und ein Netzteil mit weniger als 1A dürfte selbst bei kleinen Strangströmen Probleme haben.
Zu guter letzt: diese Module sind eigentlich keine Schrittmotortreiber, obwohl ich sie selbst so bezeichne. Es sind Eval bzw Breakouboards der A4988 Chips von Allegro (oder der DRV8825 Chips von TI) für Entwickler und Bastler. Sie machen SMD Chips steckbretttauglich. Ein industrieller Schrittmotortreibern sieht ganz anders aus. Wie aus dem Schaltplan ersichtlich, enthalten sie nur das Minimum an notwendiger externer Beschaltung. Man könnte auch sagen, sie enthalten schon das Minimum, um einem das Entwickeln zu erleichtern. Alle Daten gehen also aus dem Datenblatt des Chips hervor, die Pollolu Entwickler geben dazu noch zusätzlich Tips aus ihrer Praxis. So benutzen sie den Pullup von SLEEP auch für RST, indem sie beide Anschlüsse verbinden. Das spart den Anschluß eines eigenen Pullups. Wenn man aber SLEEP oder RST aktiv steuert, geht das natürlich nicht. Für das Verhalten dieser Boards ist also das Datenblatt die Bibel. Und ansonsten Messen statt vermuten.
MfG Klebwax
Ich habe es noch nicht verstanden. Erstmal soll man an die Arduino-Pins keine Spannung einspeisen. Die 5V oder 3.3V an der Stiftbuchsenleiste kommen doch von einem Spannungsregler oder nicht? Warum sollen dort am 5V-Pin 4V eingespeist werden? Was soll das ändern?Zitat:
Zitat von inka
Hier mal eine Übersetzung aus dem Datenblatt eines mega2560:
Ich denke jetzt mal, dass Du "die Stiftleisten Gnd und Vin" vom Power-Anschluss meinst. Aber wieso mit 4V da dran? Vielleicht mag ein mega2560 auch mit 3.3V betrieben werden können - keine Ahnung jetzt.Zitat:
Der Arduino Mega kann über den USB-Anschluss oder mit einem externen Netzteil betrieben werden.Die Stromquelle wird automatisch ausgewählt.
Externe (Nicht-USB-) Stromversorgung kann entweder von einem AC-zu-DC-Adapter (Wall-Wart) oder von einem anderen Gerät erfolgen.
Batterie. Der Adapter kann durch Einstecken eines 2,1 mm Mittelpositivsteckers in das Gerät angeschlossen werden.
an der Strombuchse des Boards. Leitungen von einer Batterie können in die Stiftleisten Gnd und Vin von
den POWER-Anschluss.
Das Board kann mit einer externen Versorgung von 6 bis 20 Volt betrieben werden. Bei Lieferung mit weniger als
7V, jedoch kann der 5V-Pin weniger als fünf Volt liefern und die Platine kann instabil sein.
Bei Verwendung von mehr als 12V kann der Spannungsregler überhitzen und die Platine beschädigen. Die
empfohlener Bereich ist 7 bis 12 Volt.
Übersetzt mit www.DeepL.com/Translator
Mag vielleicht funktionieren, aber für die Arduino-Ausgänge gibts eine Definition, die müsste im Datenblatt stehen. Genannt hatte ich die auch schon, man muss sie nur kennen: bevor die Pins im Programm definiert sind, sind die im "Z3-State", also weder Eingang, noch Ausgang. Mit dem Wissen kann man seine Beschaltung logisch sicher gestalten. Und genau aus diesem Grund, falls das zu unsicher sein sollte, kann man mit einem Arduino-Pin Transistoren in Open-Collector-Schaltung als Treiber steuern. Dann hast Du genau den Effekt, dass erst der Arduino gestartet und vom Programm her initialisiert sein muss, bevor die A4988-Module überhaupt bestromt werden und die Motoren eine Chance hätten, zu drehen. Da sparst Du den ganzen merkwürdigen Klamauk mit "Vorglühtaste".Zitat:
...für 5 sekunden dazuzuschalten?
So, wie Du das aber beschreibst, dass das Motorchassis nur funktioniert, wenn der Arduino mit unabhängiger Spannungsquelle versorgt ist, dann müsste das doch auch immer so sein (getrennte Stromkreise oder wenigstens eine Entkopplung).
Und wenn das eher unerwünscht ist, dann muss dafür gesorgt werden, dass möglichst keine entgegengerichteten Ströme (falls so etwas überhaupt da ist) zurück zur Spannungsquelle fließen, weil die dann auch an dem Arduino-Spannungseingang ankommen. Eine Freilaufdiode, direkt am Abzweig zu den Motorversorgungen, könnte das verhindern. Wenn das nicht reicht, kann man eine Freilaufdiode auch am Arduino-Spannungseingang schalten, wenn das besser wäre. Zu hohe Spannungen sollten auch nicht zurückfließen können - meine Meinung, denn das käme auch am Arduino-Spannungseingang an. Man könnte eine Stromkreis-Entkopplung vornehmen (idee zwei getrennter Stromkreise); Diode in Plus zur Versorgung der Motoren, wäre eine Möglichkeit. Spannungseinbrüche haben wir auch schon besprochen. Deshalb noch mal, ich weiß dass das evtl. nervt: Die Spannungsquelle muss belastbar sein und Reserve nach oben haben, nicht zu knapp ausgelegt. Wenn dann die Spannungsquelle belastbar genug ist und massive Störungen auf der Versorgungsleitung am Arduino-Eingang ausgeschlossen sind und man vermutet, dass die Arduino-Ausgänge im hochohmigen Zustand zu Problemen führen, könnte man die Spannungsversorgung, der A4988, vom Arduino aus steuern oder Pull-Up-/Pull-Down-Widerstände einsetzen.
Wichtig:
Egal, ob der Arduino bereits im Betrieb ist oder nicht. Sobald der A4988, in der Beschaltung RESET+SLEEP verbunden und mit 5k-Ohm Pull-Up versehen - weil so ist die Schaltung hier und so habe ich sie nachgebaut, mit Spannung versorgt wird / an die Versorgung angeschlossen wird, dreht sich der angeschlossene Stepper, d.h. dort fließt kurzzeitig Strom durch die Spulen (schätzungsweise eine viertel Sekunde). Liegt vielleicht auch daran, was das Datenblatt beschreibt:
Zitat:
At power-on or reset, the translator sets the DACs and the phasecurrent polarity to the initial Home state (shown in Figures 9
through 13), and the current regulator to Mixed decay mode for
both phases.
Sollten Störungen durch die Motorspulen entstehen, die störend wirken, sind die also in jedem Fall da, wenn sie nicht wirkungsvoll unterdrückt wurden. Sollten die Störungen durch Einschaltstromspitzen der Stepper entstehen, sind die, aus demselben Grund, auch da und nicht verschwunden (siehe 100µF-Elko, habe auch schon 220µF gesehen).
Gut, in Ordnung. Ich hatte das mit dem "vorglühen" noch nicht kapiert. Und jetzt doch wieder alle Gedanken dazu aufgeschrieben und verm. viel zu viel. :)
MfG
moin,
zunächst der einfachere teil (20/80 regel):Zitat:
Zitat von Moppi
für's erreichen von 80% der gewollten/spezifizierten funktionalität eine gerätes braucht man 20% der gestellten mittel (geld, zeit...), für die restlichen 20% der funktionalität auch die restlichen 80% der mittel. Folglich muss man sich überlegen, wann man aufhört und zufrieden zu sein hat :-)
was die stromversorgung von einem arduino betrifft hier ein link...
weiteres im laufe des tages...
Inka, das ist ein UNO, kein MEGA. Aber egal. Schau mal ins Datenblatt vom MEGA2560, wo die Pins für die Stromversorgung sind.
Ich verbuche dieses: "was die stromversorgung von einem arduino betrifft hier ein link..." mal unter 20/80-Regel ;)
:)
"weiteres im laufe des tages..."
Ich habe meinen Testschaltkreis abgebaut und alles brav weggeräumt.
Mal sehen, wie es weiter geht.
Übrigens habe ich da mal was gefunden. Ist nicht so teuer, auch nicht so genau sicherlich etc. Aber für 0815-Überprüfung der Leitungen könnte das doch ausreichend sein!?
Da ich noch keins habe, bestelle ich mal so ein Teil. Besser als gar nichts.
MfG
- - - Aktualisiert - - -
Da wir hier im Forum das Thema auch schon mehrfach hatten, habe ich nochmal einen nützlichen Beitrag auf github rausgekramt. Sehr lesenswert, mit genauer Erklärung und vielen Bildern.
klar ist es ein UNO, ich bin halt davon ausgegangen, dass die "grungsätzlichen" pins und anchlüsse - und dazu zähle ich auch die 5V und GND pins auch - identische funktionen haben. Vielleicht ein trugschluss, aber das mit dem kleinen 3,7V lipoakku da dran funktioniert, nachprüfbar :-)Zitat:
Zitat von Moppi
Zitat:
Zitat von Moppi
was es heutzutage nicht alles schon gibt:-)? Ich habe mir mal für viel geld einen gebrauchten HAMEG HM203 angeschafft, kann damit nicht umgehen. Ziert nur mein arbeitsplatz und schindet eindruck, wenn's mal einer sieht :-(
EDIT:
ok, ich hab alles von @klebwaxs und von Dir gelesen, der versuch mit dem 3,7V am 5V pin war und ist dilettantisch, auch wenn es funktioniert hat....
Ich habe noch die 12V versorgung aus dem kabelbaum rausgenommen, bzw. an beiden seiten abgeklemmt und durch freiverdrahtung ersetzt, keine änderung, die stepper rattern. Also hätten wir auch diese "ursache" abgeräumt. Bleibt wirklich noch der akku und das zusammenbrechen der 12V und damit der 5V versorgung des arduino.
Ich glaube nicht, dass es mir gelingt mit einem vernünftigem aufwand das zusammenbrechen der spannung beim einschalten der stepper zu verhindern, der/die akkus sind da und sollten auch verwendet werden....
Würde es was bringen den einschaltvorgang in zwei stufen aufzuteilen? Schalter 1: 12V und 5V arduino, paar sekunden später schalter 2: stepper?
Dazu hatte ich ganz viel geschrieben.
Um es einfach auszuprobieren:
1. nimm die Leitung vom Arduino zum ENABLE-Pin, am ENABLE-Pin, weg.
2. Verbinde den ENABLE-Pin mit GND.
3. Trenne die Verbindung von Vdd, des A4988, zu +5V.
4. Nimm die Leitung, die vom ENABLE-Pin weggenommen wurde und verbinde sie mit Vdd (Logikspannung) des A4988.
5. Nimm für jeden A4988 einen Arduino-Ausgang. Im MEGA-Datenblatt steht was von nur 40mA, das ist gut für EINEN A4988 (normal könnte man 4 Treiber damit versorgen, könnte aber zu knapp werden).
Jetzt kannst Du jeden A4988 extra einschalten, nachdem der Arduino gestartet ist. Solange der A4988 keine Logikspannung bekommt, gibt der Motor Ruhe.
A4988#1 anschalten - 2s Pause - A4988#2 anschalten - 2s Pause - A4988#3 anschalten - 2s Pause - A4988#4 anschalten
Pausen können dann verkürzt werden, bis die Probleme erneut auftreten, dann die Pausen wieder etwas verlängern.
Gilt natürlich alles nur, wenn es Einschaltspitzen sind, die den Akku zu sehr belasten, in welcher Form auch immer.
- - - Aktualisiert - - -
Wenn ich das richtig sehe, können die 12V für die Motorspannung ruhig von Anfang an am A4988 anliegen. Die DMOS-Bridge wird solange nicht gesteuert, wie keine Logikspannung am A4988 anliegt. Also bekommen auch die Motoren keinerlei Strom.
- - - Aktualisiert - - -
Man soll die Motorspannung nicht abklemmen, wenn der A4988 in Betrieb ist. Normal ist das kein Problem, wenn die Treiberstufe des A4988 keinen Strom zu den Motorwicklungen leitet, machst Du da aber einen Fehler im Programm, könntest Du den Treiber zerstören, wenn Du die Motorspannung nach der Logikspannung anlegst.
- - - Aktualisiert - - -
Falls Du einen Riesenelko (4700µF, 10000µF, 22000µF) hast, könntest Du auch den noch mit in die Versorgung hängen, vielleicht behebt es das Problem schon (wäre vielleicht weniger aufwendig).
Bist du sicher, daß die Spannung zusammenbricht oder ist es eine Vermutung?Zitat:
Zitat von inka
Ein analoges Scope hilft dir bei einmaligen Ereignissen wie deinem Startproblemen leider nicht wirklich. Da braucht man einen Speicher. Aber zum Überprüfen von Signalen geht das schon. Einfach den Trigger auf AUTO stellen. Die Zeitbasis wird auf einen Millisekundenwert eingestell. Dann sollten 2 Linien für die 2 Kanäle zu sehen sein. Jetzt den Eingang auf 2V/cm und den Masseclip an GND. Wenn man jetzt mit der Tastspitze an 5V geht, springt die Linie um 2,5cm, 5V halt, nach oben. Jetzt kann man ganz schnell alle Signale ansehen. Wenn die nicht entweder auch 5V oder 0V haben, muß man sich dieses Signal genauer ansehen. Wenn ich etwas länger beobachten will, klemme ich die Tastspitze fest. Zur Not löte ich ein krzes Drahtstück an den Anschluß und klemme da den Tastkopf an. So kann man auch zwei Signale gleichzeitig ansehen. Und dann mit Single-Step durchs Programm und schauen, ob die Signale dem entsprechen, was man meint programmiert zu haben.Zitat:
..gebrauchten HAMEG HM203 angeschafft...
MfG Klebwax
Der ENABLE-pin war mit arduino-pin 40 (beispiel) verbunden. Ich könnte also diese verbindung nutzen um den Vdd pin des A4988 mit arduino zu verbinden und mit dem befehl "digitalWrite (40,HIGH)" den A4988 einschalten.Zitat:
Zitat von Moppi
- - - Aktualisiert - - -
ich hatte beim einschalten am 12V anschluss ein voltmeter hängen. Es zeigte beim einschalten sehr kurz 10V, dann ca.6 bis 7V und dann - nach dem rattern - 11V.Zitat:
Zitat von Klebwax
Hast Du richtig verstanden.Zitat:
Zitat von inka
MfG
- - - Aktualisiert - - -
Ich habe mich nochmal mit der Batterie beschäftigt, weil manchmal bekommt man aus China Produkte, die nicht das halten, was sie versprechen. Ich habe mir jetzt eine 1-Stern-Bewertung angesehen:
Zitat:
Lieferung ist sehr schnell. Die batterie arbeitet richtig. Aber drei von sechs batterien ist nur ein dummy. ICH hoch zweifel, dass in die batterie 8 amps. Tun nicht overpay für müll.
Zitat:
Batterie kapazität ist über 1000-1200 mAh. Ist nicht in der lage, entladung zu mehr als 0, 6A (nicht 5A als verkäufer sagt). Die batterie aufgeladen ist in 2 stunden mit dem verkäufer ladegerät (500 mA).
Inka, prüfe bitte die Batterie/Akku, ob alle Zellen vorhanden sind und irgendwie auch, ob die die angegebene Kapazität hat.Zitat:
Die produkt nicht spiel die beschreibung 8000mAh für 6 zellen 18650 von 2500mAh max in serie es der 2500mAh und nicht 8000mAh
Daten Deines Akkus:
Zitat:
Nennspannung: 12 V Eingangs spannung: 12,6 V
Ausgang spannung: 9 V-12,6 V
Batterie kapazität: 8000 mAh (8Ah)
Insgesamt gewicht: weniger als 300 gramm
Preis: 12 EUR inkl. Netzteil
Im Vergleich ein "richtiges" Li-Ion Akkupack, bei Conrad zu finden (Akkupack 3x 18650 Kabel Li-Ion 3.7 V 7800 mAh):
Zitat:
Zellen-Zahl: 3
Spannung: 3.7 V
Kapazität: 7800 mAh
Technologie: Li-Ion
Gewicht: 140 g
Preis: 50 EUR exkl. Netzteil
Wenn man damit auf 11.1V kommen möchte, muss man also 3 Packs davon nehmen, das sind dann 420g.
Wie kann dann der Akku, den Du gekauft hast, mit 12 bis 12.6V, 8000mAh, mehr als 120g weniger wiegen?
Im Vergleich würde ein LiPo_Akku mit 11.1V Nennspannung (voll geladen 12.6V) und 8000mAh ca. 65,-EUR kosten. Bei Conrad: 11.1V LiPo 5000mAh = 41,-EUR.
MfG
hallo Moppi,
mit diesem
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....Code:// DIR und STEP pins definieren
#define dirPin_HL 4
#define stepPin_HL 5
//start pin definieren
#define start_HL 42
//steps pro umdrehung definieren:
#define stepsPerRevolution 200
void setup()
{
//pins als output:
pinMode(dirPin_HL, OUTPUT);
pinMode(stepPin_HL, OUTPUT);
pinMode(start_HL, OUTPUT);
//richtung bestimmen
digitalWrite(dirPin_HL, HIGH);
Serial.begin(115200);
void loop()
{
delay(2000);
digitalWrite(start_HL, HIGH);
delay(2000);
for (int i = 0; i < stepsPerRevolution; i++)
{
digitalWrite(stepPin_HL, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin_HL, LOW);
delayMicroseconds(500);
}
}
Mit den akkus beschäftige ich mich anschliessend, die machen eigentlich einen guten eindruck, das was man halt sehen kann. Das gewicht ist natürlich gering, 270gramm. Die spannung stimmt wohl auch mit den angaben überein, ob die kapazität stimmt? Wie soll ich das denn messen? Wenn das mit dem rattern nun weg sein sollte, lasse ich den roboter über meine wippe hin und her fahren. Bis die akkus leer sind...
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?Zitat:
Mit den akkus beschäftige ich mich anschliessend, die machen eigentlich einen guten eindruck, das was man halt sehen kann.
Du kannst natürlich die mA auch mal messen, die dort beim Einschalten vorhanden sind.
was bedeutet "alle 2 sec macht der jeweils eine sequenz in CW richtung"?Zitat:
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
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.
War ganz schön anstrengend ;)Zitat:
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
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.Zitat:
Zitat von Moppi
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);
}
/***********************************************************/
/************************************************************/
warum? damit der roboter nicht wegrollt?Zitat:
Zitat von Moppi
wird gemacht, allerdings wird in der verdrahtung erstmal aufgeräumt. :-)Zitat:
Zitat von Moppi
Ja. Obwohl der so einfach nicht wegrollt, bei Schrittmotoren. Aber das wirst Du dann sehen. Nur dass Du Bescheid weißt.Zitat:
warum? damit der roboter nicht wegrollt?
Gut. Dann war's wohl vor allem wichtig, dass der Arduino vor den Treibern "an" ist. Welche Wechselspiele die auch immer miteinander ausgefochten haben.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.
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
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.Zitat:
Zitat von Moppi
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:
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; 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);
}
}
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:
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:
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.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?
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
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
hast recht, wäre schon was als druckprojekt - eigentlich eine sache für so ein 3D-drucker-unterforum... :-)Zitat:
Zitat von Moppi
Was hälst Du von dem stepper / akku test?