Mit µ sek. Arbeiten

[Andyh]

Hallo

Ich bin wieder an den Schrittmotoren angekommen.
Jetzt habe ich auch die Vorschubsteuerung im Griff (Mathemathisch gesehen).

Mein Probel:
Ich Steuere den Schittmotor mit einem Takt von 10µsek (ist noch zu viel sollte so bei 8µsek liegen) an, wenn ich jetzt eine Geschwindigkeit von 1mm/min angebe und 2mm fahre mit meiner Fräsmaschine brauche ich aber 3,4 min, also 1,4 min zuviel.

Ich habe die befürchtung das die Pausezeiten nicht genau eingehalten werden.

Bis jetzt mache ich das mit "time.sleep()".

Kenn da jemand auch schon was in die Richtung?

Gruß
Andyh

[numerix]

Ich habe die besten Erfahrungen beim Messen bzw. Festlegen sehr kurzer Zeiträume/Verzögerungen mit time.time() (unter Linux) bzw. time.clock() (unter Windows) gemacht. Mit time.sleep() habe ich ähnlich (schlechte) Erfahrungen gemacht wie du.

[Andyh]

Hallo

Danke das hört sich doch schon besser an.
Werds mal testen!

gerade gesehen:
mit "time.clock()" kann keine Zeit stoppen.

Weiss jemand eine Methode wir ich genau(er) an meine 10µsek. rankommen?

Gruß
Andyh

[gerold]

Steuere den Schittmotor mit einem Takt von 10µsek (ist noch zu viel sollte so bei 8µsek liegen) an

Hallo Andyh!

Schrittmotoren die ich kenne, laufen eine Umdrehung bei 100 Schritten. Es gibt auch Schrittmotoren, die mehr Schritte für eine Umdrehung brauchen.

Und das Nächste ist, dass Schrittmotoren nicht unendlich schnell angesteuert werden können. Je schneller du einen Schrittmotor ansteuerst, desto schwächer wird er. Irgendwann, bei irgendeiner Ansteuergeschwindigkeit ist er so schwach, dass er sich überhaupt nicht mehr dreht.

Und jetzt mal ein wenig rechnen. Wenn du möchtest, dass ein Schrittmotor, der 100 Schritte für eine Umdrehung braucht, sich ein mal die Sekunde dreht, dann musst du 100 Schritte an den Schrittmotor schicken. Das ist ein Impuls alle 0,001 Sekunden. Das wäre eine Pause von 1 ms (Millisekunde).

Bei einer Pause von nur 10 µs (Mikrosekunden), würde der Schrittmotor 100.000 Impulse die Sekunde bekommen.

1 / 0,00001 = 100000
100000 / 100 = 1000

Er würde sich theoretisch also 1000 mal die Sekunde drehen. Irgendwie stimmt da etwas nicht.

Was das Timing betrifft: ``time.sleep`` kann nicht unendlich kurz warten. Das Abarbeiten des Befehls braucht selbst auch seine Zeit. Je nach Geschwindigkeit deines Computers, kannst du kürzere oder längere Pausen machen. Bei mir sind z.B. nur Pausen von wenigen Millisekunden machbar. Aber in den Mikrosekundenbereich werde ich kaum vorstoßen können.

Und noch etwas. Du musst auch daran denken, dass die Abarbeitung der Befehle Zeit braucht. Du kannst also nicht einfach 10 ms warten und glauben, dass du damit den Schrittmotor mit einer Frequenz von 100 Hz ansteuerst. Die Frequenz wird sich verkleinern, da die Abarbeitung der Befehle auch seine Zeit braucht.

Wenn du genau arbeiten möchtest, dann darfst du nicht einfach mit ``time.sleep`` warten. Du müsstest dir ein Event-System aufbauen, welches exakt nach 10 ms einen Event auslöst. So ist es egal, wie lange die Abarbeitung der Befehle dauert, so lange es nicht länger als 10 ms ist.

Vielleicht findest du in diesem Thread http://www.python-forum.de/topic-6671.html noch ein paar Informationen, die dich weiter bringen.

mfg
Gerold

[ChrisGTJ]

Hallo Andyh,

zumindest früher war es so, daß der PC unter Windows keine (wenigstens nicht ohne weiteres) Intervalle unter 10ms erzeugen konnte. Vor allem hast Du mit dem normalen PC (Win, Linux...) kein Echtzeitsystem (garantierte Antwortzeiten usw.) zur Verfügung. Ich würde mal Vermuten, daß Du extra Hardware zur Ansteuerung des Motors brauchst (hoffe ich erzähle Dir nicht Sachen, die Du schon weißt...).

Gruß,

Christoph

[Andyh]

Hallo

Das es möglich ist steht außer Frage.
z.B. Mach3 (nicht der Rasierer, sondern die CNC-Software) kann das und zwar perfeck unter Win mit dem Paralleport.

@Christoph
Mit einem Microcontroller währe das eine saubere lösung wenn ich dem dann sage er soll 20 mm verfahren, nur soll das Programm an schon bestehenden anlagen laufen und die sizen meistens am LPT-Port.


@Gerold
Wie immer gut erklärt. Nur stimme ich dem nicht zu, gut ich habe noch was vergessen:

Das Signal ist 10µsek lang aber dann kommt eine pause um genau auf den Vorschub zu kommen den ich brauche.

Ich habe heute nochmal mit einem Telefoniert (Herr Ostermann, in Deutschald der größte entwickler für Schrittmotoren Steuerungen fürs hobby) der sag das optimale Signal liegt bei 8 µsek.

Ist es besser ich steige mit der Ausgabe auf "C" um?

Gruß
Andyh

[Leonidas]

Ist es besser ich steige mit der Ausgabe auf "C" um?

Ohne ein Echtzeit-OS bekommst du nun mal keine garantierten Zeitspannen, in keiner Sprache.

[gerold]

Hallo Andyh!

Einfache, nicht ganz so genaue Schrittmotoransteuerung zur "unipolaren" Ansteuerung eines Schrittmotors mit 200 Halbschritten für eine Umdrehung:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: iso-8859-15 -*-

import parallel
import time

half_steps = [
    int("1001", 2),
    int("0001", 2),
    int("0101", 2),
    int("0100", 2),
    int("0110", 2),
    int("0010", 2),
    int("1010", 2),
    int("1000", 2),
]

def main():
    round_counter = 0
    rounds = 0
    p = parallel.Parallel(port = 0)
    while True:
        for half_step in half_steps:
            p.setData(half_step)
            time.sleep(0.001)
            round_counter += 1
            if round_counter == 200:
                round_counter = 0
                rounds += 1
                print "Round: ", rounds

if __name__ == "__main__":
    main()

http://halvar.at/krimskrams2/schrittmot ... ar_v15.gif
siehe: untere Hälfte des Schaltplanes

Für dieses Programm, müsste man die Eingänge A, B, C und D mit Data1, Data2, Data3 und Data4 des Parallelports verbinden.

Als Schrittmotor wird im Schaltplan ein 24 V Schrittmotor mit mit Mittelanzapfung der Spulen verwendet. Da eine halbe Spule auch nur mit der halben Spannung versorgt werden darf, wird hier mit 12 Volt gearbeitet.

Der Parallelport wird hier mit 6 mA belastet. Das halten sehr alte Parallelports nicht aus. Aber neue Parallelports sollten damit kein Problem haben. Man könnte den Schaltplan ändern, so dass weniger Strom über den Parallelport geht, aber wie man sieht, ist der Schaltplan eigentlich für einen Mikrocontroller gedacht. Man könnte die Widerstände an den Eingängen etwas erhöhen z.B. auf 1200 Ohm. Dann würde weniger Strom (4 mA) über den Parallelport fließen.

Zugehöriger Thread: http://www.loetstelle.net/forum/viewtopic.php?t=2207

Ich habe es nicht ausprobiert. Aber ich bin mir trotzdem sehr sicher, dass der Schrittmotor mit diesem Programm laufen wird.

Und wenn du möchtest, dass der Schrittmotor schneller dreht, dann kannst du von 200 Halbschritten auf 100 Vollschritte umsteigen.

mfg
Gerold


PS: Falls es jemanden interessiert. Die Schaltung ist für so einen Schrittmotor gedacht: http://www.pollin.de/shop/shop.php?cf=d ... Q2OTg2OTk=

.

[gerold]

Das Signal ist 10µsek lang aber dann kommt eine pause um genau auf den Vorschub zu kommen den ich brauche.

Ich habe heute nochmal mit einem Telefoniert (Herr Ostermann, in Deutschald der größte entwickler für Schrittmotoren Steuerungen fürs hobby) der sag das optimale Signal liegt bei 8 µsek.

Hallo Andyh!

Wenn du den Schrittmotor direkt ansteuerst, dann ist nichts mit 8 µs. Eine Signallänge von 8 µs könnte dazu gedacht sein, um einen Schrittmotortreiber (z.B. mit L297 und L298 --> http://www.roboternetz.de/bilder/l298standard.gif) anzusteuern. Aber auch diese Teile arbeiten nicht mit einer Signallänge, sondern reagieren auf Flanken (LOW/HIGH oder HIGH/LOW). Und damit ist es egal wie lang die Signale sind, hauptsache nicht zu kurz, so dass der IC die Flanke erkennen kann.

Und da ich nicht weiß, wie deine Schaltung aussieht, halte ich jetzt den Mund.

mfg
Gerold

[gerold]

Hallo Andyh!

So oder ähnlich, kriegst du einen genaueren Timer hin:
http://paste.pocoo.org/show/88848/

Mit den Wartezeiten habe ich etwas experimentiert. Diese Zahlen gelten nur für meinen Computer. Bei anderen Computern sieht es gleich wieder ganz anders aus.

Die Queue darf nicht mehr als einen Eintrag haben, sonst wird die Sache recht unregelmäßig. Die Queue stellt sicher, dass kein Schritt verloren geht.

Je länger der Intervall, desto genauer läuft das Programm. je länger der Intervall, desto länger kann auch die Wartezeit zwischen den Prüfungen der Zeit sein. Ich habe diese Wartezeit auf ein Zwanzigstel der Intervallzeit eingestellt. Damit fahre ich auf meinem Computer ziemlich genau. Je länger der Intervall, desto weniger wird der Computer belastet.

Intervalle von 8 µs lassen sich damit aber auf keinen Fall generieren. Millisekunden -- Ja. Mikrosekunden -- Nein.

mfg
Gerold

[ChrisGTJ]

Hallo, ich noch mal:

Allein die Tatsache, daß Gerold schreibt: "die Zahlen gelten nur für meinen Computer" zeigt, wie fragil die ganze Sache ist. Was passiert wohl, wenn Du nebenbei ein Filmchen guckst?

Um Leonidas' Vorschlag aufzugreifen: Hast Du schon mal über RTLinux nachgedacht? Kost nix und könnte helfen.

Gruß,

Christoph

[gerold]

zeigt, wie fragil die ganze Sache ist.

Hallo Christoph!

Ganz so problematisch sehe ich die Sache nicht, da es sich ja nur um eine Fräse handeln soll.
Durch das Übergeben der Schritte an eine Queue, gehen keine Schritte verloren. Und wenn eine Fräse den Kopf kurzfristig etwas langsamer bewegt, dann passiert nichts Tragisches. Schlimm wäre nur, wenn der Fräskopf kurz stehen bleiben würde. Das könnte sich nachteilig auf das Werkstück auswirken. Das Ansteuern von Fräsen mit Nicht-Echtzeitbetriebssystemen ist aber kein Problem und hat sich in der Praxis schon längst etabliert.
Und wenn jemand neben dem Fräsen den Computer mit anderen Programmen auslastet, dann ist er/sie meist selber schuld.

mfg
Gerold

[Andyh]

Hallo
@ Gerold
Du hast es erraten ich arbeite mit L297 und L298.
Du schreibst ja "Das Ansteuern von Fräsen mit Nicht-Echtzeitbetriebssystemen ist aber kein Problem und hat sich in der Praxis schon längst etabliert", weis ich habe ich ja selber, nur wie machen die das?

Wenn´s nicht klappt mit dem PC werde ich wohl auf Microcontroller umsteigen. Schaft dann der meine 8µsek?

Achso, Danke für die ganzen hilfen!!!

Gruß
Andyh

[gerold]

hat sich in der Praxis schon längst etabliert", weis ich habe ich ja selber, nur wie machen die das?

Hallo Andyh!

Ganz einfach -- die pfeifen auf diese 8 µs.

Denn es ist einfach nicht notwendig, dieses Signal so kurz zu halten. Ich schrieb ja schon, dass nicht die Länge des Signales entscheidend ist, so lange das Signal nicht zu kurz ist (mindestens 0,5 µs). Das Signal kann sogar mehrere Sekunden lang sein -- der IC reagiert nur auf die Flanken (LOW/HIGH oder HIGH/LOW).

EDIT: Direkt aus dem Datenblatt kopiert:

Step clock. An active low pulse on this input advances the motor
one increment. The step occurs on the rising edge of this signal.

mfg
Gerold

[Andyh]

Hallo

@ Gerold

Erst mal Danke für deine Bemühungen!

Mir kommt da so ein blöder gedanke das ich was Falsch mache.

Ich gebe bis jetzt so Schritte aus:

- Richtungs Port Einschalten
- Warten 10ms
- Tack Port dazu Schalten
- Warten 10ms
- Tack Port wieder ausschalten
- Warten 10ms
- Tack Port dazu Schalten
- Warten 10ms
-usw.

Wenn ich von Signal reden dann meine ich einer dieser Schritte.
Du redes ja immer von Flanken (LOW/HIGH oder HIGH/LOW) das ist schon das gleiche was ich mache?

Ich erhalte jetzt mit 0.001 sek gute ergebnisse. Am besten sind sie wenn ich die ausgabe in einen Thread im Thread lege und dann den Prozess Priorität auf "Hoch" Stelle.

Gruß
Andyh

[gerold]

- Richtungs Port Einschalten
- Warten 10ms
- Tack Port dazu Schalten
- Warten 10ms
- Tack Port wieder ausschalten
- Warten 10ms
- Tack Port dazu Schalten
- Warten 10ms

Hallo Andyh!

Laut Datenblatt, genügt es, wenn du 1 µs wartest, bevor du nach dem Ändern der Richtung (Pin CW/^CCW), das Taktsignal raus lässt. Das bedeutet, dass du praktisch nicht warten musst. Du könntest zur Sicherheit ein ``sleep(0.000001)`` einschieben. Dir muss aber klar sein, dass du damit nicht eine µs, sondern viel länger wartest, da das Betriebssystm so eine kurze Wartezeit nicht timen kann. Aber auch, wenn du damit 2 ms wartest, macht das nichts.

Ausgangssituation herstellen:
- Clock-Pin auf HIGH schalten (weil der Clock-Pin LOW-aktiv ist)
- CW/^CCW-Pin für die Richtung setzen
- mindestens 1 µs warten (``sleep(0.000001)``)

Und das hier ist für **einen Schritt** zu tun:
- Clock-Pin von HIGH auf LOW schalten
- mindestens 1 µs warten (``sleep(0.000001)``)
- Clock-Pin wieder auf HIGH zurück schalten (das ist der Moment, in dem sich der Motor um einen Schritt weiter bewegt)

mfg
Gerold

[gerold]

Hallo Andyh!

Und so würde ich mir so eine Schrittmotorsteuerung vorstellen (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: iso-8859-15 -*-
# nur für Windows

import parallel
import time

# Nehmen wir einfach mal an, dass der Pin Data1 für die Richtung und der
# Pin Data2 für das Clock-Singal zuständig sind. Der Pin Data3 ist für das
# Umschalten zwischen Halbschritt- und Vollschrittmodus zuständig.
DIRECTION_BIT = 1 # Data 1
CLOCK_BIT = 2 # Data 2
HALFSTEP_BIT = 4  # Data 3


def timed_xrange(values_per_second, *args):
    """
    Gibt, wie ``xrange``, eine einstellbare Anzahl an Werten zurück.
    Der Unterschied ist der, dass man angeben kann, wie oft die Sekunde
    ein neuer Wert zurück gegeben werden darf.
   
    :param values_per_second: Gibt an, wie viele Werte maximal in der
        Sekunde zurück gegeben werden dürfen. Bei heutigen Computern wird
        das machbare, halbwegs genaue Maximum in etwa bei 1000 Werte die
        Sekunde liegen (=Spekulation).
    :param *args: Diese Parameter werden an ``xrange`` weitergegeben.
    """
   
    interval_seconds = 1.0 / values_per_second
    sleep_seconds = interval_seconds / 20.0
    if sleep_seconds < 0.0001:
        sleep_seconds = 0.0001
   
    for i in xrange(*args):
        old = time.clock()
        while True:
            new = time.clock()
            if (new - old) > interval_seconds:
                old = new
                yield i
                break
            time.sleep(sleep_seconds)


class MotorInterface(object):
   
    def __init__(self, port = 0):
        # LPT initialisieren und in den Anfangszustand setzen (=vorwärts, halbschritte)
        self.parallel = parallel.Parallel(port)
        self.data = DIRECTION_BIT | CLOCK_BIT | HALFSTEP_BIT
        self.parallel.setData(self.data)
   
   
    def set_forward(self):
        self.data = self.data | DIRECTION_BIT
        self.parallel.setData(self.data)
        time.sleep(0.000001)


    def set_backward(self):
        self.data = self.data | DIRECTION_BIT
        self.data = self.data ^ DIRECTION_BIT
        self.parallel.setData(self.data)
        time.sleep(0.000001)
   
   
    def set_halfstep_mode(self):
        self.data = self.data | HALFSTEP_BIT
        self.parallel.setData(self.data)
        time.sleep(0.000001)
   
   
    def set_fullstep_mode(self):
        self.data = self.data | HALFSTEP_BIT
        self.data = self.data ^ HALFSTEP_BIT
        self.parallel.setData(self.data)
        time.sleep(0.000001)
   
   
    def step(self):
        # Taktsignal auf LOW und warten, damit das Signal sicher akzeptiert wird
        self.data = self.data | CLOCK_BIT
        self.data = self.data ^ CLOCK_BIT
        self.parallel.setData(self.data)
        time.sleep(0.000001)
        # Taktsignal auf HIGH und warten, damit das Signal sicher akzeptiert wird
        self.data = self.data | CLOCK_BIT
        self.parallel.setData(self.data)
        time.sleep(0.000001)

   
def main():
    motor = MotorInterface()
    motor.set_halfstep_mode()

    # 2000 Schritte vorwärts, 500 Schritte die Sekunde
    motor.set_forward()
    old = time.clock()
    for i in timed_xrange(500, 2000):
        motor.step()
    print time.clock() - old # wie lange gedauert?

    # 2000 Schritte rückwärts, 500 Schritte die Sekunde
    motor.set_backward()
    old = time.clock()
    for i in timed_xrange(500, 2000):
        motor.step()
    print time.clock() - old # wie lange gedauert?


if __name__ == "__main__":
    main()

EDIT: Oder so --> http://paste.pocoo.org/show/89096/

mfg
Gerold

[Andyh]

Hallo Gerold

Ist ja mal wieder super wie du sowas erklärst!!!
Meine Hochachtung

Gruß
Andyh

[gerold]

Hallo Andyh!

Eines würde mich, mangels Testaufbau, noch interessieren: Funktionierte der Code, den ich da zusammengewurstelt habe auch in echt, oder nur in meiner Vorstellung?

lg
Gerold

[Andyh]

Hallo

Wird natürlich erledigt, aber erst nach meiner Abschlussprüfung.
Also am Freitag.

Gruß
Andyh
(ohh man morgen schon wieder Prüfung, genau wie heute und übermorgen)