PIC-Assembler - Spezielle Befehle

einige spezielle Schreibweisen/Befehle erleichtern die Arbeit mit Assembler

Spezial-Befehlsübersicht

SKPC , SKPDC , SKPNC , SKPNDC , SKPNZ , SKPZ

CLRC , CLRDC , CLRZ , SETC , SETDC , SETZ ,

Befehlsübersicht nach Gruppen

Aritmetische Operationen (ADD.., SUB..)
Sprungbefehle
Skip-Befehle
Setzen und Löschen einzelner Flags (CL..., SET...)
Kopierbefehle (MOV...)

Spezielle Befehle?

Auf der Seite über die Assembler-Befehle wurden bereits alle Befehle behandelt, die die PIC16F/PIC12F-Prozessoren beherrschen. Trotzdem wird man in vielen Listings scheinbar andere Befehle finden. Dafür gibt es zwei Gründe:

für einige besonders kryptische Befehle (z.B. BTFNZ STATUS,C) die schwer zu verstehen aber häufig zu verwenden sind, gibt es einfache Alternativschreibweisen,
für einige häufig benötigte Befehlskombinationen gibt es Abkürzungen, die wie ein Makro verwendet werden.

Auch wenn solche Spezialbefehle nicht unbedingt nötig sind, können sie doch die Verständlichkeit und die Lesbarkeit von Assemblercode deutlich verbessern.

nach oben

Die Spezial-Befehle

Aritmetische Operationen (ADD.., SUB..)
Sprungbefehle (B..., SK...)
Skip-Befehle
Setzen und Löschen einzelner Flags (CL..., SET...)
Kopierbefehle (MOV...)

Aritmetische Operationen (ADD.., SUB..)

Das sind die Befehle zur "Datenverarbeitung". Hier wird also gerechnet.

ADDCF Addiere den Wert des Carry-Flags zum Register f

Syntax: ADDCF f,d

echter Code BTFSC   STATUS, C
incf    f, d

Bedeutung: Der Inhalt des Registers f wird um 1 erhöht, falls das C-Flag gesetzt ist
wenn d=0:
Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.

wenn d=1
Das Ergebnis wird wieder in der Speicherzelle f gespeichert

Beispiel: ADDCF 0x20,1 ; Falls das C-Flag gesetzt ist, wird der Inhalt der Speicherzelle
              ;   20h um 1 erhöht. Die Summe wird in der
              ;   Speicherzelle 20h abgelegt.

Flags: Z

ADDDCF Addiere den Wert des DigitCarry-Flags zum Register f

Syntax: ADDDCF f,d

echter Code BTFSC   STATUS, DC
incf    f, d

Bedeutung: Der Inhalt des Registers f wird um 1 erhöht, falls das DC-Flag gesetzt ist
wenn d=0:
Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.

wenn d=1
Das Ergebnis wird wieder in der Speicherzelle f gespeichert

Beispiel: ADDDCF 0x20,1 ; Falls das DC-Flag gesetzt ist, wird der Inhalt der Speicherzelle
               ;   20h um 1 erhöht. Die Summe wird in der
               ;   Speicherzelle 20h abgelegt.

Flags: Z

SUBCF Subtrahiere den Wert des Carry-Flags vom Register f

Syntax: SUBCF f,d

echter Code BTFSC   STATUS, C
decf    f, d

Bedeutung: Der Inhalt des Registers f wird um 1 verringert, falls das C-Flag gesetzt ist
wenn d=0:
Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.

wenn d=1
Das Ergebnis wird wieder in der Speicherzelle f gespeichert

Beispiel: SUBCF 0x20,1 ; Falls das C-Flag gesetzt ist, wird der Inhalt der Speicherzelle
              ;   20h um 1 verringert. Das Ergebnis wird in der
              ;   Speicherzelle 20h abgelegt.

Flags: Z

SUBDCF Subtrahiere den Wert des DigitCarry-Flags vom Register f

Syntax: SUBDCF f,d

echter Code BTFSC   STATUS, DC
decf    f, d

Bedeutung: Der Inhalt des Registers f wird um 1 verringert, falls das DC-Flag gesetzt ist
wenn d=0:
Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.

wenn d=1
Das Ergebnis wird wieder in der Speicherzelle f gespeichert

Beispiel: SUBDCF 0x20,1 ; Falls das DC-Flag gesetzt ist, wird der Inhalt der Speicherzelle
               ;   20h um 1 vermindert. Das Ergebnis wird in der
               ;   Speicherzelle 20h abgelegt.

Flags: Z

Sprungbefehle

Hier geht es in erster Linie um die Vereinfachung der berüchtigten Befehlskombinationen a'la:

BTFSC STATUS, C
GOTO nirwana

B	Unbedingter Sprung (B steht für Branch=Verzweigung)
`Syntax:`	`B k`
`echter Code`	`GOTO k`
`Bedeutung:`	`Springe im Programm zur Adresse k. (k ist 11 Bit lang)` `Normalerweise ist k eine Marke. Dadurch wird dann ein Bezeichner und keine nackte Zahl verwendet.`
`Beispiel:`	`B Marke1 ; Springe zur Marke1 im Programm.` `.` `.` `Marke1` `; hier geht es weiter.`

BC	Springe falls C-Flag gesetzt ist
`Syntax:`	`BC k`
`echter Code`	`BTFSC STATUS, C` `GOTO k`
`Bedeutung:`	`wenn das Carry-flag gesetzt ist, wird zur Adresse k gesprungen.`
`Beispiel:`	`BC Marke1 ; prüfe das Carry-Flag, bei C=1 wird zur Marke 1 gesprungen` `GOTO Marke2 ; bei C=0 wird diese Zeile ausgeführt: Sprung zu Marke2`

BDC	Springe falls DC-Flag gesetzt ist
`Syntax:`	`BDC k`
`echter Code`	`BTFSC STATUS, DC` `GOTO k`
`Bedeutung:`	`wenn das DigitCarry-flag gesetzt ist, wird zur Adresse k gesprungen.`
`Beispiel:`	`BDC Marke1 ; prüfe das DC-Flag, bei DC=1 wird zur Marke 1 gesprungen` `GOTO Marke2 ; bei DC=0 wird diese Zeile ausgeführt: Sprung zu Marke2`

BNC	Springe falls C-Flag nicht gesetzt ist
`Syntax:`	`BNC k`
`echter Code`	`BTFSS STATUS, C` `GOTO k`
`Bedeutung:`	`wenn das Carry-flag nicht gesetzt ist, wird zur Adresse k gesprungen.`
`Beispiel:`	`BNC Marke1 ; prüfe das Carry-Flag, bei C=0 wird zur Marke 1 gesprungen` `GOTO Marke2 ; bei C=1 wird diese Zeile ausgeführt: Sprung zu Marke2`

BNDC	Springe falls DC-Flag nicht gesetzt ist
`Syntax:`	`BNDC k`
`echter Code`	`BTFSS STATUS, DC` `GOTO k`
`Bedeutung:`	`wenn das DigitCarry-flag nicht gesetzt ist, wird zur Adresse k gesprungen.`
`Beispiel:`	`BNDC Marke1 ; prüfe das DC-Flag, bei DC=0 wird zur Marke 1 gesprungen` `GOTO Marke2 ; bei DC=0 wird diese Zeile ausgeführt: Sprung zu Marke2`

BZ	Springe falls Z-Flag gesetzt ist
`Syntax:`	`BZ k`
`echter Code`	`BTFSC STATUS, Z` `GOTO k`
`Bedeutung:`	`wenn das Zero-flag gesetzt ist, wird zur Adresse k gesprungen.`
`Beispiel:`	`BZ Marke1 ; prüfe das Zero-Flag, bei Z=1 wird zur Marke 1 gesprungen` `GOTO Marke2 ; bei Z=0 wird diese Zeile ausgeführt: Sprung zu Marke2`

BNZ	Springe falls Z-Flag nicht gesetzt ist
`Syntax:`	`BNZ k`
`echter Code`	`BTFSS STATUS, Z` `GOTO k`
`Bedeutung:`	`wenn das Zero-flag nicht gesetzt ist, wird zur Adresse k gesprungen.`
`Beispiel:`	`BNZ Marke1 ; prüfe das Zero-Flag, bei Z=0 wird zur Marke 1 gesprungen` `GOTO Marke2 ; bei Z=1 wird diese Zeile ausgeführt: Sprung zu Marke2`

Skip-Befehle

Ein SKIP-Befehl (Auslass-Befehl) entscheidet anhand von Flags, ob der nachfolgende Befehl ausgelassen (übersprungen) wird.
Das sind lediglich andere (eingängigere) Schreibweisen für einige Befehle der Form:

BTFSC STATUS,...

SKPC	SKIP wenn C-Flag gesetzt ist
`Syntax:`	`SKPC`
`echter Code`	`BTFSS STATUS, C`
`Bedeutung:`	`Überspringe den folgenden Befehl, falls das Carry-Flag gesetzt ist.`
`Beispiel:`	`SKPC ; teste das C-Flag` `CLRW ; dieser Befehl wird nicht ausgeführt falls C=1`

SKPDC	SKIP wenn DC-Flag gesetzt ist
`Syntax:`	`SKPDC`
`echter Code`	`BTFSS STATUS, DC`
`Bedeutung:`	`Überspringe den folgenden Befehl, falls das DigitCarry-Flag gesetzt ist.`
`Beispiel:`	`SKPDC ; teste das DC-Flag` `CLRW ; dieser Befehl wird nicht ausgeführt falls DC=1`

SKPNC	SKIP wenn C-Flag nicht gesetzt ist
`Syntax:`	`SKPNC`
`echter Code`	`BTFSC STATUS, C`
`Bedeutung:`	`Überspringe den folgenden Befehl, falls das Carry-Flag nicht gesetzt ist.`
`Beispiel:`	`SKPNC ; teste das C-Flag` `CLRW ; dieser Befehl wird nicht ausgeführt falls C=0`

SKPNDC	SKIP wenn DC-Flag nicht gesetzt ist
`Syntax:`	`SKPNDC`
`echter Code`	`BTFSC STATUS, DC`
`Bedeutung:`	`Überspringe den folgenden Befehl, falls das DigitCarry-Flag nicht gesetzt ist.`
`Beispiel:`	`SKPNDC ; teste das DC-Flag` `CLRW ; dieser Befehl wird nicht ausgeführt falls DC=0`

SKPNZ	SKIP wenn Z-Flag nicht gesetzt ist
`Syntax:`	`SKPNZ`
`echter Code`	`BTFSC STATUS, Z`
`Bedeutung:`	`Überspringe den folgenden Befehl, falls das Zero-Flag nicht gesetzt ist.`
`Beispiel:`	`SKPNZ ; teste das Z-Flag` `CLRW ; dieser Befehl wird nicht ausgeführt falls Z=0`

SKPZ	SKIP wenn Z-Flag gesetzt ist
`Syntax:`	`SKPZ`
`echter Code`	`BTFSS STATUS, Z`
`Bedeutung:`	`Überspringe den folgenden Befehl, falls das Zero-Flag gesetzt ist.`
`Beispiel:`	`SKPZ ; teste das Z-Flag` `CLRW ; dieser Befehl wird nicht ausgeführt falls Z=1`

Setzen und Löschen einzelner Flags (CL..., SET...)

Das sind Kurzschreibweisen für befehler der Art:

BSF/BCF STATUS, ...

CLRC	lösche das C-Flag
`Syntax:`	`CLRC`
`echter Code`	`BCF STATUS, C`
`Bedeutung:`	`löscht das Carry-Flag`
`Beispiel:`	`CLRC ; nun ist C=0`

CLRDC	lösche das DC-Flag
`Syntax:`	`CLRDC`
`echter Code`	`BCF STATUS, DC`
`Bedeutung:`	`löscht das DigitCarry-Flag`
`Beispiel:`	`CLRDC ; nun ist DC=0`

CLRZ	lösche das Z-Flag
`Syntax:`	`CLRZ`
`echter Code`	`BCF STATUS, Z`
`Bedeutung:`	`löscht das Zero-Flag`
`Beispiel:`	`CLRZ ; nun ist Z=0`

SETC	setze das C-Flag
`Syntax:`	`SETC`
`echter Code`	`BSF STATUS, C`
`Bedeutung:`	`setzt das Carry-Flag`
`Beispiel:`	`SETC ; nun ist C=1`

SETDC	setze das DC-Flag
`Syntax:`	`SETDC`
`echter Code`	`BSF STATUS, DC`
`Bedeutung:`	`setzt das DigitCarry-Flag`
`Beispiel:`	`SETDC ; nun ist DC=1`

SETZ	setze das Z-Flag
`Syntax:`	`SETZ`
`echter Code`	`BSF STATUS, Z`
`Bedeutung:`	`setzt das Zero-Flag`
`Beispiel:`	`SETZ ; nun ist Z=1`

Kopierbefehle und Anderes (MOV...)

MOVFW lade den Inhalt des Registers f nach W

Syntax: MOVFW

echter Code MOVF    f, w

Bedeutung: der Inhalt des Registers f wird nach W kopiert

Beispiel: MOVFW       0x20h    ;

Flags: Z

NEGF wandelt den Inhalt des Registers f in das Zweierkomplement um

Syntax: NEGF    f, d

echter Code COMF    f, 1
INCF    f, d

Bedeutung: der Inhalt des Registers f wird invertiert und incrementiert, um das Zweierkomplement zu bilden

Beispiel: NEGF     0x20h    ;

Flags: Z

TSTF prüfe ob im Registers f eine Null steht

Syntax: TSTF    f

echter Code MOVF    f, 1

Bedeutung: fall im Register f Null steht, dann wird das Z-Flag gesetzt

Beispiel: TSTF     0x20h

Flags: Z

nach oben

zurück zu PIC-Prozessoren , Elektronik , Homepage

erstellt am: 21.01.2003
letzte Änderung: 24.01.2004

ADDCF	Addiere den Wert des Carry-Flags zum Register f
`Syntax:`	`ADDCF f,d`
`echter Code`	`BTFSC STATUS, C` `incf f, d`
`Bedeutung:`	`Der Inhalt des Registers f wird um 1 erhöht, falls das C-Flag gesetzt ist` `wenn d=0:` `Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.` `wenn d=1` `Das Ergebnis wird wieder in der Speicherzelle f gespeichert`
`Beispiel:`	`ADDCF 0x20,1 ; Falls das C-Flag gesetzt ist, wird der Inhalt der Speicherzelle` `; 20h um 1 erhöht. Die Summe wird in der` `; Speicherzelle 20h abgelegt.`
`Flags:`	`Z`

ADDDCF	Addiere den Wert des DigitCarry-Flags zum Register f
`Syntax:`	`ADDDCF f,d`
`echter Code`	`BTFSC STATUS, DC` `incf f, d`
`Bedeutung:`	`Der Inhalt des Registers f wird um 1 erhöht, falls das DC-Flag gesetzt ist` `wenn d=0:` `Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.` `wenn d=1` `Das Ergebnis wird wieder in der Speicherzelle f gespeichert`
`Beispiel:`	`ADDDCF 0x20,1 ; Falls das DC-Flag gesetzt ist, wird der Inhalt der Speicherzelle` `; 20h um 1 erhöht. Die Summe wird in der` `; Speicherzelle 20h abgelegt.`
`Flags:`	`Z`

SUBCF	Subtrahiere den Wert des Carry-Flags vom Register f
`Syntax:`	`SUBCF f,d`
`echter Code`	`BTFSC STATUS, C` `decf f, d`
`Bedeutung:`	`Der Inhalt des Registers f wird um 1 verringert, falls das C-Flag gesetzt ist` `wenn d=0:` `Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.` `wenn d=1` `Das Ergebnis wird wieder in der Speicherzelle f gespeichert`
`Beispiel:`	`SUBCF 0x20,1 ; Falls das C-Flag gesetzt ist, wird der Inhalt der Speicherzelle` `; 20h um 1 verringert. Das Ergebnis wird in der` `; Speicherzelle 20h abgelegt.`
`Flags:`	`Z`

SUBDCF	Subtrahiere den Wert des DigitCarry-Flags vom Register f
`Syntax:`	`SUBDCF f,d`
`echter Code`	`BTFSC STATUS, DC` `decf f, d`
`Bedeutung:`	`Der Inhalt des Registers f wird um 1 verringert, falls das DC-Flag gesetzt ist` `wenn d=0:` `Das Ergebnis wird Arbeitsregister W gespeichert. Die Speicherzelle f bleibt unverändert.` `wenn d=1` `Das Ergebnis wird wieder in der Speicherzelle f gespeichert`
`Beispiel:`	`SUBDCF 0x20,1 ; Falls das DC-Flag gesetzt ist, wird der Inhalt der Speicherzelle` `; 20h um 1 vermindert. Das Ergebnis wird in der` `; Speicherzelle 20h abgelegt.`
`Flags:`	`Z`

MOVFW	lade den Inhalt des Registers f nach W
`Syntax:`	`MOVFW`
`echter Code`	`MOVF f, w`
`Bedeutung:`	`der Inhalt des Registers f wird nach W kopiert`
`Beispiel:`	`MOVFW 0x20h ;`
`Flags:`	`Z`

NEGF	wandelt den Inhalt des Registers f in das Zweierkomplement um
`Syntax:`	`NEGF f, d`
`echter Code`	`COMF f, 1` `INCF f, d`
`Bedeutung:`	`der Inhalt des Registers f wird invertiert und incrementiert, um das Zweierkomplement zu bilden`
`Beispiel:`	`NEGF 0x20h ;`
`Flags:`	`Z`

TSTF	prüfe ob im Registers f eine Null steht
`Syntax:`	`TSTF f`
`echter Code`	`MOVF f, 1`
`Bedeutung:`	`fall im Register f Null steht, dann wird das Z-Flag gesetzt`
`Beispiel:`	`TSTF 0x20h`
`Flags:`	`Z`