Mit µ sek. Arbeiten

[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)

[Andyh]

Hallo

@Gerold
Test ist bestanden!

Gruß
Andyh