Assembler in C einbinden, Parameter übergabe

[kein Rahul (Gast)]

Hallo!

Dank euch habe ich doch tatsächlich recht viel über Mikrocontroller 
gelernt und habe auch schon einiges damit angestellt. Bisher habe ich 
immer in ASM programmiert und bin damit auch prima zurecht gekommen.
Beim aktuellen Projekt habe ich ein Handydisplay an den AVR 
angeschlossen. Ich habe die Ansteuerung in ASM geschrieben. Nun ist es 
aber wirklich zeitrauben und mühsam um irgendwelche Grafiken etc zu 
zeichnen, es wird einfach ziemlich unübersichtlich.
Gut habe ich mir gedacht, C kannst du ja ein bisschen jetzt wirds Zeit 
um auf C umzusteigen, den MC kennst du ja nun doch ziemlich gut.
Gesagt getan, habe ich die Ansteuerungsroutinen in C nochmals 
geschrieben. Und oh Schreck, das ist ja um mindestens den Faktor 2-3 
langsamer. Jetzt schaffe ich noch eine Bildwiderholrate von ca. 5/s, mit 
den ASM Routinen habe ich gegen 20 (oder doch mehr) geschafft. Und das 
trotz Optimierungsstufe 2!
OK, es gibt ja noch die Möglichkeit ASM in C einzubinden. Habe dazu im 
Tutorial ein bisschen was gefunden, auch wenn ich da noch nicht wirklich 
durchsteige wie man das jetzt am einfachsten macht (nicht 
inline-assembler, sondern ganze Funktionen oder so).
Die Hauptfrage die sich aber aufdrängt, wie mache ich die 
Parameterübergabe an eine ASM-Funktion am einfachsten? per Stack, kann 
ich in C Register direkt verwenden, oder über S-Ram?
Danke für alle Tipps diesbezüglich. Da schweigt das Tutorial...

Gruss

[Luhar (Gast)]

> Und oh Schreck, das ist ja um mindestens den Faktor 2-3 langsamer.

Dann solltest Du Deinen Programmierstil optimieren :-)

Wie die Parameterübergabe von C stattfindet sagt Dir das Handbuch. Aber 
Du kannst sie auch herausfinden, indem Du eine C-Routine schreibst und 
Dir im Ass-Listing ansiehst, was in Registern und was auf dem Stack 
übergeben wird.
Was immer klappt: globale Variablen anlegen, Paramater dort eintragen 
und die Ass-Routinen darauf zugreifen lassen.

[deter (Gast)]

wenn du den c code assemblierst, kannst du deine Funktion einfach 
einbinden.

dannach compilest du erst

[antworter (Gast)]

C ist gerade bei Grafikoperationen sehr dankbar, wenn man 
Pointerberechnungen aus den Schleifen herauszieht... z.B. (konstruiertes 
Beispiel):



for (y = 0; y < 64; y++)
  for (x = 0; x < 5; x++)
    pixelout[y*64+x] = quellpixel



würde zu


uint8_t* pixelptr = pixelout

for (y=0; y < 64; y++)
{
  for (x = 0; x < 5; x++)
    *(pixelptr++) = quellpixel;
  pixelptr += (64 - 5);
}


sowas wird dann meist sehr gut optimiert

[Oliver (Gast)]

"Da schweigt das Tutorial..."

Nö.

guggst du hier

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Assembler_und_Inline-Assembler

Oliver

[Peter D. (peda)]

kein Rahul wrote:

> geschrieben. Und oh Schreck, das ist ja um mindestens den Faktor 2-3
> langsamer. Jetzt schaffe ich noch eine Bildwiderholrate von ca. 5/s, mit
> den ASM Routinen habe ich gegen 20 (oder doch mehr) geschafft. Und das

Scheib einfach so, wie in Assembler, bloß mit C-Ausdrücken.

Du darfst sogar goto verwenden.

Zeig doch mal ein Beispiel.


Peter

[kein Rahul (Gast)]

Hallo!

Also ihr dürft mich schlagen oder quälen wie ihr wollt. Ich habe nach 
jedem Frame das geschrieben wird eine delay-Funktion drin, die mir das 
ganze um 50ms pro Frame gebremst hat.... Schande über mich. Jetzt läufts 
ganz schön :)
Somit werde ich wohl doch verzichten diese Funktion in ASM zu schreiben, 
zumal das ganze miner Meinung nach eher mühsam ist (die Cracks werden 
das nicht verstehen, aber es ist doch sehr gewöhnungsbedürftig wenn 
man es noch  nie gemacht hat)
Danke für die Hilfe, ich gebe mir mühe, dass so was nicht mehr vorkommt 
:)

[Peter D. (peda)]

kein Rahul wrote:

> Somit werde ich wohl doch verzichten diese Funktion in ASM zu schreiben,
> zumal das ganze miner Meinung nach eher mühsam ist (die Cracks werden
> das nicht verstehen, aber es ist doch sehr gewöhnungsbedürftig wenn
> man es noch  nie gemacht hat)


Ne, zumindest ich sehe es genauso.

Ich habe auch erst versucht, alten Assembler einzubinden, als ich mit C 
angefangen habe. Das ist ne Sackgasse.

Nun programmiere ich nach der Devise: alles in C schreiben.

Notfalls guckt man sich den erzeugten Assembler an und dann sieht man 
eigentlich schnell, wo man dem Compiler etwas nicht richtig gesagt hat 
und er etwas umständlich vorgeht.

Und man muß erstmal überlegen, ob es sich überhaupt lohnt, um nem Zyklus 
mehr zu feilschen. Das bringt ja nur in der innersten kurzen von 
mehrfachen Schleifen etwas oder in häufigen kurzen Interrupts.


Peter