Hi,

ich habe einen Code mit einem GLCD 320*240.
Dort zähle ich die Zeit für das Aufauen des Bildes.

Nun tausche ich einige Code Zeilen von Bascom in Assembler.
Das bringt sehr viel, jetzt ist das Display schon 45% schneller.

Mein ganzes Projekt ist fertig und ich möchte nicht alles neu in einem anderen Code machen. Desshalb wäre ich dankbar für eine kleine Hilfestellung

Z.B.
Code:
 Pix_x = Gl_x / 8
in.
Code:
 lds R24, {Gl_x}
 lds R25, {Gl_x+1}
 lsr r25
 ror r24                                                    '/2
 lsr r25
 ror r24                                                    '/4
 lsr r25
 ror r24                                                    '/8
 sts {Pix_x} , R24
 sts {Pix_x+1} , R25
Das geht viel schneller. Auch schieben in Bascom ist noch langesamer.

So nun das Problem, ich denke der Code ist nicht optimal.

in Bascom:
Lcd_cr ist ein Byte und Gl_y ist ein Word.
Also 16bit mit 8bit malnehmen.
Code:
Lcd_cr = 40
Gl_y = 340
Pix_y = Gl_y * Lcd_cr
Assembler ist:
Code:
Lcd_cr = 40
Gl_y = 340
Gl_addrhi = High(gl_y)
Gl_addrlo = Low(gl_y)

$asm

 lds R17, {Gl_addrhi}                                       '; obere 8 Bitsvon y
 lds R16, {Gl_addrlo}                                       '; niedrigere 8Bits y
 lds R18, {Lcd_cr}                                          '; 8-BitKonstante
 mul R16,R18                                                ';Multipliziere LSB
 mov R2,R0                                                  '; kopiereErgebnis in Ergebnisregister
 mov R3,R1
 mul R17,R18                                                '; Multiplizere MSB
 mov R4,R1                                                  '; Kopiere MSBdes Ergebnisses zum Ergebnis-Byte 3
 add R3,R0                                                  '; Addiere LSBdes Ergebnisses zum Ergebnis-Byte 2
 brcc NoInc1                                                '; Wenn Carrynicht gesetzt, springe
 inc R4                                                     '; erhoeheErgebnis-Byte 3
NoInc1:
 sts {Pix_y} , R2
 sts {Pix_y+1} , R3

$end Asm
Warum ist der Assembler code langsamer?
Geht das kürzer?

Danke.