$nomod51
$nopaging
$title (SHT11 via 8051 auf 4-Zeilen-Display)
$include (80C515.mcu)
	DSEG AT 20h
;Für die Festkommazahlausgabe
Fix_Flags:	ds	1	;Steuerbits
Fix_Feldb:	ds	1	;Feldbreite in Zeichen
Fix_Dezim:	ds	1	;Dezimalstellen

	DSEG AT 30h
CurDisplay:	ds	1	;Für folgende Ausgabe aktive Display-Hälfte(n)
Num_Messung:	ds	1	;mein 8-bit-Zähler
Produkt:	ds	4	;das 16x16-Produkt
TMinMax:	ds	4	;minimale (LOW) und maximale (HIGH) Temperatur
FMinMax:	ds	4	;minimale (LOW) und maximale (HIGH) Feuchte
	CSEG AT RESET

;******************************************************************************
;** Wenn man beim Löten etwas Mist baut (hier: die Steuer- und Datenpins     **
;** unglücklich verteilt), kann man's auch durch Software wieder hinbiegen,  **
;** ist aber NICHT nachahmenswert!					     **
;** Verbleibenden Portpins werden rigoros auf den _gelesenen_ Pegel gesetzt, **
;** Vorsicht bei Eingängen!						     **
;******************************************************************************

DISP_DATA	set	P4	; Port mit den 4 Datenleitungen (Nibble-Modus)
DATA0_BIT	set	0
DATA1_BIT	set	2
DATA2_BIT	set	4
DATA3_BIT	set	6
DATA0		set	1 shl DATA0_BIT
DATA1		set	1 shl DATA1_BIT
DATA2		set	1 shl DATA2_BIT
DATA3		set	1 shl DATA3_BIT

DISP_CONTROL	set	P5	; Port mit den 4 Steuerleitungen
E_unten		set	1 shl 7		; 1=Enable untere 2 Zeilen
E_oben		set	1 shl 6		; 1=Enable obere 2 Zeilen
RW		set	1 shl 5		; 0=Schreiben, 1=lesen
RS		set	1 shl 4		; 0=Steuerbefehl, 1=Zeichen
Eu_BIT		set	DISP_CONTROL.7
Eo_BIT		set	DISP_CONTROL.6
RW_BIT		set	DISP_CONTROL.5
RS_BIT		set	DISP_CONTROL.4

SCK		set	P3.4			; für SHT11
DAT		set	P3.5			; für SHT11

	ljmp	init		;Reset-Vektor (keine Interrupts)
	
;******************************
;** Eine dumme Warteschleife **
;******************************
wait1:
;Wartet 1 Millisekunde
;PE: -
;PA: -
;VR: R5=0
	MOV     R5,#250
wait4xR5:
	NOP			;1	Wartet R5*4µs
	NOP			;1
	DJNZ    R5,wait4xR5	;2	;4µs*256=1ms
	ret
;wait1 ENDP

wait:
;Wartet <R4> Millisekunden
	call	wait1
	djnz	r4,wait
        RET                   

;*******************************
;** Anzeige: LowLevel-Zugriff **
;*******************************
;PUBLIC disp_addr_in, disp_data_in, disp_ctrl_out, disp_char_out, disp_init_ll

disp_nib_in:
;1 Nibble vom Display einlesen
;PE: [CurDisplay]=E_unten _oder_ E_oben, RW_BIT=1 und RS_BIT schon gesetzt
;PA: a=gelesenes Nibble, High-Teil=0
;VR: a
	mov	a,DISP_DATA
	orl	a,#(DATA3 or DATA2 or DATA1 or DATA0)
	mov	DISP_DATA,a	; alle Bits high = hochohmig
	mov	a,DISP_CONTROL
	orl	a,CurDisplay
	mov	DISP_CONTROL,a
	nop			;Zeit bis zum Erscheinen der Daten t(DDR)=360ns
	clr	a
	mov	c,DISP_DATA.DATA3_BIT
	rlc	a
	mov	c,DISP_DATA.DATA2_BIT
	rlc	a
	mov	c,DISP_DATA.DATA1_BIT
	rlc	a
	mov	c,DISP_DATA.DATA0_BIT
	rlc	a
disp_disable:
	clr	Eu_BIT
	clr	Eo_BIT
	ret

disp_data_in:	; Befehl "Read Data"
;PE: r2=E_oben _oder_ E_unten
;PA: a=gelesene Daten
;VR: a,b, RW_BIT=1, RS_BIT=1
	setb	RS_BIT
	sjmp	disp_byt_in
disp_addr_in:	; Befehl "Read Busy+Addr"
;PE: r2=E_oben _oder_ E_unten
;PA: a=gelesene Daten
;VR: a,b, RW_BIT=1, RS_BIT=0
	clr	RS_BIT
disp_byt_in:
;1 Byte vom Display einlesen
;PE: [CurDisplay] = E_oben _oder_ E_unten sowie RW=1 und RS wie gewünscht
;PA: a=gelesene Daten
;VR: a,r2
	setb	RW_BIT
	call	disp_nib_in	;High-Nibble zuerst lesen
	swap	a
	mov	r2,a
	call	disp_nib_in	;Low-Nibble danach lesen	
	orl	a,r2
	ret
	
disp_wait_ready:	;Wartet bis Display bereit zum Datenempfang
;VR: RW_BIT=1, RS_BIT=0, kann komplett blockieren!
	push	ACC
disp_warte:
	 call	disp_addr_in
	 jb	ACC.7,disp_warte
	pop	ACC
	ret

disp_char_out:
;1 Zeichen (mit RS=1) auf Display-Hälfte(n) ausgeben, wartet auf Bereitschaft
;PE: a=Zeichen (oder Zeile des Zeichenbildes) [CurDisplay]=Display-Hälften-Bit(s)
;PA: -
;VR: r2
	call	disp_wait_ready
	setb	RS_BIT
	sjmp	disp_byt_out
disp_ctrl_out:
;1 Steuer-Byte (mit RS=0) auf Display-Hälfte(n) ausgeben, wartet auf Bereitschaft
;PE: a=Steuerbyte, [CurDisplay]=Display-Hälften-Bit(s)
;PA: -
;VR: r2
	call	disp_wait_ready	;löscht RS bereits(!)
disp_byt_out:
;1 Byte auf Display ausgeben OHNE zu warten
;PE: a=Zeichen- oder Steuerbyte, RS_BIT nach Wunsch, [CurDisplay]=Bits
;PA: -
;VR: r2
	clr	RW_BIT		;immer "schreiben"
	acall	disp_nib_out
disp_nib_out:	;Ausgabe eines Nibbles <a> aufs Display(s) <r2> ohne auf Not-Busy warten
;PE: a=Zeichen- oder Steuer-Nibble IM HIGH-TEIL, r2="Steuerleitungen", also
;       E_oben = oberen Controller ansprechen, E_unten = entsprechend, auch beide gleichzeitig möglich
;	RS_BIT = Zeichenausgabe (sonst Steuerbefehl)
;PA: a: Low-Nibble zum High-Nibble geschafft, Low-Nibble undefiniert
;VR: a,r2
	rlc	a		;Bit ausschieben
	mov	DISP_DATA.DATA3_BIT,c	;Bit3 hier einsetzen
	rlc	a		;Bit ausschieben
	mov	DISP_DATA.DATA2_BIT,c	;Bit2 dort einsetzen
	rlc	a		;Bit ausschieben
	mov	DISP_DATA.DATA1_BIT,c	;dito
	rlc	a		;Bit ausschieben
	mov	DISP_DATA.DATA0_BIT,c
	mov	r2,a
	mov	a,DISP_CONTROL
	orl	a,CurDisplay
	mov	DISP_CONTROL,a	;das setzt die gewünschen Bits
	mov	a,r2
	jmp	disp_disable	;fallende Flanke(n) erzeugen

disp_init_ll:
;LowLevel-Initialisierung des Displays und seines Interfaces
;PE: -
;PA: [CurDisplay] adressiert noch beide Display-Hälften
;VR: a,r2,r4,r5
	mov	CurDisplay,#E_oben or E_unten	;beide Hälften
	clr	RS_BIT		;immer "Steuerbefehl"
	clr	RW_BIT		;immer "schreiben"
	mov	a,#30h
	call	disp_nib_out
	mov	r4,#4
	call	wait
	mov	a,#30h
	call	disp_nib_out
	call	wait1
	mov	a,#30h
	call	disp_nib_out
	call	wait1
	mov	a,#20h		; auf Nibble-Betrieb stellen
	call	disp_nib_out
	call	wait1
	mov	a,#28h		; "System Set": 2/4 Zeilen
	jmp	disp_ctrl_out

;********************************
;** Anzeige: HighLevel-Zugriff **
;********************************
;PUBLIC put_cg, gotoxy, put_xy, Put_Follow, Put_XY_Follow, disp_init

put_cg:	;Zeichen-Bitmap setzen
;PE: a=CG-Adresse (40h=1. Zeichen, 48h=2. Zeichen usw.)
;    r3=Anzahl Bytes
;    DPTR=Bitmap-Zeiger (ins Code-Segment) 8 Bytes
;PA: DPTR zeigt hinter die 8 Bytes
;VR: a,b,DPTR,r2,r3,[CurDisplay] (danach gotoxy aufrufen!)
	mov	CurDisplay,#E_oben or E_unten	;beide Chips
	call	disp_ctrl_out	; "CG-Adresse setzen"
pu_cg_next:
	clr	a
	movc	a,@a+dptr
	inc	dptr
	call	disp_char_out
	djnz	r3,pu_cg_next
	ret

gotoxy:	
;PE: R3=Spalte (Bits 0..5) und Zeile (Bits 6 und 7)
;PA: [CurDisplay]=Zeichen-Ausgabe-"Adresse" für folgende byt_out-Aufrufe
;VR: a,r2
	mov	CurDisplay,#E_oben
	mov	a,r3		;r3 legt fest E_oben oder E_unten mit Bit 7
	anl	a,#80h
	jz	pu_1		;E_oben oder E_unten?
	mov	CurDisplay,#E_unten
pu_1:	mov	a,r3
	orl	a,#80h		; Adress-Befehl zusammensetzen
	jmp	disp_ctrl_out	; "CC-Adresse setzen"
;gotoxy ENDP

put_xy:	;String-Ausgabe aus Codesegment
;PE: r3=Ausgabe-Adresse (0=1. Zeile, 40h=2. Zeile, 80h=3. Zeile, C0h=4. Zeile)
;    DPTR=String-Zeiger (im Code-Segment)
;PA: DPTR zeigt hinter die Null
;VR: a=0,DPTR,r2
	call	gotoxy
	sjmp	put_string
put_string_loop:
	call	disp_char_out
put_string:
	clr	a
	movc	a,@a+dptr
	inc	dptr
	jnz	put_string_loop		;(noch ein) Zeichen ausgeben
	ret

Put_Follow:
;Ausgabe konstanter ASCIIZ-String, der nach dem Unterprogramm-Aufruf
;notiert wird
;PE: - (CurDisplay muss durch einen Aufruf von gotoxy stehen)
;PA: -
;VR: a=0,dptr,r2
	pop	DPH
	pop	DPL
	call	put_string
	jmp	@a+dptr		;zurück zum Aufrufer (wirklich!)

Put_XY_Follow:
;wie "gotoxy" und "Put_Follow" zusammen
;PE: R3 = Position
;PA: -
;VR: a=0,dptr,r2
	pop	DPH
	pop	DPL
	call	put_xy
	jmp	@a+dptr		;zurück zum Aufrufer (wirklich!)
	
disp_init:
;HighLevel-Initialisierung: Modus setzen u.ä.
	mov	a,#08h
	call	disp_ctrl_out
	mov	a,#01h
	call	disp_ctrl_out
	mov	a,#06h
	call	disp_ctrl_out
	mov	a,#00001100b	;Cursors blinken usw.
	jmp	disp_ctrl_out	
	
;********************************************************
;** Anzeige: Anwendungs-orientierte Routinen und Daten **
;********************************************************

;Hallo2:	db	1,9,"  Tr",0E1h,"nen",0F5h,"berstr",0EFh,"mt ",0e4h,"F k",8,0
;Hallo3:	db	"µ@#+*'€^^ ",0

;ein paar "hübsche" (fehlende) Zeichen fürs Display
ZG0:	db	01110b		;SYMBOL großes Ohm
	db	10001b		; (das kleine sieht ja hässlich aus!)
	db	10001b
	db	10001b
	db	01010b
	db	01010b
	db	11011b
	db	00000b		;Cursorzeile

ZG1:	db	10001b		;LATIN1 großes Ä
	db	00100b
	db	01010b
	db	10001b
	db	11111b
	db	10001b
	db	10001b
	db	00000b		;Cursorzeile

ZG2:	db	10001b		;LATIN1 großes Ö
	db	01110b
	db	10001b
	db	10001b
	db	10001b
	db	10001b
	db	01110b
	db	00000b		;Cursorzeile

ZG3:	db	10001b		;LATIN1 großes Ü
	db	00000b		;(auch das kleine ü sieht blöd aus)
	db	10001b
	db	10001b
	db	10001b
	db	10001b
	db	01110b
	db	00000b		;Cursorzeile
	
ZG4:	db	00111b		;WIN1250 Euro-Symbol (hä?)
	db	01000b
	db	11111b
	db	10000b
	db	11110b
	db	10000b
	db	01110b
	db	00000b		;Cursorzeile

ZG5:	db	00000b		;ASCII Backslash \
	db	10000b
	db	01000b
	db	00100b
	db	00010b
	db	00001b
	db	00000b
	db	00000b		;Cursorzeile

ZG6:	db	00000b		;ASCII Schlange/Tilde ~
	db	00000b
	db	10110b
	db	01101b
	db	00000b
	db	00000b
	db	00000b
	db	00000b		;Cursorzeile
	
Prepare_Display:
	mov	r3,#0*64+0	;oben links
	call	Put_XY_Follow
	db	"Temperatur + Feuchtemessung",0
	;Spalte mit 3x "°C" ausgeben
	mov	r3,#1*64+13	;Zeile 1 = 2. Zeile
ph1:	call	Put_XY_Follow
	db	0DFh,"C",0
	mov	a,r3
	add	a,#1*64		;1 Zeile runter
	mov	r3,a
	jnc	ph1
	;Spalte mit 3x "%rF" ausgeben
	mov	r3,#1*64+24	;ganz hinten
ph2:	call	Put_XY_Follow
	db	"%rF",0
	mov	a,r3
	add	a,#1*64		;1 Zeile runter
	mov	r3,a
	jnc	ph2
	;"Min" und "Max" ausgeben
	mov	r3,#2*64+0
	call	Put_XY_Follow
	db	"Min:",0
	mov	r3,#3*64+0
	call	Put_XY_Follow
	db	"Max:",0
	ret

itoa:
;PE: r4=auszugebende 8-bit-Zahl
	mov	r3,#0
	mov	a,r4
itoa_1:	mov	B,#10
	div	ab
	push	B
	inc	r3
	jnz	itoa_1
itoa_2:
	pop	ACC
	add	a,#'0'
	call	disp_char_out
	djnz	r3,itoa_2
	ret
	
FixOut16:	;PROC
;Ausgabe einer 16-bit-Festkommazahl
;PE: r7:r6 = 16-bit-Zahl vzb.
;    Fix_Feldb = Feldbreite
;    Fix_Dezim  = Anzahl Dezimalstellen
;    Fix_Flags  = weitere Steuerbits... (???)
;PA: -
;VR: r3=0,r4,r5=0,r6=0,r7=0
	mov	a,r7
	rlc	a
	mov	Fix_Flags.7,c	;Vorzeichen-Merker
	jnc	do_6
	clr	c
	clr	a
	subb	a,r6		;Zweierkomplement
	mov	r6,a
	clr	a
	subb	a,r7
	mov	r7,a
do_6:	mov	r3,#0
do_3:	mov	r5,#16
	mov	r4,#0
do_2:	;Dividend R4:R7:R6 linksschieben
	mov	a,r6
	rlc	a
	mov	r6,a
	mov	a,r7
	rlc	a
	mov	r7,a
	mov	a,r4
	rlc	a
	mov	r4,a
	;Bedingte Subtraktion von 10 von R4
	add	a,#-10
	jnc	do_1
	mov	r4,a
do_1:	;cpl	c
	mov	a,r6	;CY ins Bit 0 setzen
	rr	a
	rlc	a
	mov	r6,a
	djnz	r5,do_2
	;nach der Division: R4 = Rest, R7:R6=Quotient
do_8:	push	AR4
	inc	r3
	mov	a,r3
	cjne	a,Fix_Dezim,do_7
	mov	r4,#'.'-'0'
	push	AR4	;Punkt einpushen
	inc	r3
do_7:	mov	a,r6
	orl	a,r7
	jnz	do_3
	mov	r4,#0
	mov	a,r3	;bspw. =3 bei 2 Dezimalstellen ist (noch) nicht OK
	dec	a
	setb	c
	subb	a,Fix_Dezim
	jc	do_8
	jnb	Fix_Flags.7,do_9
	mov	r4,#'-'-'0'
	push	AR4
	inc	r3
;ab hier wird gepoppt und ausgegeben	
do_9:	setb	c
	mov	a,Fix_Feldb
	subb	a,r3
	jc	do_4
	inc	a
	mov	r4,a
do_5:	mov	a,#' '
	call	disp_char_out	;führende Leerzeichen
	djnz	r4,do_5
do_4:
	pop	ACC
	add	a,#'0'
	call	disp_char_out
	djnz	r3,do_4
	ret
;DezOut16 ENDP

SaveFixOut16XY:
	call	gotoxy
SaveFixOut16:
	push	AR3
	push	AR6
	push	AR7
	 call	FixOut16
	pop	AR7
	pop	AR6
	pop	AR3
	ret
	
HexOut:	;PROC
;PE: A=auszugebende Hex-Zahl, R2 siehe nib_out
;PA: -
;VR: A
	push	ACC
	 swap	a
	 acall	NibOut	;vorwärts
	pop	ACC
NibOut:	;gibt Low-Nibble von A hexadezimal aus
	anl	a,#0Fh
	add	a,#90h
	da	a
	addc	a,#40h
	da	a	;auf wundersame Weise wird so aus 0..F ein '0'..'F'
	jmp	disp_char_out
;HexOut ENDP

Mul16x16: ;PROC
;PE: R5:R4 = Faktor 1 (vzl.)
;    R7:R6 = Faktor 2 (vzl.)
;PA: [Produkt] = Produkt
;VR: a,b
	;1.
	mov	a,r4
	mov	B,r6
	mul	ab
	mov	Produkt,a
	mov	Produkt+1,B
	;2.
	mov	a,r5
	mov	B,r7
	mul	ab
	mov	Produkt+2,a
	mov	Produkt+3,B
	;3.
	mov	a,r4
	mov	B,r7
	acall	mu2	;vorwärts: ASM51 macht nur 1 Pass
	mov	a,r5
	mov	B,r6
mu2:	mul	ab
	add	a,Produkt+1
	mov	Produkt+1,a
	mov	a,B
	addc	a,Produkt+2
	mov	Produkt+2,a
	jnc	mu1
	inc	Produkt+3
mu1:	ret
;Mul16x16 ENDP

;*******************
;** SHT11-Zugriff **
;*******************
SHT11_ConnReset:	;PROC
;Reset- und Startsequenz für SHT11 ausgeben --> muss das sein?? 
;PE: - (DATA=H, SCL=L)
;PA: - (DATA=H, SCL=L)
;VR: r5=0
;ALLE__ Zeiten sind evtl viel zu lang!
	mov	r5,#10
	setb	DAT
abcd:	
	setb	SCK
	setb	DAT
	nop
	clr	SCK
	setb	DAT
	nop
	djnz	r5,abcd
SHT11_Start:
	setb	SCK
	nop
	nop
	clr	DAT
	nop
	nop
	clr	SCK
	nop
	nop
	setb	SCK
	nop
	nop
	setb	DAT
	nop
	nop
	clr	SCK		;Ende SHT_Start
	ret
;SHT11_ConnReset ENDP
	
SHT11_ByteOut:	;PROC
;(Kommando-) Byte ausgeben und Acknowledge abholen
;PE: A=Kommando-Byte (DATA=H, SCL=L)
;PA: CY=1 wenn Fehler, CY=0 wenn Ack-Bit OK (DATA=H, SCL=L)
;VR: R5=0,a
  ;Zähler mit 8 Laden
	mov	r5,#8
SHT11_ByteOut_Loop:
	rlc	a	;Bits ausschieben
	mov	DAT,c	;Datenbit setzen oder rücksetzen
	setb	SCK	;Takt=H
	nop
	clr	SCK	;Takt=L
	setb	DAT
	djnz	r5,SHT11_ByteOut_Loop
;SHT11ack:
	setb	SCK
	nop	
	mov	C,DAT
	;!!!!!!!!Wenn SHT11_DATA = 1 wird, alles ok!
	clr	SCK
	setb	DAT
	ret
;SHT11_ByteOut ENDP

SHT11_ByteIn: ;PROC
;PE: a=0: weiteres Byte anfordern (Bit 0)
;    a=1: kein weiteres Byte anfordern
;PA: a=gelesenes Byte
	mov	r5,#8	
SHT11_ByteIn_Loop:
	setb	SCK
	setb	DAT
	nop
	nop
	mov	c,DAT
	rlc	a
	clr	SCK
	setb	DAT
	djnz	r5,SHT11_ByteIn_Loop
	;Quittungsbit
	mov	DAT,c	;aus A gekommen
	setb	SCK
	nop
	nop
	clr	SCK
	setb	DAT
	ret
;SHT11_ByteIn ENDP

SHT11_Get_Messwert: ;proc
;PE: r6=5 für %rF, =3 für Temperatur
;PA: r7:r6=Messwert vom SHT11
;    CY=1 wenn kein Messwert lieferbar
;VR: r7,r6,r4,r5=0,a
	call	SHT11_Start
	mov	a,r6
	call	SHT11_ByteOut
	jc	SHT11_raus
	mov	r4,#0		;256 ms warten
	call	wait
	setb	C
	jb	DAT,SHT11_raus	;wenn SHT11 immer noch nicht fertig
	clr	a	;weitere Daten anfordern
	call	SHT11_ByteIn
	mov	r7,a	;High-Byte %rF
	mov	a,#1	;keine weiteren Daten (Prüfsumme) anfordern
	call	SHT11_ByteIn
	mov	r6,a	;Low-Byte %rF
	clr	C
SHT11_raus:
	ret
;SHT11_Get_Messwert endp

Calc_Feuchte: ;PROC
;PE: R7:R6=Wert vom Sensor ("SO(RH)")
;PA: R7:R6=Feuchte in Hundertstel Prozent (Festkomma)
;VR: R4,R5
	push	AR2
	push	AR3
	 ;linearer Summand
	 mov	r4,#LOW(1037)	;LOW(4.05*256)
	 mov	r5,#HIGH(1037)
	 call	Mul16x16
	 mov	r2,Produkt+1		;"mittlerer" Teil, entspr. /256
	 mov	r3,Produkt+2
	 ;quadratischer Summand
	 mov	r4,6
	 mov	r5,7
	 call	Mul16x16		;Quadrat
	 mov	r4,#LOW(4698)		;0.07168*64K
	 mov	r5,#HIGH(4698)
	 mov	r6,Produkt+1		;"mittlerer" Teil, /256
	 mov	r7,Produkt+2
	 call	Mul16x16
	 ;subtrahieren
	 clr	c
	 mov	a,r2
	 subb	a,Produkt+2		;"oberer" Teil, /64K
	 mov	r2,a
	 mov	a,r3
	 subb	a,Produkt+3
	 mov	r3,a
	 ;konstanter Summand
	 mov	a,r2
	 add	a,#LOW(-400)
	 mov	r6,a
	 mov	a,r3
	 addc	a,#HIGH(-400)
	 mov	r7,a
	pop	AR3
	pop	AR2
	ret
;Calc_Feuchte ENDP

InitAllMinMax:	
;initialisiert TMinMax und FMinMax (aufeinanderfolgend!)
;PE: - PA: - VR: R0
	mov	r0,#TMinMax
	call	InitMinMax
InitMinMax:	
;initialisiert zwei aufeinanderfolgende WORDs mit MAXINT und -MAXINT
	mov	@r0,#0FFh
	inc	r0
	mov	@r0,#07Fh
	inc	r0
	mov	@r0,#000h
	inc	r0
	mov	@r0,#080h
	inc	r0
	ret

MakeMinMax:
;Berechnet neue Minima und Maxima und gibt diese bei Veränderung aus
;PE: R3 = Cursor-Spalte (Bit 5:0), Zeile=1
;    R7:R6 = aktueller Messwert
;    R0 = Zeiger auf Minimum-WORD (LOW) und Maximum-WORD (HIGH), d.h.
;	[R0]=LOW Minimum, [R0+1]=HIGH Minimum, [R0+2]=LOW Maximum usw.
;PA: -
;VR: R0,R2,R3
	clr	c
	mov	a,r6
	subb	a,@r0
	inc	r0
	mov	a,r7
	subb	a,@r0
	jnb	OV,mmm1	;=OV	
	cpl	a
mmm1:	jnb	ACC.7,NoNewMin
	mov	a,r7
	mov	@r0,a
	dec	r0
	mov	a,r6
	mov	@r0,a
	inc	r0
	mov	a,r3
	anl	a,#03Fh		;Spalte stehen lassen
	orl	a,#2*64		;Zeile 2
	mov	r3,a
	call	SaveFixOut16XY
NoNewMin:
	inc	r0	;jetzt zeigt R0 aufs Maximum
	clr	c
	mov	a,@r0
	subb	a,r6
	inc	r0
	mov	a,@r0
	subb	a,r7
	swap	a		;sprungfreie Version, genauso lang
	rr	a
	xrl	a,PSW
	jnb	ACC.2,NoNewMax
	mov	a,r7
	mov	@r0,a
	dec	r0
	mov	a,r6
	mov	@r0,a
	mov	a,r3
	anl	a,#03Fh		;Spalte stehen lassen
	orl	a,#3*64		;Zeile 3
	mov	r3,a
	call	SaveFixOut16XY
NoNewMax:	
	ret

NoFixOutXY:
;Ausgabe KEINER Zahl bei Interface-Problem mit dem SHT11
	call	Put_XY_Follow
	db	" ---.--",0
	ret
	
init:
	mov	SP,#07Fh
	call	disp_init_ll	;LowLevel-Initialisierung
	call	disp_init	;HighLevel-Init.

	mov	DPTR,#ZG0	;großes Ohm, Ä, Ö, Ü, Euro, \, ~
	mov	a,#40h		;Adress-Befehl: Adresse 0
	mov	r3,#8*7		;7 aufeinanderfolgende Zeichen
	call	put_cg
	call	Prepare_Display

	mov	Fix_Feldb,#7
	mov	Fix_Dezim,#2
	mov	Num_Messung,#0
	call	InitAllMinMax

MainLoop:
	mov	r3,#1*64+1
	call	gotoxy
	inc	Num_Messung
	mov	a,Num_Messung
	call	HexOut
	;Temperatur einlesen, umrechnen und ausgeben
	mov	r6,#00000011b		;Kommando: Temperatur
	call	SHT11_Get_Messwert
	mov	r3,#1*64+5
	jc	NoTemp
	mov	a,r6
	add	a,#LOW(-4000)
	mov	r6,a
	mov	a,r7
	addc	a,#HIGH(-4000)
	mov	r7,a
	call	SaveFixOut16XY
	mov	r0,#TMinMax
	call	MakeMinMax	;übernimmt auch R3
	sjmp	TempOK
NoTemp:	call	NoFixOutXY
TempOK:	;Feuchte einlesen, umrechnen und ausgeben
	mov	r6,#00000101b		;Kommando: %rF
	call	SHT11_Get_Messwert
	mov	r3,#1*64+16
	jc	NoHumi
	call	Calc_Feuchte		;"umrechnen" in Prozent
	call	SaveFixOut16XY
	mov	r0,#FMinMax
	call	MakeMinMax	;übernimmt auch R3
	sjmp	HumiOK
NoHumi:	call	NoFixOutXY
HumiOK:
	mov	r4,#0
	call	wait		;256 ms (Maximum) verbraten
	mov	P1,#128
	mov	a,P6		;P6 ist leider nicht bitadressierbar
	jb	ACC.0,MainLoop
	call	InitAllMinMax	;mit der Taste an P6.0 Minima/Maxima rücksetzen
	sjmp	MainLoop
END