Zeitprobleme bei Berechnung linearer Rampe für Schrittmotor(AVR)

[stepper motor (Gast)]

Hallo,

ich will eine lineare Rampe für einen Schrittmotor implementieren. Als 
Endstufe verwende ich das Triple Beast, das über den LPT-Port-Eingang 
die
Schritt- und Richtungssignale vom µC erhält. Die Application Note von 
Atmel (AVR446) und diese Seite
http://www.embedded.com/design/mcus-processors-and-socs/4006438/Generate-stepper-motor-speed-profiles-in-real-time
habe ich mir dazu schon angesehen.
Mein Problem ist, dass die Berechnung des nächsten Reloadwertes für die 
Beschleunigungsrampe nach dieser Formel

$$c_n = c_{n-1}-\frac{2c_{n-1}}{4N+1}$$

zu lange dauert, sodass ich keine genügend hohen Schrittfrequenzen 
erzeugen kann. Benötigen würde ich maximal ca. 5 U/s also eine 
Schrittfrequenz von 5kHz bei 1000 Mikroschritten pro Umdrehung. Die ISR 
muss dazu aber leider mit 10kHz aufgerufen werden, da die Endstufe nur 
auf steigende Flanken beim Schrittsignal reagiert und ich in der ISR den 
Pin nur toggeln kann.
Die Berechnung dauert momentan laut Simulator ca. 120 µs.
Eine Tabelle mit den Reloadwerten möchte ich nicht verwenden, da später 
auch die Beschleunigung variabel sein soll.
Ich programmiere mit Bascom. Bei der Berechnung des nächsten 
Reloadwertes habe ich mich an den Beispielcode aus der AVR446 gehalten, 
also diese Zeilen:

new_step_delay = srd.step_delay - (((2 * (long)srd.step_delay) + rest)/
(4 * srd.accel_count + 1));

rest = ((2 * (long)srd.step_delay)+rest)%(4 * srd.accel_count + 1);

Hier mein Testprogramm, worin auch µC und dessen Taktfrequenz stehen:

$regfile = "m328def.dat"
$crystal = 11059200

$hwstack = 64
$swstack = 64
$framesize = 64

Dim C_n_alt As Word
Dim C_n_neu As Word
Dim Rest As Word
Dim 4n_plus1 As Long
Dim 2c_n_alt As Long
Dim Reload_akt As Word
Dim Restsumme As Long
Dim N As Long
Dim Motor_nr As Byte

Dim Constant As Bit

Config PORTD = Output

Config Timer1 = Timer , Clear Timer = 1 , Prescale = 8
Enable Timer1
On Timer1 Clk
Enable Interrupts


Declare Sub Calculate_reload_akt


'Beschleunigung: 1 U/s², 1000 Mikroschritte pro Umdrehung(U)
C_n_alt = 29552
Reload_akt = 65536 - C_n_alt
Timer1 = Reload_akt
Rest = 0
N = 0
Constant = 0

Do

'Bis ca. 4,5 U/s beschleunigen und dann Drehungszahl halten
If Reload_akt > 65383 Then
   Constant = 1
   Reload_akt = 65383
End If

Loop

'Dauer(laut Simulator): ca. 0,12 ms
Sub Calculate_reload_akt
2c_n_alt = 2 * C_n_alt
4n_plus1 = 4 * N
4n_plus1 = 4n_plus1 + 1
2c_n_alt = 2c_n_alt + Rest
Restsumme = 2c_n_alt
2c_n_alt = 2c_n_alt / 4n_plus1
C_n_neu = C_n_alt - 2c_n_alt
Reload_akt = 65536 - C_n_neu
Rest = Restsumme Mod 4n_plus1
C_n_alt = C_n_neu
End Sub

Clk:
If Constant = 0 Then
   Incr N
   Call Calculate_reload_akt
End If
Timer1 = Reload_akt
Toggle Portd.motor_nr

Return

Ich hoffe mir kann jemand weiterhelfen.

[radiostar (Gast)]

stepper motor schrieb:
> Eine Tabelle mit den Reloadwerten möchte ich nicht verwenden, da später
> auch die Beschleunigung variabel sein soll.

Dann mach mehrere Tabellen für verschiedene Beschleunigungen.

[Karl H. (kbuchegg)]

Überprüf mit deinen konkret auftretenden Zahlenwerten, welche der 
Variablen

Dim C_n_alt As Word
Dim C_n_neu As Word
Dim Rest As Word
Dim 4n_plus1 As Long
Dim 2c_n_alt As Long
Dim Reload_akt As Word
Dim Restsumme As Long
Dim N As Long
Dim Motor_nr As Byte

tatsächlich Long sein müssen, und bei welchen Berechnungen (auch 
Zwischenergebnissen), du dem µC eine Menge Fleissaufgaben aufbürdest, 
indem du ihn zwingst in 32 Bit zu rechnen, wo es 16 Bit auch tun.

[Karl H. (kbuchegg)]

Ich mag mich auch täuschen, aber ob BASCOM zb das hier

4n_plus1 = 4 * N

in einen Links-Shift umwandelt, da bin ich mir nicht sicher.

Auf jeden Fall sind 0.12ms für diese simple Berechnung bei 11Mhz recht 
indiskutabel. Aber fang mal damit an, die Datentypen an das anzupassen, 
was du tatsächlich brauchst.

[LostInMusic (Gast)]

Ich vermute den Kern des Problems hier:

2c_n_alt / 4n_plus1

Integer- oder Float-Division? Wie wird das gerechnet?

[stepper motor (Gast)]

Also ich habe jetzt die Multiplikationen durch Shifts ersetzt und die 
Datentypen auf Word geändert. Jetzt dauert die Berechnung ca. 60 µs.
Das reicht leider noch nicht, da bei Maximalgeschwindigkeit jede 100 µs 
die ISR aufgerufen wird und das Hauptprogramm auch noch zum Zuge kommen 
soll. Kann man das Problem mit dem Toggeln nicht irgendwie lösen? Die 
Impulsbreite des Schrittsignals muss für die Endstufe jedoch mindestens 
2 µs betragen.

[LostInMusic (Gast)]

>Kann man das Problem mit dem Toggeln nicht irgendwie lösen?

Ich würde Timer 1 im CTC-Modus laufen lassen. Nach jeder Neuberechnung 
OCR1A auf C_n_neu setzen, und OCR1B auf die Hälfte davon. Du kannst den 
Timer so konfigurieren, dass bei Erreichen des OCR1B-Wertes von der 
Hardware ein Pin gesetzt oder gelöscht wird. Weitere Infos siehe 
Datenblatt.

[stepper motor (Gast)]

Ich habe gerade bemerkt, dass ich 2c_n_alt doch 32 Bit groß machen muss, 
da der Rest auch noch hinzuaddiert wird und leider auch sehr groß werden 
kann.
Damit sind Division(Festkomma) und Modulo auch wieder 32 Bit 
Operationen.
Mit dem zweimaligen Toggeln und neuen µC-Takt von 18,432 MHz komme ich 
auf eine Berechnungsdauer von ca. 80 µs, was für 4 U/s reichen sollte, 
da die ISR nur jede 250 µs aufgerufen wird.

Der Bascom-Simulator setzt TCNT1 immer auf 0 sobald der kleinste Wert 
von OCR1A und OCR1B erreicht ist. Wenn jetzt z.B. OCR1B auf 10000 und 
OCR1A auf 20000 gesetzt ist, würde der Interrupt von OCR1A nie ausgelöst 
werden.
Ist das ein Fehler im Simulator?

[LostInMusic (Gast)]

>Damit sind Division(Festkomma) und Modulo auch wieder 32 Bit Operationen.

Du hast zwei Alternativen: (1) Solange rumprobieren, bis es irgendwie 
geht und Du mit dem Ergebnis leben kannst, oder (2) den Algorithmus und 
den Code von vorne bis hinten durchanalysieren und auf Basis der 
gewonnenen Erkenntnisse fundierte Entscheidungen treffen. (1) ist 
schnell und (2) ist sauber.

>Mit dem zweimaligen Toggeln und neuen µC-Takt von 18,432 MHz komme ich
>auf eine Berechnungsdauer von ca. 80 µs, was für 4 U/s reichen sollte,
>da die ISR nur jede 250 µs aufgerufen wird.

Aber ist es eigentlich nötig, mit jedem Motorstep eine Neuberechnung 
durchführen? Würde es nicht auch reichen, das nur z. B. 80 mal pro 
Sekunde zu machen? Um einen entsprechenden Takt zu erzeugen, kannst Du 
Timer 0 nehmen, und die "lahme" Rechenroutine gehört dann ins Main, 
damit sie von den schnellen Timer 1-Interrupts unterbrochen werden kann. 
Die Aktualisierung des OCR1A-Werts musst Du in der ISR vom Timer1-OCRA 
erledigen, und die Bereitstellung des Ergebnisses durch die 
Rechenroutine atomar machen. You understand? Ist aber alles relativ easy 
zu bewerkstelligen.

>Ist das ein Fehler im Simulator?

Wahrscheinlich... keine Ahnung, sorry. Das von Dir beschriebene 
Verhalten ist jedenfalls nicht konform zu dem eines realen Controllers.