Benedikt.Seidl: meins ;-)

2007-04-12T14:16:00Z

meins ;-)

Neue Seite

== Kurzübersicht Assembler Befehle ==

{|
|-
| valign=top |

{| {{Blauetabelle}}
|ADDLW||Add literal and W
|-
|ADDWF||Add W and f
|-
|ANDLW||AND literal with W
|-
|ANDWF||AND W with f
|-
|BCF||Bit Clear f
|-
|BSF||Bit Set f
|-
|BTFSC||Bit Test f, Skip if Clear
|-
|BTFSS||Bit Test f, Skip if Set
|-
|CALL||Call subroutine
|-
|CLRF||Clear f
|-
|CLRW||Clear W
|-
|CLRWDT||Clear Watchdog Timer
|}

| valign=top |

{| {{Blauetabelle}}
|-
|COMF||Complement f
|-
|DECF||Decrement f
|-
|DECFSZ||Decrement f, Skip if 0
|-
|GOTO||Go to address or label
|-
|INCF||Increment f
|-
|INCFSZ||Increment f, Skip if 0
|-
|IORLW||Inclusive OR literal with W
|-
|IORWF||Inclusive OR W with f
|-
|MOVF||Move f
|-
|MOVLW||Move literal to W
|-
|MOVWF||Move W to f
|-
|NOP||No Operation
|}

| valign=top |

{| {{Blauetabelle}}
|-
|RETFIE||Return from interrupt
|-
|RETLW||Return with literal in W
|-
|RETURN||Return from Subroutine
|-
|RLF||Rotate Left f through Carry
|-
|RRF||Rotate Right f through Carry
|-
|SLEEP||Go into standby mode
|-
|SUBLW||Subtract W from literal
|-
|SUBWF||Subtract W from f
|-
|SWAPF||Swap nibbles in f
|-
|XORLW||Exclusive OR literal with W
|-
|XORWF||Exclusive OR W with f
|}
[[:bild:pic_asm_short.jpg|Kurzübersicht zum Ausdrucken]]
|}


==Ausführliche Beschreibung zu den Befehlen==

Erklärungen zu den Verwendeten Platzhaltern:
*'''k''' stellt einen fest definierten Wert da. z.B. <tt>0x20</tt>, <tt>d'42'</tt> oder <tt>b'00101010'</tt>
*'''W''' steht für das W-Register.
*'''d''' steht für ''destination'' (Ziel). Im code wird d durch ein <tt>w</tt> bzw. <tt>0</tt> (der Wert wird in das W-Register gespeichert ) oder <tt>f</tt> bzw. <tt>1</tt> (der Wert wird in das davor definierte Register gespeichert)
*'''b''' steht für Bitnummer im Register (eine Zahl zwischen 0 und 7)
*'''R''' steht für ein Register
*'''fett''' geschrieben Bedeutet, dass es ein Platzhalter ist und im Quellcode durch eine Registeradresse oder einen Wert ersetzt werden muss
*<tt>Schreibmaschinenstil</tt> bedeutet, dass es so im Quellcode geschrieben werden kann.

 ADDLW k Add W and literal - Addiere W und Zahl<hr>
:Es wird die Rechenoperation <math>k+W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ADDWF R,d Add W and f - Addiere W und f <hr>
:Es wird die Rechenoperation <math>R+W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 ANDWF k AND literal with W<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ k</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Register, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
1100
1010
---- and
1000
</dd></dl>

 ANDWF R,d AND W with f - ???<hr>
:Es wird bitweise die logische Funktion <math>W\ and\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche ANDWF

BCF R,b Bit Clear f - Bit b im R wird gelöscht<hr>
:Mit dem Befehl <tt>BCF</tt> wird das Bit '''b''' im Register '''R''' gelöscht. Ein Beispiel:
<dl><dd>
movlw b'11111111' ;es wird b'11111111' in das W-Register geschrieben
BCF W,2 ;es wird bit 2 im W-Register gelöscht.
;das Ergebnis ist: b'11111011'
</dl></dd>

BSF R,b Bit Set f - Bit b im R wird gesetzt<hr>
:Mit dem Befehl <tt>BSF</tt> wird das Bit '''b''' im Register '''R''' gesetzt. Ein Beispiel:
<dl><dd>
clrw ;es wird b'00000000' in das W-Register geschrieben
BSF W,2 ;es wird bit 2 im W-Register gesetzt.
;das Ergebnis ist: b'00000100'
</dl></dd>

BTFSC R,b Bit Test f, Skip if Clear - Wenn das Bit b im Register R 0 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSC</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 0 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSC W,0 ;es wird bit 0 geprüft.
;wenn es 0 ist, wird der nächste Befehl übersprungen
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser Sprungbefehl ausgeführt.
goto IST_NULL ;springt zur Marke "IST_NULL"
</dl></dd>

BTFSS R,b Bit Test f, Skip if Set - Wenn das Bit b im Register R 1 ist, überspringe den nächsten Befehl<hr>
:Mit dem Befehl <tt>BTFSS</tt> kann eine Verzweigung im Programmablauf bewirkt werden. Wenn das Bit '''b''' im Register '''R''' 1 ist, wird der nächste Befehl übersprungen. Ein Beispiel:
<dl><dd>
movlw b'00000001' ;es wird die Zahl 1 in das W-Register kopiert.
BTFSS W,0 ;es wird bit 0 geprüft.
;wenn es 1 ist, wird der nächste Befehl übersprungen
goto IST_NULL ;springt zur Marke "IST_NULL"
goto IST_EINS ;springt zur Marke "IST_EINS" <- in diesem Fall wird dieser
;Sprungbefehl ausgeführt, da der Befehl
;darüber übersprungen wurde.
</dl></dd>

CALL Call Subroutine - Rufe Unterprogramm auf<hr>
:Mit dem <tt>CALL</tt> Befehl wird ein Unterprogramm aufgerufen. Mit dem <tt>RETURN</tt>-Befehl wird das Unterprogramm beendet und man kehrt zum Befehl nach dem <tt>CALL</tt>-Befehl zurück. Das Unterprogramm wird so definiert, dass im Quellcode der Name des Unterprogramms nicht eingerückt steht. Ein Beispiel:

<dl><dd>
movlw d'13' ;in das W-Register wird 13d geladen
CALL Unterprogramm1 ;es wird das Unterprogramm "Unterprogramm1" aufgerufen
movwf ergebnis ;das W-Register wird in das Register "ergebnis" kopiert.
;im Register "ergebnis" steht nun 23d

Unterprogramm1 ;zählt 10 zum W-Register
addlw d'10' ;es wird 10d zum W-Register addiert
RETURN ;kehre zurück zum Aufrufer
</dl></dd>

CLRF R Clear f - Schreibe 0 in das Register R<hr>
:Das Register '''R''' wird mit Nullen gefüllt (gelöscht).

CLRW Clear W - Schreibe 0 in W<hr>
:Das W-Register (<tt>W</tt>) wird mit Nullen gefüllt (gelöscht).

CLRWDT Clear Watchdog Timer - Setzt den Watchdog-Timer zurück<hr>
:Es wird der WDT (Watchdog-Timer) zurückgesetzt und der Zähler des WDT auf 0 gesetzt, zusätzlich werden die STATUS-bits TO und PD gesetzt.

COMF R,d Complement f - negiere alle bits im Register R<hr>
:Von der Binärzahl im Register '''R''' werden die 0 mit 1 und 1 mit 0 ersetzt. Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Ein kleines Beispiel: aus <tt>AAh</tt> (<tt>10101010b</tt>) wird <tt>55h</tt> (<tt>01010101b</tt>).

DECF R,d Decrement f, Skip if 0 - Subtrahiert 1 vom Regiser f<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das C-Flag im STATUS-Register nicht.

DECFSZ R,d Decrement f, Skip if 0 - Subtrahiert 1 vom Regiser f, überspringe wenn 0<hr>
:Vom Wert des Registers '''R''' wird 1 subtrahiert und das Ergebnis entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

GOTO Go to address - Gehe zu Adresse/Sprungmarke<hr>
:Nach dem GOTO Befehl wird das Programm ab der Adresse weiter ausgeführt, die nach dem GOTO-Befehl steht. Diese Adresse wird durch so genannte Sprungmarke definiert, welche, im Gegensatz zu den Befehlen nicht eingerückt im Quellcode stehen.

INCF R,d Increment f - Addiere 1 zum Register f<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das C-Flag im STATUS-Register nicht.

INCFSZ R,d Increment f, Skip if 0 - Addiere 1 zum Regiser f, überspringe wenn 0<hr>
:Zum Wert des Registers '''R''' wird 1 addiert und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Der Zusatz SZ steht für ''skip if zero'', d.h. wenn das Ergebnis der Rechnung Null ist, wird der nächste Befehl übersprungen. Dieser Befehl wird für Schleifen mit bestimmter Anzahl der Durchläufe benutzt.

 IORLW k OR literal with W<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ k</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Register, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Ooperation:
<dl><dd>
1100
1010
---- or
1110
</dd></dl>

 IORWF R,d OR W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ or\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche IORLW

MOVF R,d Move f - Bewege f<hr>
:Das Register R wird in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder wieder in R kopiert ('''d'''=<tt>F</tt>=<tt>1</tt>). Letzteres mag sinnlos scheinen, ist aber nützlich, da durch den Befehl das Z-Bit im STATUS-Regsiter gesetzt wird, falls R Null ist.

MOVLW k Move literal to W - Bewege Zahl in W-Register<hr>
:Der festgelegte Wert k wird in das W-Register kopiert.

MOVWF R Move W to f - Bewege W-Register in das Register F<hr>
:Das W-Register wird in das Register '''R''' kopiert.

NOP No Operation - Kein Befehl zum Ausführen (warte)<hr>
:Dieser Befehl macht nichts. Er verbraucht nur Zeit, welche sich einfach mit folgender Formel berechnen lässt. <math>t=\frac{4}{f}</math>,wobei <math>f</math> für die Frequenz des Oszillators steht.

RETFIE Return from interrupt - Kehre zurück aus der Unterbrechung<hr>
:Mit diesem Befehl wird die Interrupt Service Routine (ISR) beendet und das Programm wird an der Zeile weiter ausgeführt, vor der es durch den Interrupt angehalten wurde. Es werden auch alle Interrupts wieder erlaubt (das GIE bit wird gesetzt). Siehe hierzu auch [[#Interrupt | Interrupt]]

RETLW k Return with literal in W - Kehre zurück mit Zahl k im W-Register<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETLW</tt> zurück in die nächste Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde. Der in k angegebene Wert wird dabei in das W-Register geschrieben. Dieser Befehl wird vor allem für s.g Wertetabellen (eng: lookup tables) verwendet.

RETURN Return from Subroutine - Kehre zurück zum Übergeordneten Programmteil<hr>
:Wurde ein Programmteil mit dem Befehl <tt>CALL</tt> aufgerufen, dann springt man mit dem Befehl <tt>RETURN</tt> zurück zu der nächsten Zeile nach der Zeile aus der das <tt>CALL</tt> Befehl ausgeführt wurde.

RLF R,d Rotate Left f through Carry - Rotiere das Register f mithilfe des Carry-bits nach links<hr>
:Alle Bits im Register '''R''' werden um eine Position nach links verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) in das Bit 0 des Registers R geschoben. Bit 7 aus dem Register '''R''' wird in das Carry bit "geschoben". Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).

:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C
c 7 6 5 4 3 2 1 0 ;vor dem Verschieben
7 6 5 4 3 2 1 0 c ;nach dem Verschieben
</dd></dl>

RRF R,d Rotate Right f through Carry - Rotiere das Register f mithilfe des Carry-bits nach rechts<hr>
:Alle Bits im Register '''R''' werden um eine Position nach rechts verschoben. Dabei wird das Carry bit (<tt>STATUS,C</tt>) in das 7.Bit des Registers R geschoben. Bit 0 aus dem Register '''R''' wird in das Carry bit "geschoben". Das Ergebnis wird entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).

:Zur Verdeutlichung:
<dl><dd>
|C| |-Register R-| ;C steht für das Carry-bit, STATUS,C
C 7 6 5 4 3 2 1 0 ;vor dem Verschieben
0 C 7 6 5 4 3 2 1 ;nach dem Verschieben
</dd></dl>

SLEEP Go into standby mode - Versetze den Mirokontroller in Bereitschaftsmodus<hr>
:Der µC wird in den Sleep-Mode versetzt, in dem er weniger Strom verbraucht. Er kann durch einen Reset, einem Watchdog-Timer-Reset oder durch einen Interrupt wieder aufgeweckt werden.

 SUBLW k Subtract W from literal - Ziehe W von Zahl ab<hr>
:Es wird die Rechenoperation <math>k-W</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

 SUBWF R,d Subtract W from f - Ziehe W von f ab<hr>
:Es wird die Rechenoperation <math>R-W</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Dieser Befehl beeinflusst das STATUS-Register. Siehe hierzu [[#Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register|Überprüfung von Rechenergebnissen mit Hilfe des STATUS-Register]]

:Beispiel:
<dl><dd>
movlw d'20' ;schreibe 20 in das W-Register
movwf Register1 ;bewegt das W-Register in das Register1
movlw d'10' ;schreibt 10 in das W-Register
SUBWF Register1,F ;schreibt Register1(20)-W(10) in Register1
</dd></dl>

SWAPF R,d Swap nibbles in f - Vertausche die Halbbytes (Nibbles)<hr>
:Es werden die höheren 4 bit (bit7-bit4) mit den niedrigeren 4 bit (bit3-bit0) eines Registers vertauscht und entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>).
:Beispiel:
<dl><dd>
movlw b'00001111' ;schreibe b'00001111' in das W-Register
movwf Register1 ;kopiert das W-Register in das Register1
SWAPF Register1,W ;vertauscht die ersten 4 bit mit den letzen
;4 bit in Register 1 und schreibt es in das W-Register
;im W-Register steht nun b'11110000'
</dd></dl>

 XORLW k Exclusive OR literal with W<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ k</math> ausgeführt und das Ergebniss in das W-Register gespeichert. Dieser Befehl setzt das Z bit des STATUS-Registers, falls W=k und das Ergebnis 0 ist.
:Zur Verdeutlichung der Operation:
<dl><dd>
1100
1010
---- xor
0110
</dd></dl>

 XORWF R,d Exclusive OR W with f<hr>
:Es wird bitweise die logische Funktion <math>W\ xor\ R</math> ausgeführt und das Ergebniss entweder in das W-Register ('''d'''=<tt>W</tt>=<tt>0</tt>) oder in R gespeichert ('''d'''=<tt>F</tt>=<tt>1</tt>). Vergleiche XORLW

Benutzer:Benedikt.Seidl/asm - Versionsgeschichte

Benedikt.Seidl: meins ;-)