STM8 - STM8
Der STM8 ist eine 8-Bit- Mikrocontrollerfamilie von STMicroelectronics . Die STM8-Mikrocontroller verwenden eine erweiterte Variante der ST7- Mikrocontroller-Architektur. STM8-Mikrocontroller sind besonders kostengünstig für einen 8-Bit-Mikrocontroller mit vollem Funktionsumfang.
Die Architektur
Die STM8 ist sehr ähnlich zu der früheren ST7, ist aber besser als ein Ziel für geeignetes C aufgrund seiner 16-Bit - Indexregister und Stapelzeiger -relative Adressierungsart. Obwohl es sich intern um eine Harvard-Architektur handelt , verfügt sie über einen einheitlichen 24-Bit-Adressraum, sodass Code außerhalb des RAM ausgeführt werden kann (nützlich für die systeminterne Programmierung des Flash-ROM ) und auf Daten (z. B. Nachschlagetabellen ) außerhalb des ROM zugegriffen werden kann. Der Zugriff auf Daten über 64 KB ist auf spezielle Anweisungen zum "Laden weit" beschränkt. Die Speicheroperanden der meisten Operationen können auf höchstens 128 KB zugreifen (eine 16-Bit-Basisadresse plus 16-Bit-Offset).
Sehr wenige STM8-Mikrocontroller verfügen über mehr als 64 KB Datenspeicher.
Es hat die gleichen sechs Register (A, X, Y, SP, PC, CC) wie das ST7, aber die Indexregister X und Y wurden auf 16 Bit erweitert, und der Programmzähler wurde auf 24 Bit erweitert. Der Akkumulator A und der Stapelzeiger bleiben 8 bzw. 16 Bit.
Das Bedingungscoderegister hat zwei weitere definierte Bits für insgesamt sieben. Es gibt ein Überlauf-Flag und ein zweites Interrupt-Aktivierungsbit, das vier Interrupt-Prioritätsstufen zulässt .
Unterfamilien
- STM8AF Automobil
- STM8AL Automobil mit geringem Stromverbrauch
- STM8L stromsparend
- STM8S kostengünstig
- STM8T Touch-Sensing
- STLUX Lichtsteuerung
- STNRG Pulsweitenmodulations- Controller
Compiler-Unterstützung
Das STM8 wird vom kostenlosen Small Device C-Compiler , dem kostenlosen Closed Source Cosmic C-Compiler und den nicht kostenlosen IAR C- und Raisonance-Compilern unterstützt. Neben C gibt es STM8 eForth, einen Open-Source-Port der Programmiersprache Forth.
Änderungen gegenüber ST7
Der STM8-Befehlssatz ist meistens eine Obermenge des ST7, aber nicht vollständig binärkompatibel.
Operationen an den X- und Y-Registern werden auf 16 Bit erweitert. Somit greifen Ladevorgänge und Speicher auf zwei Bytes Speicher anstatt auf eines zu. (Außerdem wurde das Half-Carry-Flag geändert, um den Übertrag von Bit 7 auf Bit 8 des 16-Bit-Ergebnisses und nicht den Übertrag von Bit 3 auf 4 widerzuspiegeln.)
Interrupts übertragen auf dem ST7 neun statt fünf Byte Status.
Der Multiplikationsbefehl speichert das 16-Bit-Produkt im angegebenen Indexregister (z. B. X), anstatt es zwischen X und A zu teilen.
Indirekte Adressierungsarten , die eine 8-Bit - Adresse aus dem Speicher zu holen (Opcodes 92 2x , 92 3x , 92 Bx , 92 6x , 92 Ex , 91 6x , und 91 Ex ) gelöscht wurden; Alle indirekten Adressierungsmodi rufen 16-Bit-Adressen ab. Ein neues Präfixbyte 72 wurde hinzugefügt und verwendet, um indirekt beginnend mit einer 16-Bit-Adresse zu codieren.
Die Bitmanipulationsanweisungen wurden geändert, um eine 16-Bit-Adresse anzunehmen und das 72 Präfixbyte zu erfordern . Die nicht fixierten Opcodes 0x und die 1x zuvor belegten werden stattdessen für die relative Adressierung von Stapelzeigern verwendet.
Bei einigen selten verwendeten Verzweigungsbefehlen wurden die Opcodes geändert, um ein 90 Präfix zu erfordern , und die nicht vorfixierten Opcodes wurden signierten Verzweigungen zugewiesen, die vom V-Flag abhängen.
Lade- und Vergleichsanweisungen, die auf das X-Register abzielen, sind beim ST7 mit vom X-Register indizierten Adressierungsmodi von geringem Nutzen. Wenn auf dem STM8 solche Operationen einen durch das X-Register indizierten Speicheroperanden spezifizieren, wird der Registeroperand in Y geändert. Mit einem 90 Präfix werden die Register umgekehrt, so dass das Indexregister Y und das Operandenregister X ist.
Ein wesentlicher Leistungsunterschied besteht darin, dass der STM8 pro Zyklus 32 Bit aus dem ROM abruft und typische Anweisungen einen Zyklus zur Ausführung plus einen Zyklus pro RAM-Zugriff benötigen. Im Gegensatz dazu ruft der ST7 8 Bits pro Zyklus ab und benötigt einen Zyklus pro Befehlsbyte.
Befehlssatz
STM8 Anweisungen bestehen aus einem optionalen Präfix - Byte ( , , , oder ), ein Opcode - Byte, und ein paar (bis zu vier, aber selten mehr als zwei) Bytes des Operanden. Präfixbytes ändern meistens den Adressierungsmodus, der zum Angeben des Speicheroperanden verwendet wird, in einigen Fällen jedoch Präfixe und führen eine völlig andere Operation aus.
72169016911692167290
Das Präfix 90 tauscht X und Y in der folgenden Anweisung aus. In der folgenden Tabelle werden diese Varianten in einer Zeile zusammengefasst, indem "X / Y" geschrieben wird, was entweder "X" oder "Y" bedeutet. Das Präfix 90 wird auch an zwei Stellen verwendet, um neue Opcodes einzuführen: die BCPL- und BCCM-Anweisungen sowie einige Verzweigungsbedingungen.
Das Präfix 92 konvertiert Anweisungen mit einem Offset-Operanden ( addr16 , X) in eine indirekte Adressierung ([ addr8 ], X). Der Offset wird durch die 8-Bit-Adresse eines 16-Bit-Offsetwerts im Speicher ersetzt. Es wird nur für diese Funktion verwendet.
Das Präfix 91 hat beide vorhergehenden Effekte und konvertiert die Adressierungsmodi ( addr16 , X) in ([ addr8 ], Y).
Das Präfix 72 wird an mehreren Stellen in einem viel weniger regelmäßigen Muster verwendet. In einigen Fällen werden neue Adressierungsmodi eingeführt (insbesondere ein indirekter 16-Bit-Modus ([ addr16 ], X)), aber es werden auch viele völlig neue Operationen eingeführt.
| Präfix | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Operanden | Mnemonik | Beschreibung |
|---|---|---|---|---|---|---|---|---|---|---|---|
| - - | 0 | 0 | 0 | 0 | Opcode | addr8 | OP ( addr8 , SP) | Anweisungen für einen Operanden (siehe unten) | |||
| - - | 0 | 0 | 0 | 1 | Opcode | addr8 | OP A, ( addr8 , SP) | Zwei-Operanden-Befehle mit Stapeloperanden | |||
| - - | 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) | Vergleiche A - Operand |
| - - | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | addr8 | SBC A, ( addr8 , SP) | A: = A - Operand - C subtrahieren mit Ausleihen |
| - / 90 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | addr8 | CPW X / Y ( addr8 , SP) | Vergleiche X / Y - Operand (16-Bit) |
| - - | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | addr8 | UND A, ( addr8 , SP) | A: = A & Operand, bitweise und |
| - - | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | addr8 | BCP A, ( addr8 , SP) | Bitweiser Test 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. | Operand: = Y ( |
| - - | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | addr8 | XOR A, ( addr8 , SP) | A: = A ^ Operand, exklusiv-oder |
| - - | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | addr8 | ADC A, ( addr8 , SP) | A: = A + Operand + C, addiere mit Carry |
| - - | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | addr8 | ODER A, ( addr8 , SP) | A: = A | Operand, einschließlich oder |
| - - | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | addr8 | ADD A, ( addr8 , SP) | A: = A + Operand |
| - - | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | imm16 | ADDW X, # imm16 | X: = X + sofort (= |
| - - | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | imm16 | SUBW X, # imm16 | X: = X - sofort (= |
| - - | 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. | Operand: = X. |
| 72/90 | 0 | 0 | 0 | c | bisschen | v | Operanden | Bitoperationen | |||
| 72 | 0 | 0 | 0 | 0 | bisschen | 0 | addr16 soff8 | BTJT addr16 , # bit , label | Springe zu PC + soff8, wenn das Quellbit wahr ist (gesetzt) | ||
| 72 | 0 | 0 | 0 | 0 | bisschen | 1 | addr16 soff8 | BTJF addr16 , # bit , label | Springe zu PC + soff8, wenn das Quellbit falsch ist (löschen) | ||
| 72 | 0 | 0 | 0 | 1 | bisschen | 0 | addr16 | BSET addr16 , # bit | Setzen Sie das angegebene Bit auf 1 | ||
| 72 | 0 | 0 | 0 | 1 | bisschen | 1 | addr16 | BRES addr16 , # bit | Das angegebene Bit auf 0 zurücksetzen (löschen) | ||
| 90 | 0 | 0 | 0 | 1 | bisschen | 0 | addr16 | BCPL addr16 , # bit | Das ausgewählte Bit ergänzen (umschalten) | ||
| 90 | 0 | 0 | 0 | 1 | bisschen | 1 | addr16 | BCCM addr16 , # bit | Schreiben Sie das Übertragsflag in das Speicherbit | ||
| - / 90 | 0 | 0 | 1 | 0 | Bedingung | soff8 | Bedingte Verzweigungen (8-Bit-Offset mit Vorzeichen) | ||||
| - - | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | soff8 | JRA- Label | Immer verzweigen (wahr) |
| - - | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | soff8 | JRF- Label | Zweig nie (falsch) |
| - - | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | soff8 | JRUGT- Label | Verzweigen, wenn vorzeichenlos größer als (C = 0 und Z = 0) |
| - - | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | soff8 | JRULE- Label | Verzweigen, wenn vorzeichenlos kleiner oder gleich (C = 1 oder Z = 1) |
| - - | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | soff8 | JRNC- Label | Verzweigen, wenn kein Übertrag vorliegt (C = 0) |
| - - | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 | soff8 | GFS- Label | Verzweigen, wenn tragen (C = 1) |
| - - | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | soff8 | JRNE- Label | Verzweigen, wenn nicht gleich (Z = 0) |
| - - | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | soff8 | JREQ- Label | Verzweigen, wenn gleich (Z = 1) |
| - - | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | soff8 | JRNV- Label | Verzweigen, wenn nicht überlaufen (V = 0) |
| 90 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | soff8 | JRNH- Label | Verzweigen, wenn nicht halber Übertrag (H = 0) |
| - - | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | soff8 | JRV- Label | Verzweigen bei Überlauf (V = 1) |
| 90 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | soff8 | JRH- Label | Verzweigen, wenn halber Übertrag (H = 1) |
| - - | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | soff8 | JRPL- Label | Verzweigen, wenn plus (N = 0) |
| - - | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | soff8 | JRMI- Label | Verzweigen, wenn minus (N = 1) |
| - - | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | soff8 | JRSGT- Label | Verzweigung bei Vorzeichen größer als (S = 0 und N = V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | soff8 | JRNM- Label | Verzweigen, wenn nicht Interrupt-Maske (I = 0) |
| - - | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | soff8 | JRSLE- Label | Verzweigen, wenn niedriger oder gleich vorzeichenbehaftet (S = 1 oder N ≠ V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | soff8 | JRM- Label | Verzweigen, wenn Interrupts maskiert sind (I = 1) |
| - - | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | soff8 | JRSGE- Label | Verzweigen, wenn größer oder gleich signiert (N = V) |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | soff8 | JRIL- Label | Verzweigen, wenn die Unterbrechungsleitung niedrig ist |
| - - | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | soff8 | JRSLT- Label | Verzweigen, wenn weniger als (N ≠ V) signiert ist |
| 90 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | soff8 | JRIH- Label | Verzweigen, wenn die Unterbrechungsleitung hoch ist |
| Präfix | 0 | Modus | Opcode | Operand | Anweisungen mit einem Operanden | ||||||
| - - | 0 | 0 | 0 | 0 | Opcode | addr8 | OP ( addr8 , SP) | Stapelzeiger relativ | |||
| - - | 0 | 0 | 1 | 1 | Opcode | addr8 | OP addr8 | 8-Bit-Absolutadresse | |||
| 72 | 0 | 0 | 1 | 1 | Opcode | addr16 | OP [ addr16 ] | 16-Bit-indirekte Adresse | |||
| 92 | 0 | 0 | 1 | 1 | Opcode | addr8 | OP [ addr8 ] | 8-Bit-indirekte Adresse der 16-Bit-Adresse | |||
| - - | 0 | 1 | 0 | 0 | Opcode | - - | OP A. | Akkumulator | |||
| 72/90 | 0 | 1 | 0 | 0 | Opcode | addr16 | OP ( Adr 16 , X / Y) | Indiziert mit 16-Bit-Offset | |||
| - / 90 | 0 | 1 | 0 | 1 | Opcode | - - | OPW X / Y. | X / Y-Register (16-Bit-Betrieb) | |||
| 72 | 0 | 1 | 0 | 1 | Opcode | addr16 | OP addr16 | 16-Bit-Adresse | |||
| - / 90 | 0 | 1 | 1 | 0 | Opcode | addr8 | OP ( addr8 , X / Y) | 8-Bit-Adresse plus X / Y. | |||
| 72 | 0 | 1 | 1 | 0 | Opcode | addr16 | OP ([ addr16 ], X) | 16-Bit-indirekte Adresse plus X. | |||
| 92/91 | 0 | 1 | 1 | 0 | Opcode | addr8 | OP ([ addr8 ], X / Y) | 8-Bit-indirekte Adresse plus X / Y. | |||
| - / 90 | 0 | 1 | 1 | 1 | Opcode | - - | OP (X / Y) | Ohne Offset indiziert | |||
| Präfix | 0 | Modus | 0 | 0 | 0 | 0 | Operand | NEG- Operand | Zweierkomplement negieren | ||
| 0 | Modus | 0 | 0 | 0 | 1 | (Neu zugewiesen für Austauschvorgänge; siehe folgenden Abschnitt) | |||||
| 0 | Modus | 0 | 0 | 1 | 0 | (Neuoperationen zugeordnet; siehe folgenden Abschnitt) | |||||
| Präfix | 0 | Modus | 0 | 0 | 1 | 1 | Operand | CPL- Operand | Eine Ergänzung , logisch nicht | ||
| Präfix | 0 | Modus | 0 | 1 | 0 | 0 | Operand | SRL- Operand | Logisch nach rechts verschieben, msbit gelöscht, lsbit zu übertragen: (Operand: C): = (0: Operand) | ||
| 0 | Modus | 0 | 1 | 0 | 1 | (Neuoperationen zugeordnet; siehe folgenden Abschnitt) | |||||
| Präfix | 0 | Modus | 0 | 1 | 1 | 0 | Operand | RRC- Operand | Durch Carry nach rechts drehen (Operand: C): = (C: Operand) | ||
| Präfix | 0 | Modus | 0 | 1 | 1 | 1 | Operand | SRA- Operand | Arithmetik nach rechts verschieben, msbit beibehalten, lsbit zu tragen | ||
| Präfix | 0 | Modus | 1 | 0 | 0 | 0 | Operand | SLL- Operand | Nach links verschieben, msbit zu tragen: (C: Operand): = (Operand: 0) | ||
| Präfix | 0 | Modus | 1 | 0 | 0 | 1 | Operand | RLC- Operand | Durch Carry nach links drehen, (C: Operand): = (Operand, C) | ||
| Präfix | 0 | Modus | 1 | 0 | 1 | 0 | Operand | DEC- Operand | Dekrement; N und Z gesetzt, tragen nicht betroffen | ||
| 0 | Modus | 1 | 0 | 1 | 1 | (Neuoperationen zugeordnet; siehe folgenden Abschnitt) | |||||
| Präfix | 0 | Modus | 1 | 1 | 0 | 0 | Operand | INC- Operand | Zuwachs; N und Z gesetzt, tragen nicht betroffen | ||
| Präfix | 0 | Modus | 1 | 1 | 0 | 1 | Operand | TNZ- Operand | Test ungleich Null: Setzen Sie N und Z basierend auf dem Operandenwert | ||
| Präfix | 0 | Modus | 1 | 1 | 1 | 0 | Operand | SWAP- Operand | Tauschen Sie die Operandenhälften aus (4-Bit-Drehung; 8-Bit für SWAPW X und SWAPW Y). | ||
| Präfix | 0 | Modus | 1 | 1 | 1 | 1 | Operand | CLR- Operand | Setzen Sie den Operanden auf 0, N gelöscht, Z gesetzt | ||
| Präfix | 0 | Modus | Opcode | Operand | Neu zugewiesene Opoden [03-7] [125B] aus dem Ein-Operanden-Bereich | ||||||
| - / 90 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | - - | RRWA X / Y. | Wort nach rechts durch A drehen: 8-Bit nach rechts drehen bei 24-Bit-Verkettung von X / Y und A; (X: A): = (A: X) |
| - - | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | addr16 | EXG A, Adresse 16 | Tauschen Sie A mit Speicher aus |
| - - | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | - - | EXG A, XL | Tausche A mit X aus (niedrige Hälfte) |
| - - | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | - - | EXGW X, Y. | Tausche X mit Y aus (16 Bit) |
| - - | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | - - | EXG A, YL | Tauschen Sie A mit Y aus (niedrige Hälfte) |
| - - | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | - - | (reserviert) | |
| - / 90 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | - - | RLWA X / Y. | Wort nach links durch A drehen: 8-Bit nach links drehen bei 24-Bit-Verkettung von X / Y und A; (A: X): = (X: A) |
| - - | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | addr16 | POP- Adresse 16 | Pop vom Stapel |
| - / 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. | Teilen Sie X / Y durch A; 16-Bit-Quotient in X / Y, Rest in A. |
| - - | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 0 | - - | PRÄFIX | Anweisungspräfix 72 : Ändern Sie den folgenden Opcode
|
| 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | - - | (reserviert) | ||
| - - | 0 | 0 | 1 | 1 | 0 | 1 | 0 | 1 | imm8 addr16 | MOV addr16 , # imm8 | Sofort in den Speicher verschieben (Flags nicht betroffen) |
| - - | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | addr8 addr8 | MOV addr8 , addr8 | Speicher in Speicher verschieben (Flags nicht betroffen) |
| - - | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | addr16 addr16 | MOV addr16 , addr16 | Speicher in Speicher verschieben (Flags nicht betroffen) |
| - - | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 1 | - - | DIVW X, Y. | Teilen Sie X durch Y (16 Bit); Quotient in X, Rest in Y. |
| 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | - - | (reserviert) | ||
| 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | - - | (reserviert) | ||
| - - | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | addr16 | PUSH addr16 | Auf Stapel schieben |
| - - | 0 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | imm8 | PUSH # imm8 | Auf Stapel schieben |
| - - | 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. | Relativ zum Stapel lagern |
| - - | 0 | 1 | 1 | 1 | 1 | 0 | 1 | 1 | addr8 | LD A, ( addr8 , SP) | Laden relativ zum Stapel |
| - - | 1 | 0 | 0 | Opcode | - - | Verschiedene Anweisungen. Keiner setzt implizit die Bedingungscodes. | |||||
| - - | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | - - | IRET | Rückkehr vom Interrupt (Pop CC, A, X, Y, PC) |
| - - | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | - - | RET | Pop 16-Bit-Rücksprungadresse vom Stapel zum PC |
| - - | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | addr24 | INT | Spezialsprung für Interrupt-Vektortabelle |
| - - | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | - - | FALLE | Trap-Interrupt erzwingen |
| - - | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | - - | POP A. | Pop A vom Stapel |
| - / 90 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | - - | POPW X / Y. | Pop X / Y vom Stapel (16 Bit) |
| - - | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | - - | POP CC | Pop-Bedingungscodes vom Stapel |
| - - | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | - - | RETF | Pop 24-Bit-Rücksprungadresse vom Stapel zum PC |
| - - | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | - - | DRÜCKEN SIE A. | Schieben Sie A auf den Stapel |
| - / 90 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | - - | PUSHW X / Y. | Schieben Sie X / Y auf den Stapel (16 Bit) |
| - - | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | - - | PUSH CC | Schieben Sie die Bedingungscodes auf den Stapel |
| - - | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | - - | UNTERBRECHUNG | Stoppen Sie für den Debugger, falls vorhanden, oder NOP |
| - - | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | - - | CCF | Komplement (umschalten) Carry Flag |
| - - | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | addr24 | CALLF addr24 | Push 24-Bit-PC; PC: = addr24 |
| 92 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | addr16 | CALLF [ addr16 ] | Indirekter Fernanruf; Die Adresse ist ein 24-Bit-Zeiger |
| - - | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | - - | HALT | Prozessor und Uhren anhalten |
| - - | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | - - | WFI | Warten Sie auf Interrupt, halten Sie den Prozessor an, aber nicht die Uhren |
| 72 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | - - | WFE | Warten Sie auf ein Ereignis (Coprozessor) und behandeln Sie Interrupts während des Wartens normal |
| - - | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | - - | PDY | Befehlspräfix 90 : swap X und Y in nächsten Befehls
|
| - - | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | - - | PIY | Befehlspräfix 91 : PDY und PIX
|
| - - | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | - - | PIX | Befehlspräfix 92 : Verwenden Sie indirekt einen 8-Bit-Speicher für den Operanden
|
| - / 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 | Übertragsflag zurücksetzen (löschen) |
| - - | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | - - | SCF | Setze Carry Flag |
| - - | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | - - | RAND | Interrupt-Maske zurücksetzen (Interrupts aktivieren) |
| - - | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | - - | SIM | Interrupt-Maske einstellen (Interrupts deaktivieren) |
| - - | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | - - | RVF | Überlaufflag zurücksetzen (löschen) |
| - - | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | - - | NOP | Keine Operation |
| - / 90 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | - - | LD A, XH / YH | A: = XH / YH |
| - / 90 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | - - | LD A, XL / YL | A: = XL / YL |
| Präfix | 1 | Modus | Opcode | Operand | Zwei-Operanden-Befehle A: = Ein Operationsoperand | ||||||
| - - | 0 | 0 | 0 | 1 | Opcode | addr8 | OP ( addr8 , SP) | Stapelrelativer Operand (siehe oben; Opcodes 16, 17, 1C, 1D folgen nicht dem Muster) | |||
| - - | 1 | 0 | 1 | 0 | Opcode | imm8 | OP # imm8 | 8-Bit-Sofortoperand (als Ziel verboten) | |||
| - - | 1 | 0 | 1 | 1 | Opcode | addr8 | OP addr8 | 8-Bit-Absolutadresse (verboten für Sprung / Anruf) | |||
| - - | 1 | 1 | 0 | 0 | Opcode | addr16 | OP addr16 | 16-Bit-Absolutadresse | |||
| 72 | 1 | 1 | 0 | 0 | Opcode | addr16 | OP [ addr16 ] | 16-Bit-indirekte Adresse | |||
| 92 | 1 | 1 | 0 | 0 | Opcode | addr8 | OP [ addr8 ] | 8-Bit-indirekte Adresse der 16-Bit-Adresse | |||
| - / 90 | 1 | 1 | 0 | 1 | Opcode | addr16 | OP ( Adr 16 , X / Y) | Indiziert mit 16-Bit-Offset | |||
| 72 | 1 | 1 | 0 | 1 | Opcode | addr16 | OP ([ addr16 ], X) | 16-Bit indirekt + X. | |||
| 92/91 | 1 | 1 | 0 | 1 | Opcode | addr16 | OP ([ addr8 ], X / Y) | 8-Bit indirekt + X / Y. | |||
| - / 90 | 1 | 1 | 1 | 0 | Opcode | addr8 | OP ( addr8 , X / Y) | Indiziert mit 8-Bit-Offset | |||
| - / 90 | 1 | 1 | 1 | 1 | Opcode | - - | OP (X / Y) | Ohne Offset indiziert | |||
| Präfix | 1 | Modus | 0 | 0 | 0 | 0 | Operand | SUB A, Operand | A: = A - Operand | ||
| Präfix | 1 | Modus | 0 | 0 | 0 | 1 | Operand | CP A, Operand | Vergleiche A - Operand | ||
| Präfix | 1 | Modus | 0 | 0 | 1 | 0 | Operand | SBC A, Operand | A: = A - Operand - C subtrahieren mit Ausleihen | ||
| Präfix | 1 | Modus | 0 | 0 | 1 | 1 | Operand | CPW X / Y, Operand | Vergleiche X / Y - Operand (16 Bit); vergleiche Y / X, wenn der Operandenmodus durch X / Y indiziert ist (Opcodes D3, E3, F3) | ||
| Präfix | 1 | Modus | 0 | 1 | 0 | 0 | Operand | UND A, Operand | A: = A & Operand, bitweise und | ||
| Präfix | 1 | Modus | 0 | 1 | 0 | 1 | Operand | BCP A, Operand | Bitweiser Test A & Operand | ||
| Präfix | 1 | Modus | 0 | 1 | 1 | 0 | Operand | LD A, Operand | A: = Operand | ||
| Präfix | 1 | Modus | 0 | 1 | 1 | 1 | Operand | LD- Operand , A. | Operand: = A (Modus 2 |
||
| Präfix | 1 | Modus | 1 | 0 | 0 | 0 | Operand | XOR A, Operand | A: = A ^ Operand, exklusiv-oder | ||
| Präfix | 1 | Modus | 1 | 0 | 0 | 1 | Operand | ADC A, Operand | A: = A + Operand + C, addiere mit Carry | ||
| Präfix | 1 | Modus | 1 | 0 | 1 | 0 | Operand | ODER A, Operand | A: = A | Operand, einschließlich oder | ||
| Präfix | 1 | Modus | 1 | 0 | 1 | 1 | Operand | ADD A, Operand | A: = A + Operand | ||
| Präfix | 1 | Modus | 1 | 1 | 0 | 0 | Operand | JP- Operand | Niedrige 16 Bit PC: = Operand, bedingungsloser Sprung (Modi 2 |
||
| Präfix | 1 | Modus | 1 | 1 | 0 | 1 | Operand | CALL- Operand | Push 16-Bit-PC, niedrige 16-Bit-PC: = Operand (Modi 2 |
||
| Präfix | 1 | Modus | 1 | 1 | 1 | 0 | Operand | LDW X / Y, Operand | Laden X / Y: = Operand; Verwenden Sie 16 anstelle von 90 1E für LDW Y ( addr8 , SP). | ||
| Präfix | 1 | Modus | 1 | 1 | 1 | 1 | Operand | LDW- Operand X / Y. | Operand: = X / Y (16 Bit, Modus 2 |
||
| Präfix | 1 | Modus | Opcode | Operand | Neu zugewiesene Opcodes A7, AC, BC, AD, BD, AF aus dem Zwei-Operanden-Bereich | ||||||
| - / 90 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | addr24 | LDF ( addr24 , X / Y), A. | Weit |
| 92/91 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | addr16 | LDF ([ addr16 ], X / Y), A. | 16-Bit-Adresse des 24-Bit-Zeigers |
| - - | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | addr24 | JPF addr24 | PC: = addr24 (= |
| 92 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | addr16 | JPF [ addr16 ] | Indirekter Weitsprung; Die Adresse ist ein 24-Bit-Zeiger |
| - - | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | addr24 | LDF A, addr24 | Weit |
| 92 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | addr16 | LDF A, [ addr16 ] | Laden Sie weit, 16-Bit-Adresse des 24-Bit-Zeigers |
| - - | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | soff8 | CALLR- Etikett | 16-Bit-PC |
| - - | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | addr24 | LDF addr24 , A. | Operand: = A (= |
| 92 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | addr16 | LDF [ addr16 ], A. | Operand: = A, 16-Bit-Adresse des 24-Bit-Zeigers |
| - / 90 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | addr24 | LDF A, ( addr24 , X / Y) | Weit |
| 92/91 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | addr16 | LDF A, ([ addr16 ], X / Y) | 16-Bit-Adresse des 24-Bit-Zeigers |
| 72 | 1 | Modus | Opcode | Operand | Indexregisterarithmetik (16 Bit) X / Y: = X / Y ± Operand | ||||||
| 72 | 1 | 0 | 1 | 0 | Opcode | imm16 | OPW X / Y, # imm16 | 16-Bit sofort | |||
| 72 | 1 | 0 | 1 | 1 | Opcode | addr16 | OPW X / Y, Adresse 16 | 16-Bit absolut | |||
| 72 | 1 | 1 | 1 | 1 | Opcode | addr8 | OPW X / Y ( addr8 , SP) | Stapelverwandter | |||
| 72 | 1 | Modus | 0 | 0 | 0 | 0 | Operand | SUBW X, Operand | X: = X - Operand (bevorzugter Opcode 1D für SUBW X, # imm16 ) | ||
| 72 | 1 | Modus | 0 | 0 | 1 | 0 | Operand | SUBW Y, Operand | Y: = Y - Operand | ||
| 72 | 1 | Modus | 1 | 0 | 0 | 1 | Operand | ADDW Y, Operand | Y: = Y + Operand | ||
| 72 | 1 | Modus | 1 | 0 | 1 | 1 | Operand | ADDW X, Operand | X: = X + Operand (bevorzugter Opcode 1C für ADDW X, # imm16 ) | ||
Für CPW- und LDW-Anweisungen, bei denen der Operandenadressierungsmodus durch X indiziert ist, verwendet der STM8 standardmäßig das Y-Register anstelle von X. Durch Anwenden eines 90 Präfixes werden X und Y ausgetauscht, sodass das Register X ist und der Adressierungsmodus durch Y indiziert wird.