; Datei: rs232inc.asm ; Behandlung der seriellen Schnittstelle ; Proceduren ; *********************** ; ** I N T E R F A C E ** ; *********************** ; ; benutzt das Modul "arithmetik.asm" ; ; UPR-Name used Registers ch calls affects Beschreibung ; in out ; serinit - - Initialisieren der RS232 mit 9600,8,k,1 ; v24_test - - temp1 Sendet permanent "U" = 0x55 -> halbe Baudrate ; serout temp1 temp1 n - Zeichen ausgeben ; serin - temp1 j - Zeichen einlesen ; serin_echo - temp1 j serout - Zeichen mit Echo einlesen ; v24_LF - - n serout - Zeilenvorschub ausgeben ; v24_CR - - n serout - Wagenrücklauf ausgeben ; v24_LFCR - - n serout - Zeilenvorschub und Wagenrücklauf ausgeben ; v24_CD - - n serout - Clear Display ausgeben ; v24_in_hex - temp1 j serin - Zwei Zeichen als Hexziffern für ein Byte in temp1 ; v24_in_number - temp1 j serin R1 Zwei Ziffern als Zehnerziffern für ein Byte in temp1 ; v24_number temp1 temp1 n serout - Zahl in temp1 ausgeben ; v24_flash_str temp1 temp1 n serout - 0-term. String aus Flashmemory ausgeben ; v24_read_int - - j serin R2:R8 Ganzzahl <= 16,7 Mio einlesen (3-Byte) ; addbtemp1 ; bmal10 ; v24_binout temp2 - n serout - 3-Byte-Zahl in Akku B ausgeben ; Akku B n bin2asc - ; v24_eep_strin temp1 temp1 j eep_read - 0-term. String aus dem EEPROM ausgeben ; serout ; eep_serout temp1 temp2 j eep_read - Byte von Adresse in temp1(/temp2) aus dem EEPROM ausgeben ; an EEPROM-Umfang anpassen!!! ; **************************************************************************************************** serinit: push temp1 ; Baudrate für RS232 einstellen ldi temp1, high(ubrr_val) ; zuerst Baudrate Highbyte (davon Lownibble) out ubrrh, temp1 ; Weil URSEL-Bit =0 geht das für den mega8 in Ordnung ; für den Tiny2313 spielt es keine Rolle ldi temp1, low(ubrr_val) ; Lowbyte schreiben und prescaler damit triggern out ubrrl, temp1 ; frameformat setzen .ifdef mega8 ldi temp1, (1< 8 Bit Daten, kein Parity, 1 Stopbit ; Achtung! beim Mega8 belegen UBRRH und UCSRC die gleiche Adresse (0x20 bzw 0x40) ; URSEL = 0 schreibt in UBRRH ; URSEL = 1 schreibt in UCSRC ; beim Lesen wird zunächst UBRRH ausgelesen ; unmittelbar danach (Interrupts durch CLI verhindern!!) UCSRC) .else ldi temp1, (1< 8 Bit Daten, kein Parity, 1 Stopbit .endif out ucsrc, temp1 ; Transmitter einschalten, PortD Bit1 wird überschrieben sbi ucsrb, txen ; TXE-Bit (3) setzen ; Receiver einschalten, PortD Bit0 wird überschrieben sbi ucsrb, rxen ; RXE-Bit (4) setzen ; Das folgende Bit nur setzen, wenn eine ISR dazu existiert! ; sbi ucsrb, rxcie ; RXCIE-bit (7) setzen, damit ein irq ausgelöst werden kann, ; wenn ein Zeichen da ist pop temp1 ret v24_test: ; Test der rs232, sendet permanent "U" -> halbe Baudrate als ; Rechteck an TXD ldi temp1, 0x55 rcall serout rjmp v24_test ret ; Zeichen in Temp1 über rs232 ausgeben ; temp1: enthält das zu sendende Zeichen serout: sbis ucsra,udre ; udre-bit ist gesetzt, wenn der Sendepuffer leer ist ; UART Data Register Empty rjmp serout out udr, temp1 ; Zeichen senden ret ; zurück aus der Subroutine ; Zeichen über RS232 einlesen ; temp1: gibt das Zeichen zurück serin: sbis ucsra, rxc rjmp serin ; wir warten bis ein Byte angekommen ist in temp1, udr ; Zeichen einlesen ;rcall serout ; und zurücksenden ret ; Zeichen über RS232 einlesen und als Echo zurücksenden ; temp1: gibt das Zeichen zurück serin_echo: sbis ucsra, rxc rjmp serin_echo ; wir warten bis ein Byte angekommen ist in temp1, udr ; Zeichen einlesen rcall serout ; und zurücksenden ret v24_lf: ; Linefeed ausgeben push temp1 ldi temp1, LF rcall serout pop temp1 ret v24_CR: ; Wagenrücklauf ausgeben push temp1 v24_cr1: ldi temp1, CR rcall serout pop temp1 ret v24_LFCR: ; Linefeed und Wagenrücklauf ausgeben push temp1 ldi temp1, LF rcall serout rjmp v24_CR1 v24_CD: ; Clear dislay ausgeben push temp1 ldi temp1, CD rcall serout pop temp1 ret ; Die Funktion hexit ist in der Lib arithmetik.asm untergebracht .ifndef asc2bin .include "arithmetik.asm" .endif ; Ein Hex-Byte von V24 einlesen nach temp1 v24_in_hex: push temp2 push temp3 hziffer0: rcall serin mov temp2,temp1 rcall asc2bin ; in hexnibble wandeln (benutzt temp2 für transport) brcs hziffer0 ; Fehler? -> noch mal einlesen rcall serout ; echo zurücksenden mov temp3, temp2 ; ergebniszwischenspeicher swap temp3 ; ins highnibble bringen hziffer1: rcall serin mov temp2,temp1 rcall asc2bin ; in hexnibble wandeln (benutzt temp2 für transport) brcs hziffer1 ; Fehler? -> noch mal einlesen rcall serout ; echo zurücksenden mov temp1, temp2 ; Ergebnis aufbauen or temp1, temp3 ; und in temp1 zurückgeben pop temp3 pop temp2 ret ; Zahl aus 2 Digits in temp2 aufbauen ; temp1: rückgabe des Funktionswerts Zahl v24_in_number: rcall serin ; Zeichen (Zehnerstelle) von V24 holen ; rcall serout andi temp1, 0x0f; Oberes Nibble abschneiden lsl temp1 ; Zur Zehnermultiplikation vorbereiten, erst einmal x 2 mov accu1, temp1; das doppelte sichern lsl accu1 ; Sicherung mal 2 lsl accu1 ; sicherung mal 4 ist insgesamt temp1 mal 8 add accu1, temp1; 2fach plus 8fach (ohne carry) gibt zehnfach rcall serin ; Einerstelle von V24 holen ; rcall serout andi temp1, 0x0f; Oberes Nibble abschneiden add temp1, accu1; Einerstelle zu Zehnerstelle addieren ret ; fertig .ifndef lcd_number ; ein Byte als Dezimalzahl auf LCD oder via RS232 ausgeben ; Datenbyte: temp1 lcd_number: .ifdef lcd_data push temp1 push temp2 push temp3 ldi temp2, low(lcd_data) ; Adresse von Befehl "lcd_data" als mov zl, temp2 ; Sprungadresse für indirekten SUB-Call ldi temp2, high(lcd_data) ; in Z-Register ablegen mov zh, temp2 rjmp v24_number_0 .endif ; ifdef lcd_data v24_number: push temp1 push temp2 push temp3 ldi temp2, low(serout) ; Adresse von Befehl "serout" als mov zl, temp2 ; Sprungadresse für indirekten SUB-Call ldi temp2, high(serout) ; in Z-Register ablegen mov zh, temp2 v24_number_0: ldi temp3, 0 mov temp2, temp1 ; abzählen wieviele Hunderter ; in der Zahl enthalten sind ldi temp1, '0' v24_number_1: subi temp2, 100 brcs v24_number_2 inc temp1 rjmp v24_number_1 ; ; die Hunderterstelle ausgeben v24_number_2: cpi temp1, '0' breq v24_number_2a icall inc temp3 v24_number_2a: subi temp2, -100 ; 100 wieder dazuzählen, da die ; vorherhgehende Schleife 100 zuviel ; abgezogen hat ; abzählen wieviele Zehner in ; der Zahl enthalten sind ldi temp1, '0' v24_number_3: subi temp2, 10 brcs v24_number_4 inc temp1 rjmp v24_number_3 ; die Zehnerstelle ausgeben v24_number_4: cpi temp3, 0 brne v24_number_4a cpi temp1, '0' breq v24_number_4b v24_number_4a: icall v24_number_4b: subi temp2, -10 ; 10 wieder dazuzählen, da die ; vorhergehende Schleife 10 zuviel ; abgezogen hat ; die übrig gebliebenen Einer ; noch ausgeben ldi temp1, '0' add temp1, temp2 icall pop temp3 pop temp2 pop temp1 ret .endif ;lcd_number ; Einen konstanten Text aus dem Flash Speicher ; ausgeben. Der Text wird mit einer 0 beendet ; Z-Reg enthält die Adresse des Strings * 2 v24_flash_string: push temp1 v24_flash_string_1: lpm temp1, Z+ cpi temp1, 0 breq v24_flash_string_2 rcall serout rjmp v24_flash_string_1 v24_flash_string_2: pop temp1 ret .ifdef arithmetik ; Macros müssen __VOR__ der ersten Verwendung deklariert werden .MACRO lade_z ; Lade das Z-Register mit einer ldi zl, low(@0) ; Speicheradresse ldi zh, high(@0) ; Beispiel: .ENDM ; eine ganze Zahl von der V24 einlesen. ; Wert <= 16.777.215 ; benötigt Akku A, B und Temp1 ; Ergbnis steht in Akku B v24_read_int: push temp1 push temp2 in temp2,sreg lade_z buffer ; Z-Pointer auf Buffer setzen (Macro lade_Z expandieren) clr stellen ; Stellenzahl auf 0 b0_a: rcall serin_echo ; Zeichen von der V24 cpi temp1, 0x0d ; CR -> Eingabe abschließen breq b0_b ; fertig für Wandlung, falls enter gedrückt .ifdef lcd_data rcall lcd_data ; Ziffer auf LCD .endif andi temp1, 0x0f ; ASCII-Teil ausblenden st z+, temp1 ; im SRAM ablegen und Zeiger erhöhen inc stellen ; Stellenzahl erhöhen rjmp b0_a ; wieder zur Eingabe b0_b: sbic ucsra, rxc ; kein Zeichen mehr im Puffer? -> springen rcall serin ; sonst einlesen und vergessen clr lb ; Akkumulator B löschen clr mb clr hb lade_z buffer ; Z-Pointer erneut auf Bufferanfang setzen b0_c: ld temp1,z+ ; Ziffernwert aus buffer lesen rcall addbtemp1 ; zum Akku B addieren dec stellen ; Stellenzahl runterzählen breq b0_d ; war's die letzte Stelle? dann fertig rcall bmal10 ; sonst Akku B mal 10 und rjmp b0_c ; nächste Stelle verarbeiten b0_d: ; Ergebnis steht in Akku B out sreg, temp2 pop temp2 pop temp1 ret ; Binärzahl in akku b ausgeben, Binär-Stellenzahl in temp2 (<=24) ; mit bin2asc nach buffer wandeln, Ziffern-Stellenzahl + 1 in temp2 ; der bufferzeiger z steht auf der Null des String-Endes v24_binout: push temp1 push temp2 push zl push zh rcall bin2asc ; Binärzahl in eine Dezimalzahl in buffer (Z-Pointer) wandeln v24_bin2asc_0: ld temp1, -z ; Ziffernzeichen aus SRAM laden mittels Z-Pointer rcall serout dec temp2 ; Anzahl zu verarbeitender Ziffern verringern brne v24_bin2asc_0 ; noch Ziffern da? -> von vorne pop zh pop zl pop temp2 pop temp1 ret .endif ; ifdef arithmetik