[AVR GCC Kurs2] Stepper-Interface

Die letzten Werte werden weggelassen.

Ich vermute, Du hattest nicht berücksichtigt, dass die Einträge der Tabelle ab 0 gezählt werden. (100Einträge -> Länge= 99)

Bei Tabellen >150Einträgen würde ich vielleicht doch eine Berechnung zur Laufzeit vornehmen. Dazu hatte ich ja schon eine AN von ATMEL genannt. Du müsstest nur versuchen, die Geschichte so umzuschreiben, dass die Berechnung anstatt mit Zielpositionen mit einem Positionsstream (DMX) klarkommt. Die Rechenzeit könnte also bei der Wurzelberechnung kritisch werden.

"Wartezeiten" beim Richtungswechsel sollten über die Beschleunigungstabelle realisiert werden.

Bevor Du irgendwelche Sinustabellen aufschnappst, befass Dich doch erstmal mit der Physik und der Funktionsweise. Du bastelst mir mittlerweile einfach zu viel und rechnest zu wenig

Vielleicht fällt Dir ja auch ein neues Konzept für die Geschwindigkeiten ein, das wir dann hier durchgehen können. Wie firm bist Du eigentlich in der Antriebstechnik?

VG,
Hendrik

Da ich keinen fertigen Code für Deinen Stepper mehr zu bieten habe (und ich auch momentan keine Zeit und Motivation habe, mir einen völlig neuen Algorithmus auszudenken), gibt es nun ein paar Grundlagen Antriebstechnik.

Somit verstehen vielleicht auch die Schüler, Informatiker (ihr habt keine Mechanik, oder?) und "Geisteswissenschaftler" unter Euch, was wir hier eigentlich machen

Die Basis von jedem mechanischen System (und ein Movinglight ist ein solches...) ist das Krafterhaltungsgesetz nach Newton:
Die Summe aller Kräfte ist Null.
In unserem Fall heißt das:
0= Mt +Mr +Man
Dabei sind Mt das Trägheitsmoment der zu bewegenen Masse, Mr das Reibmoment (Haftreibung, Gleitreibung und viskos wegen Schierfett - also schön nichtlinear) und Man das Antriebsmoment Deines Steppers.

Trägheitsmoment:
Nach Newton gilt: Ft=m*a (Kraft=Masse*Beschleunigung)
Da wir uns drehen gilt: Mt= J*a (Moment=Massenträgheitsmoment*Winkelbeschleunigung)
Formeln zur Berechnung der Trägheitsmomente verschiedener Körper findet Ihr auf Wikipedia.

Nun haben wir mit verschiedenen Massen zu tun: Der Flower und der Rotor des Steppers. Um beide zu berücksichtigen, reduziert man in der Antriebstechnik alle Massen auf die Antriebswelle. In unserem Fall heißt das:
J_ges= J_mot +J_flower/i^2
i ist dabei die Übersetzung Deines Riementriebs (z_flower/z_ritzel)

Reibmoment:
das dürfte bei Dir verhältnismäßig klein sein. Da keine Daten vorliegen, setze es auf 0 und rechne später einen Sicherheitsfaktor mit ein...

Antriebsmoment:
Das Antriebsmoment ist abhängig vom Strom und der aktuellen Drehzahl und sollte aus einem Diagramm im Datenblatt ablesbar sein.

Auf diese Weise erhalten wir durch Umstellen der Gleichungen die maximale Beschleunigung, die der Motor bei einem bestimmten Strom und Drehzahl liefern kann.

Ein Problem ist die Resonanzdrehzahl: In diesem Bereich haben wir fast kein Antriebsmoment und können nur wenig beschleunigen - wir sollten also darunter bleiben.

Rechne mit einem Sicherheitsfaktor von 25%..50%, damit wir auch ja keine Schrittverluste erhalten

Kommen wir nun zur Bahnsteuerung:

Die Zustandsgrößen unseres mechanischen Systems sind
r = der Ruck (der den Head wackeln lässt)
a = die Beschleunigung (die durch den Motor begrenzt wird)
w= die Drehzahl (omega; sollte limitiert werden, damit Du in einer vernünftigen Zeit abbremsen kannst)
s = der Winkel (eigentlich phi - was soll's...)

Der momentane Bewegungszustand Deines Heads kann durch folgende Differentialgleichungen berechnet werden:

s(t)= v(t)*t +s_0

[X(t) bedeutet, dass die Variable sich mit der zeit ändern kann, t ist die aktuelle Zeit und X_0 ist der Ausgangswert der Variable, zu dem Zeitpunkt, an dem wir mit der betrachtung des Systems beginnen...]

v(t)= a(t)*t +a_0

a(t)= r*t +a_0

Bei meinen Tabellen habe ich keine Ruckbegrenzung (deswegen kann es evtl. wackeln...) und ich rechne mit den Ausgangswerten:
a_0= 0
v_0= 0
s_0= 0
(also Stillstand @home position)

Somit vereinfacht sich meine Rechnung zu:
s(t)= (a/2)*t^2
(einfache Integration...)

Wie funktioniert derzeit mein Code?

Die Basis von allem ist eine Tabelle mit den Schrittdauern für die Geschwindigkeiten. Sie berechnet sich nach AN446 von ATMEL:

Die Schrittzeit des ersten Schrittes aus dem Stillstand ist
t= sqrt(2*s/a), wobei s dem Winkel eines (Mikro-)schrittes entspricht.
(Die Formel sollte Euch bekannt vorkommen )

Die Anzahl der Timer-Ticks ist
n_clk= t/t_clk, wobei t_clk die Zeitdauer eines Timer-Ticks ist.

Die Zeitdauer des ersten Schrittes ist also t_2 -t_1

t_1 =sqrt(1*2*s/a)
t_2 =sqrt(2*2*s/a)

(da s der Winkel des ersten Schrittes und 2s der Winkel nach zwei Schritten ist)
also:

delta_t= sqrt(2*s/a) *(sqrt(2)-1)

oder allgemein für den n-ten Schritt:
delta_t_n= sqrt(2*s/a) *(sqrt(n+1)-sqrt(n))

Und das ergibt meine Tabelle.

Was macht nun check_accel() ?

Zunächst vergleiche ich die Differenz zwischen Soll- und Istposition, also den sogenannten Schleppabstand, mit der aktuellen Geschwindigkeit.
Wenn der Schleppabstand kleiner als die Geschwindigkeit ist, bremse ich ab. (neg. Geschw. ist linksdrehend, pos. Geschw. ist rechtsdrehend, 0 ist Stillstand)

Ansonsten beschleunige ich bis zur maximalen Geschwindigkeit, also RAMP_LEN.

Abschließend lade ich die zur berechneten Geschwindigkeit gehörende Schrittdauer aus der Tabelle (s.o.)

Die Aufgabe wäre also nun, einen Weg zu finden, ohne Tabelle aus dem Schleppabstand die maximal zulässige Geschwindigkeit zu gewinnen, bei der man noch durch Abbremsen das Ziel trifft.

Ich schätze, ich habe einen neuen Ansatz für die Geschwindigkeitsführung bei Steppern gefunden:

Schleppabstand:
e= Sollposition -Istposition;

Sollgeschwindigkeit:
v_soll= e *kp;
if (v_soll > v_max) v_soll= v_max;
else if (v_soll < v_min) v_soll= v_min;
(Also ein einfacher Proportionalregler mit Sättigung. Das Finden des richtigen Proportionalfaktors kp könnte noch interessant werden...)

Nun muss die Motorgeschwindigkeit der Zielgeschwindigkeit mit der zulässigen Beschleunigung (s.o.) nachgeführt werden:

if (v_soll > v_ist) v_ist += a;
else if (v_soll < v_ist) v_ist -= a;

(a wäre die Beschleunigung. Ich schätze dieser Teil ist suboptimal, da die Geschwindigkeit ziemlich grob mit der Stufung der maximalen Beschleunigung geführt wird. Besser wäre wohl ein weiterer P-Regler, sodass eine Kaskade gebildet wird...)

Das sähe dann so aus:
ev= v_soll -v_ist;
a= ev *kp_v;
if (a > a_max) a= a_max;
else if (a < a_min) a= a_min;
v_ist += a;

Wahrscheinlich kann man den Proportionalfaktor auf 1 setzen und direkt ev als a nutzen...

Was halten die Elektrotechniker unter Euch davon?

VG,
Hendrik

Hier mal eine Sprungantwort in Simulink mit der Kaskade:
Sprungamplitude= 4
kp_x=2
kp_v=20
Geschw.begrenzung= 10
Beschl.begrenzung= 5

kontinuierlich gerechnet.

Das Ganze ist nur zur Darstellung des Konzeptes gedacht - also keine realen Werte...

hier die Kaskade bei einer Folgeregelung. Deutlich ist der Schleppabstand sichtbar. Evtl. könnte man da noch was mit einer Vorsteuerung rausholen...

Viel Spaß dann,
Hendrik

Da keine Divisionen oder Wurzeln nötig sind, könnte man das bei jedem Universe-Refresh durchrechnen lassen.

Offen gestanden, bin ich aber zunächst gespannt, was Michael, Mathias und Dirk dazu sagen... Es ist durchaus möglich, dass ich ja was übersehen habe.

Grundsätzlich: Wenn es nicht zum Thema passt, lieber erst einmal nach anderen Threads suchen und dann ggf. einen neuen aufmachen.

Ansonsten reicht Deine "Fehlerbeschreibung" natürlich nicht aus:

Projekt mit vollst. Code (zip-Archiv) seh ich nicht.
Beschreibung müsste genauer sein
Sprache, Compiler und Toolchainversion fehlt...

Für mich hört sich das derzeit nach einem zerschossenen Stack an.

VG,
Hendrik

Henne:
Auf deiner Site steht:

Quote

Zur Konfiguration von Beschleunigungen und maximalen Winkeln - also dem Verfahrbereich - befindet sich eine Software für Windows im Archiv, die eine Datei für das EEPROM des AVRs generiert.

Welches Archive meinst du? Resources? Wie heißt die Datei denn?