Lista rozkazów mikrokontrolerów rodziny MCS-51
Poniżej w tabeli zamieszczono listę wszystkich rozkazów mikrokontrolerów rodziny MCS-51. Obok każdego rozkazu przedstawiono realizowane przez mikrokontroler operacje w ramach wykonania danego rozkazu, liczbę cykli maszynowych potrzebną do jego wykonania oraz ilość bajtów zajmowaną przez ten rozkaz w pamięci kodu.
 |
W klasycznej wersji mikrokontrolera MCS-51 jeden cykl maszynowy odpowiada 12 taktom zegara systemowego, co przy znajomości częstotliwości tego zegara pozwala na obliczenie czasu wykonywania danego rozkazu. W przypadku klonów tego mikrokontrolera liczba taktów zegara systemowego przypadająca na jeden cykl maszynowy może być inna. Wtedy po dokładną informację należy odnieść się do dokumentacji danego mikrokontrolera. |
Klikając na mnemonik danej instrukcji można przejść do strony opisującej ją dokładniej. Jednocześnie kolejne strony tego opracowania opisują każdą z grup instrukcji tematycznie.
Poniżej przedstawiono omówienie zastosowanych oznaczeń.
| Rn | Jeden z rejestrów R0 do R7 aktywnego banku rejestrów. |
| addr8 | 8-bitowy adres w wewnętrznej pamięci danych adresowanej bezpośrednio. |
| @Ri | 8-bitowy adres umieszczony w jednym z dwóch rejestrów R0 lub R1 aktywnego banku rejestrów. |
| #data8 | 8-bitowa stała kodowana wewnątrz instrukcji. |
| #data16 | 16-bitowa stała kodowana wewnątrz instrukcji. |
| addr16 | 16-bitowy adres używany w instrukcjach LJMP i LCALL (praktycznie zastępowany przez etykietę). |
| addr11 | 11-bitowy adres używany w instrukcjach AJMP oraz ACALL (praktycznie zastępowany przez etykietę). |
| rel | 8-bitowe przesuniecie traktowane jako liczba ze znakiem w kodzie U2 i używane w instrukcji SJMP oraz wszystkich instrukcjach skoków warunkowych (praktycznie zastępowane przez etykietę). |
| bit | Adres bitu z wewnętrznej pamięci danych adresowanego bitowo lub obszaru SFR. |
| (x) | W opisie operacji oznacza zawartość komórki w wewnętrznej pamięci danych o adresie bezpośrednim x. |
| ((x)) | W opisie operacji oznacza zawartość komórki wewnętrznej pamięci danych o adresie zapisanym w rejestrze x. |
| (y)XDATA | W opisie operacji oznacza zawartość komórki w zewnętrznej pamięci danych o adresie y. |
| (z)CODE | W opisie operacji oznacza zawartość komórki w pamięci kodu o adresie z. |
| Xy..z | W opisie operacji oznacza bity od y do z rejestru X. |
UWAGA: Nie wszystkie linki w poniższej tabeli działają poprawnie, gdyż nie wszystkie instrukcje zostały opracowane.
| Instrukcje arytmetyczne | ||||
|---|---|---|---|---|
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| ADD | A,Rn | (A) <− (A) + (Rn) | 1 | 1 |
| ADD | A,addr8 | (A) <− (A) + (addr8) | 1 | 2 |
| ADD | A,@Ri | (A) <− (A) + ((Ri)) | 1 | 1 |
| ADD | A,#data8 | (A) <− (A) + data8 | 1 | 2 |
| ADDC | A,Rn | (A) <− (A) + (Rn) + (C) | 1 | 1 |
| ADDC | A,addr8 | (A) <− (A) + (addr8) + (C) | 1 | 2 |
| ADDC | A,@Ri | (A) <− (A) + ((Ri)) + (C) | 1 | 1 |
| ADDC | A,#data8 | (A) <− (A) + data8 + (C) | 1 | 2 |
| SUBB | A,Rn | (A) <− (A) - (Rn) | 1 | 1 |
| SUBB | A,addr8 | (A) <− (A) - (addr8) | 1 | 2 |
| SUBB | A,@Ri | (A) <− (A) - ((Ri)) | 1 | 1 |
| SUBB | A,#data8 | (A) <− (A) - data8 | 1 | 2 |
| INC | A | (A) <− (A) + 1 | 1 | 1 |
| INC | Rn | (Rn) <− (Rn) + 1 | 1 | 1 |
| INC | addr8 | (addr8) <− (addr8) + 1 | 1 | 2 |
| INC | @Ri | ((Ri)) <− ((Ri)) + 1 | 1 | 1 |
| INC | DPTR | (DPTR) <− (DPTR) + 1 | 2 | 1 |
| DEC | A | (A) <− (A) - 1 | 1 | 1 |
| DEC | Rn | (Rn) <− (Rn) - 1 | 1 | 1 |
| DEC | addr8 | (addr8) <− (addr8) - 1 | 1 | 2 |
| DEC | @Ri | ((Ri)) <− ((Ri)) - 1 | 1 | 1 |
| MUL | AB | (BA)15..0 <− (A) · (B) A – młodszy bajt wyniku, B – starszy bajt |
4 | 1 |
| DIV | AB | całości wyniku: (A) <− int (A/B) reszta wyniku: (B) <− mod (A/B) |
4 | 1 |
| DA | A | Jeśli [[(A)3..0 > 9] lub [AC = 1]] to (A)3..0 <− (A)3..0 + 6 Jeśli [[(A)7..4 > 9] lub [C = 1]] to (A)7..4 <− (A)7..4 + 6 |
1 | 1 |
| Instrukcje logiczne | ||||
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| ANL | A,Rn | (A) <− (A) and (Rn) | 1 | 1 |
| ANL | A,addr8 | (A) <− (A) and (addr8) | 1 | 2 |
| ANL | A,@Ri | (A) <− (A) and ((Ri)) | 1 | 1 |
| ANL | A,#data8 | (A) <− (A) and data8 | 1 | 2 |
| ANL | addr8,A | (addr8) <− (addr8) and (A) | 1 | 2 |
| ANL | addr8,#data8 | (addr8) <− (addr8) and data8 | 2 | 3 |
| ORL | A,Rn | (A) <− (A) or (Rn) | 1 | 1 |
| ORL | A,addr8 | (A) <− (A) or (addr8) | 1 | 2 |
| ORL | A,@Ri | (A) <− (A) or ((Ri)) | 1 | 1 |
| ORL | A,#data8 | (A) <− (A) or data8 | 1 | 2 |
| ORL | addr8,A | (addr8) <− (addr8) or (A) | 1 | 2 |
| ORL | addr8,#data8 | (addr8) <− (addr8) or data8 | 2 | 3 |
| XRL | A,Rn | (A) <− (A) xor (Rn) | 1 | 1 |
| XRL | A,addr8 | (A) <− (A) xor (addr8) | 1 | 2 |
| XRL | A,@Ri | (A) <− (A) xor ((Ri)) | 1 | 1 |
| XRL | A,#data8 | (A) <− (A) xor data8 | 1 | 2 |
| XRL | addr8,A | (addr8) <− (addr8) xor (A) | 1 | 2 |
| XRL | addr8,#data8 | (addr8) <− (addr8) xor data8 | 2 | 3 |
| CLR | A | (A) <− 0 | 1 | 1 |
| CPL | A | (A) <− not(A) | 1 | 1 |
| RL | A | 1 | 1 | |
| RLC | A | 1 | 1 | |
| RR | A | 1 | 1 | |
| RRC | A | 1 | 1 | |
| SWAP | A | (A)0..3 <−> (A)4..7 | 1 | 1 |
| Instrukcje przesłania danych | ||||
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| MOV | A,Rn | (A) <− (Rn) | 1 | 1 |
| MOV | A,addr8 | (A) <− (addr8) | 1 | 2 |
| MOV | A,@Ri | (A) <− ((Ri)) | 1 | 1 |
| MOV | A,#data8 | (A) <− data8 | 1 | 2 |
| MOV | Rn,A | (Rn) <− (A) | 1 | 1 |
| MOV | Rn,addr8 | (Rn) <− (addr8) | 2 | 2 |
| MOV | Rn,#data8 | (Rn) <− data8 | 1 | 2 |
| MOV | addr8,A | (addr8) <− (A) | 1 | 2 |
| MOV | addr8,Rn | (addr8) <− (Rn) | 2 | 2 |
| MOV | addr8,addr8 | (addr8) <− (addr8) | 2 | 3 |
| MOV | addr8,@Ri | (addr8) <− ((Ri)) | 2 | 2 |
| MOV | addr8,#data8 | (addr8) <− data8 | 2 | 3 |
| MOV | @Ri,A | ((Ri)) <− (A) | 1 | 1 |
| MOV | @Ri,addr8 | ((Ri)) <− (addr8) | 2 | 2 |
| MOV | @Ri,#data8 | ((Ri)) <− data8 | 1 | 2 |
| MOV | DPTR,#data16 | (DPTR) <− data16 | 1 | 2 |
| MOVC | A,@A+DPTR | (A) <− ((A) + (DPTR))CODE | 2 | 1 |
| MOVC | A,@A+PC | (A) <− ((A) + (PC))CODE | 2 | 1 |
| MOVX | A,@Ri | (A) <− ((256 · (P2) + (Ri))XDATA | 2 | 1 |
| MOVX | A,@DPTR | (A) <− ((DPTR))XDATA | 2 | 1 |
| MOVX | @Ri,A | (256 · (P2) + (Ri))XDATA <− (A) | 2 | 1 |
| MOVX | @DPTR,A | ((DPTR)) <− (A) | 2 | 1 |
| PUSH | addr8 | (SP) <− (SP) + 1 ((SP)) <− (sddr8) |
2 | 2 |
| POP | addr8 | (addr8) <− ((SP)) (SP) <− (SP) - 1 |
2 | 2 |
| XCH | A,Rn | (A) <−> (Rn) | 1 | 1 |
| XCH | A,addr8 | (A) <−> (addr8) | 1 | 2 |
| XCH | A,@Ri | (A) <−> ((Ri)) | 1 | 1 |
| XCHD | A,@Ri | (A)3..0 <−> ((Ri))3..0 | 1 | 1 |
| Instrukcje działań na bitach | ||||
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| CLR | C | (CY) <− 0 | 1 | 1 |
| CLR | bit | (bit) <− 0 | 1 | 2 |
| SETB | C | (CY) <− 1 | 1 | 1 |
| SETB | bit | (bit) <− 1 | 1 | 2 |
| CPL | C | (CY) <− not(CY) | 1 | 1 |
| CPL | bit | (bit) <− not(bit) | 1 | 2 |
| ANL | C,bit | (CY) <− (CY) and (bit) | 2 | 2 |
| ANL | C,/bit | (CY) <− (CY) and not(bit) | 2 | 2 |
| ORL | C,bit | (CY) <− (CY) or (bit) | 2 | 2 |
| ORL | C,/bit | (CY) <− (CY) or not(bit) | 2 | 2 |
| MOV | C,bit | (CY) <− (bit) | 1 | 2 |
| MOV | bit,C | (bit) <− (CY) | 2 | 2 |
| JC | rel | (PC) <− (PC) + 3 Jeśli (CY) = 1 to (PC) <− (PC) + rel |
2 | 2 |
| JNC | rel | PC) <− (PC) + 2 Jeśli (CY) = 0 to (PC) <− (PC) + rel |
2 | 2 |
| JB | bit,rel | (PC) <− (PC) + 3 Jeśli (bit) = 1 to (PC) <− (PC) + rel |
2 | 3 |
| JNB | bit,rel | (PC) <− (PC) + 3 Jeśli (bit) = 0 to (PC) <− (PC) + rel |
2 | 3 |
| JBC | bit,rel | (PC) <− (PC) + 3 Jeśli (bit) = 1 to (bit) <− 0 oraz (PC) <− (PC) + rel |
2 | 3 |
| Instrukcje skoków bezwarunkowych | ||||
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| ACALL | addr11 | (PC <− (PC) + 2 (SP) <− (SP) + 1 ((SP)) <− (PC)7..0 (SP) <− (SP) + 1 ((SP)) <− (PC)15..8 (PC)10..0 <− addr11 (PC)15..11 pozostaje bez zmian |
2 | 2 |
| LCALL | addr16 | (PC <− (PC) + 3 (SP) <− (SP) + 1 ((SP)) <− (PC)7..0 (SP) <− (SP) + 1 ((SP)) <− (PC)15..8 (PC) <− addr16 |
2 | 3 |
| RET | (PC)15..8 <− ((SP)) (SP) <− (SP) - 1 (PC)7..0 <− ((SP)) (SP) <− (SP) - 1 |
2 | 1 | |
| RETI | (PC)15..8 <− ((SP)) (SP) <− (SP) - 1 (PC)7..0 <− ((SP)) (SP) <− (SP) - 1 |
2 | 1 | |
| AJMP | addr11 | (PC) <− (PC) + 2 (PC)10..0 <− addr11 (PC)15..11 pozostaje bez zmian |
2 | 2 |
| LJMP | addr16 | (PC) <− addr16 | 2 | 3 |
| SJMP | rel | (PC) <− (PC) + 2 (PC) <− (PC) + rel |
2 | 2 |
| JMP | @A+DPTR | (PC) <− (A) + (DPTR) | 2 | 1 |
| Instrukcje skoków warunkowych | ||||
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| JZ | rel | (PC) <− (PC) + 2 Jeśli (A) = 0 to (PC) <− (PC) + rel |
2 | 2 |
| JNZ | rel | (PC) <− (PC) + 2 Jeśli (A) ≠ 0 to (PC) <− (PC) + rel |
2 | 2 |
| CJNE | A,addr8,rel | (PC) <− (PC) + 3 Jeśli (A) ≠ (addr8) to (PC) <− (PC) + rel Dodatkowo: Jeśli (A) < (addr8) to (CY) <− 1 Jeśli (A) ≥ (addr8) to (CY) <− 0 |
2 | 3 |
| CJNE | A,#data8,rel | (PC) <− (PC) + 3 Jeśli (A) ≠ data8 to (PC) <− (PC) + rel Dodatkowo: Jeśli (A) < data8 to (CY) <− 1 Jeśli (A) ≥ data8 to (CY) <− 0 |
2 | 3 |
| CJNE | Rn,#data8,rel | (PC) <− (PC) + 3 Jeśli (Rn) ≠ data8 to (PC) <− (PC) + rel Dodatkowo: Jeśli (Rn) < data8 to (CY) <− 1 Jeśli (Rn) ≥ data8 to (CY) <− 0 |
2 | 3 |
| CJNE | @Ri,#data8,rel | (PC) <− (PC) + 3 Jeśli ((Ri)) ≠ data8 to (PC) <− (PC) + rel Dodatkowo: Jeśli ((Ri)) < data8 to (CY) <− 1 Jeśli ((Ri)) ≥ data8 to (CY) <− 0 |
2 | 3 |
| DJNZ | Rn,rel | (PC) <− (PC) + 2 (Rn) <− (Rn) - 1 Jeśli (Rn) ≠ 0 to (PC) <− (PC) + rel |
2 | 2 |
| DJNZ | addr8,rel | (PC) <− (PC) + 2 (addr8) <− (addr8) - 1 Jeśli (addr8) ≠ 0 to (PC) <− (PC) + rel |
2 | 3 |
| Pozostałe instrukcje | ||||
| Rozkaz | Wykonywane operacje | Cykle maszynowe |
Rozmiar [bajty] |
|
| Mnemonik | Argumenty | |||
| NOP | (PC) <− (PC) + 1 | 1 | 1 | |