General information | |
---|---|
Launched | 1977 |
Common manufacturer | |
Performance | |
Max. CPU clock rate | to 250 KHz |
Data width | 4 (RAM), 8 (ROM) |
Address width | 7 (RAM), 11 (ROM) |
Architecture and classification | |
Application | Embedded |
Instruction set | COP400 |
Number of instructions | 40 |
Physical specifications | |
Package |
|
History | |
Predecessor | MM5799 (PMOS COP) |
Successor | COP8 |
The COP400 or COP II is a 4-bit microcontroller family introduced in 1977 by National Semiconductor as a follow-on product to their original PMOS COP microcontroller. [1] COP400 family members are complete microcomputers containing internal timing, logic, ROM, RAM, and I/O necessary to implement dedicated controllers. [2] Some COP400 devices were second-sourced by Western Digital as the WD4200 family. [3] [4] In the Soviet Union several COP400 microcontrollers were manufactured as the 1820 series (e.g. the COP402 with designation КР1820ВЕ1). [5]
The COP400 is implemented in CMOS or N-channel silicon gate MOS technology. It was typically packaged in 24- or 28-pin DIP packages. Instruction cycle time of the faster family members is 4 microseconds. The COP400 family offered several memory and pinout configurations.
Notable products that used COP400-family chips include the Apple Lisa, Milton Bradley and Mattel electronic games, Coleco Head to Head Basketball, the Grundy Newbrain, and others.
The COP400 uses separate memory spaces for ROM and RAM. ROM addresses are 11-bit maximum, while data addresses are 7-bit maximum.
Program memory consists of a 512, 1024, or 2048 × 8-bit ROM. ROM bytes may be program instructions, program data, or jump address pointers. Due to the special characteristics associated with the JP and JSRP instructions, ROM must often be conceived of as organized into pages of 64 bytes each. Also, because of the unique operations performed by the LQID and JID instructions, ROM pages must sometimes be thought of as organized into blocks of 256 bytes.
Data memory consists of a 32, 64, or 128 × 4-bit RAM, organized as several data registers of 16 4-bit digits. RAM addressing is implemented by the 6- or 7-bit B register used as a pointer. The B register's upper 2 or 3 bits (Br) select one of 4 or 8 data registers and lower 4 bits (Bd) select one of 16 4-bit digits in the selected data register. The 4-bit contents of the RAM digit pointed to by the B register are usually loaded into, exchanged with, or operate on the A register.
|
The register configuration shown in the diagram is for the COP400 family members with maximum ROM (2048 × 8 bits) and RAM (128 × 4 bits). Family members with only 512 or 1024 bytes of ROM will have only a 9- or 10-bit PC. Those with 64 or 32 locations of RAM will have only a 2-bit Br register. Some low end family members omit the SC stack register. [6]
The 4-bit A register (accumulator) is the source and destination register for most arithmetic, logic, and data memory access operations. It can also be used to load the Br and Bd portions of the B register, to load and input 4 bits of the 8-bit Q latch data, to input 4 bits of the 8-bit L port and to perform data exchanges with the SIO register.
A 4-bit ALU performs the arithmetic and logic functions, storing results in A. ASC and CASC operations output a carry to the 1-bit C register, most often employed to indicate arithmetic overflow.
All ROM addressing is accomplished via the 9-, 10-, or 11-bit PC register. Its binary value selects one of the bytes contained in ROM, usually the next program instruction. The value of PC is automatically incremented by 1 prior to the execution of the current instruction to point to the next sequential ROM location, unless the current instruction is a transfer of control instruction. In the latter case, PC is loaded with the appropriate non-sequential value to implement the transfer of control operation. The PC automatically rolls over to point to the next 64 byte page or 256 byte block of program memory. The upper 1, 2, or 3 bits of PC are also used in the JID and LQID instructions.
Three levels of subroutine are implemented by the subroutine save registers, SA, SB, and SC, providing a last-in, first-out (LIFO) hardware subroutine stack. Some implementations do not have a SC.
There are no port numbers or memory addresses associated with the COP400 I/O devices. All the physical I/O registers and ports are referenced by the COP400 assembly language directly by name.
Nearly all COP400 family devices implement the following: [6]
There are a few high end members of the COP400 family such as the COP440 and COP2440 that have 40-pins. These have additional registers and ports: [7]
The COP400 family is designed to have very compact code. The most frequently used instructions are one byte. In some cases there are special one-byte forms of two byte instructions. Some features that can be used to make object code more compact are:
COP400 family instruction set | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Opcode | Operand | Mnemonic | Description | Skip | |||||||
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | ||||
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | — | CLRA | A ← 0 | — |
0 | 0 | 0 | b0 | 0 | 0 | b1 | 1 | — | SKMBZ b | — | RAM(B)b = 0 |
0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | — | XOR | A ← A ⊻ RAM(B) | — |
0 | 0 | r | 0 | 1 | 0 | 0 | — | XIS r | A ↔ RAM(B), Br ← Br ⊻ r, Bd ← Bd + 1 | Bd = 0 | |
0 | 0 | r | 0 | 1 | 0 | 1 | — | LD r | A ← RAM(B), Br ← Br ⊻ r | — | |
0 | 0 | r | 0 | 1 | 1 | 0 | — | X r | A ↔ RAM(B), Br ← Br ⊻ r | — | |
0 | 0 | r | 0 | 1 | 1 | 1 | — | XDS r | A ↔ RAM(B), Br ← Br ⊻ r, Bd ← Bd - 1 | Bd = 15 | |
0 | 0 | r | 1 | d | — | LBI r,d | Br ← r, Bd ← (d + 9) ^ 15 (Br = 0-3, Bd = 9-15, 0) | next LBI | |||
0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | — | CASC | A ← ~A + RAM(B) + C, C ← Carry | C = 1 |
0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | — | XABR | A ↔ Br, A3 ← 0 | — |
0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | — | SKC | — | C = 1 |
0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | — | SKE | — | A = RAM(B) |
0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | — | SC | C ← 1 | — |
0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 0rrrdddd | LDD r,d | A ← RAM(r,d) | — |
0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 1rrrdddd | XAD r,d | A ↔ RAM(r,d) | — |
0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | — | ASC | A ← A + RAM(B) + C, C ← Carry | C = 1 |
0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | — | ADD | A ← A + RAM(B) | — |
0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | — | RC | C ← 0 | — |
0 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | opcode | 33H prefix | See table below for instructions with this prefix | — |
0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | — | COMP | A ← ~A | — |
0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | — | SKT | Skip on timer overflow | timer |
0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | — | RMB 2 | RAM(B)2 ← 0 | — |
0 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | — | RMB 3 | RAM(B)3 ← 0 | — |
0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | — | NOP | No operation | — |
0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | — | RMB 1 | RAM(B)1 ← 0 | — |
0 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | — | SMB 2 | RAM(B)2 ← 1 | — |
0 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | — | SMB 1 | RAM(B)1 ← 1 | — |
0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | — | RET | Pop PC (PC ← SA, SA ← SB, SB ← SC) | — |
0 | 1 | 0 | 0 | 1 | 0 | 0 | 1 | — | RETSK | Pop PC | always |
0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | — | ADT | A ← A + 10 | — |
0 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | — | SMB 3 | RAM(B)3 ← 1 | — |
0 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | — | RMB 0 | RAM(B)0 ← 0 | — |
0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | — | SMB 0 | RAM(B)0 ← 1 | — |
0 | 1 | 0 | 0 | 1 | 1 | 1 | 0 | — | CBA | A ← Bd | — |
0 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | — | XAS | A ↔ SIO, SK ← C | — |
0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | — | CAB | Bd ← A | — |
0 | 1 | 0 | 1 | y | — | AISC y | A ← A + y (1 ≤ y ≤ 15, C unchanged) | carry | |||
0 | 1 | 1 | 0 | 0 | addhi | addlo | JMP a | PC[10:8] ← addhi, PC[7:0] ← addlo | — | ||
0 | 1 | 1 | 0 | 1 | addhi | addlo | JSR a | Push PC, PC[10:8] ← addhi, PC[7:0] ← addlo | — | ||
0 | 1 | 1 | 1 | y | — | STII y | RAM(B) ← y, Bd ← Bd + 1 | — | |||
1 | 0 | addr | — | JSRP a | If PC[10:6] ≠ 00010: Push PC, PC[10:6] ← 00010, PC[5:0] ← addr | — | |||||
1 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | — | LQID | Q ← ROM(PC[10:8], A, RAM(B)), SC ← SB | — |
1 | 1 | addr | — | JP a | If PC[10:6] ≠ 00010: PC[5:0] ← addr | — | |||||
1 | addr | — | JP a | If PC[10:7] = 0001: PC[6:0] ← addr | — | ||||||
1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | — | JID | PC[7:0] ← ROM(PC[10:8], A, RAM(B)) | — |
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Operand | Mnemonic | Description | Skip |
opcodes prefixed with 33H | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
Opcode | Mnemonic | Description | Skip | Types supported | ||||||||
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | |||||
0 | 0 | 0 | b0 | 0 | 0 | b1 | 1 | SKGBZ b | — | Gb = 0 | All | |
0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | XAN | A[1:0] ↔ N, A[2:3] ← 0 | — | 3 | |
0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | CEMA | RAM(B) ← EN[7:4], A ← EN[3:0] | — | 3 | |
0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | LID | RAM(B), A ← ROM(PC[10:8], A, RAM(B)) | — | 3 | |
0 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | OR | A ← A ∨ RAM(B) | — | 3 | |
0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | SKSZ | — | SIO = 0 | 3 | |
0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | CAME | EN[7:4] ← A, EN[3:0] ← RAM(B) | — | 3 | |
0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | SKGZ | — | G = 0 | All | |
0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | ININ | A ← IN | — | 2, 3 | |
0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | INIL | A ← IL3, 1, 0, IL0 or A ← IL3, CKO, 0, IL0 | — | 2, 3 | |
0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | ING | A ← G | — | All | |
0 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | INH | A ← H | — | 3 | |
0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | CQMA | RAM(B) ← Q[7:4], A ← Q[3:0] | — | 2, 3 | |
0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | INR | RAM(B) ← R[7:4], A ← R[3:0] | — | 3 | |
0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | INL | RAM(B) ← L[7:4], A ← L[3:0] | — | All | |
0 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | CTMA | RAM(B) ← T[7:4], A ← T[3:0] | — | 3 | |
0 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | OMG | G ← RAM(B) | — | All | |
0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | OMH | H ← RAM(B) | — | 3 | |
0 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | CAMQ | Q[7:4] ← A, Q[3:0] ← RAM(B) | — | All | |
0 | 0 | 1 | 1 | 1 | 1 | 0 | 1 | CAMR | R[7:4] ← A, R[3:0] ← RAM(B) | — | 3 | |
0 | 0 | 1 | 1 | 1 | 1 | 1 | 0 | OBD | D ← Bd | — | All | |
0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | CAMT | T[7:4] ← A, T[3:0] ← RAM(B) | — | 3 | |
0 | 1 | 0 | 1 | y | OGI y | G ← y | — | 2, 3 | ||||
0 | 1 | 1 | 0 | y | LEI y | EN ← y | — | All | ||||
1 | r | d | LBI r,d | Br ← r, Bd ← d | next LBI | 2, 3 | ||||||
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Mnemonic | Description | Skip | Types supported |
Types supported: Type 1 is very low-end such as COP410. Type 2, such as the COP420, is most common. Type 3 typically have resources to support 40 pins even if package does not have 40 pins. Type 4 is not shown as there is no evidence that Type 4 was produced.
This example code demonstrates several of the space saving features on the instruction set:
040 09 041 19 042 2F 043 15 044 14 045 C3 046 48 | ; Copy a block of memory from one location to another.;; There are three entry points: copyA, copyB, and copyC.; The values of the LBI instructions are expressed as; LBI Br, Bd.;copyA:LBI0,10;Copy 6 nybbles starting 0,10 to 1,10copyB:LBI1,10;Copy 6 nybbles starting 1,10 to 0,10copyC:LBI2,0;Copy 16 nybbles starting 2,0 to 3,0loop:LD1;Load src in A. XOR Br with 1 to get destXIS1;Save A in dest. Inc Bd. XOR Br with 1 to get srcJPloop;loop until Bd goes past last digit locationRET |
Early COP400 devices that have 28 pins or more support a single interrupt. The IN 1 line is used as the interrupt input. Interrupt is enabled by setting bit 1 of the EN register to 1 with a LEI instruction. In response to low-going pulse of at least two instruction cycles long on IN 1, all transfer of control instructions such as JP are completed and all sequential LBI instructions are executed. The PC is then pushed on the subroutine stack and control is transferred to the interrupt handler at address 0xFF. No subroutines may be called in the interrupt service routine on devices with a hardware stack. [6] Curiously, later devices such as the COP440 support four interrupt sources and two service routines but only one interrupt source can be selected at a time. Subroutines are supported inside interrupt service routines on devices with a stack pointer.
Although the majority of COP400 devices were targeted at low-end applications, several extensions to the architecture were created to address more demanding applications. Dual CPU, a deeper stack in RAM, and larger address spaces were added to some devices by 1985. [7]
"Dual CPU" versions of the COP400 were announced by National Semiconductor in 1981. These single-chip barrel processors contain two ostensibly independent CPUs that share instructions, memory, and most IO devices. In reality, the CPUs are not fully independent and share hardware resources similar to Intel processors with Hyper-Threading Technology (HTT). Like HTT, the dual CPU version works by duplicating certain sections of the processor—those that store the architectural state—but not duplicating the main execution resources such as ALU, buses, and memory. Separate architectural states for each of the two virtual processors is established with duplicated A (accumulators), B (pointer registers), C (carry flags), N (stack pointers), and PC (program counters). [6]
When the reset is deasserted, both processors start at location 0 which contains a CLRA instruction, then one processor jumps to location 401 (hex) followed an instruction cycle later by the second processor executing location 1. The processors will then alternately execute one byte of code each.
At maximum clock frequency, the instruction execution time (single byte instruction) for each processor is 4 microseconds, hence, the instruction cycle time for either processor is twice that amount, 8 microseconds.
Some dual CPU versions include the 40-pin COP2440N, the 28-pin COP2441N, and the 24-pin COP2442N.
|
Earlier COP400 devices included a two or three level dedicated hardware return stack. Later devices such as the COP440 feature a 4-level return stack implemented with a 2-bit stack pointer and RAM. Dual CPU versions have two separate 4-level return stacks implemented with two 2-bit stack pointers and two different RAM areas.
The basic COP400 instruction set supports ROM addresses of up to 11-bits (2,048 bytes), while data addresses are 7-bits maximum (128 locations). The so-called group 4 devices extended the memory limit by adding three-byte JMP, JSR, and LBI instructions with more address bits. These support ROM addresses of 15-bits maximum (32,768 bytes), while data addresses are 9-bits maximum (512 locations). Devices that support these instructions include COP408, COP484, COP485, C0P409. It is unclear whether any of these group 4 devices were produced.
T400 μController is an open source implementation of the COP400 microcontroller written in VHDL. COP420/421 and COP410L/411L devices are supported. T400 is intended to be a replacement for the original chip in SOCs recreating legacy systems. T400 has been implemented in several FPGA families. T400 is available under GNU General Public License. [13]
There is an open-source MAME emulator for the COP400 family and several hand held games and specialty calculators. [14] [15]
The Intel 8080 ("eighty-eighty") is the second 8-bit microprocessor designed and manufactured by Intel. It first appeared in April 1974 and is an extended and enhanced variant of the earlier 8008 design, although without binary compatibility. The initial specified clock rate or frequency limit was 2 MHz, with common instructions using 4, 5, 7, 10, or 11 clock cycles. As a result, the processor is able to execute several hundred thousand instructions per second. Two faster variants, the 8080A-1 and 8080A-2, became available later with clock frequency limits of 3.125 MHz and 2.63 MHz respectively. The 8080 needs two support chips to function in most applications: the i8224 clock generator/driver and the i8228 bus controller. The 8080 is implemented in N-type metal–oxide–semiconductor logic (NMOS) using non-saturated enhancement mode transistors as loads thus demanding a +12 V and a −5 V voltage in addition to the main transistor–transistor logic (TTL) compatible +5 V.
The Intel MCS-51 is a single chip microcontroller (MCU) series developed by Intel in 1980 for use in embedded systems. The architect of the Intel MCS-51 instruction set was John H. Wharton. Intel's original versions were popular in the 1980s and early 1990s, and enhanced binary compatible derivatives remain popular today. It is a complex instruction set computer, but also has some of the features of RISC architectures, such as a large register set and register windows, and has separate memory spaces for program instructions and data.
The Intel 8085 ("eighty-eighty-five") is an 8-bit microprocessor produced by Intel and introduced in March 1976. It is the last 8-bit microprocessor developed by Intel.
The Intel 4040 ("forty-forty") is the second 4-bit microprocessor designed and manufactured by Intel. Introduced in 1974 as a successor to the Intel 4004, the 4040 was produced with a 10 μm process and includes silicon gate enhancement-load PMOS logic technology. The 4040 contained 3,000 transistors and could execute approximately 62,000 instructions per second.
PIC is a family of microcontrollers made by Microchip Technology, derived from the PIC1640 originally developed by General Instrument's Microelectronics Division. The name PIC initially referred to Peripheral Interface Controller, and is currently expanded as Programmable Intelligent Computer. The first parts of the family were available in 1976; by 2013 the company had shipped more than twelve billion individual parts, used in a wide variety of embedded systems.
The National Semiconductor COP8 is an 8-bit CISC core microcontroller. COP8 is an enhancement to the earlier COP400 4-bit microcontroller family. COP8 main features are:
The TMS9900 was one of the first commercially available, single-chip 16-bit microprocessors. Introduced in June 1976, it implemented Texas Instruments' TI-990 minicomputer architecture in a single-chip format, and was initially used for low-end models of that lineup.
The Fairchild F8 is an 8-bit microprocessor system from Fairchild Semiconductor, announced in 1974 and shipped in 1975. The original processor family included four main 40-pin integrated circuits (ICs); the 3850 CPU which was the arithmetic logic unit, the 3851 Program Storage Unit (PSU) which contained 1 KB of program ROM and handled instruction decoding, and the optional 3852 Dynamic Memory Interface (DMI) or 3853 Static Memory Interface (SMI) to control additional RAM or ROM holding the user programs or data. The 3854 DMA was another optional system that added direct memory access into the RAM controlled by the 3852.
National Semiconductor's SC/MP for Simple Cost-effective Micro Processor, is an early 8-bit microprocessor which became available in April 1976. It was designed to allow systems to be implemented with the minimum number of additional support chips. SC/MP included a daisy-chained control pin that allowed up to three SC/MP's share a single main memory to produce a multiprocessor system, or to act as controllers in a system with another main central processing unit (CPU). Three versions were released over its lifetime, SCMP-1 through 3, the latter two also known as INS8060 and INS8070.
The Intel 8061 microcontroller is most notable for its use in the Ford EEC-IV automotive engine control unit. A close relative of the 8096, the Intel 8061 is second-sourced by Toshiba and Motorola.
The Atmel AVR instruction set is the machine language for the Atmel AVR, a modified Harvard architecture 8-bit RISC single chip microcontroller which was developed by Atmel in 1996. The AVR was one of the first microcontroller families to use on-chip flash memory for program storage.
The Signetics 2650 was an 8-bit microprocessor introduced in July 1975. According to Adam Osborne's book An Introduction to Microprocessors Vol 2: Some Real Products, it was "the most minicomputer-like" of the microprocessors available at the time. A combination of missing features and odd memory access limited its appeal, and the system saw little use in the market.
RS08 is a family of 8-bit microcontrollers by NXP Semiconductors. Originally released by Freescale in 2006, the RS08 architecture is a reduced-resource version of the Freescale MC68HCS08 central processing unit (CPU), a member of the 6800 microprocessor family. It has been implemented in several microcontroller devices for embedded systems.
TLCS is a prefix applied to microcontrollers made by Toshiba. The product line includes multiple families of CISC and RISC architectures. Individual components generally have a part number beginning with "TMP". E.g. the TMP8048AP is a member of the TLCS-48 family.
The Mitsubishi 740, also known as MELPS 740, is a series of 8-bit CMOS microcontrollers and microprocessors with an enhanced MOS Technology 6502 compatible core based on the expanded WDC 65C02. The ICs were manufactured by Mitsubishi Electric during the 1980s and 1990s.
The Intersil 6100 is a single-chip microprocessor implementation of the 12-bit PDP-8 instruction set, along with a range of peripheral support and memory ICs developed by Intersil in the mid-1970s. It was sometimes referred to as the CMOS-PDP8. Since it was also produced by Harris Corporation, it was also known as the Harris HM-6100. The Intersil 6100 was introduced in the second quarter of 1975, and the Harris version in 1976.
The 9S08 is an 8-bit microcontroller (μC) family originally produced by Motorola, later by Freescale Semiconductor, and currently by NXP, descended from the Motorola 6800 microprocessor. It is a CISC microcontroller. A slightly extended variant of the 68HC08, it shares upward compatibility with the aging 68HC05 microcontrollers, and is found in almost any type of embedded systems. The larger members offer up to 128 KiB of flash, and 8 KiB of RAM via a simple memory management unit (MMU) which allows bank-switching 16 KiB of the address space and an address/data register pair which allows data fetches from any address. The paging scheme used allows for a theoretical maximum of 4 MB of flash.
The ST6 and ST7 are 8-bit microcontroller product lines from STMicroelectronics. They are commonly used in small embedded applications like washing machines.
The STM8 is an 8-bit microcontroller family by STMicroelectronics. The STM8 microcontrollers use an extended variant of the ST7 microcontroller architecture. STM8 microcontrollers are particularly low cost for a full-featured 8-bit microcontroller.
The Mostek MK5065 was an 8-bit microprocessor introduced by Mostek in early 1974. The design was originally developed by Motorola for use in an Olivetti electronic calculator, and was licensed to Mostek for use in non-calculator roles. It featured three sets of processor registers, allowing it to switch to an interrupt handler in a single cycle, and a wait-for-data mode that aided direct memory access.