Schrittmotorsteuerung für primitive Astro-Nachführung

[Johannes M. (hannes_11)]

Hallo zusammen,

ich überlege in letzter Zeit, wie ich mir möglichst einfach und günstig 
eine simple Nachführung für die Astrofotografie bauen könnte.
(Eine Nachführung soll die Drehung der Erde ausgleichen, damit Sterne 
bei längeren Belichtungszeiten nicht zu Strichen werden und punktförmig 
bleiben.)

Ich habe vor eine Art Barndoor-Montierung zu bauen, allerdings mit einem 
Reibradantrieb an einem Kreissegment.
Die Idee, einen DC-Getriebemotor als Antrieb zu verwenden, habe ich 
verworfen, da mit diesem die Drehzahl nur schwer konstant gehalten 
werden kann.
Also soll es ein Schrittmotor sein!
Als Steuerung habe ich momentan diese hier mit L297 und L298 im Visier:
Beitrag "L297/L298 Schrittmotorsteuerung, Frage zu Bauteil"

Hierfür brauche ich dann noch einen möglichst genauen Taktgeber, den ich 
auch justieren kann, da ich vermutlich Ungenauigkeiten in der Mechanik 
ausgleichen muss.
Ich dachte da an einen Mikrocontroller mit einem Quarz als 
Frequenzreferenz.
Nett wäre dabei noch, einen Schnellrücklauf auf Knopfdruck einzubauen.
Die Taktrate könnte ich vmtl. über einen ISP einstellen - prinzipiell 
muss diese ja auch nicht oft geändert werden.
(ein Display mit Einstelltasten für die Frequenz wäre daher vmtl. nicht 
nötig)

Die Frequenz sollte im Halbschrittbetrieb vmtl. größenordnungsmäßig bei 
~1kHz liegen. Ein Fehler von ~0,1% wäre toll. (Die Mechanik ist vmtl. 
eher der Schwachpunkt)
Kann man mit so einem Mikrocontroller die Taktfrequenz so genau 
einstellen?

Schrittmotorsteuerung und Mikrocontroller sind allerdings völliges 
Neuland für mich...

Welchen Controller könnt ihr mir dafür empfehlen?
Brauche dafür auch noch Programmer und software.
Was meint ihr zu der erwähnten Schrittmotor-Steuerung mit L297 / L298 ?


Schonmal Danke für eure Hilfe :)

Viele Grüße
Hannes

Ps:
Programmierkenntnisse sind praktisch nicht vorhanden - lediglich 
Überreste aus einer Vorlesung Computergrundlagen im 1. Semester, wo u.A. 
mit C und Python rumgespielt wurde.
Elektronikkentnisse sind teilweise Vorhanden: Elektronikpraktikum 
(Transistorschaltungen, OPV, Logik, Schieberegister,... )
Löten kann ich einigermaßen - aber bitte kein smd.

Die Schaltung würde ich vmtl. auf Streifenraster aufbauen, wenn nichts 
dagegen spricht.
Als Stromversorgung dachte ich an einen 12V-Bleiakku.

[Amateur (Gast)]

Ohne Not würde ich diese Antiquitäten (L297/L298) nicht mehr verwenden. 
Es stimmt, lange Zeit waren diese Chips Standard, weshalb man sie auch 
in vielen Beispielen findet - aber lang, lang ist’s her.

Such Dir was Aktuelleres und Komfortableres.

Da sich die Schrittmuster, zur Steuerung eines Schrittmotors, nur 
schlecht "manuell" generieren lassen, Du zur genauen Nachführung sowieso 
eine möglichst genaue Zeit braucht, kommst Du um einen µP wohl nicht 
rum. Ein Quarz bzw. eine quarzgenaue Zeit ist dann sozusagen "Abfall".

[oszi40 (Gast)]

Johannes M. schrieb:
> eine simple Nachführung für die Astrofotografie

Diese Baustelle wird wohl doch etwas größer werden. Die 
Schrittmotoransteuerung ist evtl. noch der einfachere Teil dabei. Dazu 
findest Du hier viele Beiträge wie: 
Beitrag "Schrittmotoren steurrung - fragen" Du brauchst auch eine sehr 
solide Mechanik, die nicht wackelt, wenn einer im Haus herumläuft und 
die korrekt nachführen kann!!!

[Karl H. (kbuchegg)]

Johannes M. schrieb:

> Ps:
> Programmierkenntnisse sind praktisch nicht vorhanden

Das könnte sich als Stolperstein erweisen.
Es sei denn, deine Montierung ist exakt waagrecht und exakt eingenordet.
(*)

> Die Schaltung würde ich vmtl. auf Streifenraster aufbauen, wenn nichts
> dagegen spricht.

Die Schaltung ist nicht das Problem


(*) und der periodische Schneckenfehler deines Getriebes ist unter 
"ferner liefen".

[Johannes M. (hannes_11)]

oszi40 schrieb:
> Du brauchst auch eine sehr
> solide Mechanik, die nicht wackelt, wenn einer im Haus herumläuft und
> die korrekt nachführen kann!!!

Das die Mechanik der schwierigste oder zumindest fehleranfäligste Teil 
der ganzen Konstruktion wird, ist für mich klar.
Aber dabei kommt es auch auf die verwendeten Brennweiten und die 
Belichtungszeit an - ich habe nicht vor, mich mit professionellen 
schweren Montierungen zu messen, die auch mehrere Meter Brennweite noch 
sauber nachführen können.
Bei den möglichen Belichtungszeiten habe ich an < 10min gedacht. Als 
Brennweite vllt. 100 bis 200mm...

wenn man nach Barndoor-Montierung googelt, bekommt man mMn. einen guten 
Eindruck davon, wie solche Konstruktionen ausehen können und was möglich 
ist.
An "richtige" Astrofotografie reicht das natürlich nicht heran :)

http://forum.astronomie.de/phpapps/ubbthreads/ubbthreads.php/topics/1029545/Mein_Bandoorplan_wird_umgesetz

Dieser Bericht zeigt sozusagen eine Luxus-Barndoor-Montierung.
Etwas in der Art habe ich auch vor zu bauen, auch wenn ich diese 
Qualität vmtl. nicht erreichen werde. :)

Karl Heinz schrieb:

> Es sei denn, deine Montierung ist exakt waagrecht und exakt eingenordet.

Das habe ich zumindest vor. Stichworte sind hier "Polsucher" und 
"Scheiner-Methode".
Der Antrieb soll nur die Rektaszentionsachse nachführen.
Die Steuerung muss also keine Koordinatentransformationen und 
Regelungsprobleme durchführen, sondern nur einen möglichst genauen Takt 
für den Schrittmotortreiber liefern.

Amateur schrieb:
> Such Dir was Aktuelleres und Komfortableres.

http://www.watterott.com/de/Pololu-A4988-Schrittmotortreiber

Meinst du soetwas? (@ oszi40: Danke für den Link :) )
Das hat scheinbar die gleiche Funktion wie L297/L298: Takt rein -> 
Motorstrom raus.

Könnt ihr mir einen Mikrocontroller (= µP ?) empfehlen, der für diesen 
Zweck ausreicht, günstig und einfach in der Handhabung ist?

Ich hab in dem Zusammenhang mit Frequenzerzeugung etwas von CTC-Mode 
gelesen...

Danke für eure Hilfe :)

Grüße
Hannes

[Karl H. (kbuchegg)]

Johannes M. schrieb:

> Meinst du soetwas? (@ oszi40: Danke für den Link :) )
> Das hat scheinbar die gleiche Funktion wie L297/L298: Takt rein ->
> Motorstrom raus.

Der unterschied besteht in ein paar Kleinigkeiten.
Ob das aber bei dir und den zu erreichenden Drehzahlen eine Rolle 
spielt, wage ich mal zu bezweifeln.

>
> Könnt ihr mir einen Mikrocontroller (= µP ?) empfehlen, der für diesen
> Zweck ausreicht, günstig und einfach in der Handhabung ist?

So ziemlich jeder, der in den letzten 50 Jahren gebaut wurde.
Ehrlich. Es spielt keine wirkliche Rolle. Das ist so, wie wenn du 
fragst, welches Auto wohl am besten geeignet ist um eine Rolle Klopapier 
von München nach Stuttgart zu transportieren. Alles geht: vom Smart bis 
zum 40-Tonner.
Da hier im Forum die AVR bei weitem in der Überzahl sind:

AVR-Tutorial

> Ich hab in dem Zusammenhang mit Frequenzerzeugung etwas von CTC-Mode
> gelesen...

Ja. Ist eine Möglichkeit.
Aber erst mal fängst du dort an, wo alle anfangen: mit einer LED an 
einem Portpin, die du gezielt einschalten, ausschalten, blinken lassen 
kannst. Dann gehts weiter und irgendwann nach der 25-ten Vorübung bist 
du dann soweit, dass du deinen Schrittmotor in einem genauen Takt 
Schritte machen lassen kannst und das ganze dann auch noch mit ein paar 
Tasten steuern kannst.

[Noch einer (Gast)]

Schrittmotoren erzeugen recht starke Vibrationen. Moderne Treiber mit 
Mikroschritt sind da schon besser, aber kein Vergleich mit Servomotoren.

Solltest dir erst mal die Vibrationen von so einer Selbstbaufräse 
anschauen -- da bekommst du längere Striche als ganz ohne Nachführung 
:-(

[MaWin (Gast)]

Johannes M. schrieb:
> Also soll es ein Schrittmotor sein!

Willst du absichtlich verwackeln ?

Mindestens Mikroschritt mit TB6560, besser BLDC mit Vektorsteuerung, 
ältertümlich Synchronmotor an variabler Frequenz.

[Johannes M. (hannes_11)]

Karl Heinz schrieb:
> Es spielt keine wirkliche Rolle. Das ist so, wie wenn du
> fragst, welches Auto wohl am besten geeignet ist um eine Rolle Klopapier
> von München nach Stuttgart zu transportieren. Alles geht: vom Smart bis
> zum 40-Tonner.

Mir war schon bewusst, dass mein Vorhaben keine allzu großen 
Anforderungen an den Controller stellt, aber da ich noch keine Erfahrung 
mit Mikrocontrollern habe, wollte ich wissen, ob sich vllt. der Eine 
oder Andere besonders gut eignet.
Zu deinem Autovergleich: Da bin ich sozusagen noch Fahrschüler ;)

Ich werde mir vmtl. den ATmega8 zusammen mit Lochrasterplatine, 
sämtlichen Bauteilen (LED, R's, C's, Quarz, Spannungsregler,... ) und 
einem Programmer ordern.
https://shop.myavr.de/index.php?sp=shoppingCart.sp.php&ses=I1RGTfCrCwCbyyCiB8CxCc2ChCrnB8CeCfhCmCpoCo0xB3CwaCxCgC8DhCjCaByBtDeC1BaC6DhDbC7B0BoC1tBdtCyDdDdCpg4CpCoikChB3CoB4CtB8ChCsCvdi
Ist der empfehlenswert?

Noch einer schrieb:
> Moderne Treiber mit
> Mikroschritt sind da schon besser

der Pololu-Treiber unterstützt 1/16-Schritte, glaubst du dass das 
reicht?
Werden die Vibrationen schwächer, wenn ich den Motorstrom schwächer 
einstelle? Ein hohes Drehmoment brauche ich ja eigentlich nicht...

Grüße
Hannes

[m.n. (Gast)]

Johannes M. schrieb:
> Schrittmotorsteuerung und Mikrocontroller sind allerdings völliges
> Neuland für mich...

Zur Orientierung, wie so etwas praktisch gelöst werden kann:
Beitrag "Schrittmotoransteuerung mit A4982 und ATmega328"

Wenn Du nicht löten möchtest, würde sich ein Arduino Uno mit obigem 
Treibermodul (A4988) anbieten. Das Programm dafür läßt sich einfach 
anpassen, um den Motor ganz langsam zu drehen.

[Chefentwickler (Gast)]

Arduino ist dein Freund

[Noch einer (Gast)]

>Ein hohes Drehmoment brauche ich ja eigentlich nicht...

Durchaus wahrscheinlich, dass hier ein 12Volt-Billigmotor besser ist. 
Hat hohe Induktivität und geringes Rastmoment. Auch möglich, dass es mit 
passender Elastizität und Schwungmasse gut genug wird.

Lässt sich nicht so einfach vorhersagen. Sonst würde ja niemand diese 
teuren Servomotoren kaufen.

Ganz andere Frage. Lässt es sich Stufenweise machen? Vor jedem Schritt 
die Blende schließen und erst wieder öffnen, nachdem die Vibrationen 
abgeklungen sind?

[oszi40 (Gast)]

Bevor Du hier "mit Spatzen auf Kanonen" schießt, würde ich erst mal (nur 
um ein Gefühl dafür zu bekommen) einen Metallbaukasten suchen und für 
erste Heimwerker-Experimente einen Gleichstrom-Spielzeugmotor oder 
Scheibenwischermotor mit Untersetzung mit Labornetzteil testen. Die 
höhere Schule der Schrittmotorvariante kannst Du später noch machen, 
wenn Du die benötigte Kraft und Geschwindigkeit besser einschätzen 
kannst.

[Martin (Gast)]

Hallo,

da die Mintierung nur nachführen muss, ist Mikroschrittbetrieb nicht 
notwendig. Eine passende Getriebeuntersetzung kann die die Schritte 
soweit verkleinern, dass sie unter der Bildauflösung liegen.
Vibrationen sind dann nicht sichtbar.

Ein schneller Rücklauf geht dann aber nicht mehr, dafür müsste der 
Reibradantrieb kurz ausgekuppelt werden.

Gruß,
Martin Cibulski

[Johannes M. (hannes_11)]

m.n. schrieb:
> Wenn Du nicht löten möchtest, würde sich ein Arduino Uno mit obigem
> Treibermodul (A4988) anbieten. Das Programm dafür läßt sich einfach
> anpassen, um den Motor ganz langsam zu drehen.

Der Tipp mit dem Arduino ist wirklich gut!
Ich hätte zwar nichts dagegen, das Teil selbst zusammenzulöten, aber das 
reduziert zumindest einige Fehlerquellen und letzendlich soll das Teil 
ja funktionieren :)
Ich würde statt dem Uno allerdings lieber den Duemilanove verwenden, 
wenn nichts dagegen spricht, da dieser statt einem Keramikresonator ein 
wesentlich genaueres Quarz verwendet.

Kann man bedenkenlos auf günstige Angebote von Ebay zurückgreifen oder 
sind die eher nicht zu empfehlen?
Sowas z.B.:
http://www.ebay.de/itm/New-SainSmart-Duemilanove-Board-ATmega328-Free-USB-Cable-For-Arduino-DE-Lager-/221586369391?pt=Wissenschaftliche_Ger%C3%A4te&hash=item339793ab6f

Noch einer schrieb:
> Lässt es sich Stufenweise machen?

Die Schrittfrequenz liegt je nach Übersetzung und Motor vmtl. im Bereich 
von 1kHz...
Aber das Prinzip wird trotzdem oft verwendet, indem die Belichtungszeit 
auf mehrere Aufnahmen verteilt wird und man diese dann nachträglich 
aufaddiert. Dadurch kann man leichte ungenauigkeiten in der Nachführung 
ausgleichen.
Einen großen Motor werde ich vmtl. eh nicht verwenden, da ich wie 
gesagt, kein hohes Drehmoment benötige.
Ob Vibrationen ein Problem werden, wird sich zeigen, allerdings gibt es 
einige Versionen mit Schrittmotor im Netz und die scheinen zu 
funktionieren.

oszi40 schrieb:
> Die
> höhere Schule der Schrittmotorvariante kannst Du später noch machen,
> wenn Du die benötigte Kraft und Geschwindigkeit besser einschätzen
> kannst.

Die Kraft wird wie gesagt nicht das Problem sein: Die Übersetzung ist 
recht groß, wodurch das nötige Drehmoment überschaubar bleibt - das ist 
simple Mechanik. Die nötige Motordrehzahl lässt sich auch recht einfach 
berechnen.
Dass man sich in die Mikrocontrollergeschichte zunächst etwas 
einarbeiten muss und klein anfangen sollte, verstehe ich.
Was aber ein Zwischenschritt über einen DC-Antrieb bringen soll, 
leuchtet mir nicht so ganz ein.

Danke für eure Hilfe :)

Grüße
Hannes

[Werner (Gast)]

Johannes M. schrieb:
> Das habe ich zumindest vor. Stichworte sind hier "Polsucher" und
> "Scheiner-Methode".

Als Alternative solltest du dir die Methode von Edward Skinner King auch 
noch ansehen. Das ist noch einfacher als die Scheiner-Methode.

[m.n. (Gast)]

Johannes M. schrieb:
> Ich würde statt dem Uno allerdings lieber den Duemilanove verwenden,
> wenn nichts dagegen spricht, da dieser statt einem Keramikresonator ein
> wesentlich genaueres Quarz verwendet.

1. Mit einem Uno könntest Du mein Programm fast unverändert verwenden. 
Zudem ist der Motorstrom per Software einstellbar.
2. Beim Uno kann man den keram. Resonator entfernen und der Quarztakt 
vom USB-Konverter nehmen.
Unter http://www.mino-elektronik.de/fmeter/fm_software.htm#bsp7 
"automatischer Abgleich..." 2.Absatz findest Du eine Beschreibung und 
ein Bild.
Falls Du vielleicht irgendwann doch noch löten möchtest, kannst Du auch 
eine Leerplatine + A4982 meiner Schaltung bekommen.

[Johannes M. (hannes_11)]

m.n. schrieb:
> Mit einem Uno könntest Du mein Programm fast unverändert verwenden.
> Zudem ist der Motorstrom per Software einstellbar.

Das mit dem Motorstrom funktioniert aber nicht mit dem 
Pololu-Platinchen, oder? Bei dieser wird der V_ref-Eingang doch mit dem 
Poti gesteuert, wenn ich das richtig sehe, und ist nicht herausgeführt.
Aber wenn man will, kann man das sicher auch modifizieren.
(Wenn ich meine SMD-Abneigung überwinde :) )

Ist deine Software nicht etwas zu komplex für meinen Zweck?
Ich brauche doch eigentlich nur die Geschwindigkeits-Steuerung (und eine 
zusätzliche höhere Geschwindigkeit zum zurücksetzen).
Danke für dein Angebot mit der Platine, aber das Layout verwendet doch 
größtenteils SMD, oder?
Sind die Unterschiede vom Duemilanove in der Programmierung zum Uno sehr 
groß?
Die µP's sind doch auch fast identisch, oder?

Werner schrieb:
> Als Alternative solltest du dir die Methode von Edward Skinner King auch
> noch ansehen. Das ist noch einfacher als die Scheiner-Methode.

Danke für den Hinweis - ich werd mal googeln :)

[m.n. (Gast)]

Johannes M. schrieb:
> Sind die Unterschiede vom Duemilanove in der Programmierung zum Uno sehr
> groß?

Offensichtlich nicht; ich dachte, der Due... wäre schon ein 
ARM-Prozessor. Allerdings ist es wohl ein Vorgänger vom Uno.

Johannes M. schrieb:
> Ist deine Software nicht etwas zu komplex für meinen Zweck?

Sie ist fertig und funktioniert. Ohne Rampe wirst Du kaum höhere 
Geschwindigkeiten fahren können; und ohne steuerbare Stromeinstellung 
mußt Du immer den max. Strom einstellen, egal ob er gebraucht wird oder 
nicht.

[Johannes M. (hannes_11)]

m.n. schrieb:
> Allerdings ist es wohl ein Vorgänger vom Uno.

Heist das, dass man deine Software auch auf diesem verwenden kann?
Das wäre natürlich ideal und ich könnte die Bastelei am Uno vermeiden.

Als Motor habe ich jetzt mal diesen hier ausgesucht:
http://www.watterott.com/de/Schrittmotor-incl-Anschlusskabel

Den Strom kann ich hoffentlich dauerhaft auf einem relativ niedrigen 
Wert eingestellt lassen, da nach dem Motor direkt eine recht hohe 
Übersetung folgt und so kein hohes Drehmoment nötig ist.
Allerdings sollte es auch kein großes Problem sein, den Poti auf der 
Platine zu entfernen und den Kontakt mit einem PWM-Ausgang des Arduino 
zu verbinden...

m.n. schrieb:
> Ohne Rampe wirst Du kaum höhere
> Geschwindigkeiten fahren können

Zum Nachführen liegt die Drehzahl vmtl. bei ca 1 U/min und beim 
zurückfahren vlt. bei 200 U/min - hältst du das für möglich ohne Rampe?
Was hätte eine zu hohe Drehzahl für Folgen?
Schrittverlust würde in meinem Fall keine Rolle spielen, da ich keine 
absoluten Positionen anfahren muss.

Danke für deine Hilfe :)

Grüße
Hannes

[m.n. (Gast)]

Johannes M. schrieb:
> Als Motor habe ich jetzt mal diesen hier ausgesucht:
> http://www.watterott.com/de/Schrittmotor-incl-Anschlusskabel

Wenn Du schon dort kaufen möchtest, dann nimm ein anderes Model in 
Bauart NEMA17: 
http://www.watterott.com/de/Schrittmotor-Unipolar/Bipolar-200-Steps/Rev-42x48mm-40V-1200mA-NEMA-17?xfa9ed=c77580383fc9047c4bb1e6523a761621

Dich wird jetzt die geringere Phasenspannung und der höhere Strom 
irritieren. Spannung und Strom regelt der Motortreiber selber, daher ist 
das für Dich kein Problem.
Aber: mit diesen Spulendaten kann sich der Motor wesentlich schneller 
drehen als der zuvor genannte Typ. Gerne könntest Du ja die Datenblätter 
(Drehzahlkurve) vergleichen, und rate mal, warum beim 12V Motor keins 
verfügbar ist? ;-)
Der Motortreiber (mit A498x) ermöglicht auch den 24V Betrieb, wobei der 
Versorgungsstrom bei höherer Betriebsspannung sinkt, sodass die 
aufgenommene Leistung von Treiber + Motor nahezu gleich bleibt!

Johannes M. schrieb:
> Zum Nachführen liegt die Drehzahl vmtl. bei ca 1 U/min und beim
> zurückfahren vlt. bei 200 U/min - hältst du das für möglich ohne Rampe?
> Was hätte eine zu hohe Drehzahl für Folgen?

1 Upm entspricht ca. 3,3 Vollschritten/s. Es ist ratsam, die höchste 
Mikroschrittauflösung zu verwenden, die möglich und sinnvoll ist. Bei 
dem obigen Treiber A4988 ist das 1/16 Schritt, was einer Schrittfrequenz 
von 53,3 Hz entspricht. Diese Frequenz wird sehr wahrscheinlich aus dem 
Stillstand vom Motor bestens verkraftet. Natürlich hängt es von den 
äußeren Massen, und, und, und ab. Dennoch dürfte es egal sein.

Bei 200 Upm ohne Startrampe müßte die Start-Stopp-Frequenz (so nennt man 
das) bei >= 666,6 Vollschritten/s liegen. Mein Erfahrungswert bei 
NEMA17-Motoren und geringer äußerer Masse liegt bei 100-150 
Vollschritten/s (bei 12V Versorgungsspannung).
Ohne Rampe wird sich der Motor nicht bewegen und nur vor sich hinsummen: 
ohne Rampe geht es nicht!

[hp-freund (Gast)]

@ Johannes,

ist an sich eine gute Idee mit dem Selbstbau, wenn es um das Bauen geht.

Wenn ich mir allerdings die Preise für gebrauchte Teleskop Montierungen 
oder zumindest die der Antriebseinheiten ansehe und dann den teils 
robusten Aufbau dieser sehe, also ich würde mir nicht zutrauen da eine 
brauchbare Nachführung hinzubekommen.

Als Anhaltspunkt für die Herstellersuche könnten vielleicht die Typen in 
der Einstelung der Teleskopsteuerungen von Stellarium dienen.

Wenn Du lieber selst bauen möchtest, ignorier bitte diesen Beitrag...

[hp-freund (Gast)]

Hier noch ein "Blick zur Sonne" für alle die Stellarium nicht kennen.

Die Nachtansicht zeigt natürlich mehr von da ganz weit Draußen :-)

[Johannes M. (hannes_11)]

hp-freund schrieb:
> Wenn ich mir allerdings die Preise für gebrauchte Teleskop Montierungen
> oder zumindest die der Antriebseinheiten ansehe und dann den teils
> robusten Aufbau dieser sehe, also ich würde mir nicht zutrauen da eine
> brauchbare Nachführung hinzubekommen.

Kannst du mir mal eine (oder zwei) brauchbare Kombis aus Montierung und 
Antrieb vorschlagen?
Darüber, ob eine EQ-1 für Fotografie ausreicht, gibt es ja sehr 
unterschiedliche Meinungen. Ich habe vor allem Bedenken wegen der recht 
kleinen Schneckenräder, wo sich Schneckenfehler o.Ä. vmtl. recht stark 
bemerkbar machen. Viele billigen Antriebe dafür sind dann auch nur mit 
DC-Motoren ausgestattet und damit für Fotografie auch eher suboptimal.
Ich habe den Eindruck, dass man da unter 150€ (eher 200€) nicht 
wegkommt...
Wie siehst du das?

Ich vermute, dass ich zumindest die nötige Drehzahl der Nachführung 
recht genau hinbekomme mit meinem geplanten Aufbau:
Das Kreissegment (aus Multiplex) für den Reibradantrieb wird vmtl. einen 
Radius von 250mm haben und mit Oberfräse und Fräszirkel sollten relative 
Abweichungen im Radius auch recht klein sein (vmtl. 0,1mm). Als Reibrad 
nehme ich dann eine Silberstahlwelle aus einem Drucker (vmtl. leicht 
angerauht für einen höheren Haftreibungskoeffizienten), die mit einer 
Feder angepresst wird. Damit erreiche ich mit einer 8mm-Welle an der 
ersten Stufe eine Übersetzung von etwa 1/60. Der Schrittmotor wird dann 
vmtl. über ein Schneckengetriebe die Stahlwelle antreiben (wieder etwa 
1:30 übersetzt).
Schneckenfehler sollten sich dadurch eher schwach zeigen, da sich diese 
relativ schnell dreht und die Drehzahlschwankungen durch die Schnecke 
nur kleine Winkelabweichungen erzeugen.
Die Drehzahl justiere ich dann, indem ich mein längstes Objekiv auf 
einen Stern mit möglichst kleiner Deklination (-> na am Himmelsäquator 
-> höchste Geschwindigkeit am Himmel -> "worst case")

Für das Einnorden werde ich vmtl einen billigen Sucher am beweglichen 
Teil der Montierung befestigen. Um den Sucher parallel zur Drehachse 
einzustellen, will ich ihn (am Tag) auf ein weit entferntes Objekt (z.B. 
Strommasten) richten und ihn dann so einstellen, dass sich das 
Fadenkreuz beim Drehen um die Nachführachse nicht bewegt.
Ob das Justieren über den Sucher genügt, muss ich dann ausprobieren...
Wenn nicht muss ich wohl "Einscheinern" :)

Soweit meine Theorie :)

Motor und Steuerung werde ich vmtl. für unter 50€ inkl. Gehäuse etc. 
hinbekommen.
Die Mechanik kann ich vorraussichtlich aus vorhandenem Material 
aufbauen.

m.n. schrieb:
> Wenn Du schon dort kaufen möchtest, dann nimm ein anderes Model in
> Bauart NEMA17:
> 
http://www.watterott.com/de/Schrittmotor-Unipolar/Bipolar-200-Steps/Rev-42x48mm-40V-1200mA-NEMA-17?xfa9ed=c77580383fc9047c4bb1e6523a761621
>
> Dich wird jetzt die geringere Phasenspannung und der höhere Strom
> irritieren. Spannung und Strom regelt der Motortreiber selber, daher ist
> das für Dich kein Problem.

Die Preisdifferenz ist zumindest vernachlässigbar ;)
Heisst das, dass der Treiber sich die Spannung per PWM ziemlich 
verlustfrei selbst zurechtbiegt und ich mehr oder weniger nur auf die 
Leistung zu achten habe? (und ob der Treiber den Strom verträgt...)

m.n. schrieb:
> ohne Rampe geht es nicht!

Ok, dann werde ich mich wohl darauf einlassen müssen und mich am Code 
von m.n. entlanghangeln. :)
Oder eben vorerst die "Rückfahrt" von Hand machen - Der automatische 
Schnellrücklauf ist ja auch mehr ein "nice to have" :D

Läuft das Programm von m.n. ohne weiteres auf dem Duemilanov?
Der ist ja scheinbar der Vorgänger vom Uno...
Der Duemilanove wäre von daher lieber, da ich mir das Löten am Board für 
den Quartz-Takt erspare und er auch noch etwas günstiger ist...

Viele Grüße :)
Hannes

[m.n. (Gast)]

Johannes M. schrieb:
> Läuft das Programm von m.n. ohne weiteres auf dem Duemilanov?

Eine Anpassung findest Du hier, ganz unten: 
http://www.mino-elektronik.de/Generator/takte_impulse.htm#bsp7

Und auch folgendes Programm sollte nach Änderung der Taktfrequenz auf 16 
MHz auf einem ATmega328 laufen: 
http://www.mino-elektronik.de/Generator/takte_impulse.htm#bsp2
Damit kann man mit 62,5ns Auflösung eine genaue Schrittfrequenz 
vorgeben, wie es zum Testen sicherlich günstig ist. Die letzte 
Einstellung wird gespeichert, sodass der Taktgenerator nach dem 
Einschalten gleich loslaufen kann.

Ich plane eine Kombination der beiden Programme, mit der dann ein 
Schrittmotor per ser. Schnittstelle (bzw. USB beim Arduino) bedient 
werden kann. Das braucht aber noch seine Zeit!

[oszi40 (Gast)]

> as braucht aber noch seine Zeit!

Bin mir noch nicht so sicher, wie sich die mechanische Trägheit von 
schwerer Kamera und schwerem Objektiv auf Deinen SM-Antrieb auswirkt. 
Evtl. verliert ein schwächlicher SM einige Schritte?

[Karl H. (kbuchegg)]

Bei der Untersetzung?
Letzten Endes muss die Kamera 1 Umdrehung pro Tag (genauer in 23:56) 
machen. So schwach kann der Motor fast nicht sein, dass er bei einer 
Untersetzung von 1:1440 die Kamera nicht rumwuchten kann.

[Johannes M. (hannes_11)]

m.n. schrieb:
> Eine Anpassung findest Du hier, ganz unten: ...

Danke :)

Karl Heinz schrieb:
> So schwach kann der Motor fast nicht sein, dass er bei einer
> Untersetzung von 1:1440 die Kamera nicht rumwuchten kann.

Ich habe auch schon überlegt, ob ich nicht besser einen kleineren SM 
verwenden sollte.
Hat ein größerer Schrittmotor irgendwelche Nachteile gegenüber einem 
kleineren bei identischer Leistung?
(also stark gedrosselter Strom am größeren Motor)
... mal abgesehen vom Gewicht.

Grüße
Hannes

[m.n. (Gast)]

Johannes M. schrieb:
> Ich habe auch schon überlegt, ob ich nicht besser einen kleineren SM
> verwenden sollte.

Der o.g. ist schon recht klein.

Johannes M. schrieb:
> Hat ein größerer Schrittmotor irgendwelche Nachteile gegenüber einem
> kleineren bei identischer Leistung?

Pauschal gesagt haben größere SM eine größere eigene Masse zu bewegen, 
neigen stärker zu Resonanzen (bei Nennstrom) und machen mehr Geräusche.

Optimal wäre ein Motor mit geringem Rastmoment, damit er die 
Mikroschritte möglichst gut auflösen kann. Einige Motore werden 'für 
Mikroschritt geeignet' angepriesen, aber Papier ist geduldig und der 
Glaube an die Wahrheit von Werbeaussagen sehr schwach ;-)

[Roland E. (roland0815)]

Für Teleskopnachführung sind Schrittmotoren ungeeignet. Für diese 
Anwendung braucht man einen kontinuierlichen Antrieb. Im Idealfall einen 
50Hz Langsamläufer plus Getriebe...

[Johannes M. (hannes_11)]

m.n. schrieb:
> Der o.g. ist schon recht klein.

Dann werde ich es vmtl. einfach mal damit versuchen :)

Roland Ertelt schrieb:
> Für Teleskopnachführung sind Schrittmotoren ungeeignet. Für diese
> Anwendung braucht man einen kontinuierlichen Antrieb. Im Idealfall einen
> 50Hz Langsamläufer plus Getriebe...

Also Pauschalaussagen sind ja generell mit Vorsicht zu genießen aber 
hier gibt ja sicher tausende Beispiele, die das Gegenteil beweisen...

Viele Grüße
Hannes

[Bülent C. (mirki)]

Hi Johannes,

hier mal ein kleines Beispiel, wie man Schrittmotoren ansteuern könnte:

#include <stdio.h>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>
#include <stdint.h>
#include <avr/eeprom.h>

#include "IncFile1.h"

void sleep ( uint8_t ms )
{
  for(; ms > 0; ms--) _delay_ms(1);
}

void sleepS ( uint8_t s )
{  
  int i=0;
  for(i=0; i<s; i++){
    sleep(250);
    //sleep(250);
    //sleep(250);
    //sleep(250);
  }
}

int main(void)
{

  // Datenrichtungsregister festlegen;
  //TASTERPORT = 0xFF; // INTERN PULL-UPs AKTIVIEREN
  TDDRX = 0x00; // ALLE PINS ALS EINGANG    
  TDDRX = 0b00010000; // PINB0 - PINB3 auf Eingang und PINB5 Ausgang 

  MPORT = 0b00000000;  
  //MDDRX  = 0xFF;  // PORTC AUF AUSGANG
  MDDRX = 0b00011111; // 
  
  // Initialisierung des LCD
  // Nach der Initialisierung müssen auf dem LCD vorhandene schwarze Balken
  // verschwunden sein
  lcd_init();
    
  MENU = 0;
  START = 0;
  //
  WINKEL = 1;
  ZEIT = 1;
  WIEDERHOLUNGEN = 1;
  //
  WINKEL = eeprom_read_byte(&eeWINKEL);
  ZEIT = eeprom_read_byte(&eeZEIT);
  WIEDERHOLUNGEN = eeprom_read_byte(&eeWIEDERHOLUNGEN);
  //
  UpdateDisplay();          
    
    while(1)
    {
    if (IstTaste1Gedrueckt())
    {    
      Menuwahl();        
    }
    if (IstTaste2Gedrueckt()) {
      Next();
    }    

    if (IstTaste3Gedrueckt()) {
      Before();
    }
        
    if (IstTaste4Gedrueckt()) {
      StartStop();
    }
    //sleep(10);
    }
}

void StartStop(void)
{  
  char *str;  
  int i=0,j=0;
  //START++;
  //START %= 2;
  START = 1;
  
  lcd_clear();
  str = (char *) calloc(16, sizeof(char));
  
  // STARTE 
  // WERTE IN DAS EEPROM SPEICHERN
  eeprom_write_byte(&eeWINKEL, WINKEL);
  eeprom_write_byte(&eeZEIT, ZEIT);
  eeprom_write_byte(&eeWIEDERHOLUNGEN, WIEDERHOLUNGEN);
  
  MPORT |= (1<<MOT_SM0); //SM0 = 1 HALFSTEP
  MPORT &= ~(1<<MOT_DIR); // GEGEN UHRZEIGER DREHEN
  while( (i<WIEDERHOLUNGEN) && (START == 1) ){    
    //
    //
    for(j=0;j<WINKEL;j++){
      MPORT |= (1<<MOT_STEP);
      sleep(50);
      MPORT &= ~(1<<MOT_STEP);
      SignalOut();
      if(IstTaste4Gedrueckt()){
        START = 0;
        j=WINKEL;
      }      
    }    
    //
    sleepS(ZEIT);
        
    if(IstTaste4Gedrueckt()){
      START = 0;
    }    
    sleepS(ZEIT);    
    if(IstTaste4Gedrueckt()){
      START = 0;
    }
        
    i++;
    
    // LCD UPDATE
    lcd_clear();
    lcd_setcursor( 1, 1 );  
    lcd_string("Gestartet ...");    
    lcd_setcursor(1,2);
    sprintf(str,"%4i",WIEDERHOLUNGEN-i);
    lcd_string(str);
    if(IstTaste4Gedrueckt()){
      START = 0;
    }
  }
  MPORT &= ~(1<MOT_SM0); //SM0 = 0 FULLSTEP
  
  free(str);
  UpdateDisplay();
}

void SignalOut(void)
{
  PORTB |= (1<<PINB5);
  sleep(100);
  PORTB &= ~(1<<PINB5);
}


void Menuwahl(void)
{  
  MENU++;
  MENU %= nMenus;
  UpdateDisplay();
}

void Next(void)
{  
  switch(MENU){
    case 0:
      WINKEL++;
      break;
    case 1:
      ZEIT++;
      break;
    case 2:
      WIEDERHOLUNGEN++;
      break;
    case 3:
      BewegeMotor(0);
      // MOTOR SCHRITT ++
      break;
    default:
      break;
    }
  UpdateDisplay();
}

void Before(void)
{  
  switch(MENU){
    case 0:
      WINKEL--;
      if(WINKEL < 0)
        WINKEL = 0;
      break;
    case 1:
      ZEIT--;
      if(ZEIT < 0)
        ZEIT = 0;
      break;
    case 2:
      WIEDERHOLUNGEN--;
      if(WIEDERHOLUNGEN < 0)
        WIEDERHOLUNGEN = 0;
      break;
    case 3:
      // MOTOR SCHRITT --
      BewegeMotor(1);
      break;
    default:
      break;
  }
  UpdateDisplay();
}

void UpdateDisplay(void)
{
  uint16_t f_winkel1 = 0;
  uint16_t f_winkel2 = 0;
  char *str;  
  lcd_clear();  
  str = (char *) calloc(16, sizeof(char));    
  switch(MENU){
    case 0:    
      lcd_setcursor( 4, 1 );
      lcd_string("Winkel");      
      f_winkel1 = (WINKEL * 9) / 10;      
      f_winkel2 = ((WINKEL * 9) % 10);      
      //my_uitoa(f_winkel1, str);  
      //my_uitoa(f_winkel2, str);
      //itoa(f_winkel1, str, 10);
      //itoa(f_winkel2, str, 10);
      //my_uitoa(f_winkel1, str);
      sprintf(str,"%2u,%1u gr",f_winkel1,f_winkel2);
      break;
    case 1:
      lcd_setcursor( 5, 1 );
      lcd_string("Zeit");
      sprintf(str,"%4i s",ZEIT);
      break;
    case 2:
    lcd_setcursor( 1, 1 );
    lcd_string("Wiederholungen");
    sprintf(str,"%4i mal",WIEDERHOLUNGEN);
    break;          
    case 3:
      lcd_setcursor( 1, 1 );
      lcd_string("Move");
      sprintf(str,"+   -");
      break;  
    default:
      lcd_setcursor( 8, 1 );
      lcd_string("ERROR");      
      break;
  }  
  lcd_setcursor(1,2);
  lcd_string(str);  
  free(str);  
}


void BewegeMotor(uint8_t richtung)
{
  if(richtung == 0){    
    MPORT &= ~(1<<MOT_DIR);
  }
  else{
    MPORT |= (1<<MOT_DIR);
  }    
  MPORT |= (1<<MOT_STEP);
  sleep(20);
  MPORT &= ~(1<<MOT_STEP);    
}


char IstTaste1Gedrueckt(void)
{
  static unsigned char zustand;
  char rw = 0;
  if(zustand == 0 && !(TASTER & (1<<TASTE1)))   //Taster wird gedrueckt (steigende Flanke)
  {
    zustand = 1;
    rw = 1;
  }
  else if (zustand == 1 && !(TASTER & (1<<TASTE1)))   //Taster wird gehalten
  {
    zustand = 2;
    rw = 0;
  }
  else if (zustand == 2 && (TASTER & (1<<TASTE1)))   //Taster wird losgelassen (fallende Flanke)
  {
    zustand = 3;
    rw = 0;
  }
  else if (zustand == 3 && (TASTER & (1<<TASTE1)))   //Taster losgelassen
  {
    zustand = 0;
    rw = 0;
  }  
  return rw;
}

char IstTaste2Gedrueckt(void)
{
  static unsigned char zustand;
  char rw = 0;
  if(zustand == 0 && !(TASTER & (1<<TASTE2)))   //Taster wird gedrueckt (steigende Flanke)
  {
    zustand = 1;
    rw = 0;
  }
  else if (zustand == 1 && !(TASTER & (1<<TASTE2)))   //Taster wird gehalten
  {
    zustand = 2;
    rw = 0;
  }
  else if (zustand == 2 && (TASTER & (1<<TASTE2)))   //Taster wird losgelassen (fallende Flanke)
  {
    zustand = 3;
    rw = 0;
  }
  else if (zustand == 3 && (TASTER & (1<<TASTE2)))   //Taster losgelassen
  {
    zustand = 0;
    rw = 0;
  }
  else if (((zustand == 1) || (zustand == 2)) && !(TASTER & (1<<TASTE2)))   //Taster wird gehalten
  {
    zustand = 2;
    rw = 1;
    sleep(250);
    //sleep(250);
  }
  return rw;
}

char IstTaste3Gedrueckt(void)
{
  static unsigned char zustand;
  char rw = 0;
  if(zustand == 0 && !(TASTER & (1<<TASTE3)))   //Taster wird gedrueckt (steigende Flanke)
  {
    zustand = 1;
    rw = 0;
  }
  else if (zustand == 1 && !(TASTER & (1<<TASTE3)))   //Taster wird gehalten
  {
    zustand = 2;
    rw = 0;
  }
  else if (zustand == 2 && (TASTER & (1<<TASTE3)))   //Taster wird losgelassen (fallende Flanke)
  {
    zustand = 3;
    rw = 0;
  }
  else if (zustand == 3 && (TASTER & (1<<TASTE3)))   //Taster losgelassen
  {
    zustand = 0;
    rw = 0;
  }
  else if (((zustand == 1) || (zustand == 2)) && !(TASTER & (1<<TASTE3)))   //Taster wird gehalten
  {
    zustand = 2;
    rw = 1;
    sleep(250);
    //sleep(250);
  }
  return rw;
}

char IstTaste4Gedrueckt(void)
{
  static unsigned char zustand;
  char rw = 0;
  if(zustand == 0 && !(TASTER & (1<<TASTE4)))   //Taster wird gedrueckt (steigende Flanke)
  {
    zustand = 1;
    rw = 1;
  }
  else if (zustand == 1 && !(TASTER & (1<<TASTE4)))   //Taster wird gehalten
  {
    zustand = 2;
    rw = 0;
  }
  else if (zustand == 2 && (TASTER & (1<<TASTE4)))   //Taster wird losgelassen (fallende Flanke)
  {
    zustand = 3;
    rw = 0;
  }
  else if (zustand == 3 && (TASTER & (1<<TASTE4)))   //Taster losgelassen
  {
    zustand = 0;
    rw = 0;
  }
  return rw;
}

void my_uitoa(uint32_t zahl, char* string) {
  int j=0,i=0;
  char *st;
  
  st = (char *)calloc(10,sizeof(char));
  while(zahl>0){
    st[i] = (zahl%10) + '0';
    zahl = zahl / 10;
    i++;
  }
  for (j=0; j<=i; j++){
    string[j] = st[i-j-1];
  }
  string[i] = '\0';
  free(st);  
}

[Karl H. (kbuchegg)]

Bülent C. schrieb:
> Hi Johannes,
>
> hier mal ein kleines Beispiel, wie man Schrittmotoren ansteuern könnte:


Ich will dir nicht zu nahe treten.
Aber so lang du so programmierst, solltest du davon Abstand nehmen, 
anderen was beibringen zu wollen.
Lies im Forum mit, lerne von dem was du siehst, aber versuch noch nicht 
anderen zu zeigen, wie man die Dinge sauber programmiert.

Es heißt zwar immer, dass unter Blinden der Einäugige König sei, aber 
wenn es soweit ist, wird sich Johannes schon noch mal melden. Da mach 
ich mir keine Sorgen.

[Bülent C. (mirki)]

Karl Heinz schrieb:
> Aber so lang du so programmierst, solltest du davon Abstand nehmen,
> anderen was beibringen zu wollen.

:-) Hallo Karl Heinz....was genau ist denn unsauber am code? Vielleicht 
lerne ich ja mal was dazu?! ;-)

[Karl H. (kbuchegg)]

Bülent C. schrieb:
> Karl Heinz schrieb:
>> Aber so lang du so programmierst, solltest du davon Abstand nehmen,
>> anderen was beibringen zu wollen.
>
> :-) Hallo Karl Heinz....was genau ist denn unsauber am code? Vielleicht
> lerne ich ja mal was dazu?! ;-)

Leider ziemlich viel.

Kannst du zb begründen, wozu du die calloc brauchst?
Die Tastenbehandlung: das funktioniert auch nur zufällig, weil der Rest 
des Codes nur so von delays wimmelt. und dann: 4 mal denselben Code?
Die Schrittmotorsteuerung: ein generelles Prinzip in der 
µC-Programmierung lautet: delays sind für Neulinge ok, denn irgendwo 
muss man schliesslich mal anfangen. Aber nach dem man sich die ersten 
Hörner abgestossen hat, bedeutet der Begriff zeitliche Steuerung 
praktisch immer den Einsatz eines Timers.

Die Menüsteuerung ist so noch einigermassen ok, auch wenn man das 
vereinfachen und vereinheitlichen könnte. Aber ok, bei so einem kleinen 
Menü geht das so noch.

Die Ablaufsteuerung der Motorbewegung. Na, ja. Wenn ich beide Augen 
zudrücke.

Es ist eine weltweite Konvention, dass Namen, die komplett in 
Grossbuchstaben geschrieben sind ausschliesslich für Makros reserviert 
sind und auch umgekehrt: Ist etwas ausschliesslich in Grossbuchstaben 
geschrieben, dann handelt es sich um ein Makro. Dieses Wissen ist an 
manchen STellen lebenswichtig, daher ist das eine der wenigen 
Konventionen an die sich tatsächlich Millionen von C Programmierer ohne 
Wenn und Aber halten. Es gibt keinen Grund, diese Konvention über Bord 
zu werfen. Vor allen Dingen nicht fr Variablennamen.

So wie ich das sehe, gibt es da ein Include File, in dem sich eigentlich 
nur noch die globalen Variablen befinden können. Die anderen Funktionen 
sind, soweit ich das sehen kann, alle im C-File drinnen. Wozu das 
H-File? Das dient dann nur noch dazu, dass man nicht den kompletten Code 
an einer Stelle beisammen hat, sondern über mehrere Files suchen muss. 
So macht dieses Header File keinen Sinn und schadet mehr als es nützt.

[Bülent C. (mirki)]

Danke für's Feedback. Ja, jeder kann noch was dazu lernen.
Das mit den Delays gebe ich Dir vollkomen Recht. Eigentlich nutze ich 
Timer, warum ich das hier nicht gemacht habe wundert mich gerade ein 
wenig :-)
Aber wo siehst du 4x den selben Code?
Was die Namen in Großbuchstaben angeht, gebe ich Dir Recht. Ich muss mir 
das noch unbedingt intensiver angwöhnen.

Im Include ist eigentlich nur noch das hier:

#ifndef INCFILE1_H_
#define INCFILE1_H_


#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 12000000UL  
#endif

void sleep ( uint8_t);

#define TASTERPORT PORTB
#define TDDRX DDRB

#define TASTER PINB
#define TASTE1 PINB2
#define TASTE2 PINB1
#define TASTE3 PINB0
#define TASTE4 PINB3

#define MDDRX DDRC
#define MPORT PORTC

#define MOT_ENABLE PC0
#define MOT_SM1 PC1
#define MOT_SM0 PC2
#define MOT_DIR PC3
#define MOT_STEP PC4

uint8_t MENU;
uint32_t WINKEL;
uint8_t ZEIT;
uint8_t WIEDERHOLUNGEN;
uint8_t START;

uint8_t eeZEIT EEMEM;
uint8_t eeWINKEL EEMEM;
uint8_t eeWIEDERHOLUNGEN EEMEM;

const uint8_t nMenus = 4;

char IstTaste1Gedrueckt(void);
char IstTaste2Gedrueckt(void);
char IstTaste3Gedrueckt(void);
char IstTaste4Gedrueckt(void);

void Menuwahl(void);
void Next(void);
void Before(void);
void UpdateDisplay(void);
void StartStop(void);

void my_uitoa(uint32_t, char*);

void BewegeMotor(uint8_t);
void SignalOut(void);

void sleep ( uint8_t );
void sleepS ( uint8_t );

#endif /* INCFILE1_H_ */

[Thorsten O. (Firma: mechapro GmbH) (ostermann)]

Hallo Bülent,

> Aber wo siehst du 4x den selben Code?

Hier z.B.:

> char IstTaste1Gedrueckt(void);
> char IstTaste2Gedrueckt(void);
> char IstTaste3Gedrueckt(void);
> char IstTaste4Gedrueckt(void);

Mit freundlichen Grüßen
Thorsten Ostermann

[Bülent C. (mirki)]

Thorsten Ostermann schrieb:
> Hallo Bülent,
>
>> Aber wo siehst du 4x den selben Code?
>
> Hier z.B.:
>
>> char IstTaste1Gedrueckt(void);
>> char IstTaste2Gedrueckt(void);
>> char IstTaste3Gedrueckt(void);
>> char IstTaste4Gedrueckt(void);
>
> Mit freundlichen Grüßen
> Thorsten Ostermann

Hallo Thorsten,

das ist nicht 4x der selbe Code.. höchstens 4x ähnlicher Code.

VG, Bülent

[Karl H. (kbuchegg)]

Bülent C. schrieb:

> das ist nicht 4x der selbe Code..

Wenn sich Code nur in der Benamung von Variablen bzw. Konstanten 
unterscheidet, dann ist es 4 mal derselbe Code.
Ok, 1 ist ein bischen anders.
Ist aber trotzdem zumindest unschön. Denn in dem Fall fragt man sich: 
warum ist eigentlich 1 Taste anders, so man im Code überhaupt bemerkt, 
dass die eine codemässig ein wenig abweicht.
Zumal diese ganze Flankenerkennung nur deshalb auch noch entprellt, weil 
der restliche Code mit delays gespickt ist.

[Udo S. (urschmitt)]

Bülent C. schrieb:
> das ist nicht 4x der selbe Code.. höchstens 4x ähnlicher Code.

Und warum nicht sowas wie:
char IstTasteGedrueckt(uint8_t nummer);

[Bülent C. (mirki)]

Karl Heinz schrieb:
> Wenn sich Code nur in der Benamung von Variablen bzw. Konstanten
> unterscheidet, dann ist es 4 mal derselbe Code.
> Ok, 1 ist ein bischen anders.

Die Unterscheiden sich doch nicht nur in der Benamung.. Schaumal bitte 
nochmal hin, es werden jeweils unterschiedliche PIN's abgefragt.

[Karl H. (kbuchegg)]

Bülent C. schrieb:
> Karl Heinz schrieb:
>> Wenn sich Code nur in der Benamung von Variablen bzw. Konstanten
>> unterscheidet, dann ist es 4 mal derselbe Code.
>> Ok, 1 ist ein bischen anders.
>
> Die Unterscheiden sich doch nicht nur in der Benamung.. Schaumal bitte
> nochmal hin, es werden jeweils unterschiedliche PIN's abgefragt.

Sag ich doch. Unterschiedliche Konstanten.

Und was hindert dich jetzt daran, EINE EINZIGE Funktion zu schreiben, 
der man eine Pinbeschreibung mitgibt oder vielleicht gar bereits das 
Ergebnis der Bitabfrage vom Pin Register?

Man könnte es auch so sagen:
Was tust du, wenn du 8 Tasten im System hast? Kopierst du dann den Code 
noch 4 mal weiter und änderst den Namen für die Tastenkonstante?

Im übrigen. Auch wenn die Funktionen sich in der Logik der 
Ablaufsteuerung ganz leicht unterscheiden, der UNterschied besteht nach 
ein paar Durchläufen im Kopf nur darin, dass die einen Tasten sofort bei 
der ersten Flanke die gedrckte Taste melden, während die anderen die 
gedrückte Taste um ein paar Zeiteinheiten (je nach delays ausserhalb) 
verzögert den Tastendruck meldet. Aber beide Codeversionen melden den 
Tastendruck beim niederdrücken. Da frag ich mich: warum sind da 
unterschiedliche Codeversionen vertreten? Und warum haben die einen 
Funktionen einen Sleep drinnen und die anderen nicht?

[Johannes M. (hannes_11)]

Hallo zusammen,

die Bestellung für den Duemilanove, Treiber und Motor ist raus :)

Ich hab mir mal die Arduino-software installiert und beschäftige mich 
gerade mit der Programmierung. Ich weis, dass man als Anfänger erstmal 
schritt für Schritt vorgehen soll, aber ich hab mal versucht, das Ganze 
mit CTC und Rampe für den Schnellrücklauf zu programmieren...
testen kann ich das Programm logischerweise noch nicht, aber ich bin 
trotzdem gespannt auf eure Meinungen :)

Den Part mit der Timer-configuration für CTC habe ich größtenteis von 
hier übernommen:
http://letsmakerobots.com/content/arduino-101-timers-and-interrupts

Kann das so funktionieren?

hier der code:

void setup()
{
  pinMode(1, OUTPUT); //DIR-Signal
  pinMode(2, OUTPUT); //Enable-Signal (Eingang am Treiber ist invertiert!!!)
  pinMode(3, INPUT); // Vorwaertsfahrt-schalter
  pinMode(4, INPUT); // Schnellruecklauf-schalter
  pinMode(5, OUTPUT); //Taktausgang für Schrittmotortreiber

  // initialize timer1
  noInterrupts();           // disable all interrupts
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1  = 0;

  OCR1A = 40000;            // compare match register 16MHz/256/2Hz
  TCCR1B |= (1 << WGM12);   // CTC mode
  TCCR1B |= (1 << CS11);    // 8 prescaler
  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
  interrupts();             // enable all interrupts
}

ISR(TIMER1_COMPA_vect)          // timer compare interrupt service routine
{
  digitalWrite(5, digitalRead(5) ^ 1); //wechselt den Zustand am Taktausgang
}

void loop()
{
  float slowfreq = 50.0; //Schrittfrequenz Nachfuehrbetrieb
  float backfreq = 10000; //maximale Schrittfrequenz Schnellruecklauf
  //Rampenparameter für Schnellruecklauf
  int rampsteplength = 5; //Stufenlänge der Rampe in ms
//-------------------------------------------------------------------
  if ((digitalRead(3) == LOW) && (digitalRead(4) == LOW)) {
    digitalWrite(2, HIGH); //deaktiviert Treiber wenn Schalter in Mittelstellung
  }
  //Vorwaertsfahrt-------------------------------------------------------(ohne Rampe)
  if (digitalRead(3) == HIGH) { //Wenn schalter auf Vorwaerts, dann
    OCR1A = 1000000 / slowfreq; //setzt wert für Compare-Register bei 2000000 counts/s im Register bei 16MHz und prescaler 8
    //1000000 da für einen Taktzyklus zwei CTC-schritte notwendig sind
    digitalWrite(2, LOW); //aktiviert Treiber
    digitalWrite(1, HIGH); //setzt DIR-Ausgang auf Vorwaerts
  }
  //Schnellruecklauf-----------------------------------------------------(mit Rampe)
  if (digitalRead(4) == HIGH) { //Wenn schalter auf Schnellruecklauf
    digitalWrite(2, LOW); //aktiviert Treiber
    digitalWrite(1, LOW); //setzt DIR-Ausgang auf Rueckwaerts
    do {
      OCR1A = OCR1A - 100; //verringert Periodendauer
      delay(rampsteplength); //Wartezeit bis zum nächsten Rampenschritt
    } while (OCR1A < 1000000 / backfreq);
    OCR1A = 1000000 / backfreq; //setzt Compare-Register auf den Endwert
  }
}

[Johannes M. (hannes_11)]

Haben jetzt die erfahreneren Programmierer die Flucht ergriffen? :)
Wenn das Programm totaler Blödsinn ist, bitte raus damit :)

Viele Grüße
Hannes

[Karl H. (kbuchegg)]

Johannes M. schrieb:
> Haben jetzt die erfahreneren Programmierer die Flucht ergriffen? :)
> Wenn das Programm totaler Blödsinn ist, bitte raus damit :)

Ich habs mir ehrlich gesagt nicht durchgesehen bzw. durchdacht.

Warte bis du die Hardware hast, spiel es auf den Rechner und das System 
selbst wird dir 'sagen' wie gut es ist.

Das ist doch der halbe Spass an der ganzen Sache! Mit einer Idee 
hochkommen, die Idee implementieren und der gnadenlose Rechner zerlegt 
dir dann die Idee und zeigt dir, was du übersehen hast. - Nächster 
Versuch.
Nur so wird man im Lauf der Zeit besser.
Keiner von uns ist mit dem heutigen WIssen und Können zur Welt gekommen. 
Die meisten haben unzählige Nächte, über Wochen und Monate hinweg, immer 
wieder was probiert, gelernt, Programme verändert, sind in Sackgassen 
geraten, haben (aus heutiger Sicht) simple Probleme analysiert und sich 
Lösungsmöglichkeiten überlegt von denen aus heutiger Sicht 90% 
schwachsinnig waren (aber gelernt hat man eine Menge dabei, und sei es 
nur ein "so gehts nicht").
Und ehe das kommt: Bei mir war es so, dass das alles weit vor der Zeit 
des Internet war. So etwas wie ein Forum, davon konnte man noch nicht 
mal träumen, weil man gar nicht wusste was das sein sollte.

[Bülent C. (mirki)]

Was für eine Hardware hast du denn bestellt? Ich meine den Schrittmotor 
Treiber

[Bülent C. (mirki)]

Hallo Karl Heinz, ja ich könnte für die Taster eine Funktion schreiben, 
wollte ich aber nicht, bei 8 Tastern hätte ich das wohl gemacht.
Timer zu nutzen ist vernünftig, aber verrate mir mal bitte was an einer 
delay Funktion so schlimm sein soll? Im Kontext der Schrittmotor 
Steuerung! Das eine inkrementiert in der Hardware das andere in der 
Software. So zeitkritisch ist die Anwendung nun mal auch nicht
Vg, Bülent

[Johannes M. (hannes_11)]

Karl Heinz schrieb:
> Warte bis du die Hardware hast, spiel es auf den Rechner und das System
> selbst wird dir 'sagen' wie gut es ist.

Da hast du wohl Recht - mit Hardware macht das vermutlich mehr Sinn und 
vor Allem Spass...
Ich wollte mich gestern schon mal etwas in die Materie einarbeiten und 
hab diverse Tutorials durchstöbert und versucht Codes zu verstehen...
Die Arduino-Software hab ich mir auch schonmal installiert und einfach 
mal drauf los geschrieben. Die Software gibt dann zumindest schonmal 
Rückmeldung darüber, ob der Syntax passt.
Und das ist dabei raus gekommen :)

Die Hardware ist hoffentlich bis zum We da, damit ich gleich loslegen 
kann :)

Bestellt habe ich Folgendes:

Treiber:
http://www.watterott.com/de/Pololu-A4988-Schrittmotortreiber

Motor:
http://www.watterott.com/de/Schrittmotor-Unipolar/Bipolar-200-Steps/Rev-42x48mm-40V-1200mA-NEMA-17

Arduino:
http://www.ebay.de/itm/221586369391

Grüße
Hannes

[Thomas (Gast)]

Hallo,
wie Karl Heinz schon geschrieben hat, macht es einfach Spass etwas 
selber zu
machen.
Grundsätzlich brauchst du einen sehr feinen Antrieb und daher eine 
solide mechanik.Jedes ruckeln des Motors stört einfach.

[Karl H. (kbuchegg)]

Bülent C. schrieb:
> Hallo Karl Heinz, ja ich könnte für die Taster eine Funktion schreiben,
> wollte ich aber nicht, bei 8 Tastern hätte ich das wohl gemacht.
> Timer zu nutzen ist vernünftig, aber verrate mir mal bitte was an einer
> delay Funktion so schlimm sein soll? Im Kontext der Schrittmotor
> Steuerung!


Im Kontext von Astrophotografie. Da sind Belichtungszeiten von mehreren 
Stunden keine Seltenheit. In dieser Zeit muss der Motor EXAKT seine 
Anzahl an Schritten machen. Nicht 1000 mehr, nicht 1000 weniger. 
Unabhängig davon, ob irgendwann der Wunsch aufkommt, auf einem LCD die 
bisher aufgelaufene Belichtungszeit mitzuschreiben. Unabhängig davon, ob 
zwischendurch irgendjemand auf irgendeiner Taste rumhämmert (und so ein 
paar delays mehr zur Ausführung bringt).
Das ist keine CNC Maschine, bei der es egal ist, ob der Fräser nach 5 
Stunde Bearbeitung noch 2 Sekunden länger braucht oder nicht, bis er 
dann endgültig fertig ist. Nach einer Zeiteinheit x hat der Motor exakt 
die vorgeschriebene Zahl y an Schritten zu machen. Tut er das nicht, 
dann holt man im günstigsten Fall nicht das Beste aus dem Photo raus und 
im schlimmsten Fall ist die Aufnahme versaut.

Kannst du mir bitte erklären, was so schlimm daran ist, mit einem Timer 
umgehen zu lernen? Dann würde man eine Technik beherrschen, die recht 
problemlos verallgemeinert und sowohl bei kurzen als auch bei langen 
Zeiten einsetzbar ist.

> Software. So zeitkritisch ist die Anwendung nun mal auch nicht

?
Du hast dich schon mal mit Astrophotographie beschäftigt?


Und zu den Tasten. Aha. Du kopierst also lieber Code 4 mal und machst 
dir dann die Mühe, die Tastennamen einzeln per Copy&Paste auszutauschen 
anstatt dir ein für alle mal eine einzige Funktion zu schreiben, samt 
einer zugehörigen struct, in der du deine Tasten definierst (an welchem 
Pin, an welchem Port, plus Zustandsvariablen wie benötigt). Nun gut. Ich 
hab halt andere Vorstellungen davon, wie sich Qualität in einer Software 
manifestiert. Aber ok, manche Leute reparieren eine Roststelle an ihrem 
Auto auch dadurch, dass sie einen Aufkleber drüberkleben.

[Mike (Gast)]

Roland Ertelt schrieb:
> Für Teleskopnachführung sind Schrittmotoren ungeeignet.

Kannst du mal verraten, wieso dann bewährte Steuerungen, wie z.B. die 
seit langem bewährte FS2, ausgereichnet mit Schrittmotoren arbeiten und 
dabei mit 3m Brennweite absolut punktförmige Sterne liefert?

[Bülent C. (mirki)]

Karl Heinz schrieb:
> Kannst du mir bitte erklären, was so schlimm daran ist, mit einem Timer
> umgehen zu lernen? Dann würde man eine Technik beherrschen, die recht
> problemlos verallgemeinert und sowohl bei kurzen als auch bei langen
> Zeiten einsetzbar ist.

Ich habe doch nie behauptet es nicht zu können ;-) Hatte es in dem Fall 
einfach nur nicht getan.

Karl Heinz schrieb:
> Du kopierst also lieber Code 4 mal und machst
> dir dann die Mühe, die Tastennamen einzeln per Copy&Paste auszutauschen
> anstatt dir ein für alle mal eine einzige Funktion zu schreiben, samt
> einer zugehörigen struct,

JA! Wenn ich maleinen Fall habe, wo ich "viele" Tasten habe, werde ich 
da smal machen, aber nicht bei 4 Tasten!

[m.n. (Gast)]

m.n. schrieb:
> Ich plane eine Kombination der beiden Programme, mit der dann ein
> Schrittmotor per ser. Schnittstelle (bzw. USB beim Arduino) bedient
> werden kann. Das braucht aber noch seine Zeit!

Die Zeit ist gekommen ;-)
http://www.mino-elektronik.de/Generator/takte_impulse.htm#bsp8

[Johannes M. (hannes_11)]

Hallo zusammen,

wollte nochmal kurz ne Rückmeldung geben, wie der aktuelle Stand ist:
Das Projekt hat sich doch etwas hingezogen, da ich nur wenig Zeit hatte 
und die einzelnen Komponenten doch recht viel Zeit in Anspruch nehmen.
Die eigentliche Nachführmechanik mit Schrittmotorantrieb und -Steuerung 
läuft schon.
Das Säulenstativ aus einem 6cm-Stahlrohr und der Kopf mit Polhöhenwiege 
(um die Nachführung auszurichten) sind praktisch fertig.
Was noch fehlt ist ein Polsucher (wird vmtl. selbst gebastelt) und etwas 
Farbe für die Metallteile, da diese schon Flugrost ansetzen.
Wenn alles fertig ist, gibt es natürlich einen ausführlichen Bericht mit 
Bildern...
Der Schrittmotor ist vmtl. etwas überdimensioniert aber wenn der 
Motorstrom fast auf minimum eingestellt ist, läuft er recht leise.

Was mich allerdings wundert: Der Schrittmotor läuft im 
1/16-Mikroschrittbetrieb mit ~140Hz recht unruhig und scheint bei jedem 
Vollschritt einen kleinen Ruckler zu machen (-> ~8Hz), als ob die 
mikroschritte zu klein wären und zusammen nicht für einen Vollschritt 
reichen würden...

Weis jemand, woran das liegen könnte?

Viele Grüße
Hannes

[Thorsten O. (Firma: mechapro GmbH) (ostermann)]

Hallo Hannes,

was verwendest du denn für einen Treiber/Chip für die Ansteuerung?

Mit freundlichen Grüßen
Thorsten Ostermann

[Johannes M. (hannes_11)]

Den hier:

http://www.watterott.com/de/Pololu-A4988-Schrittmotortreiber

[Johannes M. (hannes_11)]

Ich habe in dem datenblatt etwas von Mixed Decay gelesen:

"For some applications where microstepping at very low speeds is
necessary, the lack of back EMF in the winding causes the current to
increase in the load quickly, resulting in missed steps. This is shown
in figure 2. By pulling the ROSC pin to ground, mixed decay is set to
be active 100% of the time, for both rising and falling currents, and
prevents missed steps as shown in figure 3."

Laut dem Schaltplan auf der webseite ist der ROSC pin jedoch bereits mit 
R4(10K) auf GND gesetzt und somit Mixed Decay auf 100%, wenn ich das 
richtig sehe.
R2, der ROSC mit 5V verbindet, ist mit "NP" bezeichnet - interpretiere 
ich das richtig, dass dieser nicht aufgelötet ist?

Viele Grüße
Hannes

[m.n. (Gast)]

Johannes M. schrieb:
> Der Schrittmotor ist vmtl. etwas überdimensioniert aber wenn der
> Motorstrom fast auf minimum eingestellt ist, läuft er recht leise.

Das heißt, das Rastmoment dominiert die Drehung, sodaß der eingeprägte 
Strom ihn nicht auf die Sollposition drehen kann. Zunächst hinkt der 
Rotor hinterher und springt dann auf den nächsten Rastpunkt.
Entweder der Strom soweit erhöhen, daß er möglichst gleichmäßig tickt, 
oder einen kleineren Motor nehmen.

Hast Du etwas von meinem Programm nutzen können?

[Johannes M. (hannes_11)]

Aber das dürfte doch erst passieren, wenn das Motordrehmoment in der 
Größenordnung des Rastmoments liegt, oder?
Das Rastmoment ist das Drehmoment, dass ich bei stromlosen und nicht 
kurzgeschlossenen Wicklungen aufwenden muss, um den Rotor zu drehen, 
richtig?

Das Drehmoment, dass nötig ist, um den Schrittmotor (per Hand) im 
Nachführbetrieb zu Schrittverlust zu zwingen, ist jedoch wesentlich 
größer.

Ich habe den Antrieb gerade nicht hier, um das zu testen, aber ich meine 
mich zu erinnern, dass das Ruckeln bei höherem Strom nicht weniger 
wurde.
Eigentlich müsste ein Schrittmotor mit 140Hz im Mikroschrittbetrieb doch 
ähnlich klingen, wie einer im Vollschrittbetrieb mit 140Hz, oder?

In diesem Threat wird ein ähnliches Problem beschrieben, allerdings auch 
ohne Lösung:
http://www.astrotreff.de/topic.asp?ARCHIVE=true&TOPIC_ID=145722&whichpage=2

Von deinem Programm habe ich leider nichts verwenden können.
Mein Programm sieht mehr oder weniger genau so aus, wie das, das ich 
weiter oben gepostet habe.
Mir war der CTC-Modus für den genauen Takt wichtig. Damit triggere ich 
einen Interrupt und die ISR wechselt den Zustand am Taktausgang.
Die Loop fragt dann zyklisch die schalterstellung ab und ändert je 
nachdem die Zustände des Enable- und Dir-Ausgangs und den Wert der 
Zählervariablen, die dann bei jeder ISR den wert für das 
CTC-Compare-Register updatet.
Die Rampe für den Schnellrücklauf funktioniert so, dass die 
Zählervariable bei jedem loop-Zyklus um einen bestimmten Wert 
verringert, bis die Soll-Geschwindigkeit erreicht wird. Die Rampe folgt 
somit einer irgendwas mit 1/x-Funktion, aber das sollte für diesen Zweck 
egal sein.
Das könnte ich noch ändern, indem ich statt dem wert für das 
compare-Register (der proportional zur Periodendauer ist) eine 
Frequenzvariable linear verändere, wodurch die Rampe auch linear werden 
würde.

Grüße
Hannes

[Thorsten O. (Firma: mechapro GmbH) (ostermann)]

Hallo Johannes,

> Aber das dürfte doch erst passieren, wenn das Motordrehmoment in der
> Größenordnung des Rastmoments liegt, oder?

Nein, auch darunter hat das schon einen z.T. entscheidenden Einfluss. 
Gerade bei den Mikroschritten, die nahe an den Halbschritt-Positionen 
liegen, ist eine Wicklung ja nur mit wenigen Prozent des Nennstroms 
bestromt. D.h. da schlägt dann das Rastmoment voll durch. Nicht umsonst 
gibt es Treiber, bei denen man die Form der Stromkurve an den Motor 
anpassen kann.

> Das Rastmoment ist das Drehmoment, dass ich bei stromlosen und nicht
> kurzgeschlossenen Wicklungen aufwenden muss, um den Rotor zu drehen,
> richtig?

Genau. Das liegt typisch bei 2-5% des Haltemomentes.

> Ich habe den Antrieb gerade nicht hier, um das zu testen, aber ich meine
> mich zu erinnern, dass das Ruckeln bei höherem Strom nicht weniger
> wurde.

Das wäre allerdings eher ein Zeichen für das im Datenblatt beschriebene 
Verhalten. Jetzt wäre es hilfreich, wenn du den Wicklungsstrom messen 
könntest. Vielleicht kann ich dazu nächste Woche auch mal Tests machen. 
Ich habe ein Testrack mit Hallsensoren zur Phasenstrommessung. Eins von 
den Pololu-Boards hatte ich mir kürzlich erst zum Testen bestellt, bin 
aber bisher noch nicht dazu gekommen, mich damit auseinander zu setzen.

> Eigentlich müsste ein Schrittmotor mit 140Hz im Mikroschrittbetrieb doch
> ähnlich klingen, wie einer im Vollschrittbetrieb mit 140Hz, oder?

Nein, gerade das soll der Mikroschritt ja verhindern. Durch das 
"sanftere" Weiterschalten sollte der Motor bei Mikroschritt deutlich 
ruhiger laufen.

Mit freundlichen Grüßen
Thorsten Ostermann

[Johannes M. (hannes_11)]

Hallo Torsten,

Thorsten Ostermann schrieb:
> Nein, auch darunter hat das schon einen z.T. entscheidenden Einfluss.
> Gerade bei den Mikroschritten, die nahe an den Halbschritt-Positionen
> liegen, ist eine Wicklung ja nur mit wenigen Prozent des Nennstroms
> bestromt. D.h. da schlägt dann das Rastmoment voll durch. Nicht umsonst
> gibt es Treiber, bei denen man die Form der Stromkurve an den Motor
> anpassen kann.

Heißt das, dass das Drehmoment im Mikroschrittbetrieb nicht für alle 
Schritte konstant ist? Ich dachte, dass die Wicklungen so bestromt 
werden, dass die Resultierende der beiden Kräfte den gleichen Betrag 
hat, wie die Kraft im Vollschrittbetrieb.

Thorsten Ostermann schrieb:
> Nein, gerade das soll der Mikroschritt ja verhindern. Durch das
> "sanftere" Weiterschalten sollte der Motor bei Mikroschritt deutlich
> ruhiger laufen.

Auch dann wenn ich 100 Mikroschritte pro Sekunde mit 100 Vollschritten 
pro Sekunde vergleiche? (ergibt dann natürlich verschiedene Drehzahlen)

Thorsten Ostermann schrieb:
> Jetzt wäre es hilfreich, wenn du den Wicklungsstrom messen
> könntest.

kann ich am We mal versuchen (Multimeter?).

Thorsten Ostermann schrieb:
> Vielleicht kann ich dazu nächste Woche auch mal Tests machen.

Das wäre klasse - vllt. hilft das ja weiter.

Grüße
Hannes

[Thorsten O. (Firma: mechapro GmbH) (ostermann)]

Hallo Johannes,

> Thorsten Ostermann schrieb:
>> Nein, auch darunter hat das schon einen z.T. entscheidenden Einfluss.
>> Gerade bei den Mikroschritten, die nahe an den Halbschritt-Positionen
>> liegen, ist eine Wicklung ja nur mit wenigen Prozent des Nennstroms
>> bestromt. D.h. da schlägt dann das Rastmoment voll durch. Nicht umsonst
>> gibt es Treiber, bei denen man die Form der Stromkurve an den Motor
>> anpassen kann.
>
> Heißt das, dass das Drehmoment im Mikroschrittbetrieb nicht für alle
> Schritte konstant ist? Ich dachte, dass die Wicklungen so bestromt
> werden, dass die Resultierende der beiden Kräfte den gleichen Betrag
> hat, wie die Kraft im Vollschrittbetrieb.

In erster Näherung ist das Drehmoment im Mikroschrittbetrieb konstant. 
Der von mir beschriebene Effekt betrifft ja immer nur eine Phase, und 
zwar die, die in dem Moment ohnehin keinen großen Beitrag zum 
resultierenden Moment liefert. Die erste Näherung vernachlässigt aber 
das Rastmoment. Das führt dann u.U. zu Winkelfehlern. Es wird gerne so 
getan, als würde Mikroschritt nicht nur die Auflösung erhöhen, sondern 
auch die Genauigkeit. Hier sieht man mal wieder, dass das nicht stimmt.

>> Nein, gerade das soll der Mikroschritt ja verhindern. Durch das
>> "sanftere" Weiterschalten sollte der Motor bei Mikroschritt deutlich
>> ruhiger laufen.
>
> Auch dann wenn ich 100 Mikroschritte pro Sekunde mit 100 Vollschritten
> pro Sekunde vergleiche? (ergibt dann natürlich verschiedene Drehzahlen)

Du hast dann ja unterschiedliche Drehfeldgeschwindigkeiten, also auch 
unterschiedliche Einflüsse durch Polteilung, Rastmoment usw.. Hinzu 
kommt, dass bei höherer Drehzahl die die Wicklung öfter umgepolt werden 
muss und die Gegen-EMK größer wird. Dann vergleichst du also Äpfel mit 
Birnen.

> Thorsten Ostermann schrieb:
>> Jetzt wäre es hilfreich, wenn du den Wicklungsstrom messen
>> könntest.
>
> kann ich am We mal versuchen (Multimeter?).

Das sollte dann aber schon ein True-RMS Multimeter sein. Und damit 
kannst du dann auch nur den statischen Fall messen. Besser wäre es 
eigentlich, wenn man per Oszilloskop und Hallsensor messen würde.

Mit freundlichen Grüßen
Thorsten Ostermann

[Johannes M. (hannes_11)]

Hallo zusammen,

über die Feiertage war wenig Zeit, sodass ich nicht nach der Ursache für 
das Ruckeln suchen konnte.
Aber dafür ist die Nachführung ansonsten fertig und hatte auch schon ihr 
"first light" - wie die Hobbyastromomen das nennen.

Da der provisorische Polsucher nicht funktioniert hat (zu dunkel) habe 
ich zur Ausrichtung einfach am Winkelprofil des Polsuchers entlang den 
Polarstern angepeilt, was erstaunlich gut funktioniert hat.

Nach einigen Versuchen mit 200mm, wo die Sterne nach 60s noch 
punktförmig waren, habe ich das 500mm-Tele montiert und den Orionnebel 
angepeilt.
Das erste Bild im Anhang ist ein Stack aus 7 Aufnahmen mit jeweils 60s 
bei f/5,6 ;ISO 400 mit einer Nikon D80.

Das zweite Bild ist eine Aufnahme mit 12mm bei 95s; ISO400; f/4.

Die Ergebnisse sind für meine Verhältnisse ganz ansehnlich und haben 
meine Erwartungen übertroffen (gerade bei 500mm).

Die übrigen 8 Bilder im Anhang zeigen den Aufbau der Montierung mit 
Polhöhenblock, Antrieb, Lager, Reibradantrieb, Stativ, Polsucher und die 
Steuerung mit Arduino und "Motor-shield".
Stativ, Polhöhenblock und Polsucher sind aus geschweißtem Stahl 
aufgebaut.
Der Reibradantrieb besteht aus Multiplex; das Kugelgelagerte Reibrad 
selbst ist eine 8mm-Welle aus einem Drucker.

Für Fragen und Verbesserungsvorschläge bin ich offen :)

Vielen Dank für eure Hilfe :)

Grüße
Hannes

[Michael R. (Firma: Brainit GmbH) (fisa)]

Johannes M. schrieb:
> Orionnebel

Wow! Wenn ich nur nicht so wenig Zeit hätte...

[Georg G. (df2au)]

Bülent C. schrieb:
> #ifndef F_CPU
> #warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
> #define F_CPU 12000000UL
> #endif

Das hier solltest du bei Gelegenheit korrigieren. Kommentar und 
Wirklichkeit sollten zueinander passen.

Glückwunsch zu dem Orion Foto. Ich könnte fast Lust bekommen, meiner 
Frau die Nikon zu entwenden und auch mal zu basteln.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Georg G. schrieb:
> Glückwunsch zu dem Orion Foto. Ich könnte fast Lust bekommen, meiner
> Frau die Nikon zu entwenden und auch mal zu basteln.

Genau. Meine hat auch eine Nikon :-)