Bascom Inside-Code: Unterschied zwischen den Versionen

Version vom 9. Juni 2006, 14:17 Uhr

Für den allgemein Interessierten und für Power-User, die ihr Bascom-Programm mit etwas Assembler-Code aufpeppen möchten, stelle ich recht zwanglos einige Assembler-Codeschnipsel zusammen mit den zugehörigen Bascom-Statements zur Verfügung.

Die meisten Beispiele könnte man mit Inline-Assemler direkt ersetzen, wenn man mal probieren wollte, man muß natürlich auf Daten- und Labeladressen aufpassen

Die meisten Bascom-Funktionen ergeben im Code dann folgende Teile:

Der Aufruf
- die Vorbereitung, also das Laden von Registern mit den konkreten Argumenten,
- einen Call auf den eigentliche Funktions-code
- das Abliefern des Ergebnisses
Die Funktion selbst

Inhaltsverzeichnis

1 ADC
2 BITWAIT
3 (Quadratur-) ENCODER
4 Dividieren 32Bit (LONG)
5 Multiplizieren 32Bit (LONG)
- 5.1 Mit "MUL" (Atmega32)
- 5.2 Ohne "MUL" (AT90S2313)
6 SERIN
7 Autor
8 Siehe auch

ADC

Config ADC

CONFIG Adc = Single , Prescaler = Auto

	LDI	r24,0x06
	OUT	ADCSR,r24

Start ADC

START ADC

	SBI	ADCSR,ADEN

Getadc()

Aufruf

DIM X AS WORD                  laut "prog.RPT"  an der Adresse 0x0063
X = GETADC(0)

ergibt folgenden Code:

	LDI	r24,0x00       ADC-Kanal-Nummer nach Register 24
	OUT	ADMUX,r24      in den ADC-Multiplexer

	CALL	L_0x00F6       Aufruf der getadc-funktion

	LDI	XL,0x63        laden der Ergebnisadresse  (DIM X AS WORD)
	LDI	XH,0x00
	ST	X+,r24         Speichern ergebnis   (R24:r25) in "X"
	ST	X,r25

Funktion

L_0x00F6:
	SBI	ADCSR,ADSC   Starten der 1. Konversion
L_0x00F8:
	SBIC	ADCSR,ADSC   Fertig ? 
	RJMP	L_0x00F8     nein, Loop1
	SBI	ADCSR,ADSC   Starten der 2. Konversion
L_0x00FE:
	SBIC	ADCSR,ADSC   Fertig ? 
	RJMP	L_0x00FE     nein, Loop2
	IN	r24,ADCL     Ergebnis auslesen r24:r25
	IN	r25,ADCH
	RET                  fertig

BITWAIT

Bitvariable

Aufruf

Dim A As Bit
BITWAIT A , Set                                             'wait until bit a is set

Code

L_0x007A:
	LDS	r24,0x0060
	SBRS	r24,7
	RJMP	L_0x007A

IO-Register

Aufruf

BITWAIT Portb.7 , Reset                                     'wait until bit 7 of Port B is 0.

Code

L_0x008C:
	SBIC	PORTB,PB7
	RJMP	L_0x008C

PULSEIN

DIM Result AS WORD
PULSEIN Result , Pind , 2 , 1

Aufruf

	LDI	ZL,0x30         // Adresse von SFR PIND
	LDI	r24,0x02	// PinNr 2
	LDI	r16,0xFF        // State 1

	CALL	PULSEIN

	LDI	XL,0x60        laden der Ergebnisadresse  
	LDI	XH,0x00
	ST	X+,r24		// store result
	ST	X,r25

Hier kommen mehrere Funktionen zum Einsatz, die auch ggf. für andere Zwecke aufgerufen werden.

Idle Loop

'-----------------------------------------------------
' der Wert in ZL:ZH wir auf Null heruntergezählt, dann geht's zurück
'-----------------------------------------------------
L_0x009C:
	SBIW	ZL,0x0001
	BRNE	L_0x009C
	RET

Set_ErrBit

Zur Erinnerung: Das Err-Bit ist das, was man mit "IF ERR = 1 THEN.." abfragt

	SET                     ' Setzen T-Bit
	BLD	r6,2            ' nach R6.2
	RET

Clear_ErrBit

	CLT                     ' Löschen T-Bit
	BLD	r6,2            ' nach R6.2
	RET

MakeMask

'-----------------------------------------------------
' Eine Bit-Nummer in r24 (0-7) wird in eine Bit-Maske umgewandelt (1,2,4,...128)
' nach r25 kommt dann die invertierte Maske
'-----------------------------------------------------
	LDI	r25,0x01             ' Maske = &B0000001
	AND	r24,r24              ' BitNummer = 0 ?
	BREQ	L_0x00BC             ' Ja, fertig
	CLC                          ' löschen Carry
L_0x00B6:
	ROL	r25                  ' Maske eins nach links
	DEC	r24                  ' Bitnummer runterzählen 
	BRNE	L_0x00B6             ' nochmal
L_0x00BC:
	MOV	r24,r25              ' Maske kopieren nach r24
	COM	r25                  ' und r25 invertieren
	RET                          ' that's it.

Pulsein, die eigentliche Funktion

PULSEIN:
	CALL	Clear_ErrBit
	CLR	ZH
	CLR	XL		// clear Timout Lo
	CLR	XH		// clear Timout Hi
	CALL	MakeMask        // R24 Mask, R25 neg Mask
	AND	r16,r24
	LDD	r0,Z + 1	// DDRD
	AND	r0,r25		// Make Input
	STD	Z + 1,r0	// DDRD
'---------------------------------------------------------------------------
' Warten, bis der Pin eine Zustand einnimmt, der anders ist als der, den man 
' messen will. Sprich, will ich die Dauer eines HIGH Zustandes messen, wartet 
' die Funktion erstmal, bis ein LOW anliegt. Eigentlich logisch. 
' Dabei wir das Registerpaar XL:XH von 0-65535 hochgezählt. Bei Überlauf wird 
' Bascom ERR gesetzt und abgebrochen. 
' Dieses Zählen ist aber nicht getimed, d.h. mit einem schnellen Quartz geht
' es auch schneller, bzw. das Timeout ist kürzer. 
'---------------------------------------------------------------------------
L_0x00D8:	// -------------	Loop
	LDD	r0,Z + 0	// PIND
	AND	r0,r24		// PIND & Mask 
	EOR	r0,r16		// (PIND & Mask) ^ State 
	BRNE	L_0x00E6	// Ok  PIN != State
	ADIW	XL,0x0001	// Timeout counter++
	BREQ	L_0x0118	// elapsed->ERR-Exit
	RJMP	L_0x00D8	// cont'd Loop
'---------------------------------------------------------------------------
' Und jetzt wird gewartet, bis der Pin den zu messenden Zustand einnimmt. Im Idealfall
' ist das genau die Flanke, garantieren kann man das aber nicht. 
' Auch hier der gleiche "Time"out zähler wie oben. 
'---------------------------------------------------------------------------
L_0x00E6:
	CLR	XL		// clear Timout Lo
	CLR	XH		// clear Timout Hi
L_0x00EA:	// -------------	Loop
	LDD	r0,Z + 0	// PIND
	AND	r0,r24		// PIND & Mask 
	EOR	r0,r16		// (PIND & Mask) ^ State 
	BREQ	L_0x00F8	// Ok  PIN == State
	ADIW	XL,0x0001	// Timeout counter++
	BREQ	L_0x0118	// elapsed->ERR-Exit
	RJMP	L_0x00EA	// cont'd Loop
'---------------------------------------------------------------------------
' jetzt wird's ernst. Jetzt wird in 10µS Intervallen der Impuls HIGH (od.LOW) 
' gemessen. Das Ergebnis also 0 - 65535 * 10 µS. Das reicht etwa für eine 1/2 
' Sekunde. Gibt's eine Überlauf, wird ERR gesetzt. 
'---------------------------------------------------------------------------
L_0x00F8:
	CLR	XL		// clear Timout Lo
	CLR	XH		// clear Timout Hi
L_0x00FC:
	PUSH	ZL		// Save
	PUSH	ZH
	LDI	ZL,0x20		// Dieser Wert wurde aus $CRYSTAL berechnet		
	LDI	ZH,0x00
	CALL	L_0x009C	// 10 µS Idle
	POP	ZH		// Restore
	POP	ZL
	LDD	r0,Z + 0	// PIND
	AND	r0,r24		// Maskieren des PIND.x 
	EOR	r0,r16		// (PIND & Mask) ^ State 
	BRNE	L_0x011C	// OK, die Funktion ist fertig 
	ADIW	XL,0x0001	// PulseCounter++
	BRNE	L_0x00FC	// und weiter
L_0x0118:
	CALL	Set_ErrBit      // Irgendein Überlauf ist eingetreten
L_0x011C:
	MOV	r24,XL		// Ergebnis --> R24:r25
	MOV	r25,XH
	RET			// Zurück

(Quadratur-) ENCODER

"Result" sollte man in Ruhe lassen oder nur lesen, es wird immer gebraucht, um den aktuellen Zustand der A / B Pins für den nächsten Check zu speichern.

Aufruf

 DIM Result AS BYTE
 Result = ENCODER(pind.1 , Pind.3 , Leftlabel , Rightlabel , 0)
  ...
  ...
Leftlabel:
   Return
Rightlabel:
   Return

Code

	LDI	XL,0x60			' Ergebnis (s.o)
	LDI	XH,0x00
	CLT				' clear t-bit  (nicht warten)
L_0x008C:
	LD	r20,X			' Lesen Result (vorheriger Pin-Wert)
	IN	r16,PIND                ' lesen PIN (d)
	CLR	r24			; Temp-Register clear
	SBRC	r16,1			; pind.1 (A) ("skip-if-bit-clear")
	ORI	r24,0x01		; R24 OR 1
	SBRC	r16,3			; pind.3 (B)
	ORI	r24,0x02		; R24 OR 2
	CP	r24,r20			; Vergleich mit altem Wert 
	BRNE	L_0x00A2		; Da gab's eine Änderung
	BRTS	L_0x008C		; t-bit ? Wenn gesetzt, dann warten wir 	
	RJMP	L_0x00C2		; no diff, no wait -> no job --> exit
'------------------------------------------------------------------------------
' das Register r24 hat nun den Level A/B auf den Bits 0 u. 1
' &B000000AB  
'------------------------------------------------------------------------------
L_0x00A2:
	ST	X,r24			; speichern für's nächste Mal 
	SWAP	r20			; den alten Werte "swappen"
'------------------------------------------------------------------------------
' das Register r20 hat nun den (alten) Level A/B auf den Bits 4 u. 5
' &B00ab0000  
'------------------------------------------------------------------------------
	ADD	r24,r20			; OLD + NEW
'------------------------------------------------------------------------------
' jetzt stehen in r24 alter UND neuer Wert
' &B00ab00AB
'------------------------------------------------------------------------------
' Aus Alt & Neu läßt sich eindeutig aus allen 4 Phasen die Drehrichtung ermitteln 
' Bascom checkt nur explizit auf die eine Richtung. Denn wenn's die nicht ist, muß es 
' ja wohl die andere sein. 
'------------------------------------------------------------------------------
' Achtung: daraus folgt: wenn die Impulse zu schnell kommen, stimmen 
' die Ergebnisse u.U. NICHT ! 
' Was vielleicht schlimmer ist: Man merkt es auch nicht
'------------------------------------------------------------------------------
	CPI	r24,0x02
	BREQ	Leftlabel		; left
	CPI	r24,0x10
	BREQ	Leftlabel		; left
	CPI	r24,0x23
	BREQ	Leftlabel		; left
	CPI	r24,0x31
	BREQ	L_0x00BE		; left
	CALL	Rightlabel		; call Right
	RJMP	L_0x00C2		; xit
L_0x00BE:
	CALL	Leftlabel		; call Left
L_0x00C2:

Anmerkung: hier ist kein Return, da der Code direkt eingefügt wird

Leftlabel:
	RET
Rightlabel:
	RET

Die Links-Rechts Routinen sind hier sparsam gehalten. Normalerweise wird man hier wohl Schritte zählen.

Dividieren 32Bit (LONG)

Das folgende Beispiel ist eigentlich eine Bascom-Source mit inline Assembler. Es zeigt, wie Bascom zwei signed LONG dividiert, und durch den Assembler kann man sich das auch im Simulator bitweise anschauen, wie das läuft.

Anmerkung: Nach der Division befindet sich der Divisionsrest in r16:r19. Wenn den jemand braucht, könnte er ihn nach einer long-Division dort abholen.

Aufruf

$regfile = "m32def.dat"                                     ' specify the used micro
$crystal = 8000000

Dim Vala As Long
Dim Valb As Long
Dim Valc As Long

   Vala = 14
   Valb = 1
' das Bascom Äquivalent wäre:
'      Valc = Vala / Valb
$asm
   Loadadr Vala , X                    ' Laden r16:r19 mit Vala
   LD r16,X+
   LD r17,X+
   LD r18,X+
   LD r19,X+
   Loadadr Valb , X                    ' Laden r20:r23 mit Valb
   LD r20,X+
   LD r21,X+
   LD r22,X+
   LD r23,X+
$end Asm

   Gosub L_0x0112                      ' Dividieren  r16:r19 / r20:r23 --> r20:r23

$asm
   Loadadr Valc , X                    ' speichern Ergebnis in Valc
   ST X+,r20
   ST X+,r21
   ST X+,r22
   ST X+,r23
$end Asm

End

Funktions-Code

'-----------------------------------------
'
'-----------------------------------------
L_0x0112:
$asm
   RCALL L_0x0174        'Operanden Vorzeichen prüfung und ggf. umdrehen auf positiv
                         'register r0.0 zeigt, ob das Ergebnis negativ ist
   RCALL L_0x0120        'Prüfen Divisor auf NULL. Wenn nicht, dann dividieren
   BLD r0,1              't-bit -> r0.1 (Error)
   RJMP L_0x010C         'finish

L_0x010C:
   SBRC r0,0             'Ergebnis negativ ?
   RCALL L_0x011A	 'ja, Ergebnis negativ machen
   RET                   'so oder so, Funktionsende

L_0x011A:
   RCALL L_0x018A        'Ergebnis auf negativ (r20:r23)
   RCALL L_0x019C        'Rest auf negativ (r16:r19) 
   RET


'-----------------------------------------
' Prüfen divisor auf NULL 
'-----------------------------------------
L_0x0120:
   MOV r24,r20                 'Kopieren r20:r23 -> r24:r27
   MOV r25,r21
   MOV r26,r22
   MOV r27,r23
   CLT			       ' clear T-bit
   !OR r20,r21                 ' prüfen auf NULL 
   !OR r20,r22
   !OR r20,r23
   BRNE L_0x0136               ' <> NULL --> dividieren
   !SET                        ' ==NULL set t-Bit
   RET
'-----------------------------------------
' dividieren r16:r19 / r20:r23  --> r20:r23
'-----------------------------------------
L_0x0136:
   MOV r20,r16                 'r16:r19->r20:r23
   MOV r21,r17
   MOV r22,r18
   MOV r23,r19
   CLR r16                     'clear r16:r19
   CLR r17
   CLR r18
   CLR r19

   LDI ZH,32                   'Zähler  (32 Bit)
'-----------------------------------------
' divisions-Schleife
'-----------------------------------------
L_0x0148:
   LSL r20                     'shift left r20:r23
   ROL r21                   
   ROL r22
   ROL r23                     '(das oberste Bit wandert nach r16:r19)

   ROL r16                     'shift left r16:r19
   ROL r17
   ROL r18
   ROL r19

   !SUB r16,r24                'subtrahieren 
   SBC r17,r25
   SBC r18,r26
   SBC r19,r27

   ORI r20,1                   'Ergebnis auf 1
   BRCC L_0x016E               'kein Überlauf, bleibt so

   ADD r16,r24                 'Überlauf, wieder addieren
   ADC r17,r25
   ADC r18,r26
   ADC r19,r27
   ANDI r20,254               'und den Ergebnis 1-er wieder löschen
L_0x016E:
   DEC ZH                     'Zähler--
   BRNE L_0x0148              '23-Bit Schleife
   RET                        'fertig

'-----------------------------------------
' Prüfen der Operanden 
'-----------------------------------------
L_0x0174:
   CLR r0                     'Kontroll-Register säubern
   CLT                        't-bit löschen
   SBRS r23,7                 ' r20:r23 Negativ ?
   RJMP L_0x0180              'nö, ist positiv
   RCALL L_0x018A             'ja, auf positiv umdrehen 
   !SET                       'und t-bit setzen
L_0x0180:
   BLD r0,0                   't-bit ins Kontroll-register r0.0
   RCALL L_0x0196	      'Prüfen r16:r19
   BLD r1,0		      't-bit -> r1.0
   EOR r0,r1		      'Exklusiv Or der beiden +- Prüfungen
                              'Vorzeichen verschieden ---> Ergebnis muss negativ sein
   RET                        'e bien
'-----------------------------------------
' r20:r23 auf positiv
'-----------------------------------------
L_0x018A:
   RCALL L_0x01B0             'invertieren
   SUBI r20,0xFF              ' +1
   SBCI r21,0xFF
   SBCI r22,0xFF
   SBCI r23,0xFF
   RET
'-----------------------------------------
' Prüfen  r16:r19
'-----------------------------------------
L_0x0196:
   CLT                        'clear t-bit
   SBRS r19,7                 'sign bit set ?
   RET                        'no
'-----------------------------------------
' r16:r19 auf positiv
'-----------------------------------------
L_0x019C:
   COM r16                   'invertieren
   COM r17
   COM r18
   COM r19
   SUBI r16,0xFF             '+1
   SBCI r17,0xFF
   SBCI r18,0xFF
   SBCI r19,0xFF
   !SET                     't-bit setzen
   RET
'-----------------------------------------
'  invertieren r20:r23
'-----------------------------------------
L_0x01B0:
   COM r20
   COM r21
   COM r22
   COM r23
   RET

$end Asm

Return

Multiplizieren 32Bit (LONG)

Hier ist ein Unterschied, ob der µC über den MUL-Befehl verfügt.

Mit "MUL" (Atmega32)

	MOVW	r24,r16         'r16:r19 -> r24:r27
	MOVW	r26,r18

	MUL	r20,r24         'r20 * r24
	MOVW	r16,r0          '-> r16:r17

	MUL	r20,r26		'r20 * r26
	MOVW	r18,r0          '-> r18:r19

	MUL	r20,r27		'r20 * r27
	MOV	r2,r0		'--> r2

	MUL	r20,r25		'r20 * r25
	ADD	r17,r0		'r17:r18:r19 + r0:r1:r2
	ADC	r18,r1
	ADC	r19,r2

	MUL	r21,r26		'r21 * r26
	MOV	r2,r0
	MUL	r21,r24		'r21 * r26
	ADD	r17,r0		'r17:r18:r19 + r0:r1:r2
	ADC	r18,r1
	ADC	r19,r2

	MUL	r21,r25		'r21 * r26
	ADD	r18,r0		'r18:r19 + r0:r1
	ADC	r19,r1

	MUL	r22,r24		'r22 * r26
	ADD	r18,r0		'r18:r19 + r0:r1
	ADC	r19,r1

	MUL	r22,r25		'r22 * r26
	ADD	r19,r0		'r19 + r0

	MUL	r23,r24		'r23 * r26
	ADD	r19,r0		'r19 + r0

	RET

Ohne "MUL" (AT90S2313)

Hier wird "zu Fuß" multipliziert. Das Vorbereiten der Operanden ist wie beim Dividieren (Prüfung auf NULL entfällt natürlich), auch die Korrektur der Ergebnisses ist genauso (Ergebnis ist diesmal aber in R16:r19).

Ich beschränke mich daher auf das Listing der eigentlichen Multiplikation der beiden 32-Bit Zahlen R16:r19 * r20:r23 ---> r16:r19

'------------------------------------------
'
'------------------------------------------
	MOV	r24,r20      'r20:r23 ---> r24:r27
	MOV	r25,r21
	MOV	r26,r22
	MOV	r27,r23
	CLR	r20          'Löschen r20:r23
	CLR	r21
	CLR	r22
	CLR	r23
	LDI	ZH,0x21      'Zähler 31 (Überlauf nach 32 Bit wird nicht berücksichtigt)
	CLC
	RJMP	L_0x00B6     'Einstieg in die Schleife
'------------------------------------------
'  Schleife
'------------------------------------------
L_0x00A4:
	BRCC	L_0x00AE     
	ADD	r20,r24      ' Nur bei Carry wird addiert
	ADC	r21,r25
	ADC	r22,r26
	ADC	r23,r27
L_0x00AE:
	LSR	r23          'shift right r20:r23
	ROR	r22
	ROR	r21
	ROR	r20          ' Carry -> r16:r19

L_0x00B6:                    'Einsprungs-Stelle
	ROR	r19          'shift right r16:r19
	ROR	r18
	ROR	r17
	ROR	r16
	DEC	ZH           'Zähler
	BRNE	L_0x00A4     'Schleife <> 0
	RET                  'fertig

SERIN

SERIN (und SEROUT) stellen die allgemeinste Form der Software UART dar. Es kann zur Run-Time von einem Aufruf zum nächsten so ziemlich alles verändert werden: PIN, Polarität, Baudrate, Stopp-Bits, Databits (7 od.8 ) und Parity. Anders als bei der normalen SW-UART kann der gleiche Pin zum Senden und Empfangen werden, was für einige half-duplex Kommunikationsformen sehr praktisch ist. Es kann aber nur entweder empfangen oder gesendet werden, eine Bus-Arbitrierung ist also nicht möglich.

Diese Variationsmöglichkeiten haben ihren Preis. Insbesonders die Berechnung der Delay-Counter für die Baudrate, die bei jedem Aufruf neu geschieht, tut weh.

Aber wir wollen hier auch keine Urteile abgeben, sondern nur "sine ira et studio" die Dinge zeigen, wie sie sind. Zum daraus lernen (und ev. dann besser machen) reicht es immer.

Aufruf

$crystal = 8000000
Dim Mystring As String * 10
Dim Mybaud As Long

  Mybaud = 9600

  Serin Mystring , 0 , D , 0 , Mybaud , 0 , 8 , 1

Zur Bedeutung der Parameter bitte Bascom-Help verwenden. Nur soviel: es wird unterschieden, ob die Empfangs-variable ein String ist oder nicht. Wenn ja, läuft die Routine, bis ein <CR> empfangen wird, ansonsten muß eine Länge angegeben werden.

Zur Berechnung der Schleifenzähler werden die internen 32-Bit Funktionen verwendet, die hatten wir schon, also laß ich sie hier weg.

Code

Vorbereiten der Parameter

	LDI	XL,0x6B       'Adresse von "MyBaud"
	LDI	XH,0x00
	LD	r16,X+        ' Baudrate --> r16:r19
	LD	r17,X+
	LD	r18,X+
	LD	r19,X

	LDI	XL,0x6F       ' next free SRAM ("___SER_BAUD") (LONG)
	LDI	XH,0x00
	ST	X+,r16        ' speichern der Baudrate
	ST	X+,r17
	ST	X+,r18
	ST	X,r19

	CALL	L_0x0374	'calc counter nach "___SER_BAUD"
'---------------------------------------------------------------------------
'Bascom berechnet:  Counter =  (( $CRYSTAL / Baudrate ) + 42 ) / 8 
'Das ist ein Schleifenzähler für die Dauer eines halben Bits
'---------------------------------------------------------------------------
	LDI	r24,0x01	'1 stopp-bit
	ST	-Y,r24
	LDI	r24,0x00	'no parity
	ST	-Y,r24
	LDI	r24,0x08	'8 Bit
	ST	-Y,r24
	LDI	XL,0x60		' Datenempfangs-adresse ("MyString")
	LDI	XH,0x00
	CLR	r24             ' Count =null, weil bei string auf <CR> gewartet wird
	ST	-Y,r24		
	LDI	ZL,0x31		' Adresse von  DDRD für PinD 
	LDI	r24,0x00        ' Pin # 0  
	CLT			' Polarität 
	CALL	L_0x02BE	' CALL der eigentlichen "SERIN" Funktion

Einige Hilfs-Funktionen

'-----------------------------------------
' Makemask  r24 Bit# -->  Mask ->r24  !Mask ->r25
'-----------------------------------------
L_0x01CC:
	LDI	r25,0x01
	AND	r24,r24
	BREQ	L_0x01DA
	CLC
L_0x01D4:
	ROL	r25
	DEC	r24
	BRNE	L_0x01D4
L_0x01DA:
	MOV	r24,r25
	COM	r25
	RET
'-----------------------------------------
' Odd-Even PARITY --> r25
'-----------------------------------------
L_0x01E0:
	PUSH	r16
	PUSH	r24
	LDI	r16,0x08          ' Counter 8-Bit  
	CLR	r25
L_0x01E8:
	ROL	r24               ' shift Datenbyte r24 
	BRCC	L_0x01EE          ' no carry
	INC	r25               ' Bit-count++
L_0x01EE:
	DEC	r16               'Loop Count
	BRNE	L_0x01E8          'continue
	POP	r24               
	POP	r16
	RET
'-----------------------------------------
' stringleng  ASCIZ   R24 =  strlen( @X )
'-----------------------------------------
L_0x0202:
	LDI	r24,0xFF          'beginn mit -1
L_0x0204:
	INC	r24               'length++
	LD	r25,X+            'nächstes Zeichen
	AND	r25,r25           'NULL ?
	BRNE	L_0x0204          'nö, weitermachen
	RET                       'ja, fertig

Die Funktion

'-----------------------------------------
'SERIN
'-----------------------------------------
L_0x02BE:
	RCALL	L_0x01CC	' Pin-# nach BitMask und !BitMask
	CLR	ZH              '

	LDD	r0,Z + 0	' adresse von DDRD
	AND	r0,r25		' Pin wird Input
	STD	Z + 0,r0	

	INC	ZL		' jetzt zeigt Z auf PORTD

	LDD	r0,Z + 0        ' Clear PORTD.x
	AND	r0,r25
	STD	Z + 0,r0

	SBIW	ZL,0x0002       ' jetzt zeigt Z auf PIND

	MOV	r16,r24		' Mask
	MOV	r22,r25		' !Mask

	LD	r20,Y+          ' Byte count  
	MOV	r19,r20
'-------------------------------------------------------------------------
' Ausrechnen der effektive Framesize  (Data-Bits, Parity, Stopp-Bits)
'-------------------------------------------------------------------------
L_0x02DA:
	LDD	r17,Y + 0	' Data-Bits (7/8)
	CPI	r17,0x07	' 7 Bit ?
	BRNE	L_0x02F2	' nein, es sind 8
'---------------------------------------------------
' 7 Data-Bits 
'---------------------------------------------------
	LDD	r17,Y + 1	' parity 
	CPI	r17,0x00        ' Y/N
	BRNE	L_0x02EC        ' Y
	LDD	r18,Y + 2       ' stopp-bits
	SUBI	r18,0xF9	' +7    (0xF9 == -7 )
	RJMP	L_0x0302        
L_0x02EC:
	LDD	r18,Y + 2	' stopp-bits
	SUBI	r18,0xF8	' +8    (0xF8 == -8 )
	RJMP	L_0x0302
'---------------------------------------------------
' 8 Data-Bits
'---------------------------------------------------
L_0x02F2:
	LDD	r17,Y + 1	' parity
	CPI	r17,0x00        ' Y/N
	BRNE	L_0x02FE	' Y 
	LDD	r18,Y + 2	' stopp-bits	
	SUBI	r18,0xF8	' +8    (0xF8 == -8 )
	RJMP	L_0x0302
L_0x02FE:
	LDD	r18,Y + 2	' stopp-bits
	SUBI	r18,0xF7	' +9    (0xF7 == -9 )	

L_0x0302:
	MOV	r21,r18         ' Framesize
'----------------------------------------
' Der eigentlich BYTE-Read-Loop
'----------------------------------------
' R18 /R21 frame bits  
' X data pointer  
' Z PIN(d)  
' T-Bit revert polarity 
' Y Parameter  
' r20 Laufender Byte-Zähler
' r19 gewünschte Anzahl Bytes (bei einem String ist das NULL)
'----------------------------------------


'----------------------------------------
' Die fallende(od. steigende) Flanke des Start-Bits finden
'----------------------------------------
L_0x0304:
	LDD	r0,Z + 0	' Rx Pin
	AND	r0,r16		' mask
	BRTS	L_0x030E	' T-Bit ?
	BREQ	L_0x0312	' Low--> start
	RJMP	L_0x0304	' wait loop

' reverse polarity
L_0x030E:   
	BRNE	L_0x0312	' high--> start
	RJMP	L_0x0304	' wait loop

'----------------------------------------
'StartBit Flanke gefunden, bis zur ~Mitte dauert es noch 1/2 Bit
'----------------------------------------
L_0x0312:
	RCALL	L_0x035E	' Warten 1/2 Bit
'----------------------------------------
' Data Bit Loop
'----------------------------------------
L_0x0314:
	RCALL	L_0x035E	' Warten 1/2 Bit			
	RCALL	L_0x035E	' Warten 1/2 Bit			

	CLC			' clear carry		
	LDD	r0,Z + 0	' Lesen PIN 
	AND	r0,r16		' Maskieren Bit
	BREQ	L_0x0322	' Bit ist Low
	SEC			' Bit ist High --> set carry
L_0x0322:
	DEC	r18		' Frame Bit-Zähler 
	BREQ	L_0x032C	' fertig
	ROR	r24		' das Carry reinschieben nach r24:r25
	ROR	r25		
	RJMP	L_0x0314	' und weiter

L_0x032C:
	CPI	r21,0x0A	' Framesize  <> 10 	?
	BRLO	L_0x033A	' lower
	SUBI	r21,0x09	' >= 10 --> sub 9
L_0x0332:
	ROL	r25		' Ausrichten Data Byte 
	ROL	r24
	DEC	r21             '
	BRNE	L_0x0332	' Zählschleife
L_0x033A:
	BRTC	L_0x033E        ' Polarität ?
	COM	r24		' Umdrehen data Byte
L_0x033E:
	LDD	r17,Y + 0       ' Data-Bits
	CPI	r17,0x07
	BRNE	L_0x0346        ' = 8
	ANDI	r24,0x7F	' = 7 , also löschen 2^^7
L_0x0346:
	ST	X+,r24		' speicher DataByte
	CPI	r19,0x00	' soll es ein string werden ?
	BRNE	L_0x0358	' nein
	CPI	r24,0x0D	' ja, ist das ein <CR>
	BRNE	L_0x02DA	' nö, weiter in der Byte-Schleife
	CLR	r24		' Ja, in der Empfangs string wird aber statt dessen 
	ST	X,r24		' 0x00 geschrieben, damit es ein Null-terminierter String wird
L_0x0354:
	ADIW	YL,0x0003	' restore Y auf den Einstiegswert
	RET			' fertig
L_0x0358:
	DEC	r20		' kein String, müssen wir also zählen 
	BREQ	L_0x0354	' geschafft.
	RJMP	L_0x02DA	' weiter geht's

'-------------------------------------------
' 1/2 Bit Delay
'-------------------------------------------
L_0x035E:
	PUSH	r24		
	PUSH	r25		
	LDS	r24,0x006F	' das LSB von "___SER_BAUD" (s.o.)
	LDS	r25,0x0070	' das MSB
L_0x036A:
	SBIW	r24,0x0001	
	BRNE	L_0x036A	
	POP	r25		
	POP	r24		
	RET

Autor

Benutzer:PicNick

Siehe auch

Bascom Inside