STM8 - STM8
STM8 jest 8-bitowy mikrokontroler rodziny przez STMicroelectronics . Mikrokontrolery STM8 wykorzystują rozszerzony wariant architektury mikrokontrolera ST7 . Mikrokontrolery STM8 są szczególnie tanie jak na w pełni funkcjonalny 8-bitowy mikrokontroler.
Architektura
STM8 jest bardzo podobny do wcześniejszego ST7, ale lepiej nadaje się jako cel dla C ze względu na jego 16-bitowe rejestry indeksowe i tryb adresowania zależny od wskaźnika stosu . Chociaż wewnętrznie architekturze Harvard to posiada zunifikowany 24-bitową przestrzeń adresową, umożliwiając kod do wykonania z pamięci RAM (przydatne przy programowaniu w-systemie z pamięci flash ROM ) i danych (takich jak stoły odnośników ), aby uzyskać dostęp z ROM. Dostęp do danych powyżej 64K jest ograniczony do specjalnych instrukcji „załaduj daleko”; większość operandów pamięci operandów ma dostęp do maksymalnie 128K (16-bitowy adres bazowy plus 16-bitowy offset).
Bardzo niewiele mikrokontrolerów STM8 ma więcej niż 64 KB pamięci danych.
Ma te same sześć rejestrów (A, X, Y, SP, PC, CC) co ST7, ale rejestry indeksowe X i Y zostały rozszerzone do 16 bitów, a licznik programu został rozszerzony do 24 bitów. Akumulatory A i wskaźnik stosu pozostają 8 i 16 bitów, odpowiednio.
Rejestr kod warunek ma dwa bity bardziej zdefiniowane, w sumie siedem. Istnieje flaga przepełnienia i drugi bit włączający przerwanie, umożliwiający cztery poziomy priorytetu przerwań .
Podrodziny
- Samochód STM8AF
- STM8AL samochód małej mocy
- STM8L małej mocy
- STM8S tani
- Czujniki dotykowe STM8T
- Sterowanie oświetleniem STLUX
- STNRG Pulse-width modulacja -controllers
Wsparcie kompilatora
STM8 jest obsługiwany przez darmowy kompilator Small Device C Compiler , bezpłatny kompilator Cosmic C o zamkniętym kodzie źródłowym oraz niewolne kompilatory IAR C i Raisonance. Oprócz C istnieje STM8 eForth, port open source języka programowania Forth.
Zmiany w porównaniu do ST7
Zestaw instrukcji STM8 jest przeważnie nadzbiorem ST7, ale nie jest w pełni zgodny binarnie.
Operacje na rejestrach X i Y są rozszerzone do 16 bitów. W ten sposób ładuje i przechowuje dostęp do dwóch bajtów pamięci zamiast jednego. ( Zmieniono również flagę przeniesienia w połowie, aby odzwierciedlić przeniesienie z bitu 7 na bit 8 wyniku 16-bitowego, zamiast przeniesienia z bitu 3 do 4).
Przerwania przesuwają dziewięć bajtów stanu zamiast pięciu w ST7.
Instrukcja mnożenia przechowuje 16-bitowy produkt w określonym rejestrze indeksowym (np. X), zamiast dzielić go między X i A.
Pośrednich związanych z trybów pracy, które sprowadzić 8-bitowy adres z pamięci (rozkazy 92 2x , 92 3x , 92 Bx , 92 6x , 92 Ex , 91 6x , a 91 Ex ), zostały usunięte; wszystkie tryby adresowania pośredniego pobierają adresy 16-bitowe. Dodano nowy bajt prefiksu, 72 który jest używany do kodowania pośredniego, zaczynając od adresu 16-bitowego.
Instrukcje manipulacji bitami zostały zmienione tak, aby przyjmowały adres 16-bitowy i wymagały 72 bajtu prefiksu. Nieprefiksowane kody operacyjne 0x i 1x poprzednio zajmowane są zamiast tego używane do względnego adresowania wskaźnika stosu.
W przypadku niektórych rzadko używanych instrukcji rozgałęzień zmieniono kody rozkazów, aby wymagały 90 prefiksu, a kody rozkazów bez prefiksu zostały ponownie przypisane do gałęzi podpisanych, które zależą od flagi V.
Instrukcje ładowania i porównywania skierowane do rejestru X są mało przydatne w ST7 z trybami adresowania indeksowanymi przez rejestr X. W STM8, gdy takie operacje określają operand pamięci indeksowany przez rejestr X, operand rejestru jest zmieniany na Y. Z 90 prefiksem rejestry są odwrócone, więc rejestr indeksu ma wartość Y, a rejestr argumentu X.
Jedną z głównych różnic w wydajności jest to, że STM8 pobiera 32 bity z pamięci ROM na cykl, a wykonanie typowych instrukcji zajmuje jeden cykl plus jeden cykl na dostęp do pamięci RAM. Z kolei ST7 pobiera 8 bitów na cykl i pobiera jeden cykl na bajt instrukcji.
Zestaw instrukcji
Instrukcje STM8 składają się z przedrostka opcjonalnego bajt ( , , , lub ), bajt rozkazu, a kilka (do czterech, ale rzadko więcej niż dwie) bajtów argumentów. Bajty prefiksów w większości modyfikują tryb adresowania używany do określenia operandu pamięci, ale w niektórych przypadkach prefiksy i całkowicie wykonują inną operację.
72169016911692167290
Prefiks 90 zamienia X i Y w poniższej instrukcji. W poniższej tabeli warianty te są łączone w jednej linii poprzez zapis „X / Y”, co oznacza „X” lub „Y”. Prefiks 90 jest również używany w dwóch miejscach do wprowadzenia nowych rozkazów: instrukcje BCPL i BCCM oraz niektóre warunki rozgałęzienia.
Prefix 92 przekształca instrukcje z operandem przesunięcia ( addr16 , X) na adresowanie pośrednie ([ addr8 ], X). Przesunięcie jest zastępowane 8-bitowym adresem 16-bitowej wartości przesunięcia w pamięci. Służy tylko do tej funkcji.
Prefiks 91 ma oba poprzednie efekty, konwertując ( addr16 , X) tryby adresowania na ([ addr8 ], Y).
Prefiks 72 jest używany w wielu miejscach, w znacznie mniej regularnym układzie. W niektórych przypadkach wprowadza nowe tryby adresowania (szczególnie ([ addr16 ], X) 16-bitowy tryb pośredni), ale wprowadza również wiele zupełnie nowych operacji.
| Prefiks | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Operandy | Mnemoniczny | Opis |
|---|---|---|---|---|---|---|---|---|---|---|---|
| - | 0 | 0 | 0 | 0 | kod operacji | addr8 | OP ( addr8 , SP) | Instrukcje jednoargumentowe (patrz poniżej) | |||
| - | 0 | 0 | 0 | 1 | kod operacji | addr8 | OP A, ( addr8 , SP) | Instrukcje dwuargumentowe z operandem stosu | |||
| - | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | addr8 | SUB A, ( addr8 , SP) | A: = A - operand |
| - | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | addr8 | CP A, ( addr8 , SP) | Porównaj A - operand |
| - | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | addr8 | SBC A, ( addr8 , SP) | A: = A - operand - C odejmij z pożyczką |
| - / 90 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | addr8 | CPW X / Y, ( addr8 , SP) | Porównaj X / Y - operand (16-bitowy) |
| - | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | addr8 | AND A, ( addr8 , SP) | A: = A & operand, bitowe i |
| - | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | addr8 | BCP A, ( addr8 , SP) | Test bitowy A & operand |
| - | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | addr8 | LDW Y, ( addr8 , SP) | Y: = operand ( |
| - | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | addr8 | LDW ( addr8 , SP), Y | Argument: = Y ( |
| - | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | addr8 | XOR A, ( addr8 , SP) | O: = A ^ operand, wyłączny-lub |
| - | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | addr8 | ADC A, ( addr8 , SP) | A: = A + operand + C, dodaj z przeniesieniem |
| - | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | addr8 | LUB A, ( addr8 , SP) | Odp .: = A | operand, włącznie lub |
| - | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | addr8 | DODAJ A, ( addr8 , SP) | A: = A + operand |
| - | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | imm16 | DODAJ X, # imm16 | X: = X + natychmiastowe (= |
| - | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | imm16 | SUBW X, # imm16 | X: = X - natychmiastowe (= |
| - | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | addr8 | LDW X, ( addr8 , SP) | X: = operand |
| - | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | addr8 | LDW ( addr8 , SP), X | Argument: = X |
| 72/90 | 0 | 0 | 0 | do | kawałek | v | operandy | Operacje bitowe | |||
| 72 | 0 | 0 | 0 | 0 | kawałek | 0 | addr16 soff8 | BTJT addr16 , # bit , etykieta | Przejdź do PC + soff8, jeśli bit źródłowy jest prawdziwy (ustawiony) | ||
| 72 | 0 | 0 | 0 | 0 | kawałek | 1 | addr16 soff8 | BTJF addr16 , # bit , etykieta | Przejdź do PC + soff8, jeśli bit źródłowy jest fałszywy (wyczyść) | ||
| 72 | 0 | 0 | 0 | 1 | kawałek | 0 | addr16 | BSET addr16 , # bit | Ustaw określony bit na 1 | ||
| 72 | 0 | 0 | 0 | 1 | kawałek | 1 | addr16 | Adres BRES16 , # bit | Zresetuj (wyczyść) określony bit do 0 | ||
| 90 | 0 | 0 | 0 | 1 | kawałek | 0 | addr16 | BCPL addr16 , # bit | Uzupełnij (przełącz) wybrany bit | ||
| 90 | 0 | 0 | 0 | 1 | kawałek | 1 | addr16 | BCCM addr16 , # bit | Zapisz flagę przeniesienia do bitu pamięci | ||
| - / 90 | 0 | 0 | 1 | 0 | stan: schorzenie | soff8 | Gałęzie warunkowe (8-bitowe przesunięcie ze znakiem) | ||||
| - | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | soff8 | Etykieta JRA | Odgałęzienie zawsze (prawda) |
| - | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | soff8 | Etykieta JRF | Oddział nigdy (fałsz) |
| - | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | soff8 | Etykieta JRUGT | Rozgałęzienie, jeśli bez znaku większe niż (C = 0 i Z = 0) |
| - | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | soff8 | Etykieta JRULE | Rozgałęzienie, jeśli bez znaku mniejszy lub równy (C = 1 lub Z = 1) |
| - | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | soff8 | Etykieta JRNC | Oddział, jeśli nie ma przeniesienia (C = 0) |
| - | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 | soff8 | Etykieta JRC | Branch if carry (C = 1) |
| - | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | soff8 | Etykieta JRNE | Rozgałęzienie, jeśli nie jest równe (Z = 0) |
| - | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | soff8 | Etykieta JREQ | Rozgałęzienie, jeśli równe (Z = 1) |
| - | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | soff8 | Etykieta JRNV | Odgałęzienie, jeśli nie przepełnienie (V = 0) |
| 90 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | soff8 | Etykieta JRNH | Oddział, jeśli nie w połowie przeniesienia (H = 0) |
| - | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | soff8 | Etykieta JRV | Odgałęzienie w przypadku przepełnienia (V = 1) |
| 90 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | soff8 | Etykieta JRH | Oddział, jeśli pół przeniesienia (H = 1) |
| - | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | soff8 | Etykieta JRPL | Rozgałęzienie, jeśli plus (N = 0) |
| - | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | soff8 | Etykieta JRMI | Rozgałęzienie jeśli minus (N = 1) |
| - | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | soff8 | Etykieta JRSGT | Rozgałęzienie, jeśli ze znakiem większym niż (S = 0 i N = V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | soff8 | Etykieta JRNM | Maska rozgałęzienia, jeśli nie przerwać (I = 0) |
| - | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | soff8 | Etykieta JRSLE | Odgałęzienie, jeśli podpisane mniejsze lub równe (S = 1 lub N ≠ V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | soff8 | Etykieta JRM | Rozgałęzienie w przypadku maskowania przerwań (I = 1) |
| - | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | soff8 | Etykieta JRSGE | Odgałęzienie, jeśli podpisane większe lub równe (N = V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | soff8 | Etykieta JRIL | Rozgałęzienie, jeśli linia przerwania jest niska |
| - | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | soff8 | Etykieta JRSLT | Oddział, jeśli podpisany mniej niż (N ≠ V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | soff8 | Etykieta JRIH | Rozgałęzienie, jeśli linia przerwania jest wysoka |
| prefiks | 0 | tryb | kod operacji | operand | Instrukcje jednoargumentowe | ||||||
| - | 0 | 0 | 0 | 0 | kod operacji | addr8 | OP ( addr8 , SP) | Względny wskaźnik stosu | |||
| - | 0 | 0 | 1 | 1 | kod operacji | addr8 | Adres OP 8 | 8-bitowy adres bezwzględny | |||
| 72 | 0 | 0 | 1 | 1 | kod operacji | addr16 | OP [ addr16 ] | 16-bitowy adres pośredni | |||
| 92 | 0 | 0 | 1 | 1 | kod operacji | addr8 | OP [ addr8 ] | 8-bitowy adres pośredni o 16-bitowym adresie | |||
| - | 0 | 1 | 0 | 0 | kod operacji | - | OP A | Akumulator | |||
| 72/90 | 0 | 1 | 0 | 0 | kod operacji | addr16 | OP ( addr16 , X / Y) | Indeksowane z 16-bitowym przesunięciem | |||
| - / 90 | 0 | 1 | 0 | 1 | kod operacji | - | OPW X / Y | Rejestr X / Y (operacja 16-bitowa) | |||
| 72 | 0 | 1 | 0 | 1 | kod operacji | addr16 | Adres OP 16 | 16-bitowy adres | |||
| - / 90 | 0 | 1 | 1 | 0 | kod operacji | addr8 | OP ( addr8 , X / Y) | 8-bitowy adres plus X / Y | |||
| 72 | 0 | 1 | 1 | 0 | kod operacji | addr16 | OP ([ addr16 ], X) | 16-bitowy adres pośredni plus X | |||
| 92/91 | 0 | 1 | 1 | 0 | kod operacji | addr8 | OP ([ addr8 ], X / Y) | 8-bitowy adres pośredni plus X / Y | |||
| - / 90 | 0 | 1 | 1 | 1 | kod operacji | - | OP (X / Y) | Indeksowane bez przesunięcia | |||
| prefiks | 0 | tryb | 0 | 0 | 0 | 0 | operand | Operand NEG | Negacja uzupełnienia do dwóch | ||
| 0 | tryb | 0 | 0 | 0 | 1 | (przeniesiony do operacji wymiany; patrz następna sekcja) | |||||
| 0 | tryb | 0 | 0 | 1 | 0 | (przydzielony do innych operacji; patrz następna sekcja) | |||||
| prefiks | 0 | tryb | 0 | 0 | 1 | 1 | operand | Operand CPL | Uzupełnienie jednych, logiczne nie | ||
| prefiks | 0 | tryb | 0 | 1 | 0 | 0 | operand | SRL operand | Shift w prawo logiczne, msbit wyczyszczony, lsbit do przeniesienia: (operand: C): = (0: operand) | ||
| 0 | tryb | 0 | 1 | 0 | 1 | (przydzielony do innych operacji; patrz następna sekcja) | |||||
| prefiks | 0 | tryb | 0 | 1 | 1 | 0 | operand | Operand RRC | Obróć w prawo przez przeniesienie, (operand: C): = (C: operand) | ||
| prefiks | 0 | tryb | 0 | 1 | 1 | 1 | operand | Operand SRA | Przesunięcie arytmetyki w prawo, zachowane msbit, przeniesienie lsbit | ||
| prefiks | 0 | tryb | 1 | 0 | 0 | 0 | operand | Operand SLL | Przesuń w lewo, msbit do przeniesienia: (C: operand): = (operand: 0) | ||
| prefiks | 0 | tryb | 1 | 0 | 0 | 1 | operand | Operand RLC | Obróć w lewo przez przeniesienie, (C: operand): = (operand, C) | ||
| prefiks | 0 | tryb | 1 | 0 | 1 | 0 | operand | Operand DEC | Zmniejszenie; N i Z ustawione, przenoszenie nienaruszone | ||
| 0 | tryb | 1 | 0 | 1 | 1 | (przydzielony do innych operacji; patrz następna sekcja) | |||||
| prefiks | 0 | tryb | 1 | 1 | 0 | 0 | operand | Argument INC | Przyrost; N i Z ustawione, przenoszenie nienaruszone | ||
| prefiks | 0 | tryb | 1 | 1 | 0 | 1 | operand | Operand TNZ | Test niezerowy: ustaw N i Z na podstawie wartości argumentu | ||
| prefiks | 0 | tryb | 1 | 1 | 1 | 0 | operand | SWAP operand | Zamiana połówek operandu (4-bitowy obrót; 8-bitowy dla SWAPW X i SWAPW Y) | ||
| prefiks | 0 | tryb | 1 | 1 | 1 | 1 | operand | Argument CLR | Ustaw operand na 0, N wyczyszczony, Z ustawiony | ||
| prefiks | 0 | tryb | kod operacji | operand | Ponownie przypisane opodes [03-7] [125B] z zakresu jednego argumentu | ||||||
| - / 90 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | - | RRWA X / Y | Obróć słowo w prawo przez A: 8-bitowy obrót w prawo z 24-bitową konkatenacją X / Y i A; (X: A): = (A: X) |
| - | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | addr16 | EXG A, adr16 | Wymień A z pamięcią |
| - | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | - | EXG A, XL | Wymień A na X (dolna połowa) |
| - | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | - | EXGW X, Y | Zamień X na Y (16 bitów) |
| - | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | - | EXG A, YL | Zamień A na Y (dolna połowa) |
| - | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | - | (zarezerwowany) | |
| - / 90 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | - | RLWA X / Y | Obróć słowo w lewo do A: 8-bitowy obrót w lewo z 24-bitową konkatenacją X / Y i A; (A: X): = (X: A) |
| - | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | addr16 | Adres POP 16 | Wyskakuj ze stosu |
| - / 90 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | - | MUL X / Y, A | X / Y: = XL / YL × A |
| - | 0 | 1 | 0 | 1 | 0 | 0 | 1 | 0 | imm8 | SUBW SP, # imm | SP: = SP - imm8 |
| - / 90 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | - | DIV X / Y, A | Podziel X / Y przez A; 16-bitowy iloraz w X / Y, reszta w A |
| - | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 0 | - | PREFIKS | Prefiks instrukcji 72 : modyfikuj następujący kod operacji
|
| 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | - | (zarezerwowany) | ||
| - | 0 | 0 | 1 | 1 | 0 | 1 | 0 | 1 | imm8 addr16 | Adres MOV 16 , # imm8 | Przenieś natychmiast do pamięci (flagi bez zmian) |
| - | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | addr8 addr8 | MOV adr8 , adr8 | Przenieś pamięć do pamięci (flagi bez zmian) |
| - | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | addr16 addr16 | Adres MOV 16 , Adres 16 | Przenieś pamięć do pamięci (flagi bez zmian) |
| - | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 1 | - | DIVW X, Y | Podziel X przez Y (16 bitów); iloraz w X, reszta w Y |
| 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | - | (zarezerwowany) | ||
| 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | - | (zarezerwowany) | ||
| - | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | addr16 | Adres PUSH 16 | Wepchnij na stos |
| - | 0 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | imm8 | PUSH # imm8 | Wepchnij na stos |
| - | 0 | 1 | 0 | 1 | 1 | 0 | 1 | 1 | imm8 | ADDW SP, # imm8 | SP: = SP + imm8 |
| - | 0 | 1 | 1 | 0 | 1 | 0 | 1 | 1 | addr8 | LD ( addr8 , SP), A. | Przechowywać względem stosu |
| - | 0 | 1 | 1 | 1 | 1 | 0 | 1 | 1 | addr8 | LD A, ( addr8 , SP) | Załaduj względem stosu |
| - | 1 | 0 | 0 | kod operacji | - | Różne instrukcje. Brak niejawnie ustawia kody warunków. | |||||
| - | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | - | IRET | Powrót z przerwania (pop CC, A, X, Y, PC) |
| - | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | - | GNIĆ | Prześlij 16-bitowy adres zwrotny ze stosu na komputer |
| - | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | addr24 | INT | Specjalny skok dla tablicy wektorów przerwań |
| - | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | - | PUŁAPKA | Przerwanie pułapki siłowej |
| - | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | - | POP A | Pop A ze stosu |
| - / 90 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | - | POPW X / Y | Zdejmij X / Y ze stosu (16 bitów) |
| - | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | - | POP CC | Zdejmij kody warunków ze stosu |
| - | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | - | RETF | Prześlij 24-bitowy adres zwrotny ze stosu na komputer |
| - | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | - | PUSH A | Wepchnij A na stos |
| - / 90 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | - | PUSHW X / Y | Wepchnij X / Y na stos (16 bitów) |
| - | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | - | PUSH CC | Wypchnij kody warunków na stos |
| - | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | - | PRZERWA | Zatrzymaj debugera, jeśli jest obecny, lub NOP |
| - | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | - | CCF | Uzupełnienie (przełączanie) flagi przenoszenia |
| - | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | addr24 | CALLF addr24 | Push 24-bitowy komputer; PC: = addr24 |
| 92 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | addr16 | CALLF [ addr16 ] | Pośrednie połączenie dalekie; adres ma 24-bitowy wskaźnik |
| - | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | - | POSTÓJ | Zatrzymaj procesor i zegary |
| - | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | - | WFI | Poczekaj na przerwanie, zatrzymanie procesora, ale nie zegary |
| 72 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | - | WFE | Czekaj na zdarzenie (koprocesor), normalna obsługa przerwań podczas oczekiwania |
| - | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | - | PDY | Prefiks instrukcji 90 : zamień X i Y w następnej instrukcji
|
| - | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | - | PIY | Prefiks instrukcji 91 : PDY plus PIX
|
| - | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | - | SZKATUŁKA | Prefiks instrukcji 92 : użyj pośredniej pamięci 8-bitowej dla argumentu
|
| - / 90 | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | - | LDW X / Y, Y / X | X / Y: = Y / X |
| - / 90 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | - | LDW SP, X / Y | SP: = X / Y |
| - / 90 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | - | LD XH / YH, A. | XH / YH: = A |
| - / 90 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | - | LDW X / Y, SP | X / Y: = SP |
| - / 90 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | - | LD XL / YL, A. | XL / YL: = A |
| - | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | - | RCF | Zresetuj (wyczyść) flagę przenoszenia |
| - | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | - | SCF | Ustaw flagę nośną |
| - | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | - | OBRĘCZ | Zresetuj maskę przerwań (włącz przerwania) |
| - | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | - | SIM | Ustaw maskę przerwań (wyłącz przerwania) |
| - | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | - | RVF | Zresetuj (wyczyść) flagę przepełnienia |
| - | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | - | NOP | Bez operacji |
| - / 90 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | - | LD A, XH / YH | Odp .: = XH / YH |
| - / 90 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | - | LD A, XL / YL | Odp .: = XL / YL |
| Prefiks | 1 | tryb | kod operacji | operand | Instrukcje dwuargumentowe A: = A operand op | ||||||
| - | 0 | 0 | 0 | 1 | kod operacji | addr8 | OP ( addr8 , SP) | Operand względem stosu (patrz wyżej; kody rozkazowe 16, 17, 1C, 1D nie są zgodne z wzorcem) | |||
| - | 1 | 0 | 1 | 0 | kod operacji | imm8 | OP # imm8 | 8-bitowy natychmiastowy operand (zabroniony jako miejsce docelowe) | |||
| - | 1 | 0 | 1 | 1 | kod operacji | addr8 | Adres OP 8 | 8-bitowy adres bezwzględny (zabroniony dla skoku / połączenia) | |||
| - | 1 | 1 | 0 | 0 | kod operacji | addr16 | Adres OP 16 | 16-bitowy adres bezwzględny | |||
| 72 | 1 | 1 | 0 | 0 | kod operacji | addr16 | OP [ addr16 ] | 16-bitowy adres pośredni | |||
| 92 | 1 | 1 | 0 | 0 | kod operacji | addr8 | OP [ addr8 ] | 8-bitowy adres pośredni o 16-bitowym adresie | |||
| - / 90 | 1 | 1 | 0 | 1 | kod operacji | addr16 | OP ( addr16 , X / Y) | Indeksowane z 16-bitowym przesunięciem | |||
| 72 | 1 | 1 | 0 | 1 | kod operacji | addr16 | OP ([ addr16 ], X) | 16-bitowy pośredni + X | |||
| 92/91 | 1 | 1 | 0 | 1 | kod operacji | addr16 | OP ([ addr8 ], X / Y) | 8-bitowy pośredni + X / Y | |||
| - / 90 | 1 | 1 | 1 | 0 | kod operacji | addr8 | OP ( addr8 , X / Y) | Indeksowane z 8-bitowym przesunięciem | |||
| - / 90 | 1 | 1 | 1 | 1 | kod operacji | - | OP (X / Y) | Indeksowane bez przesunięcia | |||
| prefiks | 1 | tryb | 0 | 0 | 0 | 0 | operand | SUB A, argument | A: = A - operand | ||
| prefiks | 1 | tryb | 0 | 0 | 0 | 1 | operand | CP A, operand | Porównaj A - operand | ||
| prefiks | 1 | tryb | 0 | 0 | 1 | 0 | operand | SBC A, operand | A: = A - operand - C odejmij z pożyczką | ||
| prefiks | 1 | tryb | 0 | 0 | 1 | 1 | operand | CPW X / Y, operand | Porównaj X / Y - operand (16 bitów); porównaj Y / X, jeśli tryb operandu jest indeksowany przez X / Y (opkody D3, E3, F3) | ||
| prefiks | 1 | tryb | 0 | 1 | 0 | 0 | operand | AND A, operand | A: = A & operand, bitowe i | ||
| prefiks | 1 | tryb | 0 | 1 | 0 | 1 | operand | BCP A, operand | Test bitowy A & operand | ||
| prefiks | 1 | tryb | 0 | 1 | 1 | 0 | operand | LD A, operand | A: = operand | ||
| prefiks | 1 | tryb | 0 | 1 | 1 | 1 | operand | Operand LD , A | Argument: = A (tryb 2 |
||
| prefiks | 1 | tryb | 1 | 0 | 0 | 0 | operand | XOR A, operand | O: = A ^ operand, wyłączny-lub | ||
| prefiks | 1 | tryb | 1 | 0 | 0 | 1 | operand | ADC A, operand | A: = A + operand + C, dodaj z przeniesieniem | ||
| prefiks | 1 | tryb | 1 | 0 | 1 | 0 | operand | OR A, operand | Odp .: = A | operand, włącznie lub | ||
| prefiks | 1 | tryb | 1 | 0 | 1 | 1 | operand | DODAJ A, operand | A: = A + operand | ||
| prefiks | 1 | tryb | 1 | 1 | 0 | 0 | operand | Argument JP | Niskie 16 bitów PC: = operand, bezwarunkowy skok ( ponownie przypisane tryby 2 |
||
| prefiks | 1 | tryb | 1 | 1 | 0 | 1 | operand | CALL operand | Push 16-bitowy PC, niskie 16 bitów PC: = operand ( ponownie przypisane tryby 2 |
||
| prefiks | 1 | tryb | 1 | 1 | 1 | 0 | operand | LDW X / Y, operand | Załaduj X / Y: = operand; użyj 16 zamiast 90 1E dla LDW Y, ( addr8 , SP) | ||
| prefiks | 1 | tryb | 1 | 1 | 1 | 1 | operand | Operand LDW , X / Y | Argument: = X / Y (16-bitowy, tryb 2 |
||
| Prefiks | 1 | tryb | kod operacji | operand | Ponownie przypisane rozkazy A7, AC, BC, AD, BD, AF z zakresu dwuargumentowego | ||||||
| - / 90 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | addr24 | LDF ( adres24 , X / Y), A. | Załaduj daleko (= |
| 92/91 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | addr16 | LDF ([ adr16 ], X / Y), A | 16-bitowy adres 24-bitowego wskaźnika |
| - | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | addr24 | Adres JPF 24 | PC: = addr24 (= |
| 92 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | addr16 | JPF [ addr16 ] | Pośredni skok w dal; adres ma 24-bitowy wskaźnik |
| - | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | addr24 | LDF A, adres 24 | Wczytaj daleko (= |
| 92 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | addr16 | LDF A, [ adres16 ] | Załaduj daleko, 16-bitowy adres 24-bitowego wskaźnika |
| - | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | soff8 | Etykieta CALLR | Push 16-bitowy PC, PC: = PC + operand (= |
| - | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | addr24 | Adres LDF 24 , A. | Argument: = A (= |
| 92 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | addr16 | LDF [ adr16 ], A | Argument: = A, 16-bitowy adres 24-bitowego wskaźnika |
| - / 90 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | addr24 | LDF A, ( addr24 , X / Y) | Załaduj daleko (= |
| 92/91 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | addr16 | LDF A, ([ addr16 ], X / Y) | 16-bitowy adres 24-bitowego wskaźnika |
| 72 | 1 | tryb | kod operacji | operand | Arytmetyka rejestru indeksowego (16-bitowa) X / Y: = X / Y ± operand | ||||||
| 72 | 1 | 0 | 1 | 0 | kod operacji | imm16 | OPW X / Y, # imm16 | 16-bitowe natychmiastowe | |||
| 72 | 1 | 0 | 1 | 1 | kod operacji | addr16 | OPW X / Y, adres 16 | 16-bitowe absolutne | |||
| 72 | 1 | 1 | 1 | 1 | kod operacji | addr8 | OPW X / Y, ( addr8 , SP) | Stosunek względny | |||
| 72 | 1 | tryb | 0 | 0 | 0 | 0 | operand | SUBW X, argument | X: = X - operand (preferowany kod operacji 1D dla SUBW X, # imm16 ) | ||
| 72 | 1 | tryb | 0 | 0 | 1 | 0 | operand | SUBW Y, argument | Y: = Y - operand | ||
| 72 | 1 | tryb | 1 | 0 | 0 | 1 | operand | ADDW Y, operand | Y: = Y + operand | ||
| 72 | 1 | tryb | 1 | 0 | 1 | 1 | operand | ADDW X, argument | X: = X + operand (preferuj kod operacji 1C dla ADDW X, # imm16 ) | ||
W przypadku instrukcji CPW i LDW, w których tryb adresowania argumentów jest indeksowany przez X, STM8 domyślnie używa rejestru Y zamiast X. Zastosowanie 90 przedrostka powoduje wymianę X i Y, więc rejestr jest X, a tryb adresowania jest indeksowany przez Y.
