Ich selbst arbeite bei meinem Motorfocuser mit einerm TMCL-Script auf dem StepRocker-Board.

Dieses dient der Referenzierung des Fokusierers und führt die folgenden Aufgaben durch:

  1. Motorabhängige Parameter wie Motorstrom und StallGuard und
  2. Referenzierung
    1. Der Fokussierer wird ein Stück nach aussen bewegt um sicher zu stellen dass er sich nicht in einem mechanischen Anschlag befindet.
    2. Es wird eine Bewegung nach innen durchgeführt bis der Fokusierer innen anschlägt.
    3. Dann wird eine kurze, definierte Strecke nach aussen gefahren und die 0-Position gesetzt
    4. Es wird so weit nach aussen gefahren bis der Fokusierer gegen den Anschlag fährt und es wird ein kleines Stück nach innen gefahren und es wird die Maximale Position in die Bank 2 Speicherplatz 0 geschrieben und zusätzlich für die interne Verwendung als Koordinate gespeichert.
    5. Die absolute 0-Position wird angefahren.
  3. Seperate Laufende Überwachung der Position

Nach dem Abschluss der Referenzierung steht der Fokussierer für den vollständigen Einsatz zur Verfügung.

TMCL steht für Trinamic Motion Controll Language und stellt eine auf die Trinamic-Controller zugeschnittene Komandosprache zur Verfügung. Diese kann zum einen für die Steuerung von extern verwendet werden, was bei dem ASCOM-Treiber genutzt wird und zum anderen können damit Scripte erstellt werden, welche wie in meinem Fall direkt auf der Treiberkarte abgelegt sind.

Ich möchte hier nicht zu tief ein die Programmierung mit der Scriptsprache eingehen und verweise für Details auf die hervorragende IDE und die Referenz von Trinamic. Lediglich den Aufbau der Befehle möchte ich hier an ein paar Beispielen erläutern.

  • Beispiel 1, festlegen der Geschwindigkeit '50' für Motor 0:
    • SAP 4,0,50
      • SAP=Mnemonische Bezeichnung für 'Set Axis Parameter'. Hiermit können eine ganze Anzahl Parameter für die Achsen engestellt werden.
      • 4=definiert den Parameter dessen Wert gesetzt werden soll. In diesem Fall ist das die Positioniergeschwindigkeit der Achse
      • 0=bezeichnet die Achse. Die Trinamic-Controller unterstützen bis zu drei Schrittmotoren (0,1,2) In diesem Fall ist das der erste Motor und damit auch der, dessen Treiber direkt auf dem Board sitzen.
      • 50=legt den eigentlichen Wert fest. Bei z.B. Beschleunigung und Geschwindigkeit kann dieser ganzzahlig von 0-2047 gewählt werden.
  • Beispiel 2, speichert einen festen Wert auf der Karte zur späteren Verwendung im Skript oder dem ASCOM-Treiber
    • SGP 3,2,170           //Store 170 in Bank 2, Var. 3
      • SGP=Mnemonische Bezeichnung für 'Store Global Parameter'
      • 3=bezeichnet den Speicherplatz. In diesem Fall #3
      • 2=legt die Speicherbank fest. Es stehen die Bank 0,1 und 2 zur Verfügung. Wobei 0 und 1 für das System reserviert sind und nicht überschrieben werden sollten. Bank 2 ist speziell für das ablegen von Benutzerdaten vorgesehen und wird auch vom Treiber auf wunsch abgefragt.
      • 170=Wert, der in den Speicherblock geschrieben wird.

Wenn man sich mit dem Board beschäftigt und vielleicht ein eigenes Script verwenden, oder meines übernehmen will, rate ich jedem vor dem endgültigen einsetzen als Fokusierer mit dem Board, einem Motor und der Scriptsprache rumzuprobieren. Es lohnt sich.

Im folgenden gehe ich näher auf das Script ein.

//Setting Motorparamter for a Motorfocusser
//Reference-Routine: moves the Focusser with the value 'MechStop' out of a possible mechanichal stop, moves inwards until
//mechanichal stop, moves 'MoveOut' outwards and set Absolute Position to 0
//IMPORTANT: It is Important, to calculate and set the Motorcurrent correct. See here the Hardware-Manual and the TMCL-Reference
//Use the stallGuard2-Tool for find the optimal StallGuard-Parameter you need.

//Values NEEDED to correct

Ich arbeite wegen der Übersichtlichkeit und mehrfachen Verwendbarkeit gerne mit Variablen.
Das schöne an der TMCL ist, dass man diese nicht vorher bezeichnen muss.
Diese definiere ich ab hier:

//Speed, Acceleration and Stepping
Mic=1                     //Microsteppingresolution 7=128 Microsteps/Fullstep
RefSearch=50              //Velocity for Reference-Search
Acceleration=1000         //Acceleration of the Stepper-Motor

//Short Movement Values
MechStop=1000            //Move outwards, away from possible mechanichal stop
MoveOut=200              //move away from inner stop (must POSITIVE)
MoveIn=-25               //move away from outer stop (musst NEGATIVE)


//From here Changes here are opional, but not recommended
//Motorparameter
//Motorcurrent and StallGuard
Imot=255                  //Maximum Motorcurrent (670mA=1A/0,67A=255/0,67=170)
Istb=0                    //Motorcurrent in Standby (1A/255*0=0,0A)
Rmp=0                     //Rampmode

//Settings for ROL
l173= 1        //stallGuard2 filter setting
l174= 1        //stallGuard2 threshold value
l181= 1        //set StallGuard active
l168= 0        //coolStep minimum current setting
l169= 3        //coolStep down step setting
l171= 3        //coolStep up step setting
l170= 1        //coolStep hysteresis width
l172= 3        //coolStep hysteresis start
l182= 50       //coolStep threshold speed
l183= 255      //coolStep slow run current
//Settings for ROR
r173= 1        //stallGuard2 filter setting
r174= 35       //stallGuard2 threshold value
r181= 1        //stop on stall value
r168= 0        //coolStep minimum current setting
r169= 3        //coolStep down step setting
r171= 3        //coolStep up step setting
r170= 1        //coolStep hysteresis width
r172= 3        //coolStep hysteresis start
r182= 50       //coolStep threshold speed
r183= 255       //coolStep slow run current
       
//Set Axis-Parameter
SAP 4,0,RefSearch  //set Velocity for positioning
SAP 5,0,Acceleration  //set acceleration
SAP 6,0,Imot     //Motorcurrent
SAP 7,0,Istb     //Standbycurrent
SAP 138,0,Rmp    //Rampmode (see Reference)
SAP 140, 0, Mic  //Microstepping

Hier schreibe ich einige Parameter in die Bank 2 um sie mit der '#'-Funktion später evtl. im Treiber zu verwenden.

//Stor Parameter to Uservariable in Bank 2
SGP 1,2,RefSearch      //Store RefSearch in Bank 2, Var. 1
SGP 2,2,Acceleration   //Store Acceleration in Bank 2, Var. 2
SGP 3,2,Imot           //Store Imot in Bank 2, Var. 3
SGP 4,2,Istb           //Store Istb in Bank 2, Var. 4
SGP 5,2,Rmp            //Store Rmp in Bank 2, Var. 5
SGP 6,2,Mic            //Store Mic in Bank 2, Var. 6

Hier beginnt das eigentliche Programm.
Zuerst wird der StallGuard DEaktiviert und es wird um 'MechStop' nach aussen gefahren um dicher zu stellen, dass der Fokusierer NICHT am Anschlag anliegt und die Bewegung nach innen wird gestartet.
      
//From here, nothing should be changed.
//StartUp-Script
            SAP 181, 0, 0         //StallGuard DEactive
            MVP REL, 0, MechStop  //move motor out of a possible mechanichal stop
            WAIT POS, 0, 0 //wait until position is reached       
            ROL 0,RefSearch       //move left (inwards) with RefSearch-speed
//StallGuard for ROL
SAP 173, 0, l173    //stallGuard2 filter setting
SAP 174, 0, l174    //stallGuard2 threshold value
SAP 181, 0, l181    //set StallGuard active
SAP 168, 0, l168    //coolStep minimum current setting
SAP 169, 0, l169    //coolStep down step setting
SAP 171, 0, l171    //coolStep up step setting
SAP 170, 0, l170    //coolStep hysteresis width
SAP 172, 0, l172    //coolStep hysteresis start
SAP 182, 0, l182    //coolStep threshold speed
SAP 183, 0, l183    //coolStep slow run current

Mit der folgenden Funktion wird (nach dem aktivieren der StallGuard-Funktion zuerst der inner Mechanische Anschlag gesucht. Dazu wird kontinuierlich die Motorgeschwindigkeit überwacht. Wenn diese 0 ist, hat der StallGuard ausgelöst, Der Motor wird um 'MoveOut' rausgefahren und die 0-Position gesetzt.
  Inref:     GAP 3, 0              //read motor-speed
            COMP 0                //compare with 0
            JC NE, Inref           //if motor-speed is >0 jump to Inref
            MST  0                //Motor Stop
            WAIT TICKS, 0, 250    //Wait 100 Ticks
            SAP 1, 0, 0           //set position to 0
            SAP 181, 0, 0         //StallGuard DEactive
            MVP REL,0,MoveOut     //move away from mechanichal stop
            WAIT POS, 0, 0  //wait until position reached
            SAP 1, 0, 0           //set position to 0
Hier beginnt die Rechtsdrehung für das finden des Maximalen Fokusierweges. Die Referenzierung an sich arbeitet genau so wie oben beschrieben.
            ROR 0,RefSearch       //rotate right
            WAIT TICKS, 0, 25     //wait until motor turns (buffer start-tourque)
//StallGuard for ROL
SAP 173, 0, r173    //stallGuard2 filter setting
SAP 174, 0, r174    //stallGuard2 threshold value
SAP 181, 0, r181    //set StallGuard active
SAP 168, 0, r168    //coolStep minimum current setting
SAP 169, 0, r169    //coolStep down step setting
SAP 171, 0, r171    //coolStep up step setting
SAP 170, 0, r170    //coolStep hysteresis width
SAP 172, 0, r172    //coolStep hysteresis start
SAP 182, 0, r182    //coolStep threshold speed
SAP 183, 0, r183    //coolStep slow run current
  Outref:   GAP 3, 0              //read motor-speed
            COMP 0                //compare with 0
            JC NE, Outref         //if motor-speed is >0 jump to Outref
            WAIT TICKS, 0, 25
            MST  0                //Motor Stop
            SAP 181, 0, 0         //StallGuard DEaktiviert
            MVP REL, 0, MoveIn    //Move inwards from mechanichal Stop
            WAIT POS, 0, 0

Nur das speichern des Wertes muss anders erfolgen, da wir ja nicht erneut unseren 0-Wert ändern wollen. Zuerst wird die aktuelle Position in den Akku geladen:
            GAP 1, 0              //get actual postition including write to accumulator

Danach wird der Inhalt des Akkumulators in dem Speicherplatz 0 der Bank 2 geschrieben:
            AGP 0, 2,             //stores the accumulator in uservariable 0

Es ist zwar möglich, auf einen in der Speicherbank wert zu fahren, aber es ist unnötig umständlich. Es ist wesentlich einfacher eine gespeicherte Koordinate anzufahren. Daher wird die Akuelle Position hier noch einmal gespeichert.
            CCO 1, 0              //stores the actual position to coordinate 1 (it's later needed)
            MVP ABS, 0,0          //move back to 0
            WAIT POS, 0, 0

Die Hauptschleife. Hier soll die Motorposition (unabhängig vom ASCOM-Treiber) überwacht und illigale Positionierungen (<0 & >Maximal Position) verhindert werden.           
//MainLoop

'Main:' bezeichnet die Sprungmarke. Danach wird die aktuelle Position abgefragt
  Main:     GAP 1, 0              //get actual position

Diese wird mit der Konstante -1 verglichen und das Ergebniss im Akkumulator gespeichert (0 würde zu Problemen führen, wenn man tatsächlich '0' anfahren wollte)
            COMP -1               //comp with -1

Wen das Ergebnis kleiner 0 ist, wird zu der Sprungmarke 'MotMin' gesprungen.
            JC LT, MotMin         //if accu lower 0 jump MotMin

Die Maximal-Position wird über den Akkumulator in des X-Register geladen. Dieses ist speziel für Rechenoperationen vorgesehen.
            GGP 0, 2              //load max-position to accumulator
            CALCX LOAD            //load accumulator to X-register

Es wird wieder die aktuelle Position in den Akku geladen und von diesem wird der Inhalt des X-Registers abgezogen und mit 1 verglichen.
            GAP 1, 0              //get actual position
            CALCX SUB             //subtract X-register from accu
            COMP 1

Ist die Tatsächliche Position größer als der Maximalwert und damit Akku-X-Register>1 springt das Skript zu 'MotMax'. Wenn nicht, zurück zu 'Main'
            JC GT, MotMax         //if accu-X-reg. >0 jump MotMax
            JA Main               //jump Main

Hier wird als erstes die Bewegung unterbrochen und der Motor zur Position 0 bewegt. Danach springen wir zurück zu 'Main'
            
  MotMin:   MST 0                 //motor stop
            MVP ABS, 0, 0         //move to 0
            WAIT POS, 1, 0
            JA Main               //jump Main

Bei 'MotMax' wird ähnlich vorgegangen. Allerdings wird hier nicht auf 0 gesprungen, sondern zur Koordinate 1, welche wir vorher gespeichert haben. Auch hier erfolgt der Sprung zurück zu 'Main'.
           
  MotMax:   MST 0                 //motor stop
            MVP COORD, 0, 1       //move to max-position
            WAIT POS, 1, 0
            JA Main               //jump Main

Wenn ihr noch fragen habt, könnt ihr euch gerne mit mir in Verbindung setzen.