;------------------------------------------------------------------------------------------
;LCD_ZAHL
;Es wird eine X-belibige Dezimalzahl vom Typ long in einen ASCII-Code 
;basierten String umgewandelt für die LCD Ausgabe.
;Das Erste Datenbyte wird dividert und der Rest der Division 
;wird mit dem nächsten Byte verknüpft d.h. es wird zuerst das obere Nibble
;Isoliert und mit dem Rest der Division verknüpft und der Akkuinhalt wird getauscht
;so bekommt man die erste hälfte des neuen Dividenden der in R7 zwischengespeichert 
;wird
;Das gleiche geschied jetzt mit dem unteren Nibble und das Ergebnis wird mit R7
;verknüpft das Ergebnis bildet den neuen Dividenden und wird gesichert.
;Dies solange wiederholt bis der neue Diviedend kpl. im Speicher abgelegt ist.
;Danach wird aus dem Rest der Division ein ASCII-CODE hergestellt und auf dem
;Stack abgelegt.
;Verwendete Register:  R4-R5-R6-R7 Übergaberegister von C aus
;                      long ab 100h im XDATA-Speicher
;                      STACK   als Zähler: Hält fest wieviele Zeichen gesichert wurden

_LCD_ZAHL:
          PUSH  PSW
	  PUSH  REG0
	  PUSH  REG1
          PUSH  REG4
	  PUSH  REG5
	  PUSH  REG6
	  PUSH  REG7	
	
          MOV   dptr,#long    ;Speichert übergebene Zahl im Xdatabereich ab
          MOV   A,R5
          MOVX  @dptr,A
          INC   dptr
          MOV   A,R6
          MOVX  @dptr,A
          INC   dptr
          MOV   A,R7
          MOVX  @dptr,A
          MOV  R1,#2
          MOV   R2,#6
LOOP:
          MOV   dptr,#long   ;Zeigt auf Höherwertige Byte der Zahl vom Typ long
          
          MOVX   A,@dptr     ;Lade ersten Dividend in den Akku
          MOV  B,#10         ;Divisor  ist 10
          DIV  AB            ;Teilen: Ergebnis im Akku Rest im Register B
          MOVX  @dptr,A      ;Erstes Datenbyte fertig und sichern
          INC  dptr          ;Datenpointer erhöhen zeigt jetzt auf zweites Datenbyte
LO_1:     
          MOVX  A,@dptr      ;Nächsten Dividenden Laden
          ANL  A,#0F0h       ;Benötigt wird zuerst das Obere nibble
          ORL  A,B           ;Den Rest der Division mit Akku verknüpfen
          swap A             ;Akuinhalt für Division vertauschen
          MOV  B,#10         ;Divisor  ist 10
          DIV  AB            ;Teilen: Ergebnis im Akku Rest im Register B
          swap A             ;Vertausche Akkuinhalt
          ANL  A,#0F0h       ;Oberes Nibble isolieren
          MOV  R7,A          ;Akkuinhalt in R7 zwischenspeichern
          MOVX A,@dptr       ;Lade den gleichen Dividenden nochmal
          swap A             ;Es wird jetzt das Untere nibble benötigt
          ANL  A,#0F0h       ;
          ORL  A,B           ;Den Rest der Division mit Akku verknüpfen
          swap A             ;Akuinhalt für Division vertauschen             
          MOV  B,#10         ;Divisor  ist 10
          DIV  AB            ;Teilen: Ergebnis im Akku Rest im Register B
          ORL  A,R7          ;Den R7 mit Akkuinhalt verknüpfen
          MOVX  @dptr,A      ;Zweites Datenbyte fertig und sichern
          INC  dptr          ;Datenpointer erhöhen zeigt jetzt auf letztes Datenbyte
          djnz R1,LO_1
         
          MOV  R1,#2         ;Für neuen durchgang laden
        
          MOV  A,#48         ;Aus dem Rest der Division wird nun 
          ORL  A,B           ;ein ASCII-CODE hergestellt
          PUSH ACC           ;und auf dem Stack abgelegt
          INC  STACK         ;Stackzähler erhöhen
          djnz R2,LOOP       ;Wiederhole bis die Division kpl. beendet ist
          CLR  C
ZAHL_L1:
	  POP  ACC             ;Umgewandelte Zahl vom Stack holen und 
	  JB   STATUS,ZAHL_L2  ;Statusflag gesetzt?
	  cjne A,#30h,ZAHL_L2  ;Führende Nullen ausschliessen
	  sjmp  ZAHL_L3
ZAHL_L2: 
          MOV  R7,A            ;zur Ausgabe in R7 ablegen
          setb STATUS
	  LCALL _LCD_Zeichen   ;ASCII-Zeichen jetzt ausgeben
ZAHL_L3:
          DJNZ STACK,ZAHL_L1   ;Wiederhole bis STACK-Zähler 0 ist
	  CLR  STATUS          ;Statusflag löschen
          
ZAHL_X:        
          POP   REG7
          POP   REG6 
          POP   REG5 
          POP   REG4
          POP   REG1
          POP   REG0    
          POP   PSW
          RET