Schrittmotor mit 4bit- Up/Downzähler ansteuern

Hallo,
für ein Bastelprojekt (Motorfokus eines Teleskopes) will ich einen Schrittmotor ansteuern allerdings das ganze ohne PC, sondern nur mit einer Handsteuerbox, d.h. der Motor muss vor und zurückgehen, mit variabler Geschwindigkeit und auch in Einzelschritten. Zwischen dem Schrittmotor und dem OAZ kommt noch ein Getriebe, so dass eine Genauigkeit von 10 µm erreicht wird.
Als Schaltung dachte ich an einen 4bit Up/Downzähler der mit den Motorphasen verbunden wird, für Einzelschritt vor oder zurück lässt sich einfach ein Signal an den passenden Eingang anlegen.
Und für eine kontinuierliche Bewegung wird ein variabler Taktgeber (gibt es so ein Bauteil überhaupt, oder läuft das auf einen Schwingkreis hinaus?) angesteuert, der den Up/Downzähler ansteuert.

Oder gibt es bereits eine solche Schaltung? Bis jetzt habe ich zwar einige Schaltungen für genau diesen Zweck gefunden (Motorfokus), allerdings nur in Verbindung mit einem PC, hier das soll ganz ohne PC ablaufen, sondern nur über Batterie (12V).

Viele Grüße und schonmal Danke,
Mark

Hallo Gast!

Alle deine Überlegungen sind Richtig, bloss ist noch Decoder nötig, damit momentan nur einer von 4 Zuständen aktiv ist. :D

Einfachster digitaler Taktgenerator mit variabler Frequenz lässt sich mit einem Inverter (auch bilibiegen NAND bzw. NOR Gatter) mit Schmitt-Trigger Eingang realisieren (sehe Code).

Code:

---

                  +---+
            R    |  |
          ___  _V_  |
        +-|___|-|___|-+
        |        P  |
        |    |\      |        _  _
        +-----| >O----+-----> _| |_| |_
        |    |/
    C ---
      ---
        |
      ===
      GND

(created by AACircuit v1.28.6 beta 04/19/05 www.tech-chat.de)

---

Alles klar, vielen Dank :).
Eine Frage hätte ich noch, muss die logische Schaltung (Counter und Taktgeber) vom Schrittmotor getrennt werden (Transistoren, Optokoppler etc.), oder kann ich die mit dem Motor belasten?
Könnt ihr mir einen Counter empfehlen, ich habe noch nie zuvor mit diesen gearbeitet.

Es wird sicher direkt, wegen von Motor gebrauchten Strom, nicht gehen. Üblich werden dafür L297/L298 IC's verwendet. Ich würde dir unsere Suche empfehlen, wo du bei 145 Ergebnissen für "Schrittmotor" hoffentlich etwas passendes findest. ;)

Die Kombination L297 / und L298 oder für einen kleineren Motor auch L297 und L293 sollte schon reichen. Der L297 erzeugt die Logic Singnale für einen Schrittmotor und wird mit Signalen für den Takt und die Richtung angesteuert. Bei sehr kleinen Motoren geht es ggf. direkt von einem Logic IC aus, das ist aber die Ausnahme, denn 20 mA bei maximal 5 V reichen selten.

Man kann die Steuerung auch über einen kleinen µC (und vermutlich Treiber dazu) machen, ein ganzer PC muss es nicht sein.

Hi,
danke euch beiden, der Wink mit dem Zaunpfahl zum L297/L298 hat mich auf den RN-Stepp297 gebracht. Damit erspare ich mir den Up/Downcounter und Decoder und brauche "nur" noch den Taktgeber für die kontinuierliche Bewegung. Das Board braucht aber eine Logikspannung von 5V, ist es problematisch wenn ich es nur mit 4,5V betreibe? Oder alternativ 6V mit einem Widerstand?
Klein und sparsam wird der Motor nicht, er muss eine größere Last bewegen (Kamera, OAG, OAZ), allerdings mit einem Getriebe dazwischen (1:6).

Zitat:

---

Zitat von Unregistriert

Das Board braucht aber eine Logikspannung von 5V, ist es problematisch wenn ich es nur mit 4,5V betreibe? Oder alternativ 6V mit einem Widerstand?

---

Ich kenne den RN-Step297 nicht deswegen kann ich nix konkretes über 4,5 V sagen. Wenn aber der Stromverbrauch immer gleich wäre, ist die Idee mit seriellem Widerstand bei 6 V sehr gut, sonst würde ich anstatt dem Widerstand seriell zwei Dioden (normale + Schottky) anschliessen um ca. 1V abfallen zu lassen. Eventuell, falls genug Platz vorhanden, könnte man einen "low drop" Spannungsregler z.B. L4941 anwenden.

Der L297 mag als Versorgung 4,75 bis 7 V. Da passen dann 6 V vermutlich besser. Außer dem L297 und L298 sollte da kein IC weiter drauf sein, dass sich an der Spannung stört. Nur wenn man die Platine zusammen mit einem µC nutzen will, wird man wohl 5 V wählen.

Hallo,

6V sind ok. 4,5V sind sehr wenig. Ich nehme an, du willst Batteiern nutzen. Deren Spannung nimmt dann auch noch mit der Zeit ab.

Für den Taktgeber kannst du einen NE555 nehmen, der hat auch einen weiten Spannungs- und Frequenzbereich. Für den gibt es nahezu undendlich viele Schaltungsbeispiele.

Hi,
ok vielen Dank :).
Als Schaltung habe ich mir die von Wikipedia herausgesucht (https://secure.wikimedia.org/wikiped...ator_mit_NE555) mit dem angegeben 22k Drehpoti und einem 50µF Kondensator.

Wenn ich einen Schrittmotor mit 6 Eingängen an das Board anschließe kann ich doch einfach 2 der Ausgänge (die beiden Mittelabgriffe) des Motors ignorieren?
Und einen Schrittmotor mit 5 Eingängen könnte ich nur anschließen wenn ich es schaffe, den gemeinsamen Mittelabgriff zu entfernen, oder?
Beim RN-Stepp297, wird ein längeres Rechteckmaximum als ein Impuls gezählt oder müssen diese unendlich kurz sein?

Moin,

wurde noch nicht erwähnt: Uni- oder bipolarer Motor?

Bei 5 Anchschlüssen handelt es sich i.d.R. um einen unipolaren Motor, bei 6 meist um einen bipolaren. Die Unterschiede:

Beim unipolaren Motor wird meist nur eine Spule angesteuert. Der gemeinsame Anschluss liegt an der Betriebsspannung, jeweils ein Spulensanschluss wird zur Masse durchgeschaltet. Zum Steppen wird dann jeweils die nächste Spule eingeschaltet (Varianten: *High-Torque-Steuerung: jeweils zwei Spulen in Betrieb; *Halbschrittsteuerung: abwechselnd eine und zwei Spulen in Betrieb; *dann kann man noch die "gegenüberliegende Spule" an eine negative Spannung anlegen (ist aber aufwändig in der Schaltung)).

Zur Ansteuerung eines unipolaren Motors braucht man eigentlich keine H-Brücke, wie sie der L298 enthält. Das geht einfacher! Wenn man mit 30V und 1A auskommt reicht z.B. ein ULN2803.

Beim bipolaren Motor werden die Spulen abwechselnd in unterschiedlicher Polung (eben bipolar) angesteuert. Wenn die Spulen Mittelanzapfungen haben, kann man den Motor auch wie einen unipolaren ansteuern. Das ist einfacher, aber man verliert Drehmoment.

Ich mache gerade etwas ähnliches. Ich will eine Handfräse zu einer CNC-Fräse umbauen. Hier zu habe ich folgendes gemacht:
Ein Joystick http://www.conrad.de/ce/de/product/4...archDetail=005 wird über einen kleinen Mikrokontroller ATmega- oder ATtiny-irgendwas per ADC ausgelesen ausgelesen. Je nach Stellung werden Impulse mit unterschiedlicher Frequenz erzeugt. Die dienen wiederum dazu den Motor anzusteuern. Wenn du genaueres über deinen Motor verrätst, würde ich dir ein Programm fertigmachen oder auch einen Chip präparieren. Du müsstest nur den Chip (3-5,-EUR) plus das Porto zahlen. Wenn du Interesse hast, schick mir eine E-Mail.

Hast du überhaupt schon einen Motor?

Viele Grüße
Red Baron

Hi,
danke für das Angebot, wie genau lässt es sich denn steuern, denn ich brauche auch Einzelschrittsteuerung und eine variable Schrittfrequenz bis sehr schnell (sorry für die ungenaue Angabe, die Angaben zur Timerschaltung vorher könnten doch evtl. zu einer zu langsamen Drehung führen, ich rechne das nochmal durch (hab noch ein 1:10 Getriebe dazwischen was ich vergessen habe)).

Zu den Schrittmotoren, ich habe hier drei 5polige unipolare Motoren, und drei bipolare (zwei mit 4 Anschlüssen ohne Datenblatt, und einer mit 6 Anschlüssen: http://www.landaelectronic.com/datasheet/4H4.pdf (der 2015er).
Im Datenblatt zum RNStepp297 stand, man kann keine unipolaren Motoren damit ansteuern

Moin,

wenn ich das richtig sehe, handelt es sich bei beiden um bipolare Motoren (15V; 0,5A). Die kannst du mit dem RNStepp297 super ansteuern. Beim "Sechser"-Motor werden die Mittelanzapfungen (im Datenblatt mit "BRO" bezeichnet) nicht angeschlosen.

Zur Stromversorgung: Die Motoren benötigen 15V. Wenn du mobil sein willst, kommen hier nur Akkus in Frage. Dann kannst du die 5V über einen 7805 bekommen. Den kannst du "nackt" benutzen (d.h. ohne weitere Zusätze), der RNStep297 hat bereits Siebkondensatoren. Die sollten reichen, um die Störungen durch den Motor zu neutralisieren. Alternative wäre eine Versorgung über ein Netzteil. Auch dann kannst du einen 7805 nehmen, musst aber ein Bisschen in die Siebung investieren (je nach Art des Netzteil mehr oder weniger).

Zum Takt: Bevor du dir eine Schaltung überlegst, müsstest du zunächst einmal ausprobieren, wie schnell die Motoren überhaupt maximal getaktet werden können. Die, die ich habe, haben eine maximale Schrittfrequenz von etwa 50 Schritte/sec (+/- je nach Last und Betriebsart). Bei 1,8° pro Stepp wären das 0,25 Umdrehungen /Sec. Ich nehme an, deine Motoren werden in etwa in der gleiche Größenordnung liegen. Vielleicht etwas höher, da bipolare Motoren ein höhers Drehmoment haben und deine Motoren einen größeren Strom vertragen. Ich denke aber, dass du nicht deutlich über 1/sec hinaus kommen wirst. Hierauf musst du die Dimensionierung des Taktgebers abstimmen.

Zur Takterzeugung: Du benötigst einen Taster für den Einzelstepp (inkl. Entprellung), einen variablen Taktgeber für den kontinuierlichen Betrieb, einen Schalter für die Richtungsangabe. Wenn man das in "Elektronik gießt" kommen schon einige Teile zusammen. Die Bedienung ist dann auch noch kompliziert und fehleranfällig, weil man immer zwei Tatster/Schalter/Regler bedienen muss, Richtung und Speed.

Ich würde das alles -wie bereits gesagt- mit einem Mikrochip machen. Mit folgender Beschaltung:
Taster für Einzelschritt vorwärts, Taster für Einzelschritt rückwärts, Joystick für kontinuierlichen Lauf vor- und rückwärts (nur eine Achse belegt). Der Joystick hat den Vorteil gegenüber einen Schieberegler, dass er von allein in die neutrale Mittelstellung zurückschnappt. Alternative zu den beiden Tastern wäre ein einzelner Wippschalter. Ein ATtiny45 z.B. wäre vollkommen ausreichend. Weiterer Vorteil: die Schaltung ist so einfach, dass sie auf einer kleinen Lochrasterplatine aufgebaut werden kann und weniger als 10,- EUR kostet.

Viele Grüße
Red Baron

Hallo!

Zitat:

---

Zitat von RedBaron

wurde noch nicht erwähnt: Uni- oder bipolarer Motor?

Bei 5 Anchschlüssen handelt es sich i.d.R. um einen unipolaren Motor, bei 6 meist um einen bipolaren.

---

Das ist Unsinn. Bipolare Motoren haben 4 Anschlüsse, unipolare in der Regel 6, manchmal auch 5. Bei Motoren mit 8 Adern könnte man sich darüber streiten, wo die einzuordnen sind, aber i.d.R. bezeichnet man die auch als bipolare Motoren. Unabhängig davon kann man unipolare Motoren mit 6 Anschlüssen natürlich bipolar betrieben. Zu beachten ist dann allerdings, dass man den Strom um den Faktor 0,7 reduzieren muss:
http://www.schrittmotor-blog.de/?tag=unipolar

Mit freundlichen Grüßen
Thorsten Ostermann

Hi,
ich habe mir den Schaltplan so wie ich es vorhatte (4 Schalter für Richtung sowie Einzelschritt/Kontinuierlicher Lauf, ein Poti für die Geschwindigkeit) und er ist recht groß.
Das Problem bei Mikrocontrollern ist, dass ich keine Möglichkeit habe sie zu beschreiben.
Wenn ich das ganze über den Joystick mache, kann man die Geschwindigkeit abhängig von der Auslenkung nach oben/unten machen, und nach rechts und links Einzelschritt (unabhängig von der Auslenkung)?

Viele Grüße,
Mark

Hallo Mark,

ja klar. Genau das ist der Trick. Die meisten µCs haben einen sog. A/D-Wandler, praktisch einen Spannungsmesser. Ein Joystick ist nichts anderes als zwei im rechten Winkel angeordnete Potentiometer. Allerdings mit einer Vorrichtung, die sie in die Mittelstellung zurückschnacken lassen. Übliche Joysticks haben 10-20 kOhm. Die kann man also direkt an die Versorgungsspannung legen. Mit dem ADC misst man dann die Spannung am Schleifer. Was man dann mit dem Messwerten macht: Alles was man programmieren kann.

Je nach dem was man genau machen will, ist es ungünstig Einzelschritte mit einem Joystick zu erzeugen. Da wären Taster besser.

Noch einmal zur Sicherheit: Du hast genau einen Motor, den du steuern willst, zur Fokuseinstellung?

Frage: Mobil oder Stationär? Also Akku oder Netz? Bei Akku musst du bedenken, dass Schrittmotore -wenn man keine Vorrichtung trifft- immer unter Strom stehen. Die Akkus sind dann schnell leer. Benötigt dein Teleskop eine "Haltekraft"? Wenn nicht kann man den Motor nach erfolgter Drehung ausschalten (der RN-Stepp297 lässt das zu).

Ein möglicher Schaltplan könnte so aussehen.Anhang 18964 Ist doch recht übersichtlich, oder?

... und wie gesagt, ich würde dir solch ein Ding fertig machen (auch zwei).

Viele Grüße
Red Baron

Nachtrag1: Man muss nicht unbedingt einen Joystick benutzen. Ein Schiebe- oder Drehpotemtiometer geht natürlich auch. Praktisch ist, wenn man es durch Federn, Gummis o.ä. in der Mittelstellung fixiert.

Nachtrag2: Je nach Vorliebe kann man auch auf die Taster verzichten. Folgender Vorschlag (auf ein Drehpoti bezogen): ein Drehpoti hat insgesamt 270° Drehwinkel, von der Mittelstellung aus: 135° in jede Richtung.

• bis +/-15°: Ruhestellung, nichts bewegt sich

• bis +/-45°: (quasi) Einzelstepp: sehr langsame Stepps (1..2/Sec), so dass man jederzeit steppgenau aufhören kann.

• bis +/-60°: langsame Einzelstepps: 3..5-fache Geschwindigkeit wie vorher

• ab +/-61 bis +/-135°: Anstieg der Stepprate bis zur Endgeschwindigkeit. Anstieg exponentiell oder quadratisch.

Nachtrag3: Wahrscheinlich wäre auch ein optische Anzeige ganz nett. Rote LED für Rechtslauf, Grün für links. LED geht bei jedem Takt kurz aus, damit man einen Eindruck für die Stepprate erhält.

Zitat:

---

Zitat von Unregistriert

Oder gibt es bereits eine solche Schaltung? Bis jetzt habe ich zwar einige Schaltungen für genau diesen Zweck gefunden (Motorfokus), allerdings nur in Verbindung mit einem PC, hier das soll ganz ohne PC ablaufen, sondern nur über Batterie (12V).

Viele Grüße und schonmal Danke,
Mark

---

Schaue Dir einmal den cmos 4060 an.
http://www.google.com/imgres?imgurl=...ed=0CB8Q9QEwAg noch ein Motortreiber L 239D http://www.google.com/imgres?imgurl=...ed=0CBsQ9QEwAA in dem IC sind 2 Treiber so das auch Schritt Motore betrieben werden können.

Gruß Richard

Hi,
wow, danke Redbaron :). Die Schaltung ist wirklich einfach, ich kann ja meine in vorzeigbare Form bringen und verlinken.
Die Idee mit dem Joystick finde ich besser als mit dem Drehpotentiometer.
Ja, ich hab genau einen Motor, der über ein simples Getriebe mit dem OAZ verbunden wird.
Die Stromversorgung läuft wenn ich mobil unterwegs bin über einen Akku (12V, allerdings sehr kräftig, d.h. hochregeln für den Motor ist kein Problem) und wenn nicht, dann über ein 12V Netzteil.
Wie lange können die Tinys ohne Stromversorgung überleben ohne die Programmierung zu vergessen.
Der Schrittmotor müsste nur kurzzeitig halten, am OAZ ist eine Schraube mit dem man den Fokus fixieren kann, bis ich den Strom abschalte.
Beim Joystick, lässt sich dieser nur nach oben/unten und link/rechts bewegen, oder auch im Kreis, oder kann man die unbelegte Achsen blockieren.
Was spricht eigentlich genau gegen Einzelschritt rechts/links?

Nochmal Danke und viele Grüße,
Mark

Moin,

das ist ja eine Menge Input...

Es gibt da übrigens einen etwas älteren Thread zu diesem Thema: https://www.roboternetz.de/community...p-motorisieren

Bei den üblichen µCs befindet sich das Programm in einem Flash-Speicher. Das ist die gleiche Technologie wie sie z.B. bei USB-Sticks, SD-Karten, Solid-State-Disks etc. benutzt wird. Man spricht von 10 Jahren Speicherdauer. Konkrete Herstellerangaben hab ich auf die Schnelle nicht finden können. Ich denke aber, 10 Jahre sind für diese Chips die Untergrenze. Schließlich werden die Dinger auch in Produkte eingebaut, die länger als 10 Jahre halten sollen.

Zum Haltemoment: Bei Akku-Betrieb können der Motor nicht permanent eingeschaltet bleiben.
Variante 1: Du schaltest das gesamte Gerät an und aus, bevor/nachdem du die Schraube fest-/losdrehst. Ziemlich unbequem. Wenn der Motor dreht, bevor die Schraube gelöst ist, kann das Schäden geben. Mit Getriebe haben die Motoren eine ganz schöne Kraft. Weiterhin gibts beim Ein- und Auschalten immer unschöne Zustände. Der Kontroller weiß nicht wo genau der Motor steht und wird ihn in die Grundstellung drehen, also um 0, 1 oder 2 Schritte, je nachdem wie der Motor aktuell steht.
Variante 2: Das Gerät bleibt die ganze Zeit an. Der Stromverbrauch ist minimal (einige mA max.). Du nutzt einen zusätzlichen Schalter/Taster mit dem du den Motor an und abschalten kannst. Das löst das Problem des undefinierten Zustands, aber nicht das mit der angezogen Schraube beim drehenden Motor. Außderdem brauchts du ein weiteres Bedienelement.
Variante 3: Du schaltest den Motor einfach nach erfolgter Drehung aus. Die Reibung im Getriebe sollte verhindern, dass sich noch etwas bewegt. Wenn doch: Reibung durch Schleifer erhöhen. Und zwar an der motorseitigen Seite vom Getriebe. Dann benötigt man nur eine kleine Rebung, weil die durch das Getriebe hochgesetzt wird. D.h. die Nutzung der Feststellschraube wäre nicht notwendig.

Zum Joystick: Biedenelemente sind geschmacksache. Ein Joystick ist optimal für X/Y-Steuerung. Er hat die Vorteile: 2 Achsen, automatische Mittelstellung. Das wars aber auch. Die Steuerung erfolgt erfolgt meist durch visuelle Rückkopplung. D.h. man sieht Abweichungen vom Soll und regelt die intuitiv mit den Fingern nach. Das klappt bei "normalen" X/Y-Anwendungen auch recht gut.
Du hast keine X/Y-Anwendung. Wenn du den Joystick nicht genau nach rechts/links oder oben/unten bewegst, also z.B. diagonal, muss man stest entscheiden, was denn nun gemeint ist. Das ist kompliziert und fehleranfällig.
Ein Joystick hat auch nur einen Drehwinkel von rd. 90°, also 45° in jede Richtung.
Ein Joystick lässt sich in alle Richtungen bewegen (auch im Kreis, wenn man will). Ein Achse kann man mechanisch blockieren, z.B. in dem man die Achse durch einen Schlitz führt, aber auch elektrisch, indem man eine Achse nicht anschließt.

Je länger ich darüber nachdenke, desto besser gefällt mir persönlich die Lösung mit dem 3-Zonen-Potentiometer. Entweder als Schiebregler oder als Drehpoti.
Schieberegler: Muss leichtgängig sein. Man muss längere Schraubenfedern einsetzen, damit man bei der Auslenkung nicht zuviel Kraft aufwenden muss. Bedienung ist dafür sehr intuitiv.
Drehpoti: das könnte man mit einer einfachen Feder wie in der Abb. in Mittelstellung bringen:Anhang 19000

Viele Grüße
Red Baron

Hi,
ok, danke für die lange Antwort.
Nach der Haltbarkeit der Programmierung habe ich gefragt, weil es relativ lange Perioden mit schlechten Wetter geben kann in der die Schaltung ohne Strom ist, aber wenn der Speicher 10< Jahre hält, ist das kein Problem :).

Die Steuerelektronik plante ich über eine Steckverbindung mit dem Motor der am OAZ befestigt zu verbinden, d.h. nach der Fokussierung wird der Motor abgesteckt, der OAZ festgeschraubt und die Schaltung ausgeschaltet, fokussiert wird ein bis zwei Mal höchstens in der Nacht.

Gegen Schäden kann ich noch eine Rutschkupplung einbauen (Link).

Um nochmal zum Joystick zurückzukommen, man könnte doch eine kleine Schablone aus dünnem Blech anfertigen (Kreuzform), sodass man nur eine der beiden Achsen bewegen kann.

Ich persönlich favorisiere den Joystick als Bedienelement, auch wenn nur eine Achse in benutzung ist, aber wie du sagtest, das ist Geschmackssache.

Viele Grüße und nochmal danke,
Mark

Moin,

wie gesagt, ich habe keine Ahnung von Teleskopen. Warum macht man das so aufwendig, das mit dem An- und Abstecken? Warum überhaupt einen Motoratrieb? Ist da eine Handeinstellung nicht einfacher? Würde mich schon 'mal rein interessehalber... Hast du vielleicht eine Abb. wie so ein OAZ aussieht?

Schablone ist gut. Muss man beim Knopf für den Hebel am Joystick ein wenig aufpassen. Der bewegt sich auf einer Kugelschale, da muss genügend Spiel bleiben. Sollte aber kein Problem sein.

Noch einmal zum Einzelschritt (Joystick rechts/links): Auslenken => 1 Schritt. Für den nächsten Schritt erst wieder zurück zur Mitte. Oder: Auslenken => Schritte mit langem Abstand.

Zum kontinuierlichen Betrieb (Joystick auf/ab): Auslenkung => konstante Schrittrate? Oder Schrittrate proportional zur Auslenkung? Oder Schrittrate quadratisch zur Auslenkung? Wie viele Schritte pro Sec maximal?

Wenn o.g. Dinge klar sind, fasse ich alles noch einmal zusammen und mache "eine Zeichnung".

vg
Red Baron

Hi,
ok, vielen Dank.
Das ganze sieht etwa so aus: Teleskop

Das Abstecken ist zur Reduktion des Kabelsalats (zwei Kameras die am OAZ befestigt sind und pro Kamera 2 bzw. 3 Kabel) und weil ich so wenig Gewicht am Teleskop haben will wie möglich (ok, zugegeben, die Schaltung mit Kästchen wiegt wirklich nicht viel).

Den Motor selbst lasse ich am OAZ befestigt, nur wird er von der Handsteuerbox ausgesteckt.
Bei den kommerziellen Motorfokussierern erfolgt die Verbindung zwischen Motor und Steuerbox auch über an- und absteckbare Kabel. Wäre auch beim Transport einfacher, sonst müsste man jedesmal den Motor umständlich abschrauben.
So schaut der OAZ aus den ich habe: Bild
Hier ist nochmal das Funktionsprinzip kurz erklärt: Wikipedia
Der Motor wird statt des Drehknopfes auf der linken Seite befestigt.
Mit dem Motorfokus kann man einfacher und exakter Fokussieren als mit der Hand, da man bei jeder Berührung mit dem Teleskop Schwingungen auslöst die sich auch auf das Bild auswirken, und wenn das eingestellte Objekt quer durchs das Blickfeld wackelt ist das fokussieren recht langwierig und schwer.

Beim Einzelschritt dachte ich pro Auslenkung ein Schritt, ein Schubser nach links, ein Schritt zurück, ein Schuber nach rechts, ein Schritt vor, allerdings mit einer genügend großen Deadzone.

Und bei der kontinuierlichen Bewegung die Geschwindigkeit proportional zur Auslenkung bis max. 40 Schritte pro Sekunde.

Wie sieht es mit den Bauteilen aus, ich bestelle die Tage noch ein paar andere Bauteile die ich noch brauche, soll ich dann die passenden µC und den Joystick mit bestellen und dir zuschicken?

Nochmal vielen Dank für alles,
Mark

Hallo Mark,

vielen Dank für die Erläuterung. Jetzt hab ich's einigermaßen verstanden.

Den µC habe ich hier. Da ist das hin- und hersenden zu aufwändig. Den Rest must du dir selbst besorgen. Bei den Joysticks gibt es verschiedene Ausführungen. Mit und ohne Schalter, verschiedene Ausführungen des Hebels. Achte auf verpolungssichere Stecker! Für den Motor und den Akku! Denk auch an einen Spannungsregler (7805), damit du aus den 12V die 5V für die Elektronik ableiten kannst.

Ein ATtiny45 kostet bei Conrad 2,23 EUR. Das würde ich dir auch berechnen (+Porto, Großbrief glaube ich). Übers Wochenende fasse ich noch einmal alles zusammen, was ich verstanden habe.

vg
Red Baron

Nachtrag1: Eine IC-Fassung (DIL bzw. DIP mit 8 Pins) wäre auch nicht schlecht. Dann kann man den Chip austauschen, wenn irgendetwas geändert werden soll.
Nachtrag2: Der Chip hat 6 I/O Leitungen. 4 werden benutzt (2x Joystick, CW/CCW, Clock). Da sind noch 2 frei. Man könnte zusätzlich LEDs zur Richtungs- oder Step-Anzeige anschließen. Oder zusätzlich einen Clock-Ausgang mit quadratischer oder exponentieller Kennlinie programmieren. Den könntest du dann alterniv als Clock-Signal nutzen. Oder man könnte auch einen Clock-Ausgang mit 60 Pulsen max. programmieren. Oder ... Such dir etwas aus.

Eine recht einfache Schritt Motorsteuerung, umschaltbar auf verschiedene Schrittarten. In ein eprom die Schrittfolgen in verschiedenen Bänken ablegen. Die Bänke (voll, Halbschritt u.s.w) mittels einfachen Umschalter wechseln und das eprom Zyklisch auslesen. Das klappt auch ohne Prozessor, Tacktgeber und Zähler reichen. So habe ich es zu Anfänger Bastelzeiten einmal gemacht. :-)

Gruß Richard

... und du meinst, das wäre einfacher? :confused:

Beim Motor mit 6 Anschlüssen: Ich habe übrigens noch einmal über den Hinweis von Thorsten Ostermann nachgedacht. Insbesondere darüber, dass bei diesen Motoren sich die Spannungs- und Stromangabe auf den unipolaren Betrieb bezieht. Da dur nur 12V Betriebsspannung hast musst du den Motor unipolar betreiben. Beim bipolaren Betrieb müsstest du die 1,4-fache Spannung einsetzen. Bei einem 15-V-Motor wären das 21V. Davon bist du weit entfernt. Vielleicht kann Thorsten hierzu noch einmal ein Statement abgegen.

Für den unipolaren Betrieb -insbesondere, wenn der Strom nicht zu groß ist-, ist es nicht notwendig, eine aufwändige H-Brücke, wie den RN-Stepp297, zu betreiben. Das geht einfacher! Es reicht ein ULN2803. Den kann man wie folgt anschließen: Anhang 19019 Die Eingänge kann man dann direkt durch den µC ansteuern. Einen UNL2803 hätte ich noch da. Habe einmal 5 bestellt aber nur drei für meine Fräse gebraucht.

vg
Red Baron

Hallo!

Zitat:

---

Zitat von RedBaron

Beim Motor mit 6 Anschlüssen: Ich habe übrigens noch einmal über den Hinweis von Thorsten Ostermann nachgedacht. Insbesondere darüber, dass bei diesen Motoren sich die Spannungs- und Stromangabe auf den unipolaren Betrieb bezieht. Da dur nur 12V Betriebsspannung hast musst du den Motor unipolar betreiben. Beim bipolaren Betrieb müsstest du die 1,4-fache Spannung einsetzen. Bei einem 15-V-Motor wären das 21V. Davon bist du weit entfernt. Vielleicht kann Thorsten hierzu noch einmal ein Statement abgegen.

---

Bei unipolaren Motoren beziehen sich die technischen Daten auch auf den unipolaren Betrieb. Wenn man so einen Motor bipolar betreibt, muss man den Strom entsprechend reduzieren. Die Motornennspannung erhöht sich dann prinzipiell. Das spielt aber nur dann unmittelbar eine Rolle, wenn man eine Endstufe ohne Stromregelung einsetzt. Indirekt reduziert das natürlich die Dynamik im oberen Drehzahlbereich. Ein Motor mit einer hohen Nennspannung (12V oder 24V) ist daher grundsätzlich keine gute Idee.

Mit freundlichen Grüßen
Thorsten Ostermann

Hi,
um nochmal auf den Schrittmotortreiber zurückzukommen, ich hab zwei andere gefunden:
http://www.aaroncake.net/Circuits/stepper.asp
und den hier:
http://www.watterott.com/index.php?p...duct&info=1083

Der letzte hat den Vorteil, dass er auch 5V Logikspannung liefert mit der man die Steuerung betreiben kann, allerdings ist er ausverkauft.

Hm, zu den übrigen Ausgängen, vielleicht an einem ein exponentielle Kennlinie und an die andere einfach eine LED die leuchtet wenn sich der Motor bewegt, sei es Einzelschritt oder kontinuierlicher Lauf.

Nochmal danke und viele Grüße,
Mark

Hallo Mark,

die beiden Controller haben in etwa die gleiche Funktion, wie der RN-Stepper. Beide brauchen einen externen Clock-Generator. Den von aaroncake musst du ohne Platine zusammenlöten, der andere ist nicht lieferbar ... Ich glaube, das sind beides keine wirklichen Alternativen.

Ich habe einmal zwei Schaltpläne gezeichnet. Der erste zur Ansteuerung eines Steppercontrollers, wie den RN-Stepper. Nach dem Motto so einfach wie möglich: Anhang 19041

• Spannungsregler zur Erzeugung der 5V. Mit der kann man auch den Steppercontroller betreiben.
• Anschlus eines Joysticks.
• LED zur Betriebsanzeige.

Der zweite Plan brauch keine zusätzlichen Elemente. Er ist auch so einfach, dass man ihn problemlos auf einer Lochrasterplatine auflöten kann.Anhang 19042

• Spannungsregler, so dass er mit 12V betrieben werden kann.
• Anschluss eines Joysticks.
• Zwei LEDs zur Betriebsanzeige.
• Treiber für den Schrittmotor (hier geht nur die unipolare Variante)
• JP1 dient zur Umschaltung zwischen proportionaler/exponentieller Kennlinie. Es sind noch Pins frei, man könnte weitere Optionen einbauen.

Du wirst bemerkt haben, dass ich hier einen anderen Chip benutzt habe. Der ist etwas leistungsfähiger, aber kaum teurer (ca. 3,10 EUR). Man könnte auch bei der ersten Variante einen anderen Chip nutzen. Dann könnte man weitere Bedien- oder Sichtelemente betreiben.

Zum Verhalten des Systems:
Joystick (hat übrigens +/-30°, ich habe noch einmal nachgeschaut):
Joystick nach recht, min. 2/3 Vollauslenkung -> Einzelstep CW, danach muss er mindestens auf 1/3 zurückgenommen werden, bevor ein weiterer Step möglich ist. Joystick nach links analog mit CCW. Links und rechts hängt davon ab, wie du das Teil anschließt. Wenn du die Seiten vertauschst, verstauschst du auch rechts/links und damit CW/CCW.
Joystick nach oben. Kleine Totzone, danach kontinuierlicher Anstieg der Steppfrequenz CW. Joystick nach unten: analog. Hier gilt bei Seitenvertauschung das gleiche.
Du kannst auch recht/links mit oben/unten tauschen, wenn das die Bedienung erleichtert.
Zur Totzone: die Stelle ich mir wie folgt vor. Anhang 19043 Der Kreis ist der "Aktionsradius" des Joystick. In den weißen Zonen passiert nichts. Grün Einzelstepp, rot kontinuierlich. Die Totzone ist asymetrisch, weil du für den Einzelstepp 2/3 bzw. 1/3 Auslenkung benötigst.

LED:
Bei jedem Stepp geht sie kurzeitig an. Helligkeit wird mit dem Widerstand geregelt. 220 Ohm ist sie recht hell (das kann in der Dunkelheit störend sein), 390 oder 470 Ohm sind dunkel, bei 560 oder 680 Ohm glimmt die LED nur noch. Aber das hängt sehr von der LED ab. Muss man ausprobieren. Bei zwei LEDs kann man verschiedene Farben für CW/CCW nehmen.
Du kannst bei beiden Varianten noch eine LED über einen Widerstand von Plus nach Minus anschließen, dann hast du eine Betriebsanzeige.

Ich kann die zweite Variante empfehlen. Ich habe sie selbst für meine Fräse im Einsatz. Details hierzu demnächst auf meiner Hompage. Erste Eindrücke: http://bienonline.magix.net/public/mf70-umbau.html

Viele Grüße
Red Baron

Hi Redbaron,
wow, nochmal danke.
Von den beiden Versionen finde ich die erste, einfachere besser, an Sicht- und Bedienelementen völlig ausreichend. Außerdem hat sie den Vorteil, dass man damit (je nach Controller) bipolare und unipolare Motoren antreiben kann.

Die Deadzone des Joysticks finde ich perfekt so, die LED kriegt einen Widerstand von 470 Ohm.
Schick mir eine PM, dann überweise ich die Kosten :).

Vielen Dank und viele Grüße,
Mark

Hi,
noch was zu den Treibern, der Easydriver ist wieder erhältlich und ich habe mir gleich einen geordert.
Viele Grüße,
Mark

sorry für die späte antwort. ich mach dir einen chip übers wochende fertig. melde mich dann.

Moin,

hat ein wenig länger gedauert. Ich hatte bei der Umsetzung der Kennlinien einen "Knoten im Kopf".

So sieht es jetzt aus: Anhang 19104

Die rote Kennlinie ist nicht exponentiell sondern quadratisch. Bei einer exponentiellen Linie, wäre im unteren Bereich zu wenig Dynamik vorhanden. Grund ist die notwendige Diskretisierung. Man hätte zwar mit feineren Schritten arbeiten können, jedoch passt dann die Relation Genauigkeit der Schrittfrequenz, Genauigkeit Ermittlung der Joystick-Stellung, Präzision der Joystick-Führung und Programmaufwand nicht mehr zueinander. Eine quadratische Kennlinie ist ein guter Kompromiss.

Das Programmteil zur Ermittlung der Joystick-Stellung liefert für den kontinuierlichen Bereich Werte zwischen 1 und etwa 112. Diese werden umgsetzt in Schrittfrequenzen zwischen 2 und etwa 41.

Fortsetzung folgt...

... Fortsetzung.

Den Schaltplan habe ich ein ein wenig anpassen müssen: Anhang 19107

Zum einen sind zwei Abblockkondensatoren notwendig. Das Einschalten der LED hätte sonst zu großen Einfluss auf die Messwerte des ADC. Dies führt beim Übergabg von Zone "Weiß" zu "Rot" (s.u.) zu unangenehmen Schwingungen. Der eine Kondensator muss möglichst nahe an den Stromversorgungspins des Chips angberacht werden, der andere mögichst nahe am Joystick.

Zum anderen ist es deutlich einfacher, die Kennlinien alternativ anstatt gleichzeitg zu erzeugen. Der Pin "P/Q" schaltet zwischen beiden Kennlinien um. Ist der Pin nicht angeschlossen, wird die quadratische Kennlinie realisiert. Ist er mit GND verbunden, die lineare.

+5V und GND bekommst du von der Driver-Platine. "DIR" und "STEP" entsprechen den gleichnamigen Pins auf der Driver-Platine. Die Pulslänge für "STEP" ist ca. 0,25 ms.

Fortsetzung folgt ...

...Fortsetzung.

Die Steuerung erfolgt über einen Zustandsautomaten, der auswertet, in welchen Zonen sich der Joystick befindet: Anhang 19108

• Weiß ist die neutrale Zone. Hier passiert nichts.
• Blau ist die Fehlerzone. Wird diese betreten, stoppt alles. Man muss erst wieder nach Weiß bevor es weitergeht.
• Rot ist die eine kontinuierliche Zone.
• Rosa die andere in die entgegengesetzte Richtung.
• Orange führt zu einem Einzelschritt. Danach muss zurück nach Weiß um ein weiteren Schritt auszulösen. Ob über Blau oder Gelb ist egal.
• Gelb hat keine Funktion, trennt aber Orange von Weiß.
• Violett analog zu Orange für die entgegengesetzte Richtung.
• Grün analog zu Gelb entgegengesetzte Richtung.

Die Grenzen Weiß/Gelb/Orange bzw. Weiß/Grün/Violett liegen jeweils auf etwa 1/3 des Joystick-Ausschlags.
Die Grenzen Weiß/Rot bzw. Weiß/Rosa liegen bei 1/6 des Ausschlags.

Fortsetzung folgt...

...zuletzt der Code.

Mark, ich melde mich noch einmal per E-Mail bei dir.

Code:

---

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

//**************************************************************
//Hardware-Konfiguration ATtiny45
//**************************************************************
#define LRChannel 2    // ADC für Links/Rechts-Poti
#define UDChannel 3    // ADC für Auf/Ab-Poti

#define PORT      PORTB  // I/O-Port Output-Register)
#define DDR      DDRB  // Data Direction Register
#define PIN      PINB  // I/O-Port (Input-Register)

#define PIN_DIR  _BV(2) // Pin für Richtungsausgabe (Direction, CW/CCW)
#define PIN_CLK  _BV(0) // Pin für Takt-Ausgabe
#define PIN_QUAD  _BV(1) // Pin für Kennlinie (linear, quadratrisch)
#define PIN_LED  _BV(5) // Pin für LED-Anzeige


//**************************************************************
//*** Daten des Joysticks
//**************************************************************
//Mittelstellung liegt bei einem Messwert von etwa 128 (+/-10)
//Minimum bei 3 (der Unterschied zu 0 ist vernachlässigbar)
//Maximum liegt bei 255
//**************************************************************
uint8_t LRZero = 0;  //Null-Wert für LR-Kanal
uint8_t UDZero = 0;  //Null-Wert für UD-Kanal
uint8_t LR = 0;      //aktueller Messwert LR-Kanal
uint8_t UD = 0;      //aktueller Messwert UD-Kanal

//**************************************************************
//*** Definitionen der Zonen
//**************************************************************
typedef enum
{ green,  //beginnt bei etwa 1/3 des Ausschlags (128/3 = ca. 42, also 128-42=86, Nullpunktkorrektur nicht notwendig)
  violett, //beginnt bei etwa 2/3 des Ausschlags (44)
  yellow,  //beginnt bei etwa 1/3 des Ausschlags (170)
  orange,  //beginnt bei etwa 2/3 des Ausschlags (212)
  red,    //beginnt bei etwa 1/6 des Ausschlags (1/8 = UDZero + 16 (Nullpunktskorrektor notwendig))
  pink,    //beginnt bei etwa 1/6 des Ausschlags (1/8 = UDZero - 16 (Nullpunktskorrektor notwendig)) 
  white,  //endet bei etwa 1/3 des LR-Ausschlags und 1/6 des UD-Ausschlags (s.o.)
  blue    //der Rest
} Zones;

// Beginn (ADC-Wert) der Zonen:
#define StartGreen    86
#define StartViolett  44
#define StartYellow  170
#define StartOrange  212
#define StartContZone  16

//**************************************************************
//*** Globale Variablen
//**************************************************************
volatile int8_t  Direction = 0;  // Richtung der Drehung (-1: links, 0: Stopp, 1: rechts) für kontinuierlichen Takt
volatile uint16_t LedCnt    = 0;  // ISR zählt auf 0 und schaltet dann LED aus.
volatile uint8_t  OldSpeed  = 0;  // Merker für alte Geschwindigkeit (0 falls vorher Stopp)
volatile uint16_t OvfsCnt  = 0;  // Zähler für Geschwindigkeit. ISR zählt auf 0 und startet dann wieder mit OvfsFill.
                                  // Bei 0 wird jewiels ein Taktimpuls von 0,256 ms Dauer erzeugt.
volatile uint16_t OvfsFill  = 0;  // Nach Ablauf einer Zählperiode wird wieder bei diesem Wert gestartet.


//**************************************************************
//*** Prototypen
//**************************************************************
uint8_t readADC(uint8_t channel);            // ADC auslesen
Zones  GetZone(void);                      // Zone ermitteln in der der Joystick steht
void    HandleZones(void);                  // Statemachine für den Joystick
void    DoSingleStep(int8_t Direction);      // erzeugt einzelnes Clock-Signal
void    SetSpeed(uint8_t Speed, int8_t Dir); // ermittelt die Timer-Paramter bei kontinuierlichem Takt

inline void LedOn(uint16_t ms)              // Schaltet die LED für ms Millisekunden an
{ cli();
  LedCnt = ms * 4;
  sei();
}

inline void LedOff()                        // Schaltet die LED vorzeitig wieder aus
{ cli();
  LedCnt = 0;
  sei();
}



//**************************************************************
//*** Hauptprogramm
//**************************************************************
int main(void)
{ DDR  |= PIN_DIR | PIN_CLK | PIN_LED;  //Pins auf Output
  PORT |= PIN_QUAD;                    //Pullup einschalten
 
  //LED für ca. 1/2 Sec. an
  _delay_ms(500);
  PORT |= PIN_LED; //LED aus

  TCCR0B |= _BV(CS01);  //Timer aktivieren. Prescaler: 8. OVF-Int erfolgt alle 256µs (3.9 kHz) bei 8MHz Systemtakt
#if defined (__AVR_ATmega1284P__)
  TIMSK0 |= _BV(TOIE0); //OVF-Interrupt freigeben
#else
  TIMSK  |= _BV(TOIE0); //OVF-Interrupt freigeben
#endif
  sei(); // enable Interrupts

  // ADC-Werte in Mittelstellung ermitteln
  LRZero = readADC(LRChannel);
  UDZero = readADC(UDChannel);

  while(1) // immer wieder den Zustandsautomaten aufrufen
  { HandleZones(); 
  }

}

//**************************************************************
//*** Zustandsautomat für Joystick-Bewegungen
//**************************************************************
void HandleZones(void)
{ Zones Zone = GetZone();

  if((Zone != red) && (Zone != pink)) //Motor abschalten
  { Direction = 0;
    OldSpeed  = 0;
  }

  if(Zone == blue)
  { while (GetZone() != white); //Blau kann nur durch weiß aufgelöst werden.
    return;
  }

  if(Zone == orange)
  { //SingleStep +
    LedOn(150);
    DoSingleStep(1);
    while (GetZone() != white); //Weiß muss erreicht werden, bevor es weitergeht
    LedOff();
    return;
  }

  if(Zone == violett)
  { //SingleStep -
    LedOn(150);
    DoSingleStep(-1);
    while (GetZone() != white); //Weiß muss erreicht werden, bevor es weitergeht
    LedOff();
    return;
  }

  if(Zone == red)
  { //SingleStep +
    SetSpeed(UD - UDZero - StartContZone, 1);
    return;
  }

  if(Zone == pink)
  { //SingleStep -
    Direction = -1;
    SetSpeed((UDZero - StartContZone) - UD, -1);
    return;
  }
}

//**************************************************************
//*** berechnet die Paramter für die Timer-ISR
//**************************************************************
//Speed: 0..112, proportional zur Auslenkung in den Zonen "Rot" und "Rosa" (256/2-StartContZone).
void SetSpeed(uint8_t Speed, int8_t Dir)
{ uint16_t SchrittFrequenz;
  uint16_t OVFs;

  if(Speed == 0)
    Speed=1;
  if(Speed > 112)
    Speed = 112;

  if(PIN & PIN_QUAD)
  { // quadratischer Verlauf
    // Schrittfrequenz = 0,003 * Speed ^ 2 + 0,025 * Speed + 2
    SchrittFrequenz = (uint32_t)3 * (uint32_t)Speed * (uint32_t)Speed / (uint32_t)1000 + (uint32_t)25 * (uint32_t)Speed / (uint32_t)1000 + 2;
  }
  else
  { // linearer Verlauf
    // Schrittfrequenz = 0,36 * Speed + 2
    SchrittFrequenz = (uint16_t) 36 * (uint16_t) Speed / (uint16_t)100 + 2;
  }

  //OVFs = Anzahl OVF-Interrupts für Periodendauer = 1.000.000 / 256 / Schrittfrequenz
  OVFs = (uint16_t)3900 / SchrittFrequenz;

  cli();

  OvfsFill = OVFs;

  if(OldSpeed)
  { if(OldSpeed > Speed)  // soll langsamer werden
    {/* if(OvfsCnt < OvfsFill)
        OvfsCnt = OvfsFill; // Zeit verkürzen
      Das würde dazu führen, dass bei zunehmender Verlangsamung OvfsCnt immer wieder mit neuen Werten geladen würde
      und nie auf 0 kommen würde. Dass dies im gegengesetzen Fall (siehe nächstes "if") funktioniert, liegt am
      asymetrischen Algorithmus. Der Timer zählt herunter!
    */
    }
    if(OldSpeed < Speed)  // soll schneller werden
    { if(OvfsCnt > OvfsFill)
        OvfsCnt = OvfsFill; // Zeit verkürzen
    }
  }
  else
  { OvfsCnt = 1;  // Bewirkt, dass nach einem Stopp der erste Takt unmittelbar erfolgt.
  }
  Direction = Dir;
  sei();
  OldSpeed = Speed;
}



//**************************************************************
//*** Ermittlung der Zone, in der der Joystick steht
//**************************************************************
Zones GetZone()
{ LR = readADC(LRChannel);
  UD = readADC(UDChannel);

  if((UD < UDZero + StartContZone) && (UD > UDZero - StartContZone)) // Test auf violett, grün, gelb und orange
  { if(LR < StartViolett)
      return violett;
    if(LR < StartGreen)
      return green;
    if(LR > StartOrange)
      return orange;
    if(LR > StartYellow)
      return yellow;
    return white;
  }

  if ((LR > StartGreen) && (LR < StartYellow))
  { if (UD >= UDZero + StartContZone)
      return red;
    else
      return pink;
  }
  return blue;
}

//**************************************************************
//*** ADC auslesen
//**************************************************************
uint8_t readADC(uint8_t channel)
{ uint8_t i;
  uint16_t result = 0;
   
  // Den ADC aktivieren und Teilungsfaktor auf 64 stellen
  ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);

  // Kanal des Multiplexers wählen
  // VCC als Referenzspannung verwenden (also ca. 5V)
  ADMUX = channel | (0<<REFS1) | (0<<REFS0);
  // Den ADC initialisieren und einen sog. Dummyreadout machen
  ADCSRA |= (1<<ADSC);
  while(ADCSRA & (1<<ADSC));
   
  // Jetzt 3x die analoge Spannung and Kanal channel auslesen
  // und dann Durchschnittswert ausrechnen.
  for(i=0; i<3; i++)
  { //Eine Wandlung
    ADCSRA |= (1<<ADSC);
    // Auf Ergebnis warten...
    while(ADCSRA & (1<<ADSC));
       
    result += ADCW/4;
  } // for
   
  // ADC wieder deaktivieren
  ADCSRA &= ~(1<<ADEN);
   
  result /= 3;
   
  return (uint8_t)result;
} // readADC

//**************************************************************
// EinzelSchritt durchführen
//**************************************************************
void DoSingleStep(int8_t Direction)
{ //Direction setzen
  if(Direction > 0)
    PORT |= PIN_DIR;
  else
    PORT &= ~PIN_DIR;
  _delay_us(10);
 
  //Puls für Schritt ausgeben (Pulslänge 0.256 ms)
  PORT |= PIN_CLK;
  _delay_us(256);
  PORT &= ~PIN_CLK;
  _delay_us(10);
}

//**************************************************************
//Die ISR regelt folgende zeitabhängigen Funktion
//Takterzeugung
//LED-Steuerung
//**************************************************************
ISR(TIMER0_OVF_vect)
{ if(LedCnt)
  { PORT &= ~PIN_LED;
    LedCnt--;
  }
  else
    PORT |= PIN_LED;

  if(!Direction) //Direction ist 0, also Stopp. Keine Takte notwendig
    return;

  if(Direction > 0) //Direction Pin setzen
    PORT |= PIN_DIR;
  else
    PORT &= ~PIN_DIR;

  if(OvfsCnt == 0) //Puls für Schritt ausgeben (Pulslänge 0.256 ms = 1 OVF)
  { OvfsCnt = OvfsFill;
    PORT |= PIN_CLK;
    LedOn(50);
  }
  else
  { OvfsCnt--; 
    PORT &= ~PIN_CLK;
  }
}

---